scripts.org

#+TITLE: Scripts
#+SETUPFILE: .setup.org
#+PROPERTY: header-args+
#+PROPERTY: header-args:shell+ :comments both
#+PROPERTY: header-args:bash+ :comments both
#+TAGS: wrapper(w) script(s)

This is where my custom scripts live. That includes shell scripts, dmenu
scripts, and potentially programming-language-specific scripts. One of the
things I strive for is to have the same script available in different
environments. For example, I have a dmenu script for creating a QR code, which
allows me to scan or generate a QR code with a few keystrokes. But sometimes I
want to call this script from a terminal, so I also have a =qr= command available
in =~/.local/bin=. Likewise, I have ideas to port some scripts to tridactyl (a
firefox extension) as well. Since those different versions of the same script
differ only by UX, it is useful to have all the versions defined in the same
place - here.

Note: For code reusability, I use some [[* Helper code][helper code blocks]] defined at the bottom
of this document. These code blocks are utilized via =org-sbe= or via noweb references.

* Wrappers around existing commands
** =git=                                                             :wrapper:
#+begin_src bash :tangle ~/.local/bin/git
  git() {
      alternative-command git "$@"
  }

  git_root="$(git root 2>/dev/null)"
  if [ "$git_root" = ~ ]; then
      if [ "$PWD" = ~ ] || [[ "${PWD#~/}" =~ ^\. ]]; then
          git "$@"
      else
          export GIT_CEILING_DIRECTORIES=~
          git "$@"
      fi
  else
      git "$@"
  fi
#+end_src
** =flameshot=                                                       :wrapper:
#+begin_src shell :tangle ~/.local/bin/flameshot
  o --title flameshot alternative-command flameshot
  until pgrep --quiet -x "flameshot"; do
    sleep 0.1s
  done
  alternative-command flameshot "$@"
#+end_src
** =rm=                                                              :wrapper:
#+begin_src shell :tangle ~/.local/bin/rm
  for arg in "$@"; do
      [ ! -e "$arg" ] && continue
      arg="$(realpath "$arg")"
      if echo "$arg" \
              | grep -q '^/home' && echo "$arg" \
                  | grep -qv '^/home/[^/]\+/[^/]\+'
      then
          echo "WTF: Trying to delete a home directory???"
          exit 1
      fi
  done
  /usr/bin/rm "$@"
#+end_src
** =pass=                                                            :wrapper:
This is a wrapper around GNU =pass=.
#+begin_src bash :tangle ~/.local/bin/pass
  shopt -s expand_aliases

  # TODO: Use alternative-command instead
  alias pass=/usr/bin/pass

  clipctl_previous_status="$(clipctl status || echo enable)"

  clipctl disable >/dev/null || true

  exit_status=0

  # Add a password read directly from stdin (without prompting to interactively
  # enter it)
  if [ "$1" = "add" ]; then
      dest=~/.password-store/"$2"
      destdir="$(dirname "$dest")"
      mkdir -p "$destdir"
      cat | gpg -e -o- -r "$(cat ~/.password-store/.gpg-id)" > "$dest".gpg
      exit_status=$?
  else
      pass "$@"
      exit_status=$?
  fi

  clipctl "$clipctl_previous_status" >/dev/null || true

  exit $exit_status
#+end_src
** =passmenu=                                                        :wrapper:
This is a wrapper around =passmenu=, trying to use =passmenu-otp= if present,
otherwise falling back to the default =passmenu=.
#+begin_src bash :tangle ~/.local/bin/passmenu
  if command -v passmenu-otp >/dev/null; then
      passmenu-otp "$@"
  else
      alternative-command passmenu "$@"
  fi
#+end_src
** =dmenu=                                                           :wrapper:
Note: This depends on my custom build of dmenu with the height patch applied.
The PKGFILE can be found [[https://github.com/veracioux/aur][here]].
#+NAME: dmenu
#+begin_src shell :tangle ~/.local/bin/dmenu
  alternative-command dmenu -b -f -i -h 25 \
      -nb '#1e1e1e' -nf '#dddddd' -sb '#99a3ff' -sf '#1e1e1e' \
      -fn 'Ubuntu Mono-12' \
      "$@"
#+end_src
** =ipython=                                                         :wrapper:
#+begin_src bash :tangle ~/.local/bin/ipython
  /usr/bin/ipython "$@" -i -- "$PYTHONSTARTUP"
#+end_src
** =gvim=                                                            :wrapper:
#+begin_src bash :tangle ~/.local/bin/gvim
  # Fake gvim which will just launch a terminal with neovim in it

  for arg in "$@"; do
      # Hacky solution that will open files in real gvim when opened by xdg-open
      if [ "$arg" = "-f" ]; then /usr/bin/gvim "$@"; exit; fi
  done

  # nvim is launched through the shell because otherwise it behaves weirdly
  # All arguments are surrounded with ''
  FISH_CMD="$(printf "%q " nvim "$@")"

  if [ ! -t 0 ]; then
      # Input is from a PIPE
      pipe_input="$(mktemp -t XXXXXXXXXXXXXXXX)"
      cat > "$pipe_input"
      FISH_CMD="cat $pipe_input | $FISH_CMD"
  fi

  alacritty --class Alacritty,Float -e fish -C "$FISH_CMD"

  if [ ! -t 0 ]; then
      # Input is from a PIPE
      rm -f "$pipe_input"
  fi
#+end_src
** =redshift=                                                        :wrapper:
#+begin_src shell :tangle ~/.local/bin/redshift
  /usr/bin/redshift -l 43.84:18.35
#+end_src
** =firefox=                                                         :wrapper:
#+begin_src bash :tangle ~/.local/bin/firefox
  # Honor $HARIS_FIREFOX_PROFILE: launch under that profile unless the caller
  # already passed a profile flag. This lets any firefox invocation target a
  # chosen profile, including URLs other programs open via $BROWSER=firefox.
  profile_args=()
  if [ -n "${HARIS_FIREFOX_PROFILE:-}" ]; then
      case " $* " in
          *" -P "*|*" -p "*|*" --profile "*|*" --profile="*) ;;
          *) profile_args=(-P "$HARIS_FIREFOX_PROFILE") ;;
      esac
  fi

  if [ -n "$VSCODE_PID" ]; then
      raw=("${profile_args[@]}" "$@")
  else
      raw=("${profile_args[@]}" --new-tab "$@")
  fi

  # Dedupe while preserving order
  args=()
  for a in "${raw[@]}"; do
      seen=0
      for b in "${args[@]}"; do
          [ "$a" = "$b" ] && { seen=1; break; }
      done
      [ "$seen" = 0 ] && args+=("$a")
  done

  if [ "$(get-os-type)" = ubuntu ] && [ -e ~/.local/opt/firefox ]; then
      ~/.local/opt/firefox/firefox "${args[@]}"
      exit
  fi

  alternative-command firefox "${args[@]}"
#+end_src
** =myemacs=                                                         :wrapper:
#+begin_src bash :tangle ~/.local/bin/myemacs
  # Run emacsclient in the terminal, unless the -c option is given, which will
  # open the GUI.
  # - Also enables proper color support.
  # - Any additional arguments you provide are passed to emacsclient

  export TERM='xterm-256color'
  create_frame=""
  socket_name=""
  modified_options=()

  print_help() {
      emacsclient --help
      echo
      echo "CUSTOM OPTIONS:"
      echo -e "--wait \t\t\tOverride --no-wait if it would otherwise be in effect"
      echo -e "--no-tty \t\tUndoes the effects of --tty"
  }

  declare -A custom_options_map

  # Get custom option named $1 (success code = on, error code = off)
  # If $2 is given, then the option named $1 is set to the truth
  # value of $2 (empty is false, non-empty is true)
  custom_option() {
      if [ "$#" = 2 ]; then
          custom_options_map["$1"]="$2"
      else
          [ -n "${custom_options_map["$1"]}" ]
      fi
  }

  # Since this is a wrapper around emacsclient, we need to parse and pass through
  # all options that emacsclient recognizes
  parsed_args="$(
      getopt --name "$BASH_SOURCE" \
          --options "h"VHtcre:nw:qud:s:f:a:T: \
          --long "wait,no-tty",version,help,tty,create-frame,reuse-frame,frame-parameters:,eval:,no-wait,timeout:,quiet,suppress-output,display:,parent-id:,socket-name:,server-file:,alternate-editor:,tramp: \
          -- "$@"
  )"

  eval set -- "$parsed_args"

  while :; do
      case "$1" in
          -h | --help)
              print_help
              exit ;;
          -c | --create-frame)
              create_frame="true"
              modified_options+=("$1")
              shift 1 ;;
          -s | --socket-name)
              modified_options+=("$1" "$2")
              socket_name="$2"
              shift 2 ;;
          -e | --eval)
              modified_options+=("$1" "$2")
              shift 2 ;;
          --no-wait)
              custom_option wait ""
              shift 1 ;;
          --wait)
              custom_option wait "true"
              shift 1 ;;
          -t | --tty)
              custom_option tty "true"
              shift 1 ;;
          --no-tty)
              custom_option tty ""
              shift 1 ;;
          --)
              shift 1
              break ;;
          ,*)
              modified_options+=("$1")
              shift 1 ;;
      esac
  done

  if [ ! -t 0 ]; then
      custom_option wait ""
  fi

  # Set reasonable default values for --tty option and --no-wait option
  # based on --create-frame.
  if [ ! -v custom_options_map["tty"] ]; then
      custom_option tty "$([ -z "$create_frame" ] && echo true)"
  fi
  if [ ! -v custom_options_map["wait"] ]; then
      custom_option wait "$([ -z "$create_frame" ] && echo true)"
  fi

  if custom_option tty; then
      modified_options+=(--tty)
  fi

  if ! custom_option wait; then
      modified_options+=(--no-wait)
  fi

  if [ -z "$socket_name" ]; then
      modified_options+=(--socket-name emacs)
  fi

  emacsclient() {
      exec -a "$BASH_SOURCE" command emacsclient "$@"
  }

  set -- "${modified_options[@]}" -- "$@"

  if [ ! -t 0 ]; then
      file="$(mktemp /tmp/haris-pipe-XXXXXXXX)"
      tee "$file" <&0 >/dev/null &
      bg_pid="$!"
      set -- "$@" "$file"
      trap "kill $bg_pid &>/dev/null" EXIT INT ERR
  fi

  exec -a "$BASH_SOURCE" emacsclient \
       --alternate-editor ~/.local/lib/haris/emacs-alternate-editor \
       "$@"

  if [ -n "$bg_pid" ]; then
      wait "$bg_pid"
  fi
#+end_src
*** Helper program
#+begin_src bash :tangle ~/.local/lib/haris/emacs-alternate-editor
  is_running() {
      emacsclient --no-wait --socket-name emacs --eval '(ignore)' >/dev/null 2>&1
  }

  id="$(notify-send --print-id "Emacs" "Starting daemon...")"
  systemctl restart --user emacs
  until is_running; do
      sleep 2s
  done
  notify-send --print-id --replace-id="$id" "Emacs" "Daemon ready"
#+end_src
*** Shell completion
#+begin_src fish :tangle ~/.config/fish/completions/myemacs.fish
  complete -c myemacs --wraps emacsclient
  complete -c myemacs --long "wait" --description "Override --no-wait if it would otherwise be in effect"
#+end_src
** =smart-launch=
Runs a command, and decides how to place its resulting window based on the
currently focused i3 container:
- Stacked/tabbed layout: run normally (new window tiles unobtrusively).
- Split layout: float the new window and move it to scratchpad (so tiling
  doesn't reshuffle existing windows).
- If the currently focused window is itself floating (e.g. a scratchpad), hide
  it first so the new window appears on top rather than behind it.

Usage: =smart-launch CMD...=
#+begin_src bash :tangle ~/.local/bin/smart-launch
  if [ "$#" = 0 ]; then
    echo "usage: smart-launch CMD..." >&2
    exit 2
  fi

  tree=$(i3-msg -t get_tree)

  layout=$(echo "$tree" | jq -r \
    '.. | objects | select(.nodes[]?.focused == true) | .layout' | tail -1)

  is_floating=$(echo "$tree" | jq -r \
    '.. | objects | select(.focused == true) | .floating' | head -1)
  case "$is_floating" in
    user_on|auto_on) i3-msg move scratchpad >/dev/null ;;
  esac

  case "$layout" in
    stacked|tabbed)
      exec "$@"
      ;;
    *)
      {
        con_id=$(i3-msg -t subscribe '["window"]' \
          | jq -r --unbuffered 'select(.change == "new") | .container.id' \
          | head -1)
        i3-msg "[con_id=$con_id]" floating enable, move scratchpad, scratchpad show >/dev/null
      } &
      exec "$@"
      ;;
  esac
#+end_src
** =float-launch=
Like [[*=smart-launch=][=smart-launch=]] but always floats the new window into the scratchpad and
shows it, regardless of the focused container's layout. Use for popups that
should never tile (e.g. confirmation prompts).

Usage: =float-launch CMD...=
#+begin_src bash :tangle ~/.local/bin/float-launch
  if [ "$#" = 0 ]; then
    echo "usage: float-launch CMD..." >&2
    exit 2
  fi

  is_floating=$(i3-msg -t get_tree \
    | jq -r '.. | objects | select(.focused == true) | .floating' | head -1)
  case "$is_floating" in
    user_on|auto_on) i3-msg move scratchpad >/dev/null ;;
  esac

  {
    con_id=$(i3-msg -t subscribe '["window"]' \
      | jq -r --unbuffered 'select(.change == "new") | .container.id' \
      | head -1)
    i3-msg "[con_id=$con_id]" floating enable, move scratchpad, scratchpad show >/dev/null
  } &
  exec "$@"
#+end_src
** =alacritty-hint-open=
Dispatcher for the Alacritty hint that matches URLs, local file paths and
=#NUMBER= PR tokens (see [[file:terminal.org::*Alacritty][terminal.org]]). Given the single hinted string it decides
how to open it:
- URLs / known schemes (=*://*=, =mailto:=, =magnet:=, …) -> =xdg-open=.
- A bare IPv4 =host:port= (e.g. =127.0.0.1:8080=) -> =xdg-open http://host:port=.
- A =#NUMBER= token -> handed to [[*=alacritty-hint-pr=][=alacritty-hint-pr=]] (opens that PR in the browser).
- An existing file -> handed to [[*=edit-file=][=edit-file=]], which reuses an already-open VS Code
  worktree window or otherwise opens Emacs (with a =:line[:col]= suffix honoured).

Note: Alacritty can't pre-filter which text gets a hint label (matching is
regex-only, with no validation hook), so existence is checked here, at
activation time. The path regex requires a =/=, =~/=, =./= or =../= lead (or a
bare relative path of >=3 segments), so 2-segment =word/word= tokens (e.g. git
branch refs like =feat/x=) never hint in the first place.
Relative paths are resolved against the focused pane's cwd
via [[*=alacritty-pane-cwd=][=alacritty-pane-cwd=]] (=edit-file= would otherwise resolve against =$PWD=, which
is wrong for a hint); a missing file is copied to the clipboard (with a
notification) instead of opening an empty buffer.

Usage: =alacritty-hint-open TARGET=
#+begin_src bash :tangle ~/.local/bin/alacritty-hint-open
  target="$1"
  [ -z "$target" ] && exit 0

  # A bare IPv4 host:port (no scheme) -> open in the browser over http.
  if [[ "$target" =~ ^[0-9]{1,3}(\.[0-9]{1,3}){3}:[0-9]+$ ]]; then
      exec xdg-open "http://$target"
  fi

  case "$target" in
      *://* | mailto:* | magnet:* | news:* | ipfs:* | ipns:* | gemini:* | gopher:*)
          exec xdg-open "$target" ;;
      '#'[0-9]*)
          # A `#NUMBER` PR token -> hand off to the PR opener.
          exec alacritty-hint-pr "$target" ;;
  esac

  # Treat as a file path, peeling off an optional :line[:col] suffix so the
  # existence check sees a bare path; the suffix is re-attached for edit-file.
  file="$target"
  suffix=""
  if [[ "$target" =~ ^(.+)(:[0-9]+(:[0-9]+)?)$ ]]; then
      file="${BASH_REMATCH[1]}"
      suffix="${BASH_REMATCH[2]}"
  fi

  # Expand a leading ~ and resolve relative paths against the pane's cwd.
  case "$file" in
      "~") file="$HOME" ;;
      "~/"*) file="$HOME/${file#"~/"}" ;;
      /*) ;;
      *) file="$(alacritty-pane-cwd)/$file" ;;
  esac

  if [ ! -e "$file" ]; then
      # Not a followable file: copy the raw target to the clipboard instead.
      printf '%s' "$target" | xsel -b -i
      notify-send "alacritty-hint-open" "Copied (no such file): $target"
      exit 0
  fi

  # Resolved to a real file: let edit-file pick VS Code reuse vs. Emacs.
  exec edit-file "$file$suffix"
#+end_src
** =alacritty-hint-pr=
Dispatcher for the Alacritty hint that matches =#NUMBER= tokens (see
[[file:terminal.org::*Alacritty][terminal.org]]). Opens the corresponding pull request in the browser with
=gh pr view --web=, run from the focused pane's cwd (via [[*=alacritty-pane-cwd=][=alacritty-pane-cwd=]]) so
the repo is inferred from where the hint was activated. On failure (not a git
repo, no such PR, …) the error is surfaced via [[*=notify-send=][=notify-send=]].

Usage: =alacritty-hint-pr TARGET=
#+begin_src bash :tangle ~/.local/bin/alacritty-hint-pr
  target="$1"
  [ -z "$target" ] && exit 0

  # Strip the leading '#'; the hint regex guarantees the rest is digits.
  number="${target#\#}"

  cd "$(alacritty-pane-cwd)" || exit 0

  if ! err="$(gh pr view "$number" --web 2>&1)"; then
      notify-send "alacritty-hint-pr" "Could not open PR #$number: $err"
  fi
#+end_src
** =notify-send=                                                     :wrapper:
#+begin_src shell :tangle ~/.local/bin/notify-send
  export DBUS_SESSION_BUS_ADDRESS="unix:path=/run/user/<<eval-real-uid()>>/bus"

  # If notify-send can't communicate, it blocks. That's the reason for the timeout
  timeout 1s alternative-command notify-send "$@"
#+end_src
** =sudo=                                                          :wrapper:
#+NAME: sudo
#+begin_src bash :tangle ~/.local/bin/sudo
  # Sudo but with a hook that sends a notification when the prompt is shown

  # TODO: Not robust enough. What if the wrapped command itself accepts a --stdin flag?

  if [ -z "$SUDO_ASKPASS" ] && [[ ! "$*" =~ --stdin ]] && [[ ! "$*" =~ -S ]]; then
      export SUDO_ASKPASS="$(mktemp)"
      chmod u+x "$SUDO_ASKPASS"
      cat > "$SUDO_ASKPASS" <<'EOF'
  <<sudo-askpass>>
  EOF
      trap "rm -f $SUDO_ASKPASS" EXIT
      alternative-command sudo --askpass "$@"
  else
      alternative-command sudo "$@"
  fi
#+end_src
#+NAME: sudo-askpass
#+begin_src shell :tangle no
  #!/usr/bin/env sh
  askpass "[sudo] password for $(getent passwd "$USER" | cut -d: -f1)" "SUDO password" "Please enter your password"
#+end_src
** =ssh=                                                           :wrapper:
#+begin_src bash :tangle ~/.local/bin/ssh
  # This checks whether ssh is run via sshpass or perhaps some other tool that
  # assigns its own terminal to ssh.
  is_tty_available() {
      { : >/dev/tty; } &>/dev/null
  }

  if [ -z "$SSH_ASKPASS" ] && is_tty_available; then
      export SSH_ASKPASS="$(mktemp)"
      export SSH_ASKPASS_REQUIRE="prefer"
      chmod u+x "$SSH_ASKPASS"
      cat > "$SSH_ASKPASS" <<'EOF'
  <<ssh-askpass>>
  EOF
      trap "rm -f $SSH_ASKPASS" EXIT
  fi

  alternative-command ssh "$@"
#+end_src
#+NAME: ssh-askpass
#+begin_src shell
  # The default prompt supplied as call args
  prompt="$(echo "$1" | sed 's/: $//')"
  askpass "$prompt" "SSH passphrase" "Please enter SSH passphrase"
#+end_src
** =alacritty=                                                     :wrapper:
#+begin_src shell :tangle ~/.local/bin/alacritty
  alternative-command alacritty "$@"
  #+end_src
** =alacritty-float=                                               :wrapper:
#+begin_src shell :tangle ~/.local/bin/alacritty-float
  alacritty --class Alacritty,Float "$@"
#+end_src
** =alacritty-fork=
Open a new alacritty window running the same command as the foreground process
of the current terminal. Only whitelisted commands are allowed.
#+begin_src bash :tangle ~/.local/bin/alacritty-fork
  WHITELIST=(claude opencode codex)

  # Walk the process tree rooted at $1 from a single ps snapshot, printing each
  # descendant as "pid comm" (the pid lets us inspect a match's environment).
  descendants() {
      ps -e -o pid=,ppid=,comm= | awk -v root="$1" '
          { comm[$1]=$3; children[$2]=children[$2]" "$1 }
          END {
              stack=children[root]; n=0
              while (stack != "") {
                  sub(/^ /, "", stack)
                  sp=index(stack, " ")
                  if (sp) { p=substr(stack,1,sp-1); stack=substr(stack,sp+1) }
                  else    { p=stack; stack="" }
                  print p, comm[p]
                  if (children[p] != "") stack=children[p] stack
              }
          }'
  }

  ALACRITTY_PID=$(xdotool getactivewindow getwindowpid 2>/dev/null)
  if [ -z "$ALACRITTY_PID" ]; then
      error "alacritty-fork: could not determine active window PID"
      exit 1
  fi
  info "alacritty-fork: alacritty PID=$ALACRITTY_PID"

  # tmux daemonizes its server, so pane processes are children of the tmux
  # server (under systemd), NOT under alacritty. We find the tmux session by
  # matching alacritty's child PTY against tmux client TTYs, then walk
  # descendants from the active pane's root PID.
  CHILD_PID=$(pgrep -P "$ALACRITTY_PID" | head -1)
  CHILD_TTY=$(readlink "/proc/$CHILD_PID/fd/0" 2>/dev/null)
  info "alacritty-fork: child PID=$CHILD_PID TTY=$CHILD_TTY"

  SESSION=$(tmux list-clients -F '#{client_tty} #{session_name}' 2>/dev/null \
      | awk -v tty="$CHILD_TTY" '$1 == tty {print $2}')
  info "alacritty-fork: tmux session='$SESSION'"

  if [ -n "$SESSION" ]; then
      ROOT_PID=$(tmux display-message -t "$SESSION" -p '#{pane_pid}' 2>/dev/null)
  else
      ROOT_PID="$CHILD_PID"
  fi

  DESCENDANTS=$(descendants "$ROOT_PID")
  info "alacritty-fork: root PID=$ROOT_PID descendants=$(echo "$DESCENDANTS" | tr '\n' ' ')"

  # First descendant whose command name is whitelisted; keep its PID so we can
  # inspect its environment below.
  FG_LINE=$(printf '%s\n' "$DESCENDANTS" | awk -v wl=" ${WHITELIST[*]} " '
      index(wl, " " $2 " ") { print; exit }')
  FG_PID=${FG_LINE%% *}
  FG_CMD=${FG_LINE##* }

  cd "$(alacritty-pane-cwd)"
  if [ -z "$FG_CMD" ]; then
      info "alacritty-fork: no whitelisted command found, falling back to plain term"
      term &
  else
      # `claude` and `claude2` share the same binary (comm=claude). When the
      # source window is `claude2`, do NOT pin the fork to that identity:
      # launch plain `claude` so its wrapper can re-run the cached auto-routing
      # decision and pick the healthier account.
      if [ "$FG_CMD" = claude ] && \
         grep -qz 'CLAUDE_CONFIG_DIR=.*/\.claude2$' "/proc/$FG_PID/environ" 2>/dev/null; then
          info "alacritty-fork: source is claude2; re-running claude auto-routing"
      fi
      info "alacritty-fork: forking '$FG_CMD'"
      term direnv exec . "$FG_CMD" &
  fi
