config/tmux
1
0
Fork 0
Code Issues 4 Pull Requests Releases Wiki Activity

Override ^p/^n in agent session to switch between root windows

Browse Source
This commit is contained in:
Kenneth Benzie
2026-09-14 11:55:27 +01:00
parent 4ac16ee7b4
commit 9ce131462f
4 changed files with 242 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
agent-nav.sh Executable file
View File

@@ -0,0 +1,111 @@
#!/usr/bin/env bash
# Cycle the agent popup through the windows of the session underneath it rather
# than through the agent session's own window list. Bound to <prefix>C-n and
# <prefix>C-p inside the agent session (see tmux.conf).
#
# Root windows with no agent window are stepped over; cycling never creates an
# agent window, only <prefix>A does. Both the client underneath and the popup
# move, so closing the popup leaves you on the window you cycled to.
set -e
direction=${1:-next}
us=$'\x1f'
# Fall back to plain window cycling within the agent session when there is no
# usable client underneath (popup opened before this was configured, or the
# recorded client has gone away).
fallback() {
case $direction in
prev) tmux previous-window -t agent ;;
*) tmux next-window -t agent ;;
esac
exit 0
}
popup_client=$(tmux display-message -p '#{@agent_popup_client}' 2>/dev/null || true)
[ -n "$popup_client" ] || fallback
# The session and window underneath the popup, as the client sees them now.
client_info=$(tmux list-clients -F "#{client_name}$us#{session_name}$us#{window_id}" \
| awk -v FS="$us" -v client="$popup_client" '$1 == client { print $2 FS $3; exit }')
[ -n "$client_info" ] || fallback
IFS=$us read -r client_session client_window <<<"$client_info"
# Every agent window, with what it is keyed to.
agent_ids=()
agent_dirs=()
agent_origins=()
while IFS=$us read -r window_id dir origin; do
[ -n "$dir" ] || continue
agent_ids+=("$window_id")
agent_dirs+=("$dir")
agent_origins+=("$origin")
done < <(tmux list-windows -t agent \
-F "#{window_id}$us#{@agent_dir}$us#{@agent_origin_window}" 2>/dev/null || true)
[ ${#agent_ids[@]} -gt 0 ] || exit 0
# The agent window serving a root window: by recorded origin first, then by the
# directory its first pane sits in. Mirrors agent-sync.sh's resolution, reversed.
agent_window_for() {
local root_window=$1 start_path=$2 current_path=$3 i
for i in "${!agent_ids[@]}"; do
if [ -n "${agent_origins[$i]}" ] && [ "${agent_origins[$i]}" = "$root_window" ]; then
printf '%s\n' "${agent_ids[$i]}"
return 0
fi
done
for i in "${!agent_ids[@]}"; do
if [ "${agent_dirs[$i]}" = "$start_path" ] || [ "${agent_dirs[$i]}" = "$current_path" ]; then
printf '%s\n' "${agent_ids[$i]}"
return 0
fi
done
return 1
}
# The underlying session's windows, in its own order, each with its first pane's
# directory. Panes are listed grouped by window in index order.
root_windows=()
root_paths=()
seen_window=""
while IFS=$us read -r window_id start_path current_path; do
[ "$window_id" != "$seen_window" ] || continue
seen_window=$window_id
root_windows+=("$window_id")
root_paths+=("$start_path$us$current_path")
done < <(tmux list-panes -s -t "$client_session" \
-F "#{window_id}$us#{pane_start_path}$us#{pane_current_path}" 2>/dev/null || true)
count=${#root_windows[@]}
[ "$count" -gt 0 ] || exit 0
# Where the client sits in that order.
current=0
for i in "${!root_windows[@]}"; do
if [ "${root_windows[$i]}" = "$client_window" ]; then
current=$i
break
fi
done
if [ "$direction" = prev ]; then step=-1; else step=1; fi
# Walk in that direction for the first window with an agent window, wrapping.
# Landing back on the starting window means nothing else has one: selecting it
# again is a no-op, which is the wanted behaviour.
i=$current
for _ in $(seq 1 "$count"); do
i=$(( (i + step + count) % count ))
target_root=${root_windows[$i]}
IFS=$us read -r start_path current_path <<<"${root_paths[$i]}"
target_agent=$(agent_window_for "$target_root" "$start_path" "$current_path") || continue
# Re-key the agent window to the window being moved to, so the sync hook that
# the select below fires agrees with what happened here instead of dragging
# the client back to wherever that window was last opened from.
tmux set-window-option -t "$target_agent" @agent_origin_window "$target_root"
tmux select-window -t "$target_root"
tmux select-window -t "$target_agent"
exit 0
done

90
agent-sync.sh Executable file
View File

@@ -0,0 +1,90 @@
#!/usr/bin/env bash
# Move the client that opened the agent popup to the root window matching the
# agent session's current window. Installed by agent.sh as the agent session's
# session-window-changed hook, so it runs for any window change made inside the
# popup: <prefix>C-n, <prefix>C-p, select-window, choose-tree or the mouse.
#
# Set @agent_follow_session to "off" to keep the opening client in the session
# it is already on, never switching it to the session owning the match.
set -e
# Fields are joined with a unit separator, not a tab: `read` folds runs of tabs
# and spaces even when IFS names them, so an unset option in the middle would
# silently shift every field after it.
us=$'\x1f'
# Everything recorded about the agent session's current window, in one
# round-trip. Format lookups rather than show-option, so unset user options come
# back empty instead of logging "invalid option" into the tmux message log.
state=$(tmux display-message -p -t agent "#{session_attached}$us#{@agent_dir}\
$us#{@agent_origin_window}$us#{@agent_popup_client}$us#{@agent_follow_session}" \
2>/dev/null || true)
IFS=$us read -r attached agent_dir origin_window popup_client follow <<<"$state"
# Only sync while a popup is actually attached. Without this guard the
# detach-client + kill-window agent-cmd.sh performs when an agent exits would
# drag the root client to whichever window tmux picks next.
[ "${attached:-0}" -gt 0 ] || exit 0
[ -n "$agent_dir" ] || exit 0
# An empty session means the recorded client has since gone away.
client_session=""
if [ -n "$popup_client" ]; then
client_session=$(tmux list-clients -F "#{client_name}$us#{session_name}" \
| awk -v FS="$us" -v client="$popup_client" '$1 == client { print $2; exit }')
fi
target_window=""
target_session=""
# Prefer the recorded origin window, as long as it still exists.
if [ -n "$origin_window" ]; then
while IFS=$us read -r window_id session_name; do
if [ "$window_id" = "$origin_window" ] && [ "$session_name" != agent ]; then
target_window=$window_id
target_session=$session_name
break
fi
done < <(tmux list-windows -a -F "#{window_id}$us#{session_name}")
fi
# Otherwise match the recorded directory against root windows. This covers agent
# windows created before origin recording existed, and root windows that have
# been recreated since.
if [ -z "$target_window" ]; then
seen_window=""
while IFS=$us read -r window_id session_name start_path current_path; do
# Panes are listed grouped by window in index order, so the first row for a
# window is its first pane.
[ "$window_id" != "$seen_window" ] || continue
seen_window=$window_id
[ "$session_name" != agent ] || continue
[ "$start_path" = "$agent_dir" ] || [ "$current_path" = "$agent_dir" ] || continue
# Prefer a window in the session the opening client is already on.
if [ "$session_name" = "$client_session" ]; then
target_window=$window_id
target_session=$session_name
break
fi
if [ -z "$target_window" ]; then
target_window=$window_id
target_session=$session_name
fi
done < <(tmux list-panes -a -F "#{window_id}$us#{session_name}\
$us#{pane_start_path}$us#{pane_current_path}")
fi
# No match: leave the root sessions alone rather than inventing a window.
[ -n "$target_window" ] || exit 0
# Window ids are server-global, so this moves the owning session whichever
# client happens to be on it.
tmux select-window -t "$target_window" 2>/dev/null || exit 0
# Selecting is enough when the client is already on the target session.
[ -n "$client_session" ] || exit 0
[ "$follow" != off ] || exit 0
if [ -n "$target_session" ] && [ "$target_session" != "$client_session" ]; then
tmux switch-client -c "$popup_client" -t "$target_session"
fi

22
agent.sh
View File

@@ -9,6 +9,16 @@ dir="${PWD:-$HOME}"
# Use the directory basename as window name
window_name=$dir
# The client that opened the popup, recorded by the `bind A` binding. Its
# current window is the root window <prefix>A was pressed in; the popup cannot
# pass that through itself, so resolve it here before attaching.
popup_client=$(tmux display-message -p '#{@agent_popup_client}' 2>/dev/null || true)
origin_window=""
if [ -n "$popup_client" ]; then
origin_window=$(tmux list-clients -F $'#{client_name}\x1f#{window_id}' \
| awk -v FS=$'\x1f' -v client="$popup_client" '$1 == client { print $2; exit }')
fi
# Create the agent session if it doesn't exist
if ! tmux has-session -t agent; then
tmux new-session -ds agent -c "$dir" -n "$window_name" "$script_dir/agent-cmd.sh"
@@ -20,6 +30,9 @@ fi
tmux set-option -t agent status off
tmux set-option -t agent remain-on-exit on
tmux set-option -t agent default-command "$script_dir/agent-cmd.sh"
# Session-scoped (not -g) so the root-session window changes agent-sync.sh makes
# cannot re-trigger it.
tmux set-hook -t agent session-window-changed "run -b '$script_dir/agent-sync.sh'"
# Search for an existing window with matching directory
target_window=""
@@ -32,6 +45,12 @@ for window_id in $(tmux list-windows -t agent -F '#{window_id}'); do
done
if [ -n "$target_window" ]; then
# Remember which root window this agent window came from, refreshed on every
# invocation. Recorded *before* selecting, so the sync hook select-window
# fires sees this invocation's origin rather than the previous one's.
if [ -n "$origin_window" ]; then
tmux set-window-option -t "$target_window" @agent_origin_window "$origin_window"
fi
# Select the existing window
tmux select-window -t "$target_window"
else
@@ -39,6 +58,9 @@ else
tmux new-window -t agent -c "$dir" -n "$window_name"
# Store the directory in a window option for later matching
tmux set-window-option -t agent @agent_dir "$dir"
if [ -n "$origin_window" ]; then
tmux set-window-option -t agent @agent_origin_window "$origin_window"
fi
fi
# Prune windows whose recorded directory no longer exists. This runs after the

22
tmux.conf
View File

@@ -71,6 +71,9 @@ set -ga terminal-overrides 'xterm*:smxx=\E[9m'
if -b '~/.config/tmux/check-version.sh ">= 3.2" and "< 3.3"' {
bind A if -F '#{==:#{session_name},agent}' { detach-client } {
# Record the opening client so agent-sync.sh can move it along with the
# window selected inside the popup.
run-shell "tmux set -g @agent_popup_client '#{client_name}'"
display-popup -d '#{pane_current_path}' -w 50% -h 90% -E ~/.config/tmux/agent.sh
}
bind H display-popup -w 75% -h 75% -E htop
@@ -81,6 +84,9 @@ if -b '~/.config/tmux/check-version.sh ">= 3.2" and "< 3.3"' {
}
if -b '~/.config/tmux/check-version.sh ">= 3.3"' {
bind A if -F '#{==:#{session_name},agent}' { detach-client } {
# Record the opening client so agent-sync.sh can move it along with the
# window selected inside the popup.
run-shell "tmux set -g @agent_popup_client '#{client_name}'"
display-popup -S fg=#54546D -b rounded -d '#{pane_current_path}' -w 75% -h 90% -E ~/.config/tmux/agent.sh
}
bind H display-popup -S fg=#54546D -b rounded -w 50% -h 75% -E htop
@@ -92,9 +98,19 @@ if -b '~/.config/tmux/check-version.sh ">= 3.3"' {
bind P run-shell ~/.config/tmux/project.sh
# Restore old next/previous window bindings
bind C-n next-window
bind C-p previous-window
# Restore old next/previous window bindings. Inside the agent popup these walk
# the windows of the session underneath instead, skipping any that have no agent
# window, so the popup and the client below it move together.
bind C-n if -F '#{==:#{session_name},agent}' {
run -b '~/.config/tmux/agent-nav.sh next'
} {
next-window
}
bind C-p if -F '#{==:#{session_name},agent}' {
run -b '~/.config/tmux/agent-nav.sh prev'
} {
previous-window
}
# Kill current window
bind W kill-window