tmux-stare @ 29a70cd

#!/usr/bin/env bash

CURRENT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

source "$CURRENT_DIR/helpers.sh"

declare S=$'\t'

# === common

get_current_session_name() {

  if [ "$(tmux display-message -p "#{session_grouped}")" = 0 ]; then

    tmux display-message -p "#{session_name}" 2>/dev/null || true

  else

    tmux display-message -p "#{session_group}" 2>/dev/null || true

  fi

}

session_id_map_file() { echo "$(get_opt_dir)/.session_ids" }

sync_session_id_map() {

  local map_file="$(session_id_map_file)"

  tmux list-sessions -F "#{session_id}${S}#{session_name}" >"$map_file"

}

get_session_id_by_name() {

  local session_name="$1"

  tmux display-message -p -t "$session_name" "#{session_id}" 2>/dev/null

}

get_session_name_by_id() {

  local session_id="$1"

  local map_file="$(session_id_map_file)"

  [[ -f "$map_file" ]] || return 1

  awk -F"$S" -v session_id="$session_id" '$1 == session_id { print $2; exit }' "$map_file"

}

upsert_session_id_entry() {

  local session_id="$1"

  local session_name="$2"

  local map_file="$(session_id_map_file)"

  local tmp_file="${map_file}.tmp"

  [[ -z "$session_id" || -z "$session_name" ]] && return 1

  [[ -f "$map_file" ]] || : >"$map_file"

  awk -F"$S" -v OFS="$S" -v session_id="$session_id" -v session_name="$session_name" '

    $1 == session_id {

      $2 = session_name

      found = 1

    }

    { print }

    END {

      if (!found) print session_id, session_name

    }

  ' "$map_file" >"$tmp_file" && mv "$tmp_file" "$map_file"

}

remember_session_identity() {

  local session_name="$1"

  local session_id

  session_id="$(get_session_id_by_name "$session_name")"

  [[ -n "$session_id" ]] && upsert_session_id_entry "$session_id" "$session_name"

}

rename_session_files() {

  local old="$1"

  local new="$2"

  local dir="$(get_opt_dir)"

  local old_last="${dir}/${old}_last"

  local new_last="${dir}/${new}_last"

  local global_last="${dir}/last"

  [[ -z "$old" || -z "$new" || "$old" == "$new" ]] && return 1

  [[ -e "$old_last" ]] || return 0

  [[ -e "$new_last" ]] && return 1

  if [[ -L "$old_last" ]]; then

    local actual="$(readlink "$old_last")"

    local actual_name

    local new_actual

    [[ "$actual" != /* ]] && actual="${dir}/${actual}"

    actual_name="$(basename "$actual")"

    if [[ "$actual_name" == "${old}_"* && -e "$actual" ]]; then

      new_actual="${dir}/${new}_${actual_name#${old}_}"

      mv "$actual" "$new_actual"

      ln -sf "$new_actual" "$new_last"

      rm -f "$old_last"

    else

      mv "$old_last" "$new_last"

    fi

  else

    mv "$old_last" "$new_last"

  fi

  if [[ -L "$global_last" ]]; then

    local global_target="$(readlink "$global_last")"

    local global_target_name="$(basename "$global_target")"

    if [[ "$global_target_name" == "${old}_last" ]]; then

      ln -sf "$new_last" "$global_last"

    fi

  fi

}

apply_session_rename() {

  local session_id="$1"

  local new_name="$2"

  local old_name="${3:-}"

  [[ -z "$session_id" || -z "$new_name" ]] && return 1

  [[ -n "$old_name" ]] || old_name="$(get_session_name_by_id "$session_id" || true)"

  if [[ -n "$old_name" && "$old_name" != "$new_name" ]]; then

    rename_session_files "$old_name" "$new_name"

  fi

  upsert_session_id_entry "$session_id" "$new_name"

}

rename_session() {

  local old="$1"

  local new="$2"

  local session_id

  [[ -z "$new" || "$old" == "$new" ]] && return 1

  [[ -e "$(get_opt_dir)/${new}_last" ]] && return 1

  tmux has-session -t "$new" 2>/dev/null && return 1

  session_id="$(get_session_id_by_name "$old")"

  [[ -n "$session_id" ]] || return 1

  tmux rename-session -t "$old" "$new" 2>/dev/null || return 1

  apply_session_rename "$session_id" "$new" "$old"

}

handle_session_renamed_hook() {

  local session_id="$1"

  local new_name="$2"

  [[ -z "$session_id" || -z "$new_name" ]] && return 1

  apply_session_rename "$session_id" "$new_name"

}

# === save

save_cwd() {

  local session_name="$1"

  local save_file="$2"

  tmux display-message -p -t "$session_name" -F "#{session_path}" >>"$save_file"

}

save_windows() {

  local session_name="$1"

  local save_file="$2"

  local format="window$S#{window_index}$S#{window_name}$S#{window_layout}$S#{window_active}"

  tmux list-windows -t "$session_name" -F "$format" >>"$save_file"

}

get_pane_child_pids() {

  local pane_pid="$1"

  ps -ao ppid=,pid= | awk -v pane_pid="$pane_pid" '$1 == pane_pid { print $2 }'

}

format_process_command() {

  local pid="$1"

  [[ -r "/proc/${pid}/cmdline" ]] || return 1

  xargs -0 bash -c 'printf "%q " "$0" "$@"' <"/proc/${pid}/cmdline" 2>/dev/null | sed 's/[[:space:]]*$//'

}

build_command_from_pids() {

  local pids="$1"

  local pid

  local formatted

  local command=""

  for pid in $pids; do

    formatted="$(format_process_command "$pid")"

    [[ -z "$formatted" ]] && continue

    [[ -n "$command" ]] && command+=" | "

    command+="$formatted"

  done

  printf "%s" "$command"

}

collect_process_names() {

  local pids="$1"

  local pid

  local first_arg

  local name

  for pid in $pids; do

    [[ -r "/proc/${pid}/cmdline" ]] || continue

    first_arg="$(tr '\0' '\n' <"/proc/${pid}/cmdline" 2>/dev/null | head -n1)"

    [[ -z "$first_arg" ]] && continue

    name="$(basename "$first_arg")"

    [[ -n "$name" ]] && printf "%s\n" "$name"

  done | sort -u

}

strip_prompt_prefix() {

  local line="$1"

  if [[ "$line" =~ [\$\#\%\>][[:space:]]+.+$ ]]; then

    sed -E 's/^.*[#$%>][[:space:]]+//' <<<"$line"

  fi

}

find_command_from_pane_history() {

  local pane_target="$1"

  local process_names="$2"

  local line

  local candidate

  local name

  while IFS= read -r line; do

    [[ -z "$line" ]] && continue

    candidate="$(strip_prompt_prefix "$line")"

    [[ -z "$candidate" ]] && continue

    while IFS= read -r name; do

      [[ -z "$name" ]] && continue

      if [[ "$candidate" == *"$name"* ]]; then

        printf "%s" "$candidate"

        return 0

      fi

    done <<<"$process_names"

  done < <(tmux capture-pane -pJ -S -200 -t "$pane_target" 2>/dev/null | tac)

}

save_panes() {

  local session_name="$1"

  local save_file="$2"

  local format="pane$S#{pane_index}$S#{pane_current_path}$S#{pane_active}$S#{window_index}$S#{pane_pid}"

  tmux list-panes -s -t "$session_name" -F "$format" |

    while IFS="$S" read -r line; do

      IFS="$S" read -r _ pane_index _ _ window_index pane_pid <<<"$line"

      pids="$(get_pane_child_pids "$pane_pid")"

      command="$(build_command_from_pids "$pids")"

      if [[ -n "$command" ]]; then

        process_names="$(collect_process_names "$pids")"

        pane_target="${session_name}:${window_index}.${pane_index}"

        pane_command="$(find_command_from_pane_history "$pane_target" "$process_names")"

        [[ -n "$pane_command" ]] && command="$pane_command"

      fi

      awk -v command="$command" \

        'BEGIN {FS=OFS="\t"} {$6=command; print}' \

        <<<"$line" >>"$save_file"

    done

}

link_session_last() {

  local save_file="$1"

  local last_file="$2"

  if ! cmp -s "$save_file" "$last_file"; then

    ln -sf "$save_file" "$last_file"

  else

    rm "$save_file"

  fi

}

link_last() {

  local save_file="$1"

  local save_dir="$2"

  ln -sf "$save_file" "$save_dir"/last

}

save_session() {

  local session_name="$1"

  local save_dir="$(get_opt_dir)"

  local save_file="${save_dir}/${session_name}_$(get_time)"

  local last_file="${save_dir}/${session_name}_last"

  save_cwd "$session_name" "$save_file"

  save_windows "$session_name" "$save_file"

  save_panes "$session_name" "$save_file"

  link_session_last "$save_file" "$last_file"

  link_last "$last_file" "$save_dir"

  remember_session_identity "$session_name"

}

save_all_sessions() {

  tmux list-sessions -F "#{session_name}" | while read -r session; do

    save_session "$session"

  done

  local current_session="$(get_current_session_name)"

  if [[ -n "$current_session" ]]; then

    link_last "$(get_opt_dir)/${current_session}_last" "$(get_opt_dir)"

  fi

}

unload_session() {

  local session_name="$1"

  save_session "$session_name"

  tmux kill-session -t "$session_name"

}

# === restore

restore_pane_processes_enabled() {

  local processes="$(get_opt_processes)"

  [[ "$processes" != "false" ]]

}

restore_all_processes() {

  local processes="$(get_opt_processes)"

  [[ "$processes" == ":all:" ]]

}

restore_list() {

  get_opt_processes

}

get_proc_match_element() {

  local proc="$1"

  printf "%s" "${proc%%->*}"

}

proc_matches_command() {

  local command="$1"

  local match="$2"

  if [[ "${match:0:1}" == "~" ]]; then

    local relaxed="${match#~}"

    [[ "$command" == *"$relaxed"* ]]

  else

    [[ "$command" == "$match" || "$command" == "$match "* ]]

  fi

}

command_on_restore_list() {

  local command="$1"

  local proc

  local match

  local restore_list_value

  restore_list_value="$(restore_list)"

  # shellcheck disable=SC2086

  eval "set -- $restore_list_value"

  for proc in "$@"; do

    match="$(get_proc_match_element "$proc")"

    if proc_matches_command "$command" "$match"; then

      return 0

    fi

  done

  return 1

}

should_restore_command() {

  local command="$1"

  [[ -z "$command" ]] && return 1

  restore_pane_processes_enabled || return 1

  restore_all_processes && return 0

  command_on_restore_list "$command"

}

restore_session_from_file() {

  local session_file="$1"

  local session_name=$(basename "$session_file" | sed 's/_last$//')

  exec <"$session_file"

  start_spinner "Restoring session $session_name"

  local session_path="$(head -n1)"

  [[ -n "$session_path" ]] || session_path="$HOME"

  tmux new-session -ds "$session_name" -c "$session_path"

  declare -A window_layouts

  declare active_window

  while read -r line; do

    case $line in

    window*)

      IFS=$S read -r _ window_index window_name window_layout window_active <<<"$line"

      window_id="$session_name:$window_index"

      tmux new-window -k -t "$window_id" -n "$window_name"

      window_layouts["$window_id"]="$window_layout"

      if [[ "$window_active" == "1" ]]; then

        active_window="$window_id"

      fi

      ;;

    pane*)

      IFS=$S read -r _ pane_index pane_current_path pane_active window_index command <<<"$line"

      if [[ "$pane_index" == "$(get_tmux_option base-index 0)" ]]; then

        tmux send-keys -t "$session_name:$window_index" "cd \"$pane_current_path\"" Enter "clear" Enter

      else

        tmux split-window -d -t "$session_name:$window_index" -c "$pane_current_path"

      fi

      if [[ "$pane_active" == "1" ]]; then

        tmux select-pane -t "$session_name:$window_index.$pane_index"

      fi

      if should_restore_command "$command"; then

        tmux send-keys -t "$session_name:$window_index.$pane_index" "$command" Enter

      fi

      ;;

    esac

  done

  for window in "${!window_layouts[@]}"; do

    tmux select-layout -t "$window" "${window_layouts[$window]}"

  done

  tmux select-window -t "$active_window"

  tmux switch-client -t "$session_name"

  stop_spinner "Session restored"

}

restore_session() {

  local session_name="$1"

  if tmux has-session -t "$session_name" 2>/dev/null; then

    tmux switch-client -t "$session_name"

    return 0

  fi

  local session_file="$(get_opt_dir)/${session_name}_last"

  if [[ ! -f "$session_file" ]]; then

    tmux display-message "No saved session found for: $session_name"

    return 1

  fi

  restore_session_from_file "$session_file"

}

restore_last() {

  local last_file="$(get_opt_dir)/last"

  if [[ ! -e "$last_file" ]]; then

    tmux display-message "No last session saved"

    return 1

  fi

  local session_name=$(basename "$(readlink "$last_file")" | sed 's/_last$//')

  restore_session "$session_name"

}