#+end_src
** =sway=                                                          :wrapper:
#+begin_src shell :tangle ~/.local/bin/sway
  export XDG_CURRENT_DESKTOP=Sway
  /usr/bin/sway --unsupported-gpu "$@"
#+end_src
** =xlock=                                                         :wrapper:
#+begin_src shell :tangle ~/.local/bin/xlock
  pkill gpg-agent 2>/dev/null
  alternative-command xlock "$@"
#+end_src
** =vscode=                                                        :wrapper:
The name =code= is a bit too generic. I need something more specific in order to
get better search matches.
#+begin_src shell :tangle ~/.local/bin/vscode
  code "$@"
#+end_src
** =code=                                                          :wrapper:
Runs VSCode inside a transient systemd scope under =app.slice= with a
~MemoryHigh~ ceiling and a high ~OOMScoreAdjust~ so it's the first thing killed
under memory pressure. See [[file:background.org::*Out-of-memory handling][background.org]] for the surrounding OOM setup.
#+begin_src bash :tangle ~/.local/bin/code :shebang "#!/usr/bin/env bash"
  set -e
  echo 600 > /proc/self/oom_score_adj
  exec systemd-run --user --scope --quiet \
       --unit="code-$$" \
       --slice=app.slice \
       -p MemoryHigh=12G \
       -- alternative-command code "$@"
#+end_src
** =web-ext=                                                       :wrapper:
#+begin_src bash :tangle ~/.local/bin/web-ext
  alternative-command web-ext "$@" &
  child_pid="$!"

  trap 'kill -TERM "$child_pid" 2>/dev/null' INT

  wait "$child_pid"
#+end_src
** =lnav=                                                          :wrapper:
#+begin_src shell :tangle ~/.local/bin/lnav
  export TERM=xterm-256color

  # alternative-command lnav "$@"
  /usr/bin/lnav "$@"
#+end_src
** =clipctl=                                                       :wrapper:
#+begin_src bash :tangle ~/.local/bin/clipctl
  set -e

  if [ "$#" -ne 1 ]; then
      echo "Usage: $0 enable|disable|status|tmp-disable"
      echo "  enable: enable clipboard synchronization"
      echo "  disable: disable clipboard synchronization"
      echo "  status: shows the current clipboard synchronization status"
      echo "  tmp-disable: disable clipboard synchronization for the current shell pipeline, cat stdin to stdout"
      exit 1
  fi

  status_file="$XDG_RUNTIME_DIR/haris/clipctl-status"
  mkdir -p "$(dirname "$status_file")"

  previous_state="$(cat "$status_file" 2>/dev/null || echo "enable")"

  # Perform action
  if [ "$1" = "enable" ] || [ "$1" = "disable" ]; then
      copyq "$1"
      echo "$1" > "$status_file"
  elif [ "$1" = "status" ]; then
       echo "$previous_state"
  elif [ "$1" = "tmp-disable" ]; then
      if [ "$previous_state" = "disable" ]; then
          copyq disable >/dev/null # Just making sure
          cat
      else
          copyq disable >/dev/null
          cat
          re_enable() {
              sleep 0.2s
              copyq "$(cat "$status_file" 2>/dev/null || echo "enable")" >/dev/null
          }
          export -f re_enable
          nohup bash -c re_enable &>/dev/null &
      fi
  else
      echo "Invalid argument: $1"
      exit 1
  fi
#+end_src
*** Completions
#+begin_src fish :tangle ~/.config/fish/completions/clipctl.fish
  complete -c clipctl -f -a "enable" -d "Enable clipboard synchronization"
  complete -c clipctl -f -a "disable" -d "Disable clipboard synchronization"
  complete -c clipctl -f -a "status" -d "Show the current clipboard synchronization status"
  complete -c clipctl -f -a "tmp-disable" -d "Disable clipboard synchronization for the current shell pipeline; cat"
#+end_src
** =clipdel=                                                       :wrapper:
clipmenu shipped a =clipdel= for purging entries from clipboard history.
CopyQ has no delete-by-content command, so this shim restores the
=clipdel -d PATTERN= interface (used by [[file:shells.org::*=secclip=][=secclip=]]) via a CopyQ script
that scans the active tab and removes every item whose full content equals
PATTERN (iterating top-down so row indices stay valid as items are removed).
#+begin_src bash :tangle ~/.local/bin/clipdel
  # Usage: clipdel [-d] PATTERN
  # Removes CopyQ history items whose full content equals PATTERN.
  pattern="$1"
  [ "$pattern" = "-d" ] && pattern="$2"
  [ -z "$pattern" ] && exit 0

  PATTERN="$pattern" copyq eval '
    var p = str(env("PATTERN"));
    for (var i = size() - 1; i >= 0; --i)
      if (str(read(i)) === p) remove(i);
  ' >/dev/null 2>&1
#+end_src
** =copyq-show=                                                    :wrapper:
Opens the CopyQ picker centered, with the cursor warped onto the first entry so
it is immediately mouse-navigable. CopyQ has no centering option and its window
is long-lived (shown/hidden, not recreated), so an i3 =for_window= rule only
fires once and can't re-center on each show — instead we show the window, then
re-center + focus it via i3 criteria and move the pointer into it. With
=restore_geometry=false= (see [[file:background.org::*=copyq-setup=][=copyq-setup=]]) CopyQ won't fight the placement.
Falls back to a plain show outside i3.
#+begin_src bash :tangle ~/.local/bin/copyq-show
  copyq show
  command -v i3-msg >/dev/null 2>&1 || exit 0
  sleep 0.2   # let the window map before i3 acts on it
  i3-msg '[class="copyq"] floating enable, focus, move position center' >/dev/null 2>&1

  # Warp the cursor onto the first entry so the list is instantly navigable.
  if command -v xdotool >/dev/null 2>&1; then
      wid="$(xdotool getactivewindow 2>/dev/null)"
      [ -n "$wid" ] && xdotool mousemove --window "$wid" 60 70 >/dev/null 2>&1
  fi
#+end_src
** =docker-compose=                                                :wrapper:
#+begin_src bash :tangle ~/.local/bin/docker-compose
  if grep -q 'down.*--volumes' <<<"$*"; then
      echo 'Option --volumes used. Make sure this is the intended compose project'
      echo -e "COMPOSE_PROJECT_NAME: \e[1;31m $COMPOSE_PROJECT_NAME\e[0m"
      read -p "Are you sure? [y|N]: " -n 1 answer
      if [ "$answer" != "y" ]; then
          echo
          echo "Aborting."
          exit 1
      fi
  fi

  if [ "$(which -a docker-compose | uniq | wc -l)" -gt 1 ]; then
      alternative-command docker-compose "$@"
  else
      docker compose "$@"
  fi
#+end_src
** =ngrok=                                                         :wrapper:
#+begin_src shell :tangle ~/.local/bin/ngrok
  export TERM=xterm-256color
  alternative-command ngrok "$@"
#+end_src
** =yarn=                                                          :wrapper:
#+begin_src shell :tangle ~/.local/bin/yarn
  if [ "$(which -a yarn | uniq | wc -l)" -gt 1 ]; then
      alternative-command yarn "$@"
  else
      yarnpkg "$@"
  fi
#+end_src
** =iredis=                                                        :wrapper:
#+begin_src shell :tangle ~/.local/bin/iredis
  export PAGER=cat
  alternative-command iredis "$@"
#+end_src
** =VirtualBox=                                                    :wrapper:
#+begin_src shell :tangle ~/.local/bin/VirtualBox
  export QT_QPA_PLATFORMTHEME=qt
  alternative-command VirtualBox "$@"
#+end_src
** =screenkey=                                                     :wrapper:
#+begin_src shell :tangle ~/.local/bin/screenkey
  alternative-command screenkey --bg-color "#99a3ff" --font-color "#1e1e1e" "$@"
#+end_src
** =fzf=                                                           :wrapper:
#+begin_src shell :tangle ~/.local/bin/fzf
  alternative-command fzf --layout=reverse "$@"
#+end_src
** =tmux-shell=
Launches fish inside a predictably named tmux session (=term-001=, =term-002=, ...).
This enables sharing a terminal session across multiple windows and
programmatic access to the scrollback buffer via =tmux capture-pane=.

Set =TMUX_SHELL_SESSION= to pin an explicit session name instead of the
auto-incremented =term-NNN= — useful when a caller needs to target the pane
deterministically. Keep the =term-= prefix so the
[[file:background.org::*=tmux-shell-cleanup=][cleanup timer]] and the [[file:shells.org::*=tmux=][nested-=tmux= override]] still recognise it.
#+begin_src bash :tangle ~/.local/bin/tmux-shell
  if [ -n "${TMUX_SHELL_SESSION:-}" ]; then
      name=$TMUX_SHELL_SESSION
  else
      counter_file="${XDG_RUNTIME_DIR:-/tmp}/tmux-shell.counter"
      {
          flock 9
          n=$(cat "$counter_file" 2>/dev/null || echo 0)
          n=$((n + 1))
          printf '%s\n' "$n" > "$counter_file"
      } 9>"$counter_file.lock"
      name=$(printf 'term-%03d' $n)
  fi

  # Pass the caller's env into the new session via `-e`. Without this tmux
  # would inherit the tmux server's env, which can be stale.
  env_args=()
  while IFS= read -r -d '' entry; do
      env_args+=(-e "$entry")
  done < <(env -0)

  tmux new-session "${env_args[@]}" -d -s "$name" -- fish "$@"
  tmux set-option -t "$name" prefix None
  tmux set-option -t "$name" set-titles on
  tmux set-option -t "$name" set-titles-string '#{pane_title}'
  exec tmux attach -t "$name"
#+end_src
** =claude-pending-scan=
Scan all tmux panes for the Claude confirmation pattern (=requires
confirmation= or =Do you want to=). On the first match, print =pane_id session=
to stdout and exit 0; exit 1 if nothing matches. Skips the current pane
(=$TMUX_PANE=) when invoked from within tmux so callers don't pick themselves.

Shared by [[*=claude-confirm=][=claude-confirm=]] and the [[file:background.org::*Claude pending notifier][pending-notifier service]].
#+begin_src bash :tangle ~/.local/bin/claude-pending-scan
  set -eu

  PATTERN='requires confirmation|Do you want to'

  panes=$(tmux list-panes -a -F '#{pane_id} #{session_name}' 2>/dev/null || true)
  [ -z "$panes" ] && exit 1

  while read -r pane_id session; do
      [ "$pane_id" = "${TMUX_PANE:-}" ] && continue
      content=$(tmux capture-pane -p -J -t "$pane_id" 2>/dev/null || true)
      if printf '%s\n' "$content" | grep -qE "$PATTERN"; then
          echo "$pane_id $session"
          exit 0
      fi
  done <<<"$panes"

  exit 1
#+end_src
** =claude-confirm=
Attach to a tmux pane awaiting Claude confirmation. If a pane id is given as
=$1=, attach to it directly; otherwise scan via [[*=claude-pending-scan=][=claude-pending-scan=]] and pick
the first match. Intended to run inside a fresh terminal
(=term claude-confirm [PANE]=).
#+begin_src bash :tangle ~/.local/bin/claude-confirm
  set -eu

  log() { printf 'claude-confirm: %s\n' "$*" >&2; }

  if [ -n "${1:-}" ]; then
      pane_id=$1
  else
      if ! match=$(claude-pending-scan); then
          log "no pane awaiting confirmation"
          exit 1
      fi
      pane_id=${match%% *}
  fi

  log "attaching to $pane_id"
  TMUX='' exec tmux attach -t "$pane_id"
#+end_src
** =claude-tip=
Print the arguments back if running inside Claude Code, no-op otherwise.
Useful for embedding hints in shell output that only Claude will see.
#+begin_src shell :tangle ~/.local/bin/claude-tip
  [ -n "$CLAUDECODE" ] && echo "Tip:" "$@"
  exit 0
#+end_src
** =claude-resume=
Resume a Claude Code session. Scans the current tmux pane's scrollback for the
most recent resume reference and offers to resume that exact session with the
matching tool. Recognised forms: =claude --resume <UUID>=, =claude --resume
"friendly title"= (a non-UUID title, single- or double-quoted), =codex resume
<UUID>=, and codex's own hint text =codex resume, then select <name> (<UUID>)=.
Otherwise (no match, declined, or not inside tmux) falls back to the regular
=claude --resume= picker. Extra args are forwarded to the resumed tool.
#+begin_src bash :tangle ~/.local/bin/claude-resume
  set -eu

  fallback() { exec claude --resume "$@"; }

  # Only the current pane's scrollback is meaningful.
  [ -n "${TMUX_PANE:-}" ] || fallback "$@"

  uuid_re='[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'

  # Most recent resume reference in the scrollback, in any of the forms we emit
  # or the tools print:
  #   claude --resume <UUID>
  #   claude --resume "friendly title"        (or single-quoted)
  #   codex resume <UUID>
  #   ... codex resume, then select <name> (<UUID>)   (codex's own hint text)
  # The codex-hint branch tolerates arbitrary text between `codex resume` and
  # the parenthesised UUID, so it must precede the bare `codex resume <UUID>`
  # branch.
  match=$(tmux capture-pane -p -J -t "$TMUX_PANE" 2>/dev/null \
      | grep -oE "(claude --resume ($uuid_re|\"[^\"]+\"|'[^']+')|codex resume[^(]*\($uuid_re\)|codex resume $uuid_re)" \
      | tail -n1) || match=""

  tool=$(printf '%s\n' "$match" | grep -oE "^(claude|codex)") || tool=""

  # Resume target: a UUID if the match contains one, else (claude only) the
  # quoted friendly title with its surrounding quotes stripped.
  uuid=$(printf '%s\n' "$match" | grep -oE "$uuid_re") || uuid=""
  title=""
  if [ -z "$uuid" ]; then
      title=$(printf '%s\n' "$match" | grep -oE "\"[^\"]+\"|'[^']+'" \
          | sed -E "s/^['\"]//; s/['\"]\$//") || title=""
  fi
  target=${uuid:-$title}

  [ -n "$target" ] || fallback "$@"
  [ -n "$tool" ] || fallback "$@"

  printf 'Resume %s session %s? [Y/n] ' "$tool" "$target" >&2
  read -r -n1 reply || reply=""
  printf '\n' >&2
  case "$reply" in
      [Nn]*) fallback "$@" ;;
      *)
          if [ "$tool" = codex ]; then
              exec codex resume "$uuid" "$@"
          fi
          exec claude --resume "$target" "$@"
          ;;
  esac
#+end_src
** =claude-resume2=                                                :wrapper:
[[*=claude-resume=][=claude-resume=]] for the [[*=claude2=][=claude2=]] identity. Sets the same isolated environment
as =claude2= (config dir, browser profile) and exec's =claude-resume=, whose
internal =claude --resume= then inherits it — so the scan, picker, and resumed
session all run against =~/.claude2=. Since =projects/= is shared (see the [[*Bootstrap][Claude
Code bootstrap]]), the same sessions are resumable from either identity.
#+begin_src bash :tangle ~/.local/bin/claude-resume2
  export CLAUDE_CONFIG_DIR="$HOME/.claude2"
  export HARIS_FIREFOX_PROFILE="claude-login2"
  export BROWSER="$HOME/.local/bin/firefox"
  exec claude-resume "$@"
