skel/dotfiles/shenv

#!/bin/sh
# Sourced by zshrc as well as bash.
# Should only use POSIX shell constructs.
# shellcheck shell=sh

umask 027

# Paths and preferences
export PYTHONPATH="$HOME/.python:$PYTHONPATH"
export GOPATH="$HOME/go:$HOME/Projects/Go:/usr/share/gocode"
export PATH="$HOME/bin:$HOME/bin/tools:/sbin:/usr/sbin:$PATH:$HOME/go/bin:$HOME/.npm-packages/bin"
export VISUAL=vim
export EDITOR=vim
export DEBEMAIL="david@systemoverlord.com"
export DEBFULLNAME="David Tomaschik"
export LESS="-MR"
export QUOTING_STYLE="literal"  # Coreutils quotes
export HOMEBREW_NO_ENV_HINTS=1

# Fix gnome-terminal
if [ "$TERM" = "xterm" ] && [ "$COLORTERM" = "gnome-terminal" ] ; then
  # Requires `ncurses-base` package for terminfo.
  export TERM="xterm-256color"
fi

# For virtualenvwrapper
export WORKON_HOME="$HOME/.virtualenvs"

# GPG full key id
export GPG_ID=7FD58D9A196DCEEEAD671F94F4D7A7915DEA789B

# things we need in all interactive shells
case "$-" in
  *i*)
    # Terminal preferences for i3
    if [ -z "${TERMINAL}" ] ; then
      for t in urxvt gnome-terminal; do
        if TERMINAL=$(command -v ${t}) ; then
          export TERMINAL
        fi
      done
    fi

    # Browser preferences
    if [ -z "${BROWSER}" ] ; then
      for t in google-chrome-beta google-chrome firefox ; do
        if BROWSER=$(command -v ${t}); then
          export BROWSER
          break
        fi
      done
    fi

    # Setup locale
    if test -x /usr/bin/locale ; then
      for l in en_US.utf8 en_US.UTF-8 C.UTF-8 C.utf8 C ; do
        if /usr/bin/locale -a | grep -q "${l}" ; then
          export LC_CTYPE=${l}
          export LC_NUMERIC=${l}
          export LC_TIME=${l}
          export LC_MONETARY=${l}
          export LC_MESSAGES=${l}
          export LC_PAPER=${l}
          export LC_NAME=${l}
          export LC_ADDRESS=${l}
          export LC_TELEPHONE=${l}
          export LC_MEASUREMENT=${l}
          export LC_IDENTIFICATION=${l}
          break
        fi
      done
    else
      export LC_CTYPE=C
      export LC_NUMERIC=C
      export LC_TIME=C
      export LC_MONETARY=C
      export LC_MESSAGES=C
      export LC_PAPER=C
      export LC_NAME=C
      export LC_ADDRESS=C
      export LC_TELEPHONE=C
      export LC_MEASUREMENT=C
      export LC_IDENTIFICATION=C
    fi
    export LC_COLLATE=C
    ;;
esac


# Opt out of .net telemetry
export DOTNET_CLI_TELEMETRY_OPTOUT=1

# Suppress lvm warnings
export LVM_SUPPRESS_FD_WARNINGS=1

# Default disable SSH forwarding in EARTHLY
export EARTHLY_SSH_AUTH_SOCK=""