#+end_src
** =rm-dottmp=
Remove the =.tmp= directory at the given path. Accepts either the directory
*containing* =.tmp= or the =.tmp= directory itself (in which case its basename
must be =.tmp=). Used to clean up scratch directories AI agents create per the
global instructions.
#+begin_src bash :tangle ~/.local/bin/rm-dottmp
  set -eu
  arg=${1%/}
  [ -n "$arg" ] || { echo "rm-dottmp: empty path" >&2; exit 2; }
  if [ "$(basename "$arg")" = ".tmp" ]; then
      target=$arg
  else
      target=$arg/.tmp
  fi
  rm -r "$target"
#+end_src
** =hostess-api=
CLI wrapper around the [[file:background.org::*Hostess API][Hostess API]] HTTP service. Convenience over curl —
exits non-zero on HTTP ≥ 400 and prints the server's JSON error to stderr.
#+begin_src bash :tangle ~/.local/bin/hostess-api
  set -eu
  port="${HARIS_HOSTESS_API_PORT:-10003}"
  base="http://127.0.0.1:$port"

  usage() {
      cat >&2 <<'EOF'
  Usage:
    hostess-api list
    hostess-api get  <hostname>
    hostess-api set  <hostname> <ip>     # create or update (upsert)
    hostess-api del  <hostname>
  EOF
      exit 2
  }

  req() {
      local method=$1 path=$2 data=${3:-}
      local tmp; tmp=$(mktemp -t hostess-api.XXXXXX)
      trap 'rm -f "$tmp"' RETURN
      local code
      if [ -n "$data" ]; then
          code=$(curl -sS -o "$tmp" -w '%{http_code}' \
              -X "$method" -H 'Content-Type: application/json' -d "$data" \
              "$base$path")
      else
          code=$(curl -sS -o "$tmp" -w '%{http_code}' -X "$method" "$base$path")
      fi
      if [ "$code" -ge 400 ]; then
          cat "$tmp" >&2; echo >&2
          return 1
      fi
      [ -s "$tmp" ] && { cat "$tmp"; echo; } || true
  }

  cmd=${1:-}
  [ $# -ge 1 ] && shift || usage
  case "$cmd" in
      list) [ $# -eq 0 ] || usage; req GET /hosts ;;
      get)  [ $# -eq 1 ] || usage; req GET    "/hosts/$1" ;;
      set)  [ $# -eq 2 ] || usage; req PUT    "/hosts/$1" "{\"ip\":\"$2\"}" ;;
      del)  [ $# -eq 1 ] || usage; req DELETE "/hosts/$1" ;;
      *)    usage ;;
  esac
#+end_src
** =safe-env=
Print =env= with sensitive variables redacted. Whitelisted variables show
their values; everything else shows =<redacted>=. Safe for agents to call
without permission prompts.
#+begin_src bash :tangle ~/.local/bin/safe-env
  exec env -0 | awk -F= -v RS='\0' '
    BEGIN {
      allow = "^(ALACRITTY_WINDOW_ID|CLAUDECODE|CLAUDE_CODE_ENTRYPOINT|CLAUDE_CODE_EXECPATH|CLOUDSDK_ROOT_DIR|COLORTERM|COMPOSE_BAKE|COMPOSE_PARALLEL_LIMIT|COMPOSE_PROJECT_NAME|COREPACK_ENABLE_AUTO_PIN|DISABLE_AUTOUPDATER|DISPLAY|EDITOR|EXPOSED_IP|GOOGLE_CLOUD_SDK_HOME|GOPATH|GPG_TTY|HARIS_EXCALIDRAW_PORT|HARIS_PROFILE_LOADED|HARIS_WEBSCRIPTS_PORT|HOME|LANG|LOGNAME|MANPATH|MANWIDTH|MOTD_SHOWN|MOZ_USE_XINPUT2|NIX_PROFILES|NIX_SSL_CERT_FILE|PAGER|PNPM_HOME|PWD|PYENV_ROOT|QT_QPA_PLATFORMTHEME|ROCM_PATH|RUSTC_WRAPPER|SHELL|SHLVL|TERM|TMUX|TMUX_PANE|TURBO_CACHE_DIR|TURBO_UI|USER|VAGRANT_HOME|VISUAL|VITEST_MAX_FORKS|VITEST_MAX_THREADS|WINDOWID|WINDOWPATH|XDG_DATA_DIRS|XDG_SEAT|XDG_SESSION_CLASS|XDG_SESSION_ID|XDG_SESSION_TYPE|XDG_VTNR)$"
    }
    { if ($1 ~ allow) allowed[na++] = $0; else redacted[nr++] = $1 }
    END {
      n = asort(allowed); for (i = 1; i <= n; i++) print allowed[i]
      n = asort(redacted); for (i = 1; i <= n; i++) print redacted[i] "=<redacted>"
    }
  '
#+end_src
** =claude=                                                        :wrapper:
#+begin_src bash :tangle ~/.local/bin/claude
  if [ "$(pwd)" = ~ ]; then
      mkdir -p ~/.empty
      cd ~/.empty/
  fi
  # Model and effort are set globally, not per-session. Set them here to ensure
  # consistent defaults for interactive use. To use different settings, pass
  # --model or --effort explicitly to override.
  #
  # Effort/model changes from inside a Claude Code instance write to
  # ~/.claude/settings.json and would bleed into every other running instance.
  # Point CLAUDE_CONFIG_DIR at a per-session snapshot dir whose entries
  # symlink back to the real ~/.claude (and ~/.claude.json), except
  # settings.json which is a local copy — so in-session writes to it land
  # in the snapshot and are discarded on exit. Other state (projects MRU,
  # onboarding, telemetry, session files) writes through the symlinks and
  # persists normally.
  cfgdir=${CLAUDE_CONFIG_DIR:-"$HOME/.claude"}

  # When the primary Claude account is already running hot, fail over to the
  # alternate identity before launching. `claude2` re-enters this wrapper with
  # CLAUDE_CONFIG_DIR=~/.claude2, which acts as the recursion guard.
  if [ "$cfgdir" = "$HOME/.claude" ]; then
      route=$(claude-route 2>/dev/null || true)
      if [ "$route" = claude2 ]; then
          printf 'claude: auto-switching to claude2 (cached usage high)\n' >&2
          exec claude2 "$@"
      fi
  fi

  # In a VM, skip permission prompts — the VM is the sandbox.
  extra=()
  if systemd-detect-virt -q; then
      extra+=(--dangerously-skip-permissions)
      # Suppress the bypass-permissions acceptance prompt by marking it accepted.
      if [ -f "$HOME/.claude.json" ] && \
         [ "$(jq 'has("bypassPermissionsModeAcceptedTwiceAt")' "$HOME/.claude.json")" = false ]; then
          tmp=$(mktemp -t claude-json.XXXXXX)
          jq --argjson ts "$(date +%s000)" \
              '.bypassPermissionsModeAcceptedTwiceAt = $ts' \
              "$HOME/.claude.json" >"$tmp" && mv "$tmp" "$HOME/.claude.json"
      fi
  fi

  exec alternative-command claude --model opus "${extra[@]}" "$@"