# Handle SSH_AUTH_SOCK for tmux consistency
case "$-" in
  *i*)
    _SSH_AUTH_LINK="${HOME}/.ssh/ssh_auth_sock"

    # Helper to check if a path is our link or points to it
    _is_link_path() {
      [ -z "$1" ] && return 1
      _target="${_SSH_AUTH_LINK:-${HOME}/.ssh/ssh_auth_sock}"
      [ "$1" = "${_target}" ] && { unset -v _target; return 0; }
      if [ -L "$1" ] && command -v readlink >/dev/null 2>&1; then
        _T=$(readlink "$1")
        # Handle relative symlinks
        case "${_T}" in /*) ;; *) _T="$(dirname "$1")/${_T}" ;; esac
        [ "${_T}" = "${_target}" ] && { unset -v _target _T; return 0; }
        unset -v _T
      fi
      unset -v _target
      return 1
    }

    # Helper to check if an SSH socket is valid and useful
    _is_valid_ssh_sock() {
      [ -z "$1" ] && return 1
      [ -S "$1" ] || return 1

      if command -v nc >/dev/null 2>&1; then
        # Use nc to quickly check if the socket is listening.
        # We use -N to shutdown the socket after EOF on stdin (for OpenBSD netcat compatibility).
        if echo '' | nc -w 1 -N -U "$1" >/dev/null 2>&1; then
          return 0
        fi
      fi

      if command -v ssh-add >/dev/null 2>&1; then
        SSH_AUTH_SOCK="$1" ssh-add -l >/dev/null 2>&1
        case "$?" in
          0|1) return 0 ;;
          *)   return 1 ;;
        esac
      fi

      if command -v nc >/dev/null 2>&1; then
        return 1
      fi
      return 0
    }

    # Function to get the path to the socket for the local ssh-agent
    get_local_ssh_agent_sock() {
      _found=""
      if [ "$(uname)" = "Darwin" ]; then
        _found=$(launchctl getenv SSH_AUTH_SOCK 2>/dev/null)
      elif command -v systemctl >/dev/null 2>&1; then
        # Query systemd socket units directly to avoid environment overrides.
        for _u in ssh-agent.socket openssh-agent.socket gcr-ssh-agent.socket gpg-agent-ssh.socket; do
          _p=$(systemctl --user show "${_u}" -p Listen 2>/dev/null | cut -d= -f2- | cut -d' ' -f1)
          if ! _is_link_path "${_p}" && _is_valid_ssh_sock "${_p}"; then
            _found="${_p}"
            break
          fi
        done
        # Fallback to systemd environment
        if [ -z "${_found}" ] || _is_link_path "${_found}" || ! _is_valid_ssh_sock "${_found}"; then
          _found=$(systemctl --user show-environment 2>/dev/null | grep "^SSH_AUTH_SOCK=" | cut -d= -f2-)
        fi
      fi

      if [ -n "${_found}" ] && ! _is_link_path "${_found}" && _is_valid_ssh_sock "${_found}"; then
        echo "${_found}"
        unset -v _found _u _p
        return 0
      fi

      # Search common fallback paths
      _u=$(id -u)
      for _p in "/run/user/${_u}/keyring/ssh" "/run/user/${_u}/ssh-agent.socket" "/run/user/${_u}/openssh_agent" "/run/user/${_u}/gnupg/S.gpg-agent.ssh"; do
        if ! _is_link_path "${_p}" && _is_valid_ssh_sock "${_p}"; then
          echo "${_p}"
          unset -v _found _u _p
          return 0
        fi
      done

      # Search /run/user/UID and /tmp for agent.* sockets
      _search=""
      for _d in "/run/user/${_u}" /tmp; do [ -d "${_d}" ] && _search="${_search} ${_d}"; done
      if [ -n "${_search}" ]; then
        for _p in $(find ${_search} -maxdepth 2 -type s -name 'agent.*' 2>/dev/null); do
          if ! _is_link_path "${_p}" && _is_valid_ssh_sock "${_p}"; then
            echo "${_p}"
            unset -v _found _u _p _search _d
            return 0
          fi
        done
      fi

      unset -v _found _u _p _search _d
      return 1
    }

    # Function to reset SSH_AUTH_SOCK to the local ssh-agent
    reset_ssh_socket() {
      _rss_sock=$(get_local_ssh_agent_sock)
      if [ -n "${_rss_sock}" ]; then
        _rss_link="${HOME}/.ssh/ssh_auth_sock"
        mkdir -p "$(dirname "${_rss_link}")"
        ln -sf "${_rss_sock}" "${_rss_link}"
        export SSH_AUTH_SOCK="${_rss_link}"
        if command -v systemctl >/dev/null 2>&1; then
          systemctl --user set-environment SSH_AUTH_SOCK="${_rss_link}" 2>/dev/null
        fi
        echo "Reset SSH_AUTH_SOCK to ${_rss_link} -> ${_rss_sock}"
        unset -v _rss_sock _rss_link
        return 0
      else
        echo "reset_ssh_socket: no valid local ssh-agent socket found." >&2
        unset -v _rss_sock
        return 1
      fi
    }

    _CANDIDATE=""

    # 1. If current environment has a valid socket that is NOT our link, it's a prime candidate
    # (e.g. fresh SSH login: sshd sets SSH_AUTH_SOCK to the raw forwarded socket before ssh/rc
    # rewrites it to the stable symlink; the shell inherits the original raw path).
    if ! _is_link_path "${SSH_AUTH_SOCK:-}" && _is_valid_ssh_sock "${SSH_AUTH_SOCK:-}"; then
      _CANDIDATE="${SSH_AUTH_SOCK}"
    fi

    # 2. Only look for a system agent if the stable link is already broken. If the link is
    # valid (e.g. a tmux pane where SSH_AUTH_SOCK points to our symlink which ssh/rc just
    # updated to the forwarded socket), leave it alone — don't clobber it with a local agent.
    if [ -z "${_CANDIDATE}" ] && ! _is_valid_ssh_sock "${_SSH_AUTH_LINK}"; then
      _CANDIDATE=$(get_local_ssh_agent_sock)
    fi

    # 3. Sync the stable link if we found a valid "real" socket.
    if [ -n "${_CANDIDATE}" ] && ! _is_link_path "${_CANDIDATE}" && _is_valid_ssh_sock "${_CANDIDATE}"; then
      mkdir -p "$(dirname "${_SSH_AUTH_LINK}")"
      ln -sf "${_CANDIDATE}" "${_SSH_AUTH_LINK}"
      export SSH_AUTH_SOCK="${_SSH_AUTH_LINK}"
      # Update systemd if present to keep everything in sync
      if command -v systemctl >/dev/null 2>&1; then
        systemctl --user set-environment SSH_AUTH_SOCK="${_SSH_AUTH_LINK}" 2>/dev/null
      fi
    elif _is_valid_ssh_sock "${_SSH_AUTH_LINK}"; then
      # If we found nothing better but the link is valid, use it.
      export SSH_AUTH_SOCK="${_SSH_AUTH_LINK}"
    fi

    unset _SSH_AUTH_LINK _CANDIDATE
    ;;
esac

# Setup XDG-like dirs on MacOS
# Based on https://leebyron.com/til/mac-xdg/
if [ "$(uname)" = "Darwin" ] ; then
  export XDG_BIN_HOME="${XDG_BIN_HOME:-$HOME/.local/bin}"
  export XDG_CACHE_HOME="${XDG_CACHE_HOME:-$HOME/Library/Caches}"
  export XDG_CONFIG_HOME="${XDG_CONFIG_HOME:-$HOME/.config}"
  export XDG_DATA_HOME="${XDG_DATA_HOME:-$HOME/.local/share}"
  # Using id -u for better POSIX compatibility than $UID
  export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-$TMPDIR/runtime-$(id -u)}"
  export XDG_STATE_HOME="${XDG_STATE_HOME:-$HOME/.local/state}"
  export PATH="${HOME}/bin/macos:${PATH}"
elif [ "$(uname)" = "Linux" ] ; then
  export PATH="${HOME}/bin/linux:${PATH}"
fi

if test -e "$HOME/.localenv"; then
  # shellcheck source=/dev/null
  . "$HOME/.localenv"
else
  true
fi