#+end_src
** =claude2=                                                       :wrapper:
A second Claude identity with its own login/session store, kept fully isolated
from the primary [[*=claude=][=claude=]]: [[https://docs.anthropic.com/en/docs/claude-code/settings#environment-variables][=CLAUDE_CONFIG_DIR=]] points it at =~/.claude2=, so
it can stay logged into a different account. It exec's the =claude= wrapper, so
all the shared behavior (model/effort, VM permission handling, =SHELL=bash=,
cd-out-of-home) is inherited rather than duplicated; only the environment
differs.

Browser links (including the =/login= URL) open under the dedicated
=claude-login2= firefox profile — the same profile the [[file:wm.org::*Login menu][login menu]]'s =Claude2=
mode uses. =BROWSER= must be a bare executable (claude opens URLs via
=execFile= with no shell, so a =firefox -P …= string would fail); pointing it
at the [[*=firefox=][=firefox= wrapper]] and setting =HARIS_FIREFOX_PROFILE= lets the wrapper
inject the =-P= flag.
#+begin_src bash :tangle ~/.local/bin/claude2
  export CLAUDE_CONFIG_DIR="$HOME/.claude2"
  export HARIS_FIREFOX_PROFILE="claude-login2"
  export BROWSER="$HOME/.local/bin/firefox"
  exec claude "$@"
#+end_src
** =claude-route=
Decides whether the primary [[*=claude=][=claude=]] wrapper should launch the main identity or
fail over to [[*=claude2=][=claude2=]]. It reads the cached usage snapshot already maintained
by [[file:background.org::*Agent usage notifier][=ai-usage-notifier=]] so launch-time routing stays local and fast instead
of hitting Anthropic on every invocation.

Fail-open behavior is intentional:
- missing/unreadable cache => stay on primary =claude=
- stale cache (> 15 minutes old) => stay on primary =claude=
- missing/stale =claude2= data => stay on primary =claude=

The switch heuristic now prefers the identity with the healthier *active*
window mix instead of a single coarse weighted percentage:
- treat inactive windows as informational only; they do not constrain routing
- make weekly pressure the dominant signal once it gets near exhaustion, since
  it resets far later than the 5-hour session bucket
- still refuse to route into a near-capped =claude2= session, even if its
  weekly bucket is healthier
- use a blended pressure score only as a last tie-breaker
#+begin_src python :tangle ~/.local/bin/claude-route :tangle-mode (identity #o755)
  #!/usr/bin/env python3
  import argparse
  import json
  import os
  import sys
  import time
  from pathlib import Path

  DEFAULT_MAX_AGE_SECS = 15 * 60
  DEFAULT_STATE_FILE = (
      Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local" / "state"))
      / "ai-usage-notifier"
      / "state.json"
  )
  PRIMARY_PREFIXES = {
      "name": "claude",
      "session": ("Claude|session:",),
      "week": ("Claude|weekly_all:", "Claude|weekly_scoped:"),
  }
  ALT_PREFIXES = {
      "name": "claude2",
      "session": ("Claude 2|session:", "Claude2|session:"),
      "week": (
          "Claude 2|weekly_all:",
          "Claude 2|weekly_scoped:",
          "Claude2|weekly_all:",
          "Claude2|weekly_scoped:",
      ),
  }
  CRITICAL_SESSION = 93.0
  CRITICAL_WEEK = 95.0
  PRIMARY_WEEK_ESCAPE = 90.0
  PRIMARY_SESSION_ESCAPE = 85.0
  ALT_SESSION_SAFETY = 88.0
  ALT_WEEK_SAFETY = 92.0
  WEEK_MARGIN = 8.0
  SESSION_MARGIN = 8.0
  BALANCED_MARGIN = 6.0
  SCORE_MARGIN = 10.0


  def parse_args():
      parser = argparse.ArgumentParser(
          description="Route Claude launches based on cached usage."
      )
      parser.add_argument(
          "--dry-run",
          action="store_true",
          help="print the computed inputs and decision instead of only the target",
      )
      parser.add_argument(
          "--state-file",
          type=Path,
          default=DEFAULT_STATE_FILE,
          help="override the usage cache path for testing",
      )
      return parser.parse_args()


  def load_state(path):
      try:
          return json.loads(path.read_text()), None
      except FileNotFoundError:
          return None, "missing"
      except (OSError, json.JSONDecodeError):
          return None, "unreadable"


  def state_age_secs(path):
      try:
          return max(0.0, time.time() - path.stat().st_mtime)
      except OSError:
          return None


  def entries_for_prefixes(state, prefixes):
      out = []
      for key, entry in state.items():
          if not isinstance(entry, dict):
              continue
          if not any(key.startswith(prefix) for prefix in prefixes):
              continue
          try:
              percent = float(entry.get("percent", 0))
          except (TypeError, ValueError):
              continue
          active = entry.get("active")
          if active is None:
              active = None
          else:
              active = bool(active)
          out.append({
              "percent": percent,
              "active": active,
              "resets_at": entry.get("resets_at"),
              "severity": entry.get("severity"),
          })
      return out


  def effective_percent(entries):
      active_entries = [entry for entry in entries if entry["active"] is True]
      if active_entries:
          return max(entry["percent"] for entry in active_entries), True
      unknown_entries = [entry for entry in entries if entry["active"] is None]
      if unknown_entries:
          return max(entry["percent"] for entry in unknown_entries), False
      return 0.0, True


  def summarize_identity(state, spec):
      sesh_entries = entries_for_prefixes(state, spec["session"])
      week_entries = entries_for_prefixes(state, spec["week"])
      present = bool(sesh_entries or week_entries)
      sesh, sesh_active_known = effective_percent(sesh_entries)
      week, week_active_known = effective_percent(week_entries)
      score = 0.45 * sesh + 0.55 * week
      peak = max(sesh, week)
      hot = (
          week >= 80.0
          or sesh >= 72.0
          or (sesh >= 60.0 and week >= 65.0)
          or score >= 74.0
      )
      critical = sesh >= CRITICAL_SESSION or week >= CRITICAL_WEEK or score >= 90.0
      return {
          "name": spec["name"],
          "present": present,
          "sesh": sesh,
          "week": week,
          "score": score,
          "peak": peak,
          "hot": hot,
          "critical": critical,
          "sesh_active_known": sesh_active_known,
          "week_active_known": week_active_known,
      }


  def decide(state, age_secs):
      primary = summarize_identity(state, PRIMARY_PREFIXES)
      alt = summarize_identity(state, ALT_PREFIXES)

      target = "claude"
      decision = "primary-ok"
      reasons = []
      if age_secs is None:
          decision = "fail-open"
          reasons = ["state-age-unavailable"]
      elif age_secs > DEFAULT_MAX_AGE_SECS:
          decision = "fail-open"
          reasons = [f"state-stale>{DEFAULT_MAX_AGE_SECS}s"]
      elif not primary["present"]:
          decision = "fail-open"
          reasons = ["primary-missing"]
      elif not alt["present"]:
          decision = "primary-only-cache"
          reasons = ["claude2-missing"]
      else:
          week_gap = primary["week"] - alt["week"]
          sesh_gap = primary["sesh"] - alt["sesh"]
          score_gap = primary["score"] - alt["score"]
          if primary["hot"]:
              reasons.append("primary-hot")
          if alt["critical"]:
              reasons.append("claude2-critical")
          if (
              primary["week"] >= PRIMARY_WEEK_ESCAPE
              and week_gap >= WEEK_MARGIN
              and alt["sesh"] <= ALT_SESSION_SAFETY
              and not alt["critical"]
          ):
              target = "claude2"
              decision = "switch-weekly-headroom"
              reasons = [
                  f"weekly-gap={week_gap:.2f}",
                  f"claude2-session={alt['sesh']:.2f}",
              ]
          elif (
              primary["sesh"] >= PRIMARY_SESSION_ESCAPE
              and sesh_gap >= SESSION_MARGIN
              and alt["week"] <= ALT_WEEK_SAFETY
              and not alt["critical"]
          ):
              target = "claude2"
              decision = "switch-session-headroom"
              reasons = [
                  f"session-gap={sesh_gap:.2f}",
                  f"claude2-weekly={alt['week']:.2f}",
              ]
          elif (
              primary["hot"]
              and sesh_gap >= BALANCED_MARGIN
              and week_gap >= BALANCED_MARGIN
              and not alt["critical"]
          ):
              target = "claude2"
              decision = "switch-balanced-headroom"
              reasons = [
                  f"session-gap={sesh_gap:.2f}",
                  f"weekly-gap={week_gap:.2f}",
              ]
          elif primary["hot"] and score_gap >= SCORE_MARGIN and not alt["critical"]:
              target = "claude2"
              decision = "switch-score-gap"
              reasons = [f"score-gap={score_gap:.2f}"]
          else:
              if primary["week"] >= PRIMARY_WEEK_ESCAPE:
                  reasons.append("primary-weekly-hot")
              if primary["sesh"] >= PRIMARY_SESSION_ESCAPE:
                  reasons.append("primary-session-hot")
              if week_gap < WEEK_MARGIN:
                  reasons.append(f"weekly-gap<{WEEK_MARGIN:g}")
              if sesh_gap < SESSION_MARGIN:
                  reasons.append(f"session-gap<{SESSION_MARGIN:g}")
              if score_gap < SCORE_MARGIN:
                  reasons.append(f"score-gap<{SCORE_MARGIN:g}")
          if not reasons:
              reasons = ["primary-not-hot"]

      return {
          "target": target,
          "decision": decision,
          "reasons": reasons,
          "state_age_secs": age_secs,
          "primary": primary,
          "alt": alt,
      }


  def print_dry_run(result, state_file):
      print(f"target={result['target']}")
      print(f"decision={result['decision']}")
      print(f"primary_sesh={result['primary']['sesh']:.2f}")
      print(f"primary_week={result['primary']['week']:.2f}")
      print(f"primary_peak={result['primary']['peak']:.2f}")
      print(f"primary_score={result['primary']['score']:.2f}")
      print(f"primary_hot={str(result['primary']['hot']).lower()}")
      print(
          "primary_active_known="
          f"{str(result['primary']['sesh_active_known'] and result['primary']['week_active_known']).lower()}"
      )
      print(f"claude2_present={str(result['alt']['present']).lower()}")
      print(f"claude2_sesh={result['alt']['sesh']:.2f}")
      print(f"claude2_week={result['alt']['week']:.2f}")
      print(f"claude2_peak={result['alt']['peak']:.2f}")
      print(f"claude2_score={result['alt']['score']:.2f}")
      print(f"claude2_critical={str(result['alt']['critical']).lower()}")
      print(
          "claude2_active_known="
          f"{str(result['alt']['sesh_active_known'] and result['alt']['week_active_known']).lower()}"
      )
      if result["state_age_secs"] is None:
          print("state_age_secs=")
      else:
          print(f"state_age_secs={result['state_age_secs']:.0f}")
      print(f"state_file={state_file}")
      print(f"reasons={','.join(result['reasons'])}")


  def main():
      args = parse_args()
      state, err = load_state(args.state_file)
      if state is None:
          result = {
              "target": "claude",
              "decision": "fail-open",
              "reasons": [f"state-{err}"],
              "state_age_secs": None,
              "primary": summarize_identity({}, PRIMARY_PREFIXES),
              "alt": summarize_identity({}, ALT_PREFIXES),
          }
      else:
          result = decide(state, state_age_secs(args.state_file))

      if args.dry_run:
          print_dry_run(result, args.state_file)
      else:
          print(result["target"])
      return 0


  if __name__ == "__main__":
      sys.exit(main())
#+end_src
** =opencode=                                                      :wrapper:
#+begin_src shell :tangle ~/.local/bin/opencode
  if [ "$(pwd)" = ~ ]; then
      mkdir -p ~/.empty
      cd ~/.empty/
  fi
  bunx opencode-ai@latest "$@"
#+end_src
* Utilities
** =alacritty-pane-cwd=
Print the current working directory of the active tmux pane in the calling
alacritty window. Falls back to =$HOME= if detection fails.
#+begin_src bash :tangle ~/.local/bin/alacritty-pane-cwd
  ALACRITTY_PID=$(xdotool getactivewindow getwindowpid 2>/dev/null)
  if [ -z "$ALACRITTY_PID" ]; then
      echo "$HOME"
      exit
  fi

  CHILD_PID=$(pgrep -P "$ALACRITTY_PID" | head -1)
  CHILD_TTY=$(readlink "/proc/$CHILD_PID/fd/0" 2>/dev/null)

  SESSION=$(tmux list-clients -F '#{client_tty} #{session_name}' 2>/dev/null \
      | awk -v tty="$CHILD_TTY" '$1 == tty {print $2}')

  if [ -n "$SESSION" ]; then
      tmux display-message -t "$SESSION" -p '#{pane_current_path}'
  else
      readlink "/proc/$CHILD_PID/cwd" 2>/dev/null || echo "$HOME"
  fi
#+end_src
** =edit-file=
GUI editor dispatcher: opens a file in the most appropriate window. If the
file's worktree/project is already open in a running *VS Code window*, the file
is reused in that instance via =code -g= (so it lands in the right window
instead of a stray one); otherwise it opens in =myemacs -c= (wrapped in
[[*=smart-launch=][=smart-launch=]] so the GUI frame is placed like the =code= binding's). VS Code's
=windowsState.openedWindows= (in its globalStorage =storage.json=) lists the
folders of currently-open windows; the longest folder that is an ancestor of
the file wins, picking the most specific worktree. Gated on VS Code actually
running so a stale (post-crash) window list can't spawn a fresh instance.

This is the editor half of [[*=alacritty-hint-open=][=alacritty-hint-open=]] (which adds URL dispatch and a
missing-file fallback on top), factored out so it can also serve as the desktop
default file handler (see [[file:gui.org::*edit-file][=edit-file.desktop=]]) and as =$VISUAL=.

A =file://= URI (as handed over by a =.desktop= launcher's =%U=) is decoded to a
path. A trailing =:line= or =:line:col= suffix is split off and translated into
VS Code's =-g file:line:col= or emacsclient's =+line:col= so the cursor lands
there. Relative paths resolve against =$PWD=. With =--wait= the editor blocks
until the file is closed, so this can be invoked as =$VISUAL= (a non-existent
file is opened as a fresh buffer rather than rejected).

Usage: =edit-file [--wait] TARGET=
#+begin_src bash :tangle ~/.local/bin/edit-file
  wait=""
  if [ "$1" = "--wait" ]; then
      wait=1
      shift
  fi

  target="$1"
  [ -z "$target" ] && exit 0

  # Desktop launchers hand us a file:// URI; decode it to a plain path.
  case "$target" in
      file://*)
          target="$(python3 -c 'import sys, urllib.parse; print(urllib.parse.unquote(sys.argv[1][7:]))' "$target")" ;;
  esac

  # Peel off an optional :line[:col] suffix.
  file="$target"
  line=""
  col=""
  if [[ "$target" =~ ^(.+):([0-9]+)(:([0-9]+))?$ ]]; then
      file="${BASH_REMATCH[1]}"
      line="${BASH_REMATCH[2]}"
      col="${BASH_REMATCH[4]}"
  fi

  # Expand a leading ~ and resolve relative paths against the cwd.
  case "$file" in
      "~") file="$HOME" ;;
      "~/"*) file="$HOME/${file#"~/"}" ;;
      /*) ;;
      *) file="$PWD/$file" ;;
  esac

  # Prefer a running VS Code window whose open folder contains this file (i.e.
  # the file's worktree/project is already open there). VS Code records the
  # folders of currently-open windows in `windowsState.openedWindows` of its
  # globalStorage; we pick the longest folder that is an ancestor of the file,
  # which naturally resolves to the most specific worktree. Gated on VS Code
  # actually running, so a stale (post-crash) window list can't launch a fresh
  # instance instead of falling through to Emacs.
  if pgrep -x code >/dev/null 2>&1; then
      vscode_folder="$(
          python3 - "$file" <<'PY'
  import json, os, sys, urllib.parse
  target = os.path.realpath(sys.argv[1])
  store = os.path.expanduser("~/.config/Code/User/globalStorage/storage.json")
  try:
      windows = json.load(open(store)).get("windowsState", {}).get("openedWindows", [])
  except Exception:
      sys.exit(0)
  best = ""
  for w in windows:
      uri = w.get("folder", "")
      if not uri.startswith("file://"):
          continue
      folder = os.path.realpath(urllib.parse.unquote(uri[len("file://"):]))
      if (target == folder or target.startswith(folder + os.sep)) and len(folder) > len(best):
          best = folder
  if best:
      print(best)
  PY
      )"
      if [ -n "$vscode_folder" ]; then
          goto="$file"
          [ -n "$line" ] && goto="$file:$line${col:+:$col}"
          # Thin-client reuse of the running window; skip the memory-scoped
          # `code` wrapper (no new heavyweight process is being spawned).
          exec alternative-command code ${wait:+--wait} -g "$goto"
      fi
  fi

  # No matching VS Code window: open in Emacs, translating the :line[:col]
  # suffix into emacsclient's +line:col position argument.
  pos=()
  if [ -n "$line" ]; then
      if [ -n "$col" ]; then
          pos=("+$line:$col")
      else
          pos=("+$line")
      fi
  fi

  exec smart-launch myemacs -c ${wait:+--wait} "${pos[@]}" "$file"
#+end_src
** =visual-editor=
Delegates to [[*=edit-file=][=edit-file=]] in blocking mode so it can back =$VISUAL= (git commit
messages, etc.).
#+begin_src shell :tangle ~/.local/bin/visual-editor
  exec edit-file --wait "$@"
#+end_src
** =editor=
#+begin_src shell :tangle ~/.local/bin/editor
  exists() {
      which "$1" >/dev/null
  }
  if exists myemacs; then
      smart-launch myemacs -c "$@"
  elif exists nvim; then
      nvim "$@"
  elif exists vim; then
      vim "$@"
  elif exists nvim; then
      vi "$@"
  fi
#+end_src
** =abspath=
#+begin_src bash :tangle ~/.local/bin/abspath
  pushd "$(dirname "$1")" >/dev/null
  echo "$PWD/$(basename "$1")"
  popd >/dev/null
#+end_src
** =askpass=
#+begin_src bash :tangle ~/.local/bin/askpass
  # Usage: askpass [PROMPT] [WINDOW_TITLE] [NOTIFICATION]

  prompt="$1"
  window_title="$2"
  notification="$3"

  if [ "$TERM" != "dumb" ] && [ -t 0 ]; then
      if [ -n "$DISPLAY" ]; then
          id="$(notify-send "$window_title" "$notification" --print-id --expire-time 0)"
          trap "dunstify --close=$id" EXIT
      fi
      echo -n "$prompt: " >/dev/tty

      stty -echo </dev/tty
      head -1 </dev/tty | tr -d '\n'

      echo >/dev/tty
  else
      {
          echo SETTITLE "$window_title"
          echo SETDESC "$prompt"
          echo SETPROMPT Password:
          echo GETPIN
          echo BYE
      } | pinentry -g 2>&1 | sed -n "/^D/ s/^D //p" | tr -d '\n'
  fi
#+end_src
** =askpass-gui=                                                    :script:
#+begin_src bash :tangle ~/.local/bin/askpass-gui
  TERM=dumb askpass "$@"
#+end_src
** =ansible-become-askpass=                                         :script:
Password-source script for Ansible's =become_password_file= /
=ANSIBLE_BECOME_PASSWORD_FILE=. Emulates the prompt used by the =sudo= wrapper
so the experience is identical whether sudo is invoked directly or via Ansible.
#+begin_src bash :tangle ~/.local/bin/ansible-become-askpass
  askpass "[sudo] password for $(getent passwd "$USER" | cut -d: -f1)" "SUDO password" "Please enter your password"
#+end_src
** =cached=
A small wrapper to memoize a shell command's stdout to a file with a TTL.

Usage:
  - =cached <ttl> <key> <shell-command>= -- run =<shell-command>= under =sh=,
    caching its stdout under =<key>= for =<ttl>=. On a hit, just =cat= it. =<ttl>=
    accepts a bare integer (seconds) or a =sleep=-style suffix: =s=, =m=, =h=, =d=
    (e.g. =1h=, =30m=, =2d=).
  - =cached <ttl> <key> <cmd> <arg>...= -- same, but with =4+= positional args the
    command is exec'd directly (no shell), so no quoting is needed for trivial cases.
  - =cached --path <key>= -- print the cache file path.
  - =cached --rm <key>= -- delete the cache file (manual invalidation).
#+begin_src bash :tangle ~/.local/bin/cached
  # Usage:
  #   cached <ttl> <key> <shell-command>     ttl: integer seconds, or 30s|10m|1h|2d
  #   cached <ttl> <key> <cmd> <arg>...      with 4+ args, exec directly (no shell)
  #   cached --path <key>
  #   cached --rm <key>
  set -eu

  cache_dir="${XDG_CACHE_HOME:-$HOME/.cache}/haris/cached"

  key_path() {
      printf '%s/%s\n' "$cache_dir" "$(printf '%s' "$1" | tr -c 'A-Za-z0-9._-' '_')"
  }

  parse_ttl() {
      case "$1" in
          *[!0-9smhd]*|"") echo "cached: bad ttl: $1" >&2; exit 2 ;;
          *s) echo $(( ${1%s} )) ;;
          *m) echo $(( ${1%m} * 60 )) ;;
          *h) echo $(( ${1%h} * 3600 )) ;;
          *d) echo $(( ${1%d} * 86400 )) ;;
          *)  echo $(( $1 )) ;;
      esac
  }

  case "${1-}" in
      --path) key_path "$2"; exit 0 ;;
      --rm)   rm -f -- "$(key_path "$2")"; exit 0 ;;
      -h|--help|"")
          sed -n '2,5p' "$0" | sed 's/^# *//' >&2
          exit 2
          ;;
  esac

  ttl=$(parse_ttl "$1"); key=$2; shift 2
  file=$(key_path "$key")

  if [ -f "$file" ]; then
      age=$(( $(date +%s) - $(stat -c %Y "$file") ))
      if [ "$age" -le "$ttl" ]; then
          cat "$file"
          exit 0
      fi
  fi

  # One remaining arg: treat as a shell string (allows pipes/redirects).
  # Multiple args: exec directly, no shell quoting needed.
  if [ $# -eq 1 ]; then
      set -- sh -c "$1"
  fi

  mkdir -p "$cache_dir"
  tmp=$(mktemp "$cache_dir/.tmp.XXXXXX")
  trap 'rm -f "$tmp"' EXIT
  if "$@" >"$tmp"; then
      mv -- "$tmp" "$file"
      cat "$file"
  else
      rc=$?
      cat "$tmp"
      exit "$rc"
  fi
#+end_src
** =chx=
#+begin_src shell :tangle ~/.local/bin/chx
  chmod u+x "$@"
#+end_src
** =diffgpg=
#+begin_src bash :tangle ~/.local/bin/diffgpg
  # Compare the contents of two GPG encrypted files

  diff <(gpg --decrypt --output - "$1") <(gpg --decrypt --output - "$2") "${@:3}"
#+end_src
** =diffpiped=                                                      :script:
#+begin_src bash :tangle ~/.local/bin/diffpiped
  # Diff two files named $1 and $2, piped through a command given as the remaining
  # arguments.

  options=()

  for arg in "$@"; do
      if [[ "$arg" =~ ^- ]]; then
          options=("${options[@]}" "$arg")
          shift
      else
          break
      fi
  done

  file1="$1"
  file2="$2"

  shift 2

  tmp1="$(mktemp)"
  tmp2="$(mktemp)"

  cat "$file1" | "$@" > "$tmp1"
  cat "$file2" | "$@" > "$tmp2"

  diff --color=auto "${options[@]}" "$tmp1" "$tmp2"

  rm -f "$tmp1" "$tmp2"
#+end_src
#+NAME: diffpiped/test
#+begin_src bash :tangle no
  diffpiped --strip-trailing-cr <(echo -e "a\nb") <(echo -e "a\nB") sed 's/a/A/g'
#+end_src
** =fcmd=
#+begin_src bash :tangle ~/.local/bin/fcmd
  type "$@" 2>/dev/null | awk '{print $3}'
  exit "${PIPESTATUS[0]}"
#+end_src
** =lscf=
Parses the contents of the [[*=cf=][cf]] script to obtain all the configurations that can
be listed using it. In addition it shows the =*.org= files in [[~/.haris/]].
#+begin_src shell :tangle ~/.local/bin/lscf
  for f in ~/.haris/*.org; do
      basename "$f"
  done
  cat $(fcmd cf) | sed -n 's/\s*\([^\*]\+\)).*/\1/p'
#+end_src
** =ls-wallpapers=
#+begin_src bash :tangle ~/.local/bin/ls-wallpapers
  lookup_dirs=(
      ~/.local/share/wallpapers
      ~/.local/share/backgrounds
      /usr/local/share/wallpapers
      /usr/local/share/backgrounds
      /usr/share/wallpapers
      /usr/share/backgrounds
  )

  fd . "${lookup_dirs[@]}" 2>/dev/null
#+end_src
** =printarg=
#+begin_src bash :tangle ~/.local/bin/printarg
  # Print commandline arguments passed to this function each on its own line
  printf "%q\n" "$@"
#+end_src
** =rmws=
#+begin_src shell :tangle ~/.local/bin/rmws
  # Remove whitespace from a file (or stdin if input is from a pipe) and write the
  # output to stdout (or rewrite the file if the -i option is given)

  [ ! -t 0 ] &&\
      cat | sed 's:\s\+$::' ||\
          sed 's:\s\+$::' "$@"
#+end_src
** =trim=
#+begin_src shell :tangle ~/.local/bin/trim
  # Remove trailing newline from stdin

  echo -n "$(cat)"
#+end_src
** =adhoc=
#+begin_src bash :tangle ~/.local/bin/adhoc
  # Create an ad-hoc file, edit it in $EDITOR and then print its path. If a '-'
  # argument is given, the file contents are printed instead of its path.

  destdir="/tmp/adhoc-files"
  mkdir -p "$destdir"
  cd "$destdir"

  if [ "$#" != 0 ] && [ "$1" = "-" ]; then
      print_content=true
      files=("${@:2}")
  else
      files=("$@")
  fi

  # Convert files to realpaths
  readarray -t files < <(realpath "${files[@]}" 2>/dev/null)

  if [ -z "$files" ]; then
      files=("$(mktemp "$destdir"/XXXXXXXXXXX)")
  fi

  smart-launch myemacs -c --wait "${files[@]}" >&2

  if [ -n "$print_content" ]; then
      cat "${files[@]}"
  else
      realpath "${files[@]}"
  fi
#+end_src
** =cmd-with-notify=
#+begin_src shell :tangle ~/.local/bin/cmd-with-notify
  if [ "$TERM" = "linux" ]; then
      "$@"
      exit
  fi

  "$@" && notify-send "Command $* exited successfully." || {
          err=$?
          notify-send -u critical "Command $* exited with error $err."
      }
  exit $err
#+end_src
*** Completions
#+begin_src fish :tangle ~/.config/fish/completions/cmd-with-notify.fish
  complete --command cmd-with-notify -f -a '(complete -C(commandline -cp | sed "s:\S\+::"))'
#+end_src
** =delayed-command=
#+begin_src bash :tangle ~/.local/bin/delayed-command
  sleep "$1"
  exec "${@:2}"
#+end_src
*** Completions
#+begin_src fish :tangle ~/.config/fish/completions/delayed-command.fish
  complete -c delayed-command -a '(complete -C "command ")'
#+end_src
** =xpreset=
#+begin_src shell :tangle ~/.local/bin/xpreset
  [ "$#" != 1 ] && exit 1

  ln -sf .xinitrc-"$1" ~/.xinitrc
#+end_src
*** Fish completions
#+HEADER: :tangle-mode (identity #o644)
#+begin_src fish :tangle ~/.config/fish/completions/xpreset.fish
  complete -c xpreset -f -a "(pushd ~; ls .xinitrc-* | string replace .xinitrc- ''; popd)"
#+end_src
** =xrandr-toggle=
#+begin_src shell :tangle ~/.local/bin/xrandr-toggle
  n="$(xrandr --listmonitors | head -1 | awk '{print $NF}')"

  [ "$n" = 1 ] && {\
                   xrandr2 --auto
                   MSG='enabled'
  } || {\
        xrandr2 --off
        MSG='disabled'
  }
  [ "$?" = 0 ] && notify-send "second monitor sucessfully $MSG" || notify-send -u "monitor operation unsuccessful"

  # Fix wallpaper on second monitor
  feh --bg-fill .wallpaper
#+end_src
** =xrandr2=
#+begin_src shell :tangle ~/.local/bin/xrandr2
  # Wrapper for xrandr command with some options applied based on my current
  # monitor configuration

  xrandr --output HDMI-1-0 "$@" --pos 1920x1080
#+end_src
** =pipetest=
#+begin_src bash :tangle ~/.local/bin/pipetest
  # Create three tmux panes:
  # - A SOURCE text file opened in vim
  # - A SCRIPT file opened in vim
  # - An output buffer that shows the results of processing SOURCE with SCRIPT
  #
  # The SOURCE is supplied to the SCRIPT via pipe, i.e. the output buffer shows
  # the results of:
  #
  # SCRIPT < SOURCE
  #
  # The output automatically updates when one of SCRIPT, SOURCE changes.
  #
  # USAGE: pipetest [SOURCE] [SCRIPT]
  #
  # If the optional arguments SCRIPT and SOURCE are given, the SCRIPT and SOURCE
  # buffers will have an initial content equal to the content of those files.

  vim_executable=vim
  if command -v nvim >/dev/null; then
      vim_executable=nvim
  fi
  temp_dir="$(mktemp -d)"

  INITIAL_SOURCE="$1"
  INITIAL_SCRIPT="$2"

  [ -z "$INITIAL_SOURCE" ] && INITIAL_SOURCE=/dev/null
  [ -z "$INITIAL_SCRIPT" ] && INITIAL_SCRIPT=/dev/null

  if [ "$#" -gt 2 ]; then
      echo "Too many arguments" >&2
      exit 1
  fi

  # Create a temporary file with content from stdin
  # Usage: create_file HANDLE <CONTENT
  # HANDLE is the name of the bash variable that will point to the file's path
  create_file() {
      local file
      file="$temp_dir/$1"
      if [ ! -t 0 ]; then
          cat > "$file"
      else
          touch "$file"
      fi

      declare -g "$1"="$file"
  }

  # Same as create_file but also marks it executable by the current user
  create_file_x() {
      create_file "$@"
      chmod u+x "${!1}"
  }

  # Create a fifo so the first and second windows can notify the third window of
  # changes
  fifo="$temp_dir/fifo"
  mkfifo "$fifo"

  # The source file (first buffer) that is being piped to SCRIPT
  create_file SOURCE < "$INITIAL_SOURCE"

  # The script file (second buffer) that will process the file and generate
  # output in the third buffer
  create_file_x SCRIPT < "$INITIAL_SCRIPT"

  #
  # Notifies the output terminal that some of the first two buffers have changed.
  #
  create_file_x on_change <<EOF
  <<pipetest_on_change>>
  EOF

  #
  # Supplementary vimrc file that is loaded by each vim session started from this
  # program.
  #
  create_file vimrc <<EOF
  <<pipetest_vimrc>>
  EOF

  #
  # Vim wrapper that loads our supplementary vimrc file.
  #
  create_file_x custom_vim <<EOF
  <<pipetest_custom_vim>>
  EOF

  #
  # Output script - script that is run in the third buffer that shows the output
  # of the user SCRIPT when applied to the SOURCE file.
  #
  create_file_x output_script <<EOF
  <<pipetest_output_script>>
  EOF

  #
  # Main script that launches tmux and everything.
  #
  create_file_x main_script <<EOF
  <<pipetest_main_script>>
  EOF

  tmux new "$main_script"

  #
  # Print the resulting script
  #
  cat "$SCRIPT"

  #
  # Remove created temporary directory
  #
  rm -rf "$temp_dir"
#+end_src
*** Helper scripts
These scripts are embedded into the =pipetest= script as heredocs, but we define
them as code blocks here for better readability.
**** =on_change=
#+NAME: pipetest_on_change
#+begin_src shell
  echo > "$fifo"
#+end_src
**** =vimrc=
#+NAME: pipetest_vimrc
#+begin_src text
  " On write run the on_change script
  autocmd BufWritePost * silent !$on_change
  autocmd ExitPre $SOURCE,$SCRIPT silent !tmux kill-session
#+end_src
**** =custom_vim=
#+NAME: pipetest_custom_vim
#+begin_src shell
  "$vim_executable" -c "source $vimrc" "\$@"
#+end_src
**** =output_script=
#+NAME: pipetest_output_script
#+begin_src shell
  echo "This is the output."
  echo "It will automatically refresh when either of the files change."
  echo "Press Ctrl+C here or quit any of the two vim instances to exit."

  trap "tmux kill-session" INT TERM EXIT

  while :; do
      #stty -echo
      read _ < "$fifo"
      [ "$?" != "0" ] && break
      clear
      "$SCRIPT" <"$SOURCE"
  done
#+end_src
**** =main_script=
#+NAME: pipetest_main_script
#+begin_src shell
  tmux split-window -h "$custom_vim" "$SCRIPT"
  tmux split-window -h sh -c 'cd "$(pwd)"; "$output_script"'
  tmux select-pane -L
  tmux select-layout even-horizontal

  "$custom_vim" "$SOURCE"
#+end_src
*** TODO consider extracting this script into its own project
** =auto-browser=
#+begin_src bash :tangle ~/.local/bin/auto-browser
  browser='firefox -P «eval-user-name()»'
  # If a firefox window is currently active, open the link in the active window
  if xprop -id "$(xdotool getactivewindow)" | grep -qi 'firefox'; then
      where='--new-tab'
  else # Otherwise open a new window
      where='--new-window'
  fi

  args="$(printf '%q ' "$@")"
  i3-msg exec "$browser $where $args"
#+end_src
*** Dependencies                                                     :deps:
#+begin_src text :tangle (haris/tangle-deps "auto-browser.pacman")
  xdotool xorg-xprop
#+end_src
** =alternative-command=
#+begin_src bash :tangle ~/.local/bin/alternative-command
  cmd="$(which -a "$1" | uniq | sed -n 2p)"

  exec "$cmd" "${@:2}"
#+end_src
** =curltb=
#+begin_src shell :tangle ~/.local/bin/curltb
  # Get https://termbin.com/<TERMBIN_BLOB> using curl
  # Usage: curltb TERMBIN_BLOB [CURL_OPTIONS]

  curl https://termbin.com/"$1" "${@:2}"
#+end_src
** =colortest=
#+begin_src bash :tangle ~/.local/bin/colortest
  # Print out all 256 colors in the terminals

  f=0
  l=256

  if [ -n "$1" ]; then
      l="$1"
  fi

  if [ -n "$2" ]; then
      f="$1"
      l="$2"
  fi

  (x=`tput op` y=`printf %40s`;for i in $(seq "$f" "$l");do o=00$i;echo -e ${o:${#o}-3:3} \
    `tput setaf $i;tput setab $i`${y// /=}$x;done)
#+end_src
** =myemacs-load=
Wrapper to [[*=myemacs=][myemacs]] that will load its first argument instead of opening it. The
remaining args simply passed to myemacs as usual. The main use for this is as a
shebang for elisp scripts.
*NOTE:* It must be implemented in such a convoluted way as a shell script, because
process management in emacs is shit.
#+NAME: myemacs-load
#+begin_src bash :tangle ~/.local/bin/myemacs-load :eval no
  tmpfile="$(mktemp)"
  cat >"$tmpfile" <<'EOF_c478eee3'
    <<stringify-arg-to-eval-option>>
  EOF_c478eee3

  if [ -t 0 ]; then
      input_file="$(realpath "$1")"
  else
      input_file="$(mktemp)"
      trap "$(printf "%q " rm -rf "$input_file")" ERR EXIT
      cat >"$input_file"
  fi

  arg="$(
      emacs --quick --batch --load "$tmpfile" "$input_file" "${@:2}"
  )"
  myemacs --no-tty --no-wait --eval "$arg" | sed '/^<<do-not-print-token>>$/d'

  rm -f "$tmpfile"
#+end_src
#+NAME: stringify-arg-to-eval-option
#+begin_src elisp :tangle no
  (let* ((file (car argv))
         (code `(progn
                  (defvar argv)
                  (defvar process-environment)
                  (defvar default-directory)
                  (let ((argv (list ,@(cdr argv)))
                        (process-environment (list ,@process-environment)))
                    (load ,file)
                    <<do-not-print-token>>))))
    (prin1 code))
#+end_src
#+CALL: stringify-arg-to-eval-option[:var argv='("a" "b")]()
Emacsclient prints the result of evaluation of =--eval=. The only non-hacky way I
know to disable this is to give it the =--suppress-output= option. But this would also
suppress desirable output like calls to =(message)=. So I put this token as the
last statement, and remove it from the output by piping to =sed=.
#+NAME: do-not-print-token
#+begin_src text
  "1617875f9593bd741b9637ad26aabb9f42ff3df769564f7881d7603a80ea0ae2"
#+end_src
** =o=
Wrapper command around the equivalent [[file:shells.org::*=o=][fish function]].
#+begin_src bash :tangle ~/.local/bin/o
  fish -c "o $(printf "%q " "$@")"
#+end_src
** =obsidian-open=
Open a path in Obsidian via its =obsidian://= URI scheme. Obsidian only opens
paths that belong to a registered vault, so if no vault covers the target this
registers it as a new vault first. A freshly registered vault is only picked up
if Obsidian wasn't already running.

Usage: =obsidian-open [PATH]= (defaults to the current directory).
#+begin_src bash :tangle ~/.local/bin/obsidian-open
  target="$(realpath -m "${1:-.}")"

  # Ensure some registered vault contains the target; register one if not.
  python3 - "$target" <<'PY'
  import json, os, secrets, sys, time
  target = sys.argv[1]
  cfg = os.path.expanduser("~/.config/obsidian/obsidian.json")
  try:
      with open(cfg) as f:
          data = json.load(f)
  except FileNotFoundError:
      data = {}
  vaults = data.setdefault("vaults", {})

  # The vault root is the dir itself, or the file's parent.
  root = target if os.path.isdir(target) else os.path.dirname(target)

  def covers(vpath):
      return root == vpath or root.startswith(vpath.rstrip("/") + "/")

  if not any(covers(v["path"]) for v in vaults.values()):
      vaults[secrets.token_hex(8)] = {"path": root, "ts": int(time.time() * 1000)}
      os.makedirs(os.path.dirname(cfg), exist_ok=True)
      with open(cfg, "w") as f:
          json.dump(data, f, indent=2)
  PY

  # Give freshly registered vaults our shared editor settings.
  obsidian-sync-settings >/dev/null 2>&1 || true

  xdg-open "obsidian://open?path=$(printf %s "$target" | urlencode)"
#+end_src
** Obsidian shared settings                                    :configurable:
Obsidian has no global settings — every option (Vim mode included) lives in each
vault's =.obsidian/app.json=. To get a "global" feel I keep one canonical
=app.json= and symlink each vault's copy to it, so a change in any vault (or here)
propagates to all. Edit this block for shared editor settings; the org file is
the source of truth, so a UI toggle that writes through the symlink is reverted
on the next tangle.
#+begin_src json :tangle ~/.config/obsidian/app.json :mkdirp yes
  {
    "vimMode": true
  }
#+end_src
** =obsidian-sync-settings=
Symlink the canonical [[*Obsidian shared settings][=app.json=]] into every
registered Obsidian vault (read from =~/.config/obsidian/obsidian.json=). Any
pre-existing regular =app.json= in a vault is backed up to =app.json.bak= first.
Re-run after adding vaults; [[*=obsidian-open=][=obsidian-open=]] also calls it.
#+begin_src bash :tangle ~/.local/bin/obsidian-sync-settings
  canonical="$HOME/.config/obsidian/app.json"
  registry="$HOME/.config/obsidian/obsidian.json"
  [ -f "$canonical" ] || { echo "obsidian-sync-settings: no canonical $canonical" >&2; exit 1; }
  [ -f "$registry" ]  || { echo "obsidian-sync-settings: no registry $registry" >&2; exit 0; }

  python3 -c 'import json,sys; print("\n".join(v["path"] for v in json.load(open(sys.argv[1]))["vaults"].values()))' \
    "$registry" | while IFS= read -r vault; do
    [ -d "$vault" ] || continue
    dir="$vault/.obsidian"
    dest="$dir/app.json"
    mkdir -p "$dir"
    # Already the right symlink? nothing to do.
    [ "$(readlink -- "$dest" 2>/dev/null)" = "$canonical" ] && continue
    # Preserve a real file before replacing it with the symlink.
    [ -e "$dest" ] && [ ! -L "$dest" ] && mv -- "$dest" "$dest.bak"
    ln -sf -- "$canonical" "$dest"
    echo "linked $dest"
  done
#+end_src
** =get-os-type=
Get the OS type.
#+begin_src shell :tangle ~/.local/bin/get-os-type
  cat /etc/lsb-release 2>/dev/null | grep -q 'Ubuntu'     && echo 'ubuntu' && exit
  cat /etc/os-release  2>/dev/null | grep -q 'Arch Linux' && echo 'arch'   && exit
  echo 'warning: get-os-type: Unsupported OS' >&2
  exit 1
#+end_src
** =get-self-ip=
#+begin_src shell :tangle ~/.local/bin/get-self-ip
  case "$(get-os-type)" in
      arch)   hostname -i | cut -f1 -d' ' ;;
      *)      hostname -I | cut -f1 -d' ' ;;
  esac
#+end_src
** =urlencode=
#+begin_src bash :tangle ~/.local/bin/urlencode
  python -c 'import urllib.parse as p; print(p.quote(input()))'
#+end_src
** =urldecode=
#+begin_src bash :tangle ~/.local/bin/urldecode
  python -c 'import urllib.parse as p; print(p.unquote(input()))'
#+end_src
** =fifo=
#+begin_src shell :tangle ~/.local/bin/fifo
  mkfifo /tmp/fifo 2>/dev/null

  session_exists() {
      env TMUX= tmux has-session -t fifo 2>/dev/null
  }

  create_session() {
      env TMUX= tmux new -s fifo "$@" tail --follow=name /tmp/fifo
  }

  if [ -t 0 ]; then
      if session_exists; then
          env TMUX= tmux attach -t fifo
      else
          create_session
      fi
  else
      if ! session_exists; then
          create_session -d || true
      fi
      # Writing to /tmp/fifo blocks until a reader (the tmux `tail` session)
      # is attached. If tmux can't start (e.g. when called from a systemd
      # user service), `tee` would hang forever — and a `timeout`-killed tee
      # may not flush stdout, so callers doing `| fifo >&2` would see empty
      # lines. So: slurp stdin, always emit to stdout first, then try the
      # fifo as a best-effort side-channel.
      input=$(cat)
      printf '%s\n' "$input"
      printf '%s\n' "$input" | timeout 1 dd of=/tmp/fifo 2>/dev/null || true
  fi
#+end_src
** =get-random-unused-port=                                         :script:
#+begin_src bash :tangle ~/.local/bin/get-random-unused-port
  # This piece of magic was generated by ChatGPT. Don't try to understand it, just
  # accept it.
  comm -23 <(seq 49152 65535 | sort) <(ss -tan | awk '{print $4}' | cut -d':' -f2 | sort -u) | shuf | head -n 1
#+end_src
** =portkill=
#+begin_src bash :tangle ~/.local/bin/portkill
  set -eu
  if [ "$#" -lt 1 ]; then
      echo "Usage: portkill <port> [<port>...]" >&2
      exit 1
  fi
  for port in "$@"; do
      out="$(lsof -nPi :"$port" || true)"
      if [ -z "$out" ]; then
          echo "No processes found on port $port" >&2
          continue
      fi
      header="$(echo "$out" | head -n 1)"
      echo "$out" | tail -n +2 | grep LISTEN | while IFS= read -r line; do
          pid="$(echo "$line" | awk '{print $2}')"
          echo "$header"
          echo "$line"
          printf 'Kill? [y/N]: '
          read -r ans </dev/tty
          case "$ans" in
              y|Y|yes|YES) kill "$pid" && echo "Killed $pid" ;;
              *) echo "Skipped $pid" ;;
          esac
      done
  done
#+end_src
** =docker-ls-context=
#+begin_src bash :tangle ~/.local/bin/docker-ls-context
  tag="$(date +%s%3N | sha256sum | head -c 32)"
  docker image build --tag "$tag" --no-cache -f - "$@" >&2 <<'EOF'
  «docker-ls-context/dockerfile»
  EOF

  docker run --rm "$tag"
  docker rmi "$tag" >&2
#+end_src
#+NAME: docker-ls-context/dockerfile
#+begin_src dockerfile
  FROM busybox
  WORKDIR /workdir
  COPY . .
  CMD find . | grep -v '^\.$'
#+end_src
** =info=
#+begin_src bash :tangle ~/.local/bin/info
  if [ -t 2 ]; then echo -ne "\033[1;32m" >&2; fi
  echo "$@" | fifo >&2
  if [ -t 2 ]; then echo -ne "\033[0m" >&2; fi
#+end_src
** =debug=
#+begin_src bash :tangle ~/.local/bin/debug
  if [ -t 2 ]; then echo -ne "\033[1;33m" >&2; fi
  bash -c 'printf "%q " "$@"' -s "$@" >&2
  echo | fifo >&2
  if [ -t 2 ]; then echo -ne "\033[0m" >&2; fi

  "$@"
#+end_src
** =warn=
#+begin_src bash :tangle ~/.local/bin/warn
  if [ -t 2 ]; then echo -ne "\033[1;33m" >&2; fi
  echo "$@" | fifo >&2
  if [ -t 2 ]; then echo -ne "\033[0m" >&2; fi
#+end_src
** =error=
#+begin_src bash :tangle ~/.local/bin/error
  if [ -t 2 ]; then echo -ne "\033[1;31m" >&2; fi
  echo "$@" | fifo >&2
  if [ -t 2 ]; then echo -ne "\033[0m" >&2; fi
  notify-send --urgency=critical "$@"
#+end_src
** =dragon=
#+begin_src bash :tangle ~/.local/bin/dragon
  set -- --on-top --thumb-size 32 "$@"

  if which dragon-drag-and-drop &>/dev/null; then
      dragon-drag-and-drop "$@"
  elif which dragon-drop &>/dev/null; then
      dragon-drop "$@"
  else
      alternative-command dragon "$@"
  fi
#+end_src
** =tee-notify=
#+begin_src shell :tangle ~/.local/bin/tee-notify
  content="$(cat)"
  notify-send "tee-notify" "$content"
  echo "$content"
#+end_src
** =get-cert=
#+begin_src shell :tangle ~/.local/bin/get-cert
  {
      timeout 0.5 openssl s_client -connect "$1" -showcerts 2>/dev/null
      true
  } | awk '/^-----BEGIN CERTIFICATE-----$/,/^-----END CERTIFICATE-----$/'
#+end_src
** =forever=
#+begin_src shell :tangle ~/.local/bin/forever
  while :; do
      command "$@"
      sleep 2
  done
#+end_src
** =PR=
Create a BitBucket PR.
#+begin_src bash :tangle ~/.local/bin/PR
  uriEncode() {
      tr -d '\n' | jq -sRr @uri
  }

  source_branch="$1"
  dest_branch="$2"

  if [ -z "$source_branch" ]; then
      source_branch="$(git branch --show-current | tr -d '\n')"
  fi
  source_branch_enc="$(uriEncode <<<"$source_branch")"
  if [ -z "$dest_branch" ]; then
      dest_branch="$(
          {
              git config init.defaultBranch
              git branch | sed 's/^..//'
          } | head -1
      )"
  fi
  dest_branch_enc="$(uriEncode <<<"$dest_branch")"
  remote="$(git remote get-url upstream 2>/dev/null)"
  if [ -z "$remote" ]; then
      remote="$(git remote get-url origin)"
  fi

  if [ -z "$remote" ]; then
      echo "Either upstream or origin remote must exist"
  fi

  if [[ ! "$remote" =~ .*bitbucket\.org.* ]]; then
      echo "Only BitBucket is supported currently"
      exit 1
  fi

  bitbucket_repo="$(
      echo "$remote" |
          sed  's_.*bitbucket\.org[:/]__' |
          grep '^[^/]\+/[^/]\+' |
          sed  's_\.git$__'
  )"
  url="https://bitbucket.org/$bitbucket_repo/pull-requests/new?source=$source_branch_enc&dest=$dest_branch_enc"

  echo "Opening a PR in the browser..."

  echo "Source branch: $source_branch"
  echo "Destination branch: $dest_branch"
  echo "BitBucket repo: $bitbucket_repo"
  echo "PR URL: $url"

  gtk-launch "$(xdg-settings get default-web-browser)" "$url"
#+end_src
** =mosquitto_sub_yq=
#+begin_src bash :tangle ~/.local/bin/mosquitto_sub_yq
  mosquitto_sub \
      -F '{"topic": "%t",\n"body": %p}' \
      "$@" |
      while :; do
          echo
          yq -P \
             2> >(grep -v "Error: bad file '-': yaml: line [0-9]\+: did not find expected <document start>")
      done
#+end_src
*** Completions
#+begin_src fish :tangle ~/.config/fish/completions/mosquitto_sub_yq.fish
  complete -c mosquitto_sub_yq --wraps mosquitto_sub
#+end_src
** =mosquitto_sub_jq=
#+begin_src bash :tangle ~/.local/bin/mosquitto_sub_jq
  mosquitto_sub \
      -F '{"topic": "%t",\n"body": %p}' \
      "$@" |
      while :; do
          echo
          jq
      done
#+end_src
*** Completions
#+begin_src fish :tangle ~/.config/fish/completions/mosquitto_sub_jq.fish
  complete -c mosquitto_sub_jq --wraps mosquitto_sub
#+end_src
** =@gh=
Clone a Github repo using the given URL (HTTPS or SSH) and execute the given
command there.
#+begin_src bash :tangle ~/.local/bin/@gh
  if [ "$#" -lt 3 ]; then
      echo "Usage: @gh REPO_URL [BRANCH_OR_COMMIT] COMMAND [ARGS...]"
      exit 1
  fi

  ref="$2"

  mkdir -p ~/.cache/haris/tmp-{commits,repos}
  (cd ~/.cache/haris/tmp-commits && git init --bare &>/dev/null)

  dest=~/.cache/haris/tmp-repos/"$(echo "$1" | sed 's|[:/]|_|g')_$ref"

  git clone \
      --reference ~/.cache/haris/tmp-commits \
      --depth 1 --no-checkout "$1" "$dest" 2> \
      >(sed -E 's/fatal: (destination path)/info: \1/g' >&2)

  cd "$dest" || exit 1
  git fetch origin "$ref"
  git checkout FETCH_HEAD
  shift 2
  exec "$@"
  rm -rf "$tmpdir"
#+end_src
** =with-xdg=
Run a command in the specified directory used for all XDG base directories.
#+begin_src bash :tangle ~/.local/bin/with-xdg
  dir="$1"
  shift 1

  _mkdir() {
      mkdir -p "$1"
      echo "$1"
  }

  export XDG_CONFIG_HOME="$(_mkdir "$dir/config")"
  export XDG_CACHE_HOME="$(_mkdir "$dir/cache")"
  export XDG_DATA_HOME="$(_mkdir "$dir/data")"
  export XDG_DATA_DIRS="$(_mkdir "$dir/data")"
  export XDG_RUNTIME_DIR="$(_mkdir "$dir/runtime")"
  export XDG_STATE_HOME="$(_mkdir "$dir/state")"

  exec "$@"
#+end_src
** =noxdg=
Reset all XDG environment variables to mimic a fresh user environment.
#+begin_src bash :tangle ~/.local/bin/noxdg
  tmpdir="$(mktemp -d)"
  echo "TMPDIR: $tmpdir" >&2
  with-xdg "$tmpdir" "$@"
#+end_src
** =in=
Run a command in a given directory.
#+begin_src bash :tangle ~/.local/bin/in
  print_help() {
      echo "Usage: in <directory> <command> [args...]"
      echo "Runs the specified command in the given directory."
  }

  dir="$1"
  shift 1

  (
      cd "$dir" || exit 1
      exec "$@"
  )
#+end_src
*** Completions
#+begin_src fish :tangle ~/.config/fish/completions/in.fish
  function __haris_complete_in
      set -l argv (commandline -opc) (commandline -t)
      set -l cursor_index (count $argv)
      if [ "$cursor_index" -gt 2 ]
          complete -C "command $(echo $argv[3..])"
      else
          complete -C "ls $argv[2]"
      end
  end
  complete -c in -fa '(__haris_complete_in)'
#+end_src
** =git-haris-setup=
#+begin_src bash :tangle ~/.local/bin/git-haris-setup
  # Setup git remotes for Haris' workflow
  # - If origin exists and doesn't start with "myghg:" and there's no upstream, rename origin to upstream
  # - Create remote "me" pointing to git@veracioux.me:<directory-basename>

  # Check if we're in a git repository
  if ! git rev-parse --git-dir >/dev/null 2>&1; then
      echo "Error: Not in a git repository"
      exit 1
  fi

  # Get current directory basename for the remote URL
  dir_basename="$(basename "$(pwd)")"

  # Check if origin remote exists
  if git remote get-url origin >/dev/null 2>&1; then
      origin_url="$(git remote get-url origin)"

      # Check if origin doesn't start with "myghg:" and there's no upstream remote
      if [[ ! "$origin_url" =~ ^myghg: ]] && ! git remote get-url upstream >/dev/null 2>&1; then
          echo "Renaming origin to upstream..."
          git remote rename origin upstream
          echo "Remote 'origin' renamed to 'upstream'"
      else
          echo "Origin remote already configured correctly or upstream exists"
      fi
  else
      echo "No origin remote found"
  fi

  # Create or update the "me" remote
  if git remote get-url me >/dev/null 2>&1; then
      echo "Remote 'me' already exists"
  else
      echo "Creating remote 'me' pointing to git@veracioux.me:$dir_basename..."
      git remote add me "git@veracioux.me:$dir_basename"
      echo "Remote 'me' created successfully"
  fi

  # Create or update the "me-eo" remote
  if git remote get-url me-eo >/dev/null 2>&1; then
      echo "Remote 'me-eo' already exists"
  else
      echo "Creating remote 'me-eo' pointing to me-git@veracioux.me:$dir_basename..."
      git remote add me-eo "eo-git@veracioux.me:$dir_basename"
      echo "Remote 'me-eo' created successfully"
  fi

  # Show final remote configuration
  echo
  echo "Current remotes:"
  git remote -v
#+end_src
** =git-wt-for=
Run a command in every worktree of the current repository.
#+begin_src bash :tangle ~/.local/bin/git-wt-for
  # Usage: git wt-for <command> [args...]
  set -e
  if [ $# -eq 0 ]; then
      echo "Usage: git wt-for <command> [args...]" >&2
      exit 1
  fi
  status=0
  while IFS= read -r path; do
      [ -z "$path" ] && continue
      echo "=== $path ==="
      (cd "$path" && "$@") || status=$?
  done < <(git worktree list --porcelain | awk '/^worktree /{print substr($0, 10)}')
  exit $status
#+end_src
** Utilities for AI agents
Utility scripts for AI agents to use.
*** =git-commit-from-editmsg=
#+begin_src shell :tangle ~/.local/bin/git-commit-from-editmsg
  git commit --file "$(git rev-parse --git-dir)"/COMMIT_EDITMSG
#+end_src
*** =git-dotharis-commit=
Thin wrapper around =git commit= used by the =/commit= slash command inside the
dotfiles repo. Forces the worktree to =~/.haris= regardless of the caller's
CWD, so an AI agent operating in a subdirectory or a different worktree still
commits against the dotfiles repo. Exists as a distinct command so the
permission system can allow it without opening up =git commit *= globally.
#+begin_src shell :tangle ~/.local/bin/git-dotharis-commit
  exec git -C ~/.haris commit "$@"
#+end_src
** =har-distill=
Distill a HAR file down to the operative request/response data for behavior
debugging — drops static assets (HTML, CSS, JS, fonts, images) and i18n
bundles (=translation.json=), keeps JSON traffic plus any failed (=status: 0=)
or 4xx/5xx entries, and renders the result as YAML. Reads from =$1= or stdin;
writes YAML to stdout.
#+begin_src bash :tangle ~/.local/bin/har-distill
  set -eu

  yq -y '
    .log.entries[]
    | (.response.headers[]? | select(.name | ascii_downcase == "content-type") | .value) as $ct
    | select(
        (.response.status == 0)
        or (.response.status >= 400)
        or ((($ct // "") | test("json"; "i")) and (.request.url | test("translation\\.json") | not))
      )
    | { t: .startedDateTime, ms: .time,
        req: { method: .request.method, url: .request.url,
               headers: (.request.headers | map({(.name): .value}) | add),
               body: (.request.postData.text | (fromjson? // .)) },
        res: { status: .response.status,
               statusText: .response.statusText,
               error: ._error,
               headers: (.response.headers | map({(.name): .value}) | add),
               body: (.response.content.text | (fromjson? // .)) } }
  ' "${1:--}"
#+end_src
* Applications
These are programs that are meant to be used mostly interactively. As such, they
are designed to be easily integrated into dmenu scripts.
** =cf=
#+begin_src shell :tangle ~/.local/bin/cf
  # Look up a configuration file by its user-friendly alias.

  # Note: This script is statically parsed by lscf. Keep its structure intact.

  for arg in "$@"; do
      case "$arg" in
          .haris)                  echo ~/.haris ;;
          README.org)              echo ~/.haris/README.org ;;
          temporary.org)           echo ~/.haris/temporary.org ;;
          bootstrap.org)           echo ~/.haris/bootstrap/README.org ;;
          alacritty)               echo ~/.haris/terminal.org ;;
          alias-tmp)               echo ~/.alias-tmp ;;
          alias-gui-tmp)           echo ~/.alias-gui-tmp ;;
          fish)                    echo ~/.haris/shells.org ;;
          fish-private)            echo ~/.config/fish/private.fish ;;
          fish-tmp)                echo ~/.config/fish/tmp.fish ;;
          vifm)                    echo ~/.haris/terminal.org ;;
          git)                     echo ~/.haris/vcs.org ;;
          gh)                      echo ~/.haris/vcs.org ;;
          hg)                      echo ~/.haris/vcs.org ;;
          picom)                   echo ~/.haris/wm.org ;;
          dunst)                   echo ~/.haris/misc.org ;;
          tem)                     echo ~/.haris/terminal.org ;;
          mime)                    echo ~/.haris/README.org ;;
          zathura)                 echo ~/.haris/gui.org ;;
          emacs)                   echo ~/.haris/emacs.org ;;
          spacemacs)               echo ~/.spacemacs ;;
          cron)                    echo ~/.crontab ;;
          octave)                  echo ~/.octaverc ;;
          python)                  echo ~/.startup.py ;;
          tuterm)                  echo ~/.haris/terminal.org ;;
          xinit)                   echo ~/.haris/wm.org ;;
          sxhkd)                   echo ~/.haris/wm.org ;;
          mpv)                     echo ~/.haris/gui.org ;;
          flameshot)               echo ~/.haris/gui.org ;;
          cheat)                   echo ~/.haris/terminal.org ;;
          xmrig)                   echo ~/.config/xmrig.json ;;
          tmux)                    echo ~/.tmux.conf ;;
          vscode/settings.json)    echo ~/.haris/vscode/settings.json ;;
          vscode/keybindings.json) echo ~/.haris/vscode/keybindings.json ;;
          ,*)
              if [ -f ~/.haris/"$arg" ]; then
                  echo ~/.haris/"$arg"
              fi
              ;;
      esac
  done
#+end_src
** =elisp=
#+begin_src shell :tangle ~/.local/bin/elisp
  # Run an elisp interpreter through emacs
  <<add-create-frame-option-if-term-dumb>>
  myemacs --eval "(ielm)" "$@"
#+end_src
** =eoctave=
#+begin_src shell :tangle ~/.local/bin/eoctave
  # Run octave interpreter through emacs
  <<add-create-frame-option-if-term-dumb>>
  myemacs --eval "(progn (run-octave) (delete-other-windows))" "$@"
#+end_src
** =epython=
#+begin_src shell :tangle ~/.local/bin/epython
  # Run a python interpreter through emacs
  <<add-create-frame-option-if-term-dumb>>
  myemacs --eval "(progn (call-interactively 'run-python) (delete-other-windows))" "$@"
#+end_src
** =eman=
#+begin_src shell :tangle ~/.local/bin/eman
  if [ -n "$1" ]; then
      smart-launch myemacs -c --eval "(man \"$1\")"
  else
      smart-launch myemacs -c --eval "(call-interactively 'man)"
  fi
#+end_src
#+CALL: eman(argv='())
#+CALL: eman(argv='("vim"))
#+CALL: eman(argv='("git"))
#+CALL: eman(argv='("emacs"))
*** Completions
#+begin_src fish :tangle ~/.config/fish/completions/eman.fish
  complete -c eman --wraps man
#+end_src
** =edocker=
#+begin_src shell :tangle ~/.local/bin/edocker
  smart-launch myemacs -c --eval "(run-with-timer 0.3 nil 'docker)" "$@"
#+end_src
** =edocker-compose=
#+begin_src shell :tangle ~/.local/bin/edocker-compose
  smart-launch myemacs -c --eval "(run-with-timer 0.3 nil 'docker-compose)" "$@"
#+end_src
** =ebluetooth=
#+begin_src shell :tangle ~/.local/bin/ebluetooth
  smart-launch myemacs -c --eval '(bluetooth-list-devices)'
#+end_src
** =proced=
#+begin_src shell :tangle ~/.local/bin/proced
  <<add-create-frame-option-if-term-dumb>>
  smart-launch myemacs -c --eval '(progn (proced) (delete-other-windows))' "$@"
#+end_src
** =magit=
#+begin_src shell :tangle ~/.local/bin/magit
  smart-launch myemacs -c --eval "(magit-status)" "$@"
#+end_src
** =myemacs-here=
Open emacs in the current tmux pane's working directory.
#+begin_src shell :tangle ~/.local/bin/myemacs-here
  cd "$(alacritty-pane-cwd)"
  smart-launch myemacs -c .
#+end_src
** =qr=
#+begin_src bash :tangle ~/.local/bin/qr
  # Copy, show or open the argument based on its content
  copy_or_show_or_open() {
      notify-send 'QR Code:' "$@"
      echo "$1" | xsel -b
      if echo "$1" | grep -q '^https://'; then
          firefox --new-tab "$@"
      fi
  }

  if [ "$1" = 'in' ]; then
      copy_or_show_or_open "$(timeout 20s zbarcam /dev/video0 -1 | sed 's/^QR-Code://')"
  elif [ "$1" = 'screen' -o "$1" = 's' ]; then
      copy_or_show_or_open "$(zbarimg -q <(flameshot screen --raw) | sed 's/^QR-Code://')"
  else # out
      if [ -t 0 ] || [ "$TERM" = 'linux' ]; then
          input="$(xsel -b -o)"
      else
          input="$(cat)"
          if [ -z "$input" ]; then
              input="$(xsel -b -o)"
          fi
      fi
      echo "$input" | qrencode -s 10 -o - | feh -
  fi
#+end_src
*** Dependencies                                                     :deps:
#+begin_src text :tangle (haris/tangle-deps "qr.pacman")
  zbar qrencode
#+end_src
** =rb=
# TODO: linux-only
#+begin_src shell :tangle ~/.local/bin/rb
  # One-time reboot into selected OS

  set -e # Quit if any command fails

  index="$(grep "menuentry '\|submenu '" /boot/grub/grub.cfg |\
    grep -v -P '\t' |\
    grep -i -n "$1" |\
    head -1 | awk -F':' '{print $1}')"

  if [ -z $index ]; then
      echo "No entry found"
  else
      index=$(( $index - 1 ))
      echo "Selected menuentry: $index. Proceed?"
      read response
      if [ "$response" == 'y' ]; then
          sudo grub-reboot $index >/home/haris/src/grublog 2>&1
          reboot
      fi
  fi
#+end_src
** =vimdiff=
#+begin_src shell :tangle ~/.local/bin/vimdiff
  # Like regular vimdiff, but in nvim

  nvim -d "$@"
#+end_src
** =vicc=
#+begin_src shell :tangle ~/.local/bin/vicc
  # Find and open in vim a header file from the default include path

  vim "$(echo "#include <$1>" | cpp -H 2>&1 >/dev/null | head -1 | sed 's/^. //')"
#+end_src
** =vipydoc=
#+begin_src shell :tangle ~/.local/bin/vipydoc
  # Open alacritty with pydoc in it
  # - All arguments are passed to pydoc
  # - Alacritty window class tracks those defined in my i3 config

  alacritty --class Alacritty,Float -e fish -C "pydoc $*" &
#+end_src
** =rgf=
#+begin_src shell :tangle ~/.local/bin/rgf
  # Run rg and fzf to search through file contents and jump to a file

  where="$1"
  [ -z "$where" ] && where='.'

  rg --column --line-number --no-heading --color=always --smart-case . | fzf --ansi
#+end_src
** =otp=
#+begin_src python :tangle ~/.local/bin/otp
  import shlex
  import subprocess

  import dryparse
  from dryparse.objects import Option
  import sys
  from urllib.parse import urlparse, parse_qs

  @dryparse.command
  def otp(name: str, *, new: bool = False, extract: Option("-x", "--extract", bool) = False):
      """Use and manage one-time passwords.

      :param name: name of the OTP
      :param new: store a new OTP instead of printing an existing one
      :param extract: Extract the secret from the URL given as argument
      """
      extract: bool

      def run(*args, **kwargs):
          return subprocess.run(*args, shell=True, encoding="utf-8", **kwargs)

      if new and extract:
          print("--new and --extract can't be used together", file=sys.stderr)
          sys.exit(1)

      if new:
          p = run(f"pass insert {name}/otp-secret")
          sys.exit(p.returncode)
      elif extract:
          query = parse_qs(urlparse(name).query)
          print(query["secret"][-1])
          return


      otp_secret = run(
          f"pass show {name}/otp-secret", stdout=subprocess.PIPE
      ).stdout.strip()

      p = run(f"oathtool --totp --base32 {shlex.quote(otp_secret)}")
      sys.exit(p.returncode)


  otp = dryparse.parse(otp, sys.argv)
  otp()
#+end_src
*** Dependencies                                                     :deps:
#+begin_src text :tangle (haris/tangle-deps "otp.pip-user")
  dryparse
#+end_src
** =imount=
#+begin_src bash :tangle ~/.local/bin/imount
  # List of all blocks
  listing="$(lsblk --list -o PATH,LABEL)"

  # ... with header removed
  items="$(
      echo "$listing" \
          | tail -n +2 \
          | sed 's/.*/"&"/' \
          | nl --number-width=1 \
          | grep -v '/dev/loop'
  )"
  # number of lines
  lineno="$(echo "$items" | wc -l)"

  # Open file descriptor 3
  exec 3>&1
  # Show dialog and store id of selection
  id=$(
      eval dialog  2>&1 1>&3 \
          --default-item $lineno \
          --menu '"Choose a device/partition:"' 60 50 $lineno $items
  )
  [ "$?" != 0 ] && exit 1     # Dialog exited with error
  # Select mounting directory
  mount_dir="$(dialog --fselect ~/mnt/ 60 50 2>&1 1>&3)"
  [ "$?" != 0 ] && exit 1     # Dialog exited with error

  # Clear but keep scrollback buffer
  clear -x

  if [ ! -d "$mount_dir" ]; then # Nonexisting mount directory
      read -n 1 -p\
           "The directory $mount_dir does not exist and will be created. Continue?  [y/n]: " \
           choice 1>/dev/null
      [ "$choice" != "y" ] && exit 1
      echo # newline
      mkdir "$mount_dir"
  fi

  # Get path to selected device
  device="$(echo "$items" | sed -n ${id}p | sed 's_.*"\(\S*\)\s.*_\1_')"

  read -n 1 -p\
       "$device will be mounted at $mount_dir. Continue? (requires sudo) [y/n]: " \
       choice
  echo # newline

  [ "$choice" != "y" ] && exit 1

  # Mount the device at last
  sudo mount "$device" "$mount_dir" -o umask=002,uid=$(id -u),gid=$(id -g)

  echo -e "$mount_dir" > /tmp/imount_directory
  chmod a+rw /tmp/imount_directory
#+end_src
** =kbind=
#+begin_src bash :tangle ~/.local/bin/kbind
  # Temporarily bind keys

  pkill -f '^sxhkd\.tmp '
  smart-launch myemacs --wait -c ~/.tmp.sxhkdrc

  notify-send "kbind" "Applying config"
  o --silent sxhkd.tmp
#+end_src
** =xpeek=
Create a Xephyr session for the current user that tries to mimic a regular
=startx= session as closely as possible.
#+begin_src bash :tangle ~/.local/bin/xpeek
  # Option variables
  host_display="$DISPLAY"
  display=1"$(id -u "$USER")"

  Xephyr :"$display" -once -resizeable \
      -screen "$(xdpyinfo | grep dimensions | grep -P '\d+x\d+' --only-matching | head -1)" \
      "$@" &
  sleep 0.5s
  windowid="$(xdotool getactivewindow)"
  echo "WINDOW ID: $windowid"

  export DISPLAY=:"$display"
  i3 &
  sxhkd &
  dunst &

  DISPLAY="$host_display" xev -id "$windowid" -event structure |
      while read line; do
          if grep "^ConfigureNotify event" <<<"$line"; then
              xrandr
          fi
      done
#+end_src
** =lock-screen=
#+begin_src bash :tangle ~/.local/bin/lock-screen
  # Custom configuration
  HARIS_WALLPAPER_CHANGE=true
  HARIS_WALLPAPER_CHANGE_INTERVAL_SEC=60

  # Configure xsecurelock
  export XSECURELOCK_LIST_VIDEOS_COMMAND="ls-wallpapers | grep -P '\.(mp4|webm|avi|mkv|gif)$'"
  export XSECURELOCK_AUTH_TIMEOUT=10
  export XSECURELOCK_BLANK_TIMEOUT=1200
  export XSECURELOCK_BLANK_DPMS_STATE=suspend
  export XSECURELOCK_SAVER=saver_mpv
  export XSECURELOCK_IMAGE_DURATION_SECONDS=3
  export XSECURELOCK_VIDEOS_FLAGS='--loop --panscan=1 --autofit=100%x100%'
  export XSECURELOCK_SAVER_RESET_ON_AUTH_CLOSE=0
  export XSECURELOCK_PASSWORD_PROMPT=asterisks
  export XSECURELOCK_KEY_Super_L_COMMAND='systemctl suspend'

  if [ -z "$($XSECURELOCK_LIST_VIDEOS_COMMAND)" ]; then
      # No videos found, use images
      export XSECURELOCK_LIST_VIDEOS_COMMAND="ls-wallpapers | grep -P '\.(png|jpg|jpeg|webp)$'"
      export XSECURELOCK_VIDEOS_FLAGS=''
      HARIS_WALLPAPER_CHANGE=''
  fi

  picom_running="$(systemctl --user is-active -q picom.service && echo true)"
  systemctl --user stop picom.service

  # Run xsecurelock, restarting at intervals in order to change the wallpaper
  xsecurelock &
  xsecurelock_pid="$!"
  last_change_time="$(date +%s)"

  # If a suspend was the trigger for this lock, make sure the suspend is delayed
  # until xsecurelock is ready. This makes sure the screensaver is active
  # immediately after a wake-up.
  if [ -n "$XSS_SLEEP_LOCK_FD" ]; then
      exec "$XSS_SLEEP_LOCK_FD"<&-
  fi

  # Restart xsecurelock at intervals to change the wallpaper,
  # but without interrupting the user if they are entering their password.
  while [ -n "$HARIS_WALLPAPER_CHANGE" ]; do
      sleep 1s
      if ! ps -p "$xsecurelock_pid" >/dev/null; then
          # xsecurelock exited, exit this program as well
          break
      fi
      # Check if the wallpaper has been active for enough time
      now="$(date +%s)"
      change_interval="$HARIS_WALLPAPER_CHANGE_INTERVAL_SEC"
      diff="$(($now - $last_change_time))"
      echo "Wallpaper has been active for $diff s."
      if [ "$diff" -ge "$change_interval" ]; then
          echo "Wallpaper change is due"
          idle_time="$(xprintidle)"
          if [ "$idle_time" -ge "${XSECURELOCK_AUTH_TIMEOUT}000" ]; then
              echo "Changing wallpaper"
              last_change_time="$(date +%s)"
              xsecurelock &
              new_pid="$!"
              sleep 0.3s
              kill "$xsecurelock_pid"
              xsecurelock_pid="$new_pid"
          else
              echo "Wallpaper change skipped due to user activity. idle_time: $idle_time ms"
          fi
      fi
  done

  if [ -n "$picom_running" ]; then
      sleep 0.5s
      systemctl --user start picom.service
  fi
#+end_src
* Dmenu
** Main entrypoint (=dmenu_run=)
#+begin_src bash :tangle ~/.local/bin/dmenu_run
  export HARIS_CALLER_IS_DMENU=true

  # If an argument is provided, run corresponding custom dmenu script
  if [ -n "$1" ]; then
      script=~/.local/lib/dmenu/"$1"
      if [ -e "$script" ]; then
          "$script"
          exit
      fi
  fi
  # Otherwise open a generic dmenu where the user will choose what dmenu script
  # or other program to run

  run_script() {
      if [ -n "$TMUX" ]; then
          ~/.local/lib/dmenu/"$1"
      else
          o --silent ~/.local/lib/dmenu/"$1"
      fi
  }

  get_desktop_apps() {
      cached 10h desktop-apps "$(cat <<'EOF'
  «pull_desktop_apps»
  EOF
  )" | sort | uniq
  }
  get_custom_scripts() {
      find ~/.local/bin -executable -type f -printf '%f\n' | sort | uniq | sed 's/^/ /'
  }

  # ┏━━━━━━━━━━━━━━━┓
  # ┃ dmenu entries ┃
  # ┗━━━━━━━━━━━━━━━┛
  get_dmenu_entries() {
      echo " Open"           # Open an URL or bookmark
      echo " Clipboard"      # Clipboard using copyq
      echo " Snippets"       # Text snippets
      echo " TODO"           # Open TODO file of a project
      echo " Windows"        # Choose windows
      echo " Pacman"         # Package management
      echo " Color"          # Pick a color
      echo " Unicode"        # Pick an icon
      echo " Kill Process"   # Kill process
      echo " Fix Wifi"      # Fix Wi-Fi drop issue on some networks
      echo " Config"        # Open documentation selection
      echo " System"        # System actions
      echo " Update cache"   # Update desktop app cache
      echo "Tem"              # Launch tem development environment
      echo "Octave"           # Launch octave in emacs
      echo " Python"         # Launch python interpreter in emacs
      echo " GPG"           # GPG addresses
      echo " Books"         # Pick a book to read
      echo " IRC"           # Open emacs client for IRC
      echo "Quickmenu"        # Menu to quickly revisit recent activity
      get_desktop_apps        # Programs extracted from *.desktop files
      get_custom_scripts      # Programs from ~/.local/bin
  }

  # ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  # ┃ Actions based on user's choice ┃
  # ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
  if [ -n "$1" ]; then
      choice="$1"
  else
      choice="$(get_dmenu_entries | dmenu)"
      [ "$?" = "0" ] || exit
      if grep -q '^' <<<"$choice"; then
          is_dotdesktop_app=true
      fi
      # If it starts with a non-ascii character (as in get-commands), remove it and the space following it
      if grep -qP "[^\x00-\x7F]" <<<"$choice"; then
          choice="$(cut -f2- -d' ' <<<"$choice")"
      fi
  fi
  case "$choice" in
      "Open")
          run_script open ;;
      "Clipboard")
          copyq-show ;;
      "Snippets")
          run_script snips ;;
      "TODO")
          run_script todo ;;
      "Windows")
          ~/.local/lib/i3/i3-container-commander.py ;;
      "Pacman")
          run_script pacman ;;
      "Color")
          run_script color ;;
      "Unicode")
          run_script unicode ;;
      "Kill Process")
          run_script pkill ;;
      "Fix Wifi")
          fix-wifi ;;
      "Config")
          run_script config ;;
      "System")
          run_script system ;;
      "Update cache")
          cached --rm desktop-apps ;;
      "Tem")
          alacritty -e fish -C 'pj tem; clear' ;;
      "Octave")
          eoctave -c ;;
      "Python")
          epython -c ;;
      "GPG")
          run_script gpg ;;
      "Books")
          run_script books ;;
      "IRC")
          myemacs --socket-name="irc" -c ;;
      "Quickmenu")
          run_script quickmenu ;;
      # The rest: aliases and regular commands
      ,*)
          if [ -n "$is_dotdesktop_app" ]; then
              # If the choice is an x.desktop app, launch it
              # DO NOT USE the `o` command here, because it kills the process
              # after linger-period
              gtk-launch "$choice"
              exit
          fi
          # Fallback, if the entry matches none of the above, just run the command
          fish -c "o $choice"
          ;;
  esac
#+end_src

This code block separated so that it can be run in =sh= instead of =bash= and thus
possibly benefit from a performance boost, in case =sh= happens to point to a more
lightweight shell.
#+NAME: pull_desktop_apps
#+begin_src shell
  ls -1 $(echo "$XDG_DATA_DIRS" | tr ':' '\n' | sed 's|$|/applications/*.desktop|') |
      sort | uniq |
      sed -E 's|.*/([^/]+)\.desktop$| \1|'
#+end_src
** Open
Open a website in Firefox. Suggests bookmarks managed by buku, but you can input
any URL. To suggest additional URLs, you can create the script
[[~/.local/lib/haris/custom/dmenu/open.sh]], which should print a list of additional
URLs (each on a new line) to display in this menu.
#+begin_src bash :tangle ~/.local/lib/dmenu/open
  edit=" Edit..."
  sync=" Sync..."

  firefox_about_pages() {
      cat <<'EOF_e245552b'
  about:about
  about:addons
  about:buildconfig
  about:cache
  about:certificate
  about:config
  about:crashes
  about:credits
  about:debugging#/runtime/this-firefox
  about:devtools
  about:downloads
  about:home
  about:license
  about:memory
  about:networking
  about:newtab
  about:performance
  about:plugins
  about:preferences
  about:privatebrowsing
  about:profiles
  about:protections
  about:rights
  about:robots
  about:serviceworkers
  about:sessionrestore
  about:studies
  about:support
  about:telemetry
  about:welcome
  EOF_e245552b
  }

  from_etc_hosts() {
      if ! which hostess &>/dev/null; then
          notify-send \
              --expire-time 1000 \
              "dmenu: open: warning" "hostess is not installed, some entries may be missing"
          return
      fi
      hostess ls | cut -f1 -d' '
  }

  choice="$(
      {
          echo "$edit"
          echo "$sync"
          unbuffer buku -p --format 30 | grep -v '^$' | sort
          [ -x ~/.local/lib/haris/custom/dmenu/open.sh ] && ~/.local/lib/haris/custom/dmenu/open.sh
          firefox_about_pages
          from_etc_hosts
      } | dmenu -p 'Open:'
  )"

  [ -z "$choice" ] && exit

  if [ "$choice" = "$edit" ]; then
      # Open this file for editing
      gvim "$0"
  elif [ "$choice" = "$sync" ]; then
      alacritty --class Alacritty,Float -e fish -C "
          echo -e \"--- Importing bookmarks from Firefox ---\nDefault is: n y y \";
          buku --import ~/.mozilla/firefox/haris/bookmarks.html"
  else
      # Try to open it as a bookmark in firefox
      url="$(
          buku --sreg "^$choice\$" -n 1 --format 10 |
          grep -v 'waiting for input'
      )"
      [ -z "$url" ] && url="$choice"
      # All google links shall be opened in firefox
      echo "$url" | grep -q 'google' && browser="$(echo "$browser" | sed 's_librewolf_/bin/firefox/')"

      # If choice is a number, assume it's a localhost port
      if [[ "$url" =~ ^[0-9]+$ ]]; then
          url="localhost:$choice"
      fi

      echo "$url"
      auto-browser -P haris "$url"
  fi
#+end_src
** Todo
#+begin_src bash :tangle ~/.local/lib/dmenu/todo
  edit=" Edit..."
  lookup="$(
    ls ~/proj/*/TODO.org \
       ~/proj/drytoe/*/TODO.org \
       ~/data/personal/todos/*/TODO.org
  )"
  echo "$lookup"

  entries="$(echo "$edit"
             echo "$lookup" |
             while read p; do
                 basename "$(dirname "$p")"
             done)"

  choice="$(
      echo "$entries" | dmenu -p TODO:
  )"

  [ "$?" != 0 ] && exit 1

  if [ "$choice" = " Edit..." ]; then
      cd "$(dirname "$0")"; gvim "$0"
  else
      smart-launch myemacs -c "$(echo "$lookup" | grep "/$choice/TODO.org")"
  fi
#+end_src
** Pacman
#+begin_src shell :tangle ~/.local/lib/dmenu/pacman
  install=" Install..."
  about=" About..."
  remove=" Remove..."
  manage=" Manage..."
  update=" Update..."
  keyring=" Keyring..."
  edit=" Edit..."

  print_options() {
      echo "$install"
      echo "$about"
      echo "$update"
      echo "$remove"
      echo "$manage"
      echo "$keyring"
      echo "$edit"
  }

  get_fish_cmd() {
      echo "echo 'Running command:'; echo '$*'"
      echo "$*"
  }

  choice="$(print_options | dmenu -l $(print_options | wc -l))"

  case "$choice" in
      "$install")
          # Prepend official packages to the cached AUR list
          list="$(pacman -Ssq; cached 5h aur-packages \
              "curl -s 'https://aur.archlinux.org/packages.gz' | gunzip -c")"
          choice="$(echo "$list" | dmenu -l 20)"
          [ -z "$choice" ] && exit
          cmd="$(pacman -Ss "^$choice\$" >/dev/null && echo sudo pacman -S || echo paru)"
          alacritty --class Alacritty,Float -e fish -C "$(get_fish_cmd $cmd $choice)" && exit
          ;;
      "$about")
          choice="$(echo "$(pacman -Qq)" | dmenu -p 'About:' -l 20)"
          [ -z "$choice" ] && exit
          alacritty --class Alacritty,Float -e fish -C "$(get_fish_cmd pacman -Qi $choice)" && exit
          ;;
      "$update")
          alacritty --class Alacritty,Float -e fish -C "paru -Syu"
          ;;
      "$remove")
          choice="$(pacman -Qq | dmenu -l 20)"
          [ -z "$choice" ] && exit
          alacritty --class Alacritty,Float -e fish -C "$(get_fish_cmd sudo pacman -R $choice)" && exit
          ;;
      "$manage")
          smart-launch myemacs -c "$(fcmd system-install)"
          ;;
      "$keyring")
          alacritty --class Alacritty,Float -e fish -C "$(get_fish_cmd sudo pacman -Sy archlinux-keyring && exit)"
          ;;
      "$edit")
          gvim "$0"
          ;;
  esac
#+end_src
** Color
#+begin_src bash :tangle ~/.local/lib/dmenu/color
  declare -A colors

  colors[',k black']='         #1e1e1e'
  colors[',r red']='           #ff5555'
  colors[',g green']='         #5ac2a8'
  colors[',y yellow']='        #f2b374'
  colors[',b blue']='          #6980fa'
  colors[',m magenta']='       #d098ff'
  colors[',c cyan']='          #8cceff' # TODO Change to something darker
  colors[',w white']='         #92aab7'
  colors['.k brblack']='       #6b746b'
  colors['.r brred']='         #ff8c8c'
  colors['.g brgreen']='       #98eb98'
  colors['.y bryellow']='      #e0d97b'
  colors['.b brblue']='        #99a3ff'
  colors['.m brmagenta']='     #f298c3'
  colors['.c brcyan']='        #a6d9ff'
  colors['.w brwhite']='       #dddddd'

  get_entries() {
      echo ' Edit...'
      printf '%s\n' "${!colors[@]}" | sort | sed 's_.*_ &_'
  }

  entries=$(get_entries)

  let n=$(echo "$entries" | wc -l)

  choice="$(echo "$entries" | dmenu -l $n -p 'Color:')"

  [ -z "$choice" ] && exit

  if [ "$choice" = ' Edit...' ]; then
      gvim "$0"
      exit
  fi

  # Remove decoration from the choice
  choice_filtered="$(echo $choice | sed 's_[^ ]* *\(.*\)_\1_')"
  # Copy the color, after removing whitespace
  echo -n "${colors["$choice_filtered"]}" | sed 's_[^ ]* *\(.*\)_\1_' | xsel -b
#+end_src
** Unicode
#+begin_src python :tangle ~/.local/lib/dmenu/unicode
  # Choose a font-awesome icon from dmenu and copy it

  from urllib.request import urlopen
  from subprocess import run, PIPE
  import os.path
  import yaml

  # ┏━━━━━━━━━━━━━━━━━━━━━━━┓
  # ┃ Prepare the icon list ┃
  # ┗━━━━━━━━━━━━━━━━━━━━━━━┛

  cache_file = os.path.expanduser('~/.cache/font-awesome-icon-list.yml')

  # Read the yml file from cache, or download it from GitHub
  if os.path.exists(cache_file):
      text = open(cache_file).read()
  else:
      url = 'https://raw.githubusercontent.com/FortAwesome/Font-Awesome/6.x/metadata/icons.yml'
      data = urlopen(url).read()
      text = data.decode('utf-8')
      open(cache_file, 'w').write(text)

  # Read the YAML file
  data = yaml.load(text, yaml.Loader)

  # ┏━━━━━━━━━━━━━━━━━━━━┓
  # ┃ Add custom options ┃
  # ┗━━━━━━━━━━━━━━━━━━━━┛
  top_entries =   [
      ' Edit...',
      ' FontAwesome...',
      ' From code...',
      ' Get code...',
  ]

  char_entries = []
  # Create a (decorated) list of entries
  for key in data.keys():
      unicode = int(data[key]['unicode'], base=16)
      char_entries.append(chr(unicode) + ' ' + key)

  def add_custom(char):
      global char_entries
      char_entries.append(char + ' [custom]')

  # ┏━━━━━━━━━━━━━━━━━━━━━━━┓
  # ┃ Add custom characters ┃
  # ┗━━━━━━━━━━━━━━━━━━━━━━━┛
  add_custom('├ |-')
  add_custom('└ |_')
  add_custom('─ --')
  add_custom('┃┗━┛┏━┓ ||')
  add_custom('š .sh')
  add_custom('ć .ch meko')
  add_custom('č .ch tvrdo')
  add_custom('đ .dj')
  add_custom('ž .zj')

  # Form entry lists as multi-line strings
  char_entries = '\n'.join(char_entries)
  # Add options and character entries together
  top_entries  = '\n'.join(top_entries) + '\n' + char_entries

  # Run dmenu and get user choice
  p = run(['dmenu'], stdout=PIPE, input=top_entries, encoding='utf-8')
  choice = p.stdout[:-1]

  def copy_to_clipboard(text):
      run(['xsel', '-b'], input=text, encoding='utf-8')

  # ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  # ┃ Actions based on user's choice ┃
  # ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
  if choice[2:] == 'Edit...': # Open this file for editing
     run(['alacritty', '--class', 'Alacritty,Float', '-e', 'fish', '-C',
           'cd (dirname ' + __file__ + '); vim -c "norm 45z." ' + __file__])
  elif choice[2:] == 'FontAwesome...':
      run(['firefox', 'https://fontawesome.com/search'])
  elif choice[2:] == 'From code...':
      p = run(['dmenu', '-p', 'Code:'], stdout=PIPE, input=char_entries, encoding='utf-8')
      open('/home/haris/src/testlog', 'w').write(choice)
      code = p.stdout[:-1]
      if choice:
          copy_to_clipboard(chr(int(code, base=16)))
  elif choice[2:] == 'Get code...':
      p = run(['dmenu', '-p', 'Character:'], stdout=PIPE, input=char_entries, encoding='utf-8')
      choice = p.stdout[:-1]
      if choice:
          copy_to_clipboard(str(ord(choice[0])))
  elif choice:
      copy_to_clipboard(choice.split(' ')[0])
#+end_src
** Kill Process
#+begin_src shell :tangle ~/.local/lib/dmenu/pkill
  choice="$(ps -A -o comm --no-headers | dmenu)"

  [ -z "$choice" ] && exit

  process="$choice"

  choice="$(echo " No\n Yes, kill $process" | dmenu -p 'Sure?' -l 2)"

  [ "$choice" = " Yes, kill $process" ] && pkill "$process"
#+end_src
** Config
#+begin_src python :tangle ~/.local/lib/dmenu/config
  from subprocess import run, PIPE
  import os
  import os.path
  import sys

  # Load regular configuration entries
  entries = run('lscf', stdout=PIPE, encoding='utf-8').stdout.replace('-', ' ')
  # Load dmenu scripts
  dmenu_scripts = os.listdir(os.path.expanduser('~/.local/lib/dmenu/'))

  # ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  # ┃ Additional entries and customization ┃
  # ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
  entries = (
      ' Claude...\n' +
      ' OpenCode...\n' +
      ' Edit...\n' +
      ' ' + entries.replace('\n', '\n ') +
      'dmenu\n dmenu ' +
      '\n dmenu '.join(dmenu_scripts)
  )

  # Run dmenu
  choice = run(['dmenu', '-l', '20',  '-p', 'Config:'],
               input=entries, encoding='utf-8', stdout=PIPE).stdout

  if not choice:
      sys.exit()

  # Strip decoration from the entry
  choice = choice[2:-1].replace(' ', '-')

  def run_command(cmd):
      run(['alacritty', '--class', 'Alacritty,Float', '-e',
           'fish', '-C', cmd])

  # ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  # ┃ Actions based on user's choice ┃
  # ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
  if choice == 'dmenu':
      EVAL = fr'''
          (progn (find-file "~/.haris/scripts.org")
                 (call-interactively (swiper "^\\* Dmenu"))
                 (evil-ex-nohiglight))
      '''
      run(["smart-launch", "myemacs", "-c", "--eval", EVAL])
  if choice.startswith('dmenu-'):
      submenu = choice.replace("dmenu-", "")
      submenu = submenu[0].upper() + submenu[1:]
      EVAL = fr'''
          (progn (find-file "~/.haris/scripts.org")
                 (call-interactively (swiper "^\\*\\* {submenu}"))
                 (evil-ex-nohiglight))
      '''
      run(["smart-launch", "myemacs", "-c", "--eval", EVAL])
  elif choice == 'Edit...':
      EVAL = '''
          (progn (find-file "~/.haris/scripts.org")
                 (goto-char (org-find-property "CUSTOM_ID" "cf"))
                 (evil-ex-nohiglight))
      '''
      run(["smart-launch", "myemacs", "-c", "--eval", EVAL])
  elif choice == 'Claude...':
      run(["alacritty-float", "-e", "fish", "-C", "cd ~/.haris && claude"])
  elif choice == 'OpenCode...':
      run(["alacritty-float", "-e", "fish", "-C", "cd ~/.haris && opencode --agent build"])
  else:
      run("fish -c 'ecf {}'".format(choice), shell=True)
      sys.exit()
#+end_src
** System
#+begin_src shell :tangle ~/.local/lib/dmenu/system
  choice="$(echo "Suspend\nSuspend & Lock\nShutdown\nReboot..." | dmenu)"

  # No choice, bye-bye
  [ -z "$choice" ] && exit

  if [ "$choice" = "Shutdown" ]; then

      choice="$(echo " No\n Yes, shutdown" | dmenu -p 'Sure?')"
      [ "$choice" = " Yes, shutdown" ] && shutdown now

  elif [ "$choice" = "Suspend & Lock" ]; then
      xlock &  # NOTE: using the 'o' script here doesn't detach tmux for some reason
      sleep 1
      systemctl suspend -i
  elif [ "$choice" = "Suspend" ]; then
      systemctl suspend -i
  elif [ "$choice" = "Reboot..." ]; then
      print_entries() {
          # Extract only lines with menu entries from grub
          grep "menuentry '\|submenu '" /boot/grub/grub.cfg |
              # Only top-level menus are considered
              grep -v -P '\t' |
              # Take only the entry name
              sed "s_\S* '\([^']*\)'.*_\1_" |
              # Add numbers
              nl -w 1 -v 0 -n rn | sed -E 's/\s+/ /g'
      }

      entries="$(print_entries)"
      choice="$(echo "$entries" | dmenu -l $(echo "$entries" | wc -l) | egrep --only-matching '^[0-9]+')"
      [ -z "$choice" ] && exit

      # For convenience, grub-reboot should be allowed passwordless in sudoers.
      sudo grub-reboot "$choice"
      reboot || sudo reboot
  fi
#+end_src
** GPG
#+begin_src bash :tangle ~/.local/lib/dmenu/gpg
  # Get list of all public keys
  keylist=($(gpg --list-public-keys Haris | grep '^\s' | sed 's/^\s*//g'))

  entries="$(
      for key in "${keylist[@]}"; do
          # Get info for key
          keyinfo="$(gpg --list-public-keys | grep "$key" -A1)"
          # Get email of key owner
          email="$(echo "$keyinfo" | grep '<.*>' | sed 's/^.*\]//')"
          echo "$key" "$email"
      done
  )"
  let n="$(echo "$entries" | wc -l)"

  choice="$(echo "$entries" | dmenu -l $n -p 'GPG:')"

  echo "$choice" | awk '{print $1}' | xsel -b
#+end_src
** Books
#+begin_src bash :tangle ~/.local/lib/dmenu/books
  cd ~/data/literature

  choice="$(fd --type file '' | dmenu -l 10 -p 'Book:')"

  [ -z "$choice" ] && exit

  sioyek "$choice"
  sts="$?"

  sleep 2s
  trap 'kill "$pid"' EXIT
  # trap 'printarg kill "$pid"' ERR
  # Ensure that this script stays running as long as the program, so `o` doesn't
  # time out
  while :; do
      pid="$(pgrep -a '' | grep --fixed-strings "$choice" | cut -f1 -d' ' | head -1)"
      if [ -z "$pid" ]; then break; fi
      sleep 5s
  done
#+end_src
** Quickmenu
The quickmenu script is optional and must be provided separately at
[[~/.local/lib/dmenu/quickmenu]].
** Dependencies                                                       :deps:
#+begin_src text :tangle (haris/tangle-deps "dmenu.pacman")
  # Root menu (dmenu_run)
  copyq
  # Open menu
  xdotool xorg-xprop
#+end_src
#+begin_src text :tangle (haris/tangle-deps "dmenu.aur")
  # Open menu
  buku
#+end_src
* System maintenance
** =pacman-update-mirrorlist=
#+begin_src shell :tangle ~/.local/bin/pacman-update-mirrorlist
  # Update /etc/pacman.d/mirrorlist using reflector

  sudo reflector --sort rate --save /etc/pacman.d/mirrorlist
#+end_src
** =texclean=
#+begin_src bash :tangle ~/.local/bin/texclean
  # Array of extensions
  extarray=($(sed -e '/^#/d' -e '/^$/d' ~/templates/latex/ignored_files))

  if [ "$1" == '-r' ]; then
      shopt -s globstar
      rm -f ${extarray[*]/#/\*\*\/\*.} # **/*.extension
  else
      rm -f ${extarray[*]/#/\*.} # **/*.extension
  fi

  exit
#+end_src
** =springclean=
#+begin_src shell :tangle ~/.local/bin/springclean
  docker system prune
  docker volume prune

  rm -rf ~/.local/share/Trash
  rm -rf ~/.local/share/*.xbel*

  # I think this is created by KDE plasma
  rm -rf ~/.local/share/baloo

  sudo journalctl --vacuum-size=250M
  paccache -vuk0 -r
#+end_src
** =createhome=
#+begin_src bash :tangle ~/.local/bin/createhome
  # Top level home directory
  dirs=(
      src
      tmp
      repo
      data
  )
  mkdir -p "${dirs[@]}"

  mkdir -p ~/mnt
  cd ~/mnt

  dirs=(
      drive
      dbox
      phone
      android1
      android2
      ssd
      usb
      usb-guest
      usbb1
      usbb2
      vm
  )

  mkdir -p "${dirs[@]}"
#+end_src
** =cleanhome=
#+begin_src shell :tangle ~/.local/bin/cleanhome
  # Clean home of directories like Downloads, Documents, regularly created by who
  # knows.

  rmdir ~/Desktop ~/Downloads ~/Documents ~/Pictures ~/Videos ~/Music \
        ~/Templates ~/Public ~/'VirtualBox VMs' ~/mpv_slicing.log
#+end_src
** =cleantex=
#+begin_src bash :tangle ~/.local/bin/cleantex
  # A script to clean tex build files

  shopt -s globstar

  rm **/*.aux **/*.log **/*.toc **/*.bbl **/*.fls **/*.idx **/*.ilg **/*.ind \
     ,**/*.nlo **/*.out **/*.synctex.gz **/*.fdb_latexmk 2>&1 | grep -v \
                                                                    'No such file or directory'
#+end_src
** =tangle=
#+NAME: tangle
#+begin_src shell :tangle ~/.local/bin/tangle
  ~/.haris/bootstrap/tangle.sh "$@"
#+end_src
Because this script is needed for bootstrapping my dotfiles on a new system, I
also tangle it to a standalone destination that I also keep under version control.
#+begin_src elisp :tangle ~/.haris/bootstrap/tangle.sh :tangle-mode (identity #o755)
  #!/usr/bin/env -S emacs --script

  (load-file (format "%s/tangle.el" (file-name-directory load-file-name)))

  (let* ((file (file-truename (elt argv 0)))
         (base (file-name-sans-extension (file-name-nondirectory file)))
         (hook (expand-file-name
                (format "~/.local/lib/haris/tangle-post-%s.sh" base))))
    (haris/tangle--file-non-interactively file)
    (when (file-executable-p hook)
      (message "Running post-tangle hook: %s" hook)
      (let ((rc (call-process hook nil nil nil file)))
        (unless (eq rc 0)
          (error "Post-tangle hook failed (%s): %s" rc hook)))))

  ; NOTE: Although this file is kept under version control, it is tangled from
  ; ~/.haris/scripts.org, so don't modify it directly
#+end_src
** =tangle-all=
#+NAME: tangle-all
#+begin_src shell :tangle ~/.local/bin/tangle-all
  ~/.haris/bootstrap/tangle-all.sh "$@"
#+end_src
Because this script is needed for bootstrapping my dotfiles on a new system, I
also tangle it to a standalone destination that I also keep under version control.
#+begin_src elisp :tangle ~/.haris/bootstrap/tangle-all.sh :tangle-mode (identity #o755)
  #!/usr/bin/env -S emacs --script

  ;; Tangle all my dotfiles.

  (setq this-script-dir (file-name-directory load-file-name))

  (load-file (format "%s/tangle.el" this-script-dir))
  (haris/tangle-all :dotfiles-dir (expand-file-name
                                   (format "%s/.." this-script-dir)))

  ;; vim: filetype=lisp
  ;; -*- mode: emacs-lisp -*-
  ;; NOTE: Although this file is kept under version control, it is tangled from
  ;; ~/.haris/scripts.org, so don't modify it directly
#+end_src
** =website-healthcheck=
Usage: website-healthcheck [--ignore-success]

Options:
  --notify-success  Show a notification even if the website status is 'alive'
#+begin_src shell :tangle ~/.local/bin/website-healthcheck
  notify_success="$([ "$1" = "--notify-success" ] && echo true)"

  prod_status="$(curl -L https://veracioux.me/status)"
  if [ "$?" != 0 ] || [ "$prod_status" != "alive" ]; then
      ~/.local/bin/notify-send --urgency=critical 'ERROR' 'Production website error'
  elif [ -n "$notify_success" ]; then
      ~/.local/bin/notify-send 'Production website' 'Status: alive'
  fi

  stg_status="$(curl -L https://stg.veracioux.me/status)"
  if [ "$?" != 0 ] || [ "$stg_status" != "alive" ]; then
      ~/.local/bin/notify-send --urgency-critical 'ERROR' 'Staging website error'
  elif [ -n "$notify_success" ]; then
      ~/.local/bin/notify-send 'Staging website' 'Status: alive'
  fi
#+end_src
** =vpn-toggle=                                                       :script:
#+begin_src shell :tangle ~/.local/bin/vpn-toggle
  restart_if_running() {
      if systemctl is-active --quiet "$1"; then
          sudo systemctl restart "$1"
      fi
  }

  if systemctl is-active --quiet protonvpn; then
    sudo systemctl stop protonvpn
  else
    sudo systemctl start protonvpn
  fi

  restart_if_running stubby
  restart_if_running dnsmasq

  # Make vpn-notifier perform an eager query
  systemctl kill --user vpn-notifier --signal=SIGUSR1
#+end_src
** =vpn-notifier=
#+begin_src bash :tangle ~/.local/bin/vpn-notifier
  # Interval at which queries to ipinfo.io are performed periodically
  default_requery_interval_sec=60
  requery_time_after_sigusr1=5s

  echo "PID: $$"

  signal_received=''

  trap 'signal_received=true' SIGUSR1

  old_ip=''

  while :; do
      echo
      echo "Querying ipinfo.io..."
      response="$(curl -fs ipinfo.io)"
      ip="$(jq -r .ip <<<"$response")"
      country="$(jq -r .location <<<"$response")"
      if [ "$ip" != "$old_ip" ]; then
          yaml="$(yq -y 'del(.readme)' <<<"$response")"
          echo
          echo -n "IP changed:"
          if [ -n "$old_ip" ]; then
              notify-send "🌐 IP changed " "$yaml"
          else
              echo -n " (initial state)"
          fi
          echo
          echo
          echo "$(sed 's/^/  /' <<<"$yaml")"
      else
          echo "IP unchanged."
          echo
      fi
      old_ip="$ip"
      for x in $(seq 1 "$default_requery_interval_sec"); do
          sleep 1s
          if [ -n "$signal_received" ]; then
              echo
              echo "Received SIGUSR1, querying ipinfo.io in $requery_time_after_sigusr1..."
              sleep "$requery_time_after_sigusr1"
              signal_received=''
              break
          fi
      done
  done
#+end_src
* Miscellaneous
** =term=
#+begin_src bash :tangle ~/.local/bin/term
  alacritty --working-directory "$PWD" -e tmux-shell -C "$([ "$#" -ge 1 ] && printf %q\  "$@" || :)"
#+end_src
** =i3-focused-workspace=
Print the focused i3 workspace name with any leading =N:= numeric prefix
stripped.
#+begin_src bash :tangle ~/.local/bin/i3-focused-workspace
  i3-msg -t get_workspaces 2>/dev/null \
      | jq -r '.[] | select(.focused).name' 2>/dev/null \
      | sed 's/^[0-9]*://'
#+end_src
** =worktree-workspace=
Set up an i3 workspace for working on a worktree (or any picked directory):
fzf-pick a dir via the fish =a= function, then arrange the workspace as
=split-h[ stacked[term, magit], stacked[claude] ]=. Aborts if the current
workspace is not empty.

The picker→orchestrator handoff goes through a single-shot named fifo: fish
writes either the chosen =$PWD= or =CANCELLED= back, and the orchestrator blocks
on =cat= until it gets one of them.
#+begin_src bash :tangle ~/.local/bin/worktree-workspace
  set -u

  abort() {
      notify-send -u critical 'worktree-workspace' "$1"
      exit 1
  }

  # Snapshot of all leaf window con-ids on the focused workspace.
  ws_window_ids() {
      i3-msg -t get_tree | jq -c --arg n "$ws_name" '
          [.. | objects | select(.type=="workspace" and .name==$n)] | .[0]
          | [.. | objects | select(.window?) | .id]'
  }

  # Run "$@" in the background and block until a new window appears on the
  # current workspace. Polls the i3 tree because i3-msg -t subscribe block-
  # buffers its ack, which makes event-driven sync unreliable.
  launch_and_wait() {
      local before id="" i
      before=$(ws_window_ids)
      ( "$@" ) &
      for i in $(seq 1 150); do
          sleep 0.1
          id=$(i3-msg -t get_tree | jq -r --arg n "$ws_name" --argjson b "$before" '
              [.. | objects | select(.type=="workspace" and .name==$n)] | .[0]
              | [.. | objects | select(.window?) | .id] - $b | .[0] // empty')
          [ -n "$id" ] && break
      done
      [ -n "$id" ] || abort 'timed out waiting for new window'
  }

  # 1. Empty-workspace check
  ws_name=$(i3-msg -t get_workspaces | jq -r '.[] | select(.focused) | .name')
  [ -n "$ws_name" ] || abort 'no focused workspace'
  count=$(i3-msg -t get_tree | jq --arg n "$ws_name" '
      [.. | objects | select(.type=="workspace" and .name==$n)] | .[0]
      | (.nodes + .floating_nodes) | length')
  [ "$count" = "0" ] || abort "workspace '$ws_name' is not empty"

  # 2. Single-shot fifo for picker→orchestrator handoff, plus a fish snippet
  #    file (term's printf-%q quoting mangles multi-line args fed to fish, so
  #    we pass two plain args — `source <path>` — and let fish read the file)
  fifo=$(mktemp -ut wt-ws.XXXXXX)
  mkfifo "$fifo"
  snippet=$(mktemp -t wt-ws.XXXXXX.fish)
  trap 'rm -f "$fifo" "$snippet"' EXIT

  # 3. Open terminal; fish runs `a`, writes the chosen $PWD (or CANCELLED) back
  cat > "$snippet" <<EOF
  set -l fifo '$fifo'
  if a
      echo \$PWD > \$fifo
  else
      echo CANCELLED > \$fifo
      exit
  end
  EOF
  term source "$snippet" &

  # 4. Block for the dir; empty payload = terminal closed before write
  dir=$(cat "$fifo")
  case "$dir" in
      CANCELLED|"") abort 'cancelled' ;;
      /*) [ -d "$dir" ] || abort "not a directory: $dir" ;;
      *)  abort "unexpected payload: $dir" ;;
  esac

  # 5. Wrap term in its own container and stack it
  i3-msg split v >/dev/null
  i3-msg layout stacked >/dev/null

  # 6. Magit joins the stacked container (focus is still on term → its parent)
  launch_and_wait sh -c \
      'cd "$1" && smart-launch myemacs -c --eval "(magit-status \"$1\")"' _ "$dir"

  # 7. Escape the stacked container: focus magit → its parent (the stacked
  #    container) → its parent (workspace root). Force horizontal split so the
  #    next window lands to the right rather than below.
  i3-msg focus parent >/dev/null
  i3-msg focus parent >/dev/null
  i3-msg split horizontal >/dev/null

  # 8. Claude opens as a sibling of the stacked container at workspace root
  launch_and_wait sh -c 'cd "$1" && term claude' _ "$dir"

  # 9. Wrap claude in its own stacked container so further windows can stack
  i3-msg split v >/dev/null
  i3-msg layout stacked >/dev/null
#+end_src
*** Dependencies                                                     :deps:
#+begin_src text :tangle (haris/tangle-deps "worktree-workspace.pacman")
  jq
  i3-wm
#+end_src
** =aurvote=
#+begin_src shell :tangle ~/.local/bin/aurvote
  ssh aur@aur.archlinux.org vote "$@"
#+end_src
** =handle-low-bat=
#+begin_src shell :tangle ~/.local/bin/handle-low-bat
  # Suspend when battery low

  notify() {
      timeout 0.4 notify-send "$@"
  }

  if acpi | grep -qP '\s1?[0-9]%' && acpi | grep -q 'Discharging'; then
      notify 'Low battery' 'Suspending in 5s'
      sleep 5s
      systemctl suspend -i || doas systemctl suspend -i || notify --urgency critical 'Low battery' 'Failed to suspend. See journal of cronie.service for details.'
  fi
#+end_src
*** Dependencies                                                     :deps:
#+begin_src text :tangle (haris/tangle-deps "handle-low-bat.pacman")
  acpi
  doas
#+end_src
** =cronupd=
#+begin_src shell :tangle ~/.local/bin/cronupd
  cat ~/.cron.d/* | crontab -
  crontab -l
#+end_src
** =fix-wifi=
#+begin_src shell :tangle ~/.local/bin/fix-wifi
  sudo rfkill block wifi && sudo rfkill unblock wifi
#+end_src
** sxhkd
TODO: move to main README

I have three sets of bindings for =sxhkd=:
- common; publicly available in my dotfiles repo
- private; kept in a private repo and not publicly available
- temporary; ad hoc bindings, not versioned at all

I want to be able to enable/disable each of those individually. That's why I
keep each in a separate config file. And, for each I run a separate process so I
can conveniently stop/restart each by name.
*** =sxhkd.private=
#+begin_src bash :tangle ~/.local/bin/sxhkd.private
  exec -a sxhkd.private sxhkd -c ~/.private.sxhkdrc "$@"
#+end_src
*** =sxhkd.tmp=
#+begin_src bash :tangle ~/.local/bin/sxhkd.tmp
  exec -a sxhkd.tmp sxhkd -c ~/.tmp.sxhkdrc "$@"
#+end_src
* Adapters
My main setup is Arch Linux. Sometimes I also use other setups like Ubuntu,
which sometimes have differently named packages and/or executables. I wrap the
executables here so they are available under the same executable names as on
Arch Linux.

By default, the adapters are archived. In order to enable them, simply unarchive
them if the current PC setup is the one they are intended for.
** Ubuntu                                                          :ARCHIVE:
*** =fd=
#+begin_src shell :tangle ~/.local/bin/fd
  fdfind "$@"
#+end_src
*** =passmenu=
#+begin_src shell :tangle ~/.local/bin/passmenu
  /usr/share/doc/pass/examples/dmenu/passmenu "$@"
#+end_src
*** =ipython=
#+begin_src shell :tangle ~/.local/bin/ipython
  # Some platforms don't provide ipython as a symlink/wrapper to ipython3
  ipython3 "$@"
#+end_src
*** =pycharm=
#+begin_src shell :tangle ~/.local/bin/pycharm
  pycharm-professional
#+end_src
*** =code-oss=
#+begin_src shell :tangle ~/.local/bin/code-oss
  code "$@"
#+end_src
* Helper code
These scripts are used as snippets or noweb references within this org file.
** =find-alt-cmd(name)=
Returns the second executable with the given name, looked up in execpath.
#+NAME: find-alt-cmd
#+begin_src emacs-lisp :var name="nil" :results silent
  (let ((counter 0) (executable))
    (locate-file name exec-path nil
                 (lambda (path)
                   (if (file-executable-p path)
                       (setq counter (+ counter 1)))
                   (> counter 1))))
#+end_src

# Quick test...
#+CALL: find-alt-cmd(name="emacs")
** =eval-real-uid=
#+NAME: eval-real-uid
#+begin_src emacs-lisp
  (user-real-uid)
#+end_src
** =add-create-frame-option-if-term-dumb=
#+NAME: add-create-frame-option-if-term-dumb
#+begin_src shell :tangle no
  set -- "$@" $([ "$TERM" = "dumb" ] && echo --create-frame || echo '')
#+end_src
** =eval-user-name=
#+NAME: eval-user-name
#+begin_src elisp
  (user-login-name)
#+end_src
** =eval-user-home=
#+NAME: eval-user-home
#+begin_src emacs-lisp :cache yes
  (getenv "HOME")
#+end_src
* Local variables                                                  :noexport:
# Local Variables:
# org-confirm-babel-evaluate: nil
# End: