Tmux — Terminal Multiplexer Mastery

# Find the tmux server process and its socket
$ pgrep -a tmux
48291 tmux new -s dev

$ ls -la /tmp/tmux-501/
total 0
drwx------  3 ash  wheel  96 Jun 10 09:14 .
srwxrwx---  1 ash  wheel   0 Jun 10 09:14 default

# The 's' in srwxrwx--- means it is a Unix socket
# Every tmux command communicates through this file

$ tmux list-sessions
dev: 2 windows (created Tue Jun 10 09:14:22 2025) (attached)
ops: 1 windows (created Tue Jun 10 09:30:05 2025)

# Format output for scripting
$ tmux list-sessions -F '#{session_name}: #{session_windows} windows, attached=#{session_attached}'
dev: 2 windows, attached=1
ops: 1 windows, attached=0

# List windows for a specific session
$ tmux list-windows -t dev
0: editor* (2 panes) [200x50] [layout e8b4,200x50,0,0{100x50,0,0,0,99x50,101,0,1}]
1: server- (1 panes) [200x50] [layout 2a26,200x50,0,0,2]

# The * marks the current window, - marks the last window
# Use -a to list all windows across every session
$ tmux list-windows -a -F '#{session_name}:#{window_index} #{window_name} #{window_active}'
dev:0 editor 1
dev:1 server 0
ops:0 logs 1

# List panes in the current window
$ tmux list-panes
0: [100x50] [history 1203/50000] (active)
1: [99x50] [history 47/50000]

# Target a specific session:window
$ tmux list-panes -t dev:0 -F '#{pane_index}: #{pane_current_command} #{pane_pid} active=#{pane_active}'
0: nvim 48305 active=1
1: zsh 48310 active=0

# List EVERY pane across the entire server
$ tmux list-panes -a -F '#{session_name}:#{window_index}.#{pane_index} #{pane_current_command}'
dev:0.0 nvim
dev:0.1 zsh
dev:1.0 node
ops:0.0 tail
ops:0.1 htop

# The process tree shows why this works:
$ pstree -p $(pgrep -x tmux | head -1)
tmux(48291)-+-zsh(48305)---nvim(48320)
            |-zsh(48310)
            |-zsh(48340)---node(48355)
            |-zsh(48380)---tail(48395)
            `-zsh(48385)---htop(48400)

# Your SSH session tree is completely separate:
# sshd---bash---tmux(client)  <-- only THIS dies on disconnect

# Reconnect from anywhere:
$ ssh myserver
$ tmux attach -t dev
# Everything is exactly where you left it

# Detach from current session
$ tmux detach          # or press: Ctrl-b d

# List what is running without attaching
$ tmux ls
dev: 2 windows (created Tue Jun 10 09:14:22 2025)
ops: 1 windows (created Tue Jun 10 09:30:05 2025)

# Attach to a named session
$ tmux attach -t dev

# Attach from a SECOND terminal to the same session
# Terminal 2:
$ tmux attach -t dev

# Both clients now mirror the same session in real-time.
# Typing in one terminal shows up in the other.
# Great for pair programming or multi-monitor setups.

# Independent session — completely separate window set
$ tmux new -s dev
$ tmux new -s ops   # ops has its own windows, no connection to dev

# Grouped session — shares windows with "dev" but independent view
$ tmux new -s dev-monitor -t dev

# Now "dev" and "dev-monitor" share the SAME windows.
# But each can view a different window independently:
#   dev          -> viewing window 0 (editor)
#   dev-monitor  -> viewing window 1 (server)
#
# This solves the multi-monitor resize problem:
# each grouped session sizes to its own client.

# Query the current and last window/pane in scripts
$ tmux display-message -p \
  'window: #{window_index}(#{window_name}) last: #{session_last_window}'
window: 0(editor) last: 1

$ tmux display-message -p 'pane: #{pane_index} last-pane: #{window_last_pane}'
pane: 0 last-pane: 1

# Use special tokens in targets:
$ tmux select-window -t !        # jump to last window (same as prefix l)
$ tmux last-pane                  # jump to last pane (same as prefix ;)

# Send a command to a specific pane without switching focus
$ tmux send-keys -t dev:1.0 'npm test' Enter

# Named socket — creates /tmp/tmux-501/work
$ tmux -L work new -s project-a
$ tmux -L work attach -t project-a

# Full path socket — useful for shared pair sessions
$ tmux -S /tmp/pair-session new -s collab
$ chmod 770 /tmp/pair-session
# Colleague attaches with the same socket:
$ tmux -S /tmp/pair-session attach -t collab

# List sessions on a specific socket
$ tmux -L work list-sessions

# Create a named session and immediately split the layout
tmux new-session -s project -n editor -d
tmux send-keys -t project:editor 'vim .' Enter

# Attach to the most recently used session (or create one)
tmux attach-session || tmux new-session -s default

# List sessions with their dimensions and creation time
tmux list-sessions -F '#{session_name}: #{session_windows} windows (#{session_width}x#{session_height})'

# Renumber windows so there are no gaps (1, 2, 5 → 1, 2, 3)
tmux move-window -r

# Create a window that runs a specific command
tmux new-window -n logs 'tail -f /var/log/app.log'

# Swap current window with the next one (move window right)
tmux swap-window -t +1

# Split and run a command in the new pane
tmux split-window -h 'htop'

# Join pane 1 from window 3 into current window as a horizontal split
tmux join-pane -h -s :3.1

# Resize: make the current pane 80 columns wide
tmux resize-pane -x 80

# Resize: make the current pane 24 rows tall
tmux resize-pane -y 24

# Show pane numbers — press the number to jump to that pane
# (increase display time in config: set -g display-panes-time 3000)
tmux display-panes

# Apply main-vertical: big editor pane on left, small terminals on right
tmux select-layout main-vertical

# Set the main pane size for main-* layouts (percentage of window)
tmux set-window-option main-pane-width 65%

# Save the current layout string (for scripting / restoring later)
tmux display-message -p '#{window_layout}'
# Output example: "a]b0,208x54,0,0{148x54,0,0,0,59x54,149,0[59x27,...]}"

# List ALL keybindings across all tables
tmux list-keys

# List only prefix table bindings (the ones after C-b)
tmux list-keys -T prefix

# List only root table bindings (no prefix required)
tmux list-keys -T root

# List copy-mode-vi bindings (active in scroll/copy mode)
tmux list-keys -T copy-mode-vi

# Search for a specific binding — what does C-b s do?
tmux list-keys -T prefix | grep ' s '

# Show all bindings interactively inside tmux
# Press C-b ? to open the binding list

$ tmux list-keys -T prefix | head -15
bind-key -T prefix C-b     send-prefix
bind-key -T prefix C-o     rotate-window
bind-key -T prefix C-z     suspend-client
bind-key -T prefix Space   next-layout
bind-key -T prefix !       break-pane
bind-key -T prefix "       split-window
bind-key -T prefix #       list-buffers
bind-key -T prefix $       command-prompt -I "#S" { rename-session -- "%%" }
bind-key -T prefix %       split-window -h
bind-key -T prefix &       confirm-before -p "kill-window #W? (y/n)" kill-window
bind-key -T prefix '       command-prompt -T window-target { select-window -t "%%" }
bind-key -T prefix (       switch-client -p
bind-key -T prefix )       switch-client -n
bind-key -T prefix ,       command-prompt -I "#W" { rename-window -- "%%" }
bind-key -T prefix -       delete-buffer

# Inside tmux command prompt (C-b :), drop the "tmux" prefix:
# Instead of:  tmux split-window -h
# You type:    split-window -h

# Useful commands to try from the prompt:
#   display-message "#{pane_current_path}"
#   show-options -g
#   source-file ~/.tmux.conf
#   list-commands

# Target format: session:window.pane

tmux send-keys -t work:1.0 'echo hello' Enter   # session "work", window 1, pane 0
tmux select-window -t :2                          # window 2 in current session
tmux select-pane -t :.1                           # pane 1 in current window
tmux kill-session -t myproject                     # session named "myproject"

# Relative targets
tmux select-window -t :+1     # next window
tmux select-window -t :-1     # previous window
tmux select-pane -t :.+       # next pane

# Special tokens
tmux select-window -t :!      # last (most recently active) window
tmux select-pane -t :.!       # last active pane

# Enter copy mode
# prefix + [

# Exit copy mode
# q  or  Escape

# Scroll up/down (emacs-style defaults)
# C-Up / C-Down   or   PgUp / PgDown

# You can also enter copy mode by scrolling with the mouse (if mouse is enabled)
set -g mouse on

# Switch copy mode to vi key bindings
set-window-option -g mode-keys vi

# Vi-style selection and yank
bind-key -T copy-mode-vi v   send-keys -X begin-selection
bind-key -T copy-mode-vi C-v send-keys -X rectangle-toggle
bind-key -T copy-mode-vi y   send-keys -X copy-selection-and-cancel

# Paste with prefix + P (uppercase to avoid conflict with prev-window)
bind P paste-buffer

# Bind / and ? to incremental search (already default in vi mode)
bind-key -T copy-mode-vi / command-prompt -i -p "(search down)" "send -X search-forward-incremental \"%%%\""
bind-key -T copy-mode-vi ? command-prompt -i -p "(search up)"   "send -X search-backward-incremental \"%%%\""

# In copy mode, press / then type a regex pattern:
#   /ERROR|FATAL        — find error lines
#   /[0-9]+\.[0-9]+s    — find timing values like "3.42s"
#   ?def [a-z_]+\(      — search backward for Python function defs

# Press n to jump to next match, N for previous

# List all paste buffers (most recent first)
tmux list-buffers

# Show contents of the most recent buffer
tmux show-buffer

# Show a specific buffer by name
tmux show-buffer -b buffer0001

# Save the most recent buffer to a file
tmux save-buffer ~/output.txt

# Save a specific buffer to a file
tmux save-buffer -b buffer0003 ~/snippet.txt

# Load a file into a new paste buffer
tmux load-buffer ~/input.txt

# Delete a specific buffer
tmux delete-buffer -b buffer0001

# Choose interactively from buffers (shows a selection UI)
# prefix + =

# Increase scrollback to 50,000 lines (default is 2000)
set -g history-limit 50000

# To clear a pane's scrollback history:
# prefix + :  then type  clear-history
# Or bind it:
bind C-l send-keys C-l \; clear-history

# WSL — clip.exe is available by default
set -s copy-command 'clip.exe'

bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel

# For pasting FROM Windows clipboard into tmux:
bind C-v run "powershell.exe Get-Clipboard | tmux load-buffer - && tmux paste-buffer"

# Auto-detect platform and set copy command
if-shell 'command -v pbcopy'    { set -s copy-command 'pbcopy' }
if-shell 'command -v wl-copy'   { set -s copy-command 'wl-copy' }
if-shell 'command -v xclip'     { set -s copy-command 'xclip -selection clipboard' }
if-shell 'command -v xsel'      { set -s copy-command 'xsel --clipboard --input' }
if-shell '[ -n "$WSL_DISTRO_NAME" ]' { set -s copy-command 'clip.exe' }

# ── Copy Mode Configuration ──────────────────────────────────────

# Vi mode for copy-mode key bindings
set-window-option -g mode-keys vi

# Generous scrollback
set -g history-limit 50000

# ── Selection and Yank ───────────────────────────────────────────

# Enter copy mode
bind-key -T prefix [ copy-mode

# v = start selection, C-v = toggle block selection, y = yank
bind-key -T copy-mode-vi v   send-keys -X begin-selection
bind-key -T copy-mode-vi C-v send-keys -X rectangle-toggle
bind-key -T copy-mode-vi y   send-keys -X copy-pipe-and-cancel

# Copy on mouse drag release
bind-key -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel

# Double-click selects word, triple-click selects line
bind-key -T copy-mode-vi DoubleClick1Pane select-pane \; send-keys -X select-word
bind-key -T copy-mode-vi TripleClick1Pane select-pane \; send-keys -X select-line

# ── Paste ────────────────────────────────────────────────────────

# prefix + P to paste (uppercase P avoids conflict with previous-window)
bind P paste-buffer
# prefix + = to choose from buffer list
bind = choose-buffer

# ── Incremental Search ───────────────────────────────────────────

bind-key -T copy-mode-vi / command-prompt -i -p "(search down)" "send -X search-forward-incremental \"%%%\""
bind-key -T copy-mode-vi ? command-prompt -i -p "(search up)"   "send -X search-backward-incremental \"%%%\""

# ── System Clipboard (auto-detect platform) ──────────────────────

# The last matching if-shell wins
if-shell 'command -v xclip'     { set -s copy-command 'xclip -selection clipboard' }
if-shell 'command -v xsel'      { set -s copy-command 'xsel --clipboard --input' }
if-shell 'command -v wl-copy'   { set -s copy-command 'wl-copy' }
if-shell 'command -v pbcopy'    { set -s copy-command 'pbcopy' }
if-shell '[ -n "$WSL_DISTRO_NAME" ]' { set -s copy-command 'clip.exe' }

# ── Convenience ──────────────────────────────────────────────────

# Clear scrollback buffer with prefix + C-l
bind C-l send-keys C-l \; clear-history

# Option A: Ctrl-a (Screen-style, most popular)
set -g prefix C-a
unbind C-b
bind C-a send-prefix

# Option B: Ctrl-Space (ergonomic, no conflict with readline)
# set -g prefix C-Space
# unbind C-b
# bind C-Space send-prefix

# Tell tmux the terminal supports 256 colors (or truecolor — see your terminal docs)
set -s default-terminal "tmux-256color"

# Remove the delay after pressing Escape — critical for Vim/Neovim users.
# Default is 500ms. At 0, Escape is instant.
set -sg escape-time 0

# Start window numbering at 1 instead of 0 (matches keyboard layout)
set -g base-index 1

# Automatically renumber windows when one is closed
# Without this, closing window 2 leaves a gap: 1, 3, 4
set -g renumber-windows on

# Increase scrollback buffer from the default 2000 lines
set -g history-limit 50000

# Enable mouse support — scroll, click to select panes, resize by dragging
set -g mouse on

# Start pane numbering at 1 to match window numbering
setw -g pane-base-index 1

# Use vi-style keys in copy mode (prefix + [)
setw -g mode-keys vi

tmux source-file ~/.tmux.conf

# Reload config with prefix + r
bind r source-file ~/.tmux.conf \; display-message "Config reloaded!"

# Split panes using | and - (intuitive: | is vertical line, - is horizontal)
# -c "#{pane_current_path}" opens the new pane in the same directory
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"

# Also fix the default new-window binding to keep the current path
bind c new-window -c "#{pane_current_path}"

# Unbind the old defaults (optional, keeps things clean)
unbind '"'
unbind %

# ~/.tmux.conf — Starter config
# ─────────────────────────────────────────────

# ── Prefix ──
set -g prefix C-a
unbind C-b
bind C-a send-prefix

# ── Server Options ──
set -s default-terminal "tmux-256color"
set -sg escape-time 0

# ── Session Options ──
set -g base-index 1
set -g renumber-windows on
set -g history-limit 50000
set -g mouse on
set -g display-time 3000

# ── Window Options ──
setw -g pane-base-index 1
setw -g mode-keys vi

# ── Config Reload ──
bind r source-file ~/.tmux.conf \; display-message "Config reloaded!"

# ── Pane Splitting ──
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"
bind c new-window -c "#{pane_current_path}"
unbind '"'
unbind %

# ── Pane Navigation (Vim-style) ──
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

# ── Pane Resizing ──
bind -r H resize-pane -L 5
bind -r J resize-pane -D 5
bind -r K resize-pane -U 5
bind -r L resize-pane -R 5

# Standard binding — requires prefix first
bind key command

# -n : No prefix required — key alone triggers it
bind -n key command

# -r : Repeatable — after prefix, press key multiple times
#      within repeat-time (default 500ms) without re-pressing prefix
bind -r key command

# -T table : Bind key in a specific key table
bind -T copy-mode-vi key command

# Pane navigation — Alt+hjkl, no prefix needed
bind -n M-h select-pane -L
bind -n M-j select-pane -D
bind -n M-k select-pane -U
bind -n M-l select-pane -R

# Pane resizing — prefix + H/J/K/L (uppercase), repeatable
bind -r H resize-pane -L 5
bind -r J resize-pane -D 5
bind -r K resize-pane -U 5
bind -r L resize-pane -R 5

# Increase repeat-time if 500ms feels too short
set -g repeat-time 1000

# Toggle zoom on current pane with prefix + m
bind m resize-pane -Z

# Or go prefix-free with Alt+z
bind -n M-z resize-pane -Z

# Prefix + g — open lazygit in a new pane (closes pane on exit)
bind g split-window -h -c "#{pane_current_path}" lazygit

# Prefix + T — open htop in a full-width bottom pane
bind T split-window -v -l 15 htop

# Prefix + P — open a Python REPL in the current directory
bind P split-window -h -c "#{pane_current_path}" python3

# Prefix + G — lazygit in a floating popup (80% width, 80% height)
bind G display-popup -w 80% -h 80% -d "#{pane_current_path}" -E lazygit

# Prefix + F — fzf file finder in a floating popup
bind F display-popup -w 60% -h 60% -d "#{pane_current_path}" -E \
  "fzf --preview 'cat {}'"

# Alt+t — quick floating terminal (prefix-free)
bind -n M-t display-popup -w 70% -h 70% -d "#{pane_current_path}" -E

# Built-in: prefix + s — visual tree picker
bind s choose-tree -sZ

# Power move: prefix + S — fzf-powered session switcher
bind S display-popup -E "tmux list-sessions -F '#{session_name}' \
  | fzf --reverse --header='Switch Session' \
  | xargs tmux switch-client -t"

# Prefix + ( and ) — cycle through sessions (already default, but good to know)
# Previous session
bind -r ( switch-client -p
# Next session
bind -r ) switch-client -n

# Enter resize mode with prefix + R
bind R switch-client -T resize-mode

# Inside resize-mode: h/j/k/l resize, Escape exits
bind -T resize-mode h resize-pane -L 5 \; switch-client -T resize-mode
bind -T resize-mode j resize-pane -D 5 \; switch-client -T resize-mode
bind -T resize-mode k resize-pane -U 5 \; switch-client -T resize-mode
bind -T resize-mode l resize-pane -R 5 \; switch-client -T resize-mode

# Fine-grained: Shift+h/j/k/l for 1-cell adjustments
bind -T resize-mode H resize-pane -L 1 \; switch-client -T resize-mode
bind -T resize-mode J resize-pane -D 1 \; switch-client -T resize-mode
bind -T resize-mode K resize-pane -U 1 \; switch-client -T resize-mode
bind -T resize-mode L resize-pane -R 1 \; switch-client -T resize-mode

# Press Escape or Enter to leave resize mode
bind -T resize-mode Escape switch-client -Tprefix
bind -T resize-mode Enter switch-client -Tprefix

# First, ensure vi mode is enabled
set-window-option -g mode-keys vi

# v starts selection (like Vim visual mode)
bind -T copy-mode-vi v send-keys -X begin-selection

# y yanks selection to tmux buffer AND system clipboard (macOS)
bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "pbcopy"

# For Linux (X11), replace pbcopy:
# bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "xclip -sel clipboard"

# V selects the entire line
bind -T copy-mode-vi V send-keys -X select-line

# Ctrl+v toggles rectangle (block) selection
bind -T copy-mode-vi C-v send-keys -X rectangle-toggle \; \
  send-keys -X begin-selection

# Prefix + B — break current pane out into a new window
bind B break-pane

# Prefix + j — join a pane from another window into this one
# (opens an interactive picker)
bind j choose-window "join-pane -h -s '%%'"

# Prefix + ! is the default break-pane, but this adds:
# Prefix + @ — send pane to a new window and switch to it
bind @ break-pane -d \; last-window

# List ALL current key bindings
tmux list-keys

# Find what's bound to a specific key (e.g., "g")
tmux list-keys | grep -i "  g "

# List bindings in a specific key table
tmux list-keys -T copy-mode-vi

# Check bindings in the root table (prefix-free bindings)
tmux list-keys -T root

# See what a key is currently doing — useful for debugging
tmux list-keys | grep "M-h"

# Unbind a key in the prefix table
unbind C-z

# Unbind a key in a specific table
unbind -T root M-l

# Unbind all default bindings (nuclear option — start fresh)
unbind -a

# Safer: unbind a specific key, then rebind it
unbind l
bind l select-pane -R

# ── Pane Navigation (prefix-free) ──
bind -n M-h select-pane -L
bind -n M-j select-pane -D
bind -n M-k select-pane -U
bind -n M-l select-pane -R

# ── Pane Resizing (repeatable) ──
bind -r H resize-pane -L 5
bind -r J resize-pane -D 5
bind -r K resize-pane -U 5
bind -r L resize-pane -R 5
set -g repeat-time 1000

# ── Zoom / Maximize Toggle ──
bind m resize-pane -Z

# ── Quick Tools ──
bind g split-window -h -c "#{pane_current_path}" lazygit
bind T split-window -v -l 15 htop
bind G display-popup -w 80% -h 80% -d "#{pane_current_path}" -E lazygit
bind -n M-t display-popup -w 70% -h 70% -d "#{pane_current_path}" -E

# ── Session Switching ──
bind s choose-tree -sZ
bind S display-popup -E "tmux list-sessions -F '#{session_name}' \
  | fzf --reverse --header='Switch Session' \
  | xargs tmux switch-client -t"

# ── Pane Management ──
bind B break-pane
bind j choose-window "join-pane -h -s '%%'"

# ── Resize Mode (custom key table) ──
bind R switch-client -T resize-mode
bind -T resize-mode h resize-pane -L 5 \; switch-client -T resize-mode
bind -T resize-mode j resize-pane -D 5 \; switch-client -T resize-mode
bind -T resize-mode k resize-pane -U 5 \; switch-client -T resize-mode
bind -T resize-mode l resize-pane -R 5 \; switch-client -T resize-mode
bind -T resize-mode Escape switch-client -Tprefix
bind -T resize-mode Enter switch-client -Tprefix

# ── Copy Mode (vi-style) ──
set-window-option -g mode-keys vi
bind -T copy-mode-vi v send-keys -X begin-selection
bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "pbcopy"
bind -T copy-mode-vi V send-keys -X select-line
bind -T copy-mode-vi C-v send-keys -X rectangle-toggle \; \
  send-keys -X begin-selection

# ┌──────────────┬──────────────────────────┬──────────────┐
# │ status-left  │  window-status-format(s) │ status-right │
# └──────────────┴──────────────────────────┴──────────────┘

# Left zone — session info, prefix indicator, etc.
set -g status-left "#[bold] #S "

# Center zone — individual window tabs (repeated per window)
set -g window-status-format         " #I:#W "
set -g window-status-current-format " #I:#W "

# Right zone — hostname, time, custom data
set -g status-right " %H:%M  #H "

# Basic named colors: black, red, green, yellow, blue, magenta, cyan, white
#[fg=green,bg=black,bold]

# 256-color palette (colour0 through colour255)
#[fg=colour39,bg=colour234]

# Hex colors (tmux 3.2+ required)
#[fg=#e06c75,bg=#282c34]

# Available decorations: bold, dim, italics, underscore, strikethrough
#[fg=yellow,bold,italics]

# Reset all styling back to default
#[default]

# Base status bar style
set -g status-style "fg=#abb2bf,bg=#282c34"

# Styling for inactive window tabs
set -g window-status-style "fg=#5c6370,bg=default"

# Styling for the active window tab
set -g window-status-current-style "fg=#61afef,bg=#2c323c,bold"

# Message / command line style
set -g message-style "fg=#282c34,bg=#e5c07b"

# Git branch of the active pane's working directory
#(cd #{pane_current_path} && git branch --show-current 2>/dev/null || echo '-')

# Current kubectl context
#(kubectl config current-context 2>/dev/null || echo 'none')

# AWS profile
#(echo $AWS_PROFILE)

# Battery percentage (macOS)
#(pmset -g batt | grep -Eo '[0-9]+%')

# CPU load average (1-min)
#(uptime | awk -F'load averages?: ' '{print $2}' | cut -d, -f1)

# Refresh every 5 seconds (good for dev work, git branch updates)
set -g status-interval 5

# Refresh every 30 seconds (safer when using slow commands)
set -g status-interval 30

# Put the status bar on top instead of bottom
set -g status-position top

# Max character width of left/right zones (defaults: 10 and 40)
set -g status-left-length 30
set -g status-right-length 80

# Center the window list between left and right
set -g status-justify centre

# ── Minimalist Status Bar ───────────────────────────────────────
# Looks like:  ❐ work  │  0:zsh  1:nvim  2:logs  │   14:32

set -g status-position bottom
set -g status-style "fg=#a0a0a0,bg=#1a1b26"
set -g status-left-length 20
set -g status-right-length 20

# Left: session name
set -g status-left "#[fg=#7aa2f7,bold] ❐ #S #[fg=#3b3f51]│"

# Window tabs
set -g window-status-format         "#[fg=#565f89] #I:#W "
set -g window-status-current-format "#[fg=#c0caf5,bold] #I:#W "
set -g window-status-separator      ""

# Right: just the time
set -g status-right "#[fg=#3b3f51]│#[fg=#565f89]  %H:%M "

# ── Developer Status Bar ──────────────────────────────────────
# Looks like:   work    0:zsh  1:nvim  2:test     main  app   devbox  14:32

set -g status-position bottom
set -g status-style "fg=#abb2bf,bg=#282c34"
set -g status-left-length 30
set -g status-right-length 80
set -g status-interval 5

# Left: session name with icon
set -g status-left "#[fg=#282c34,bg=#61afef,bold]  #S #[fg=#61afef,bg=#282c34]"

# Inactive window
set -g window-status-format "#[fg=#5c6370] #I:#W "

# Active window (highlighted)
set -g window-status-current-format "#[fg=#282c34,bg=#2c323c]#[fg=#61afef,bg=#2c323c,bold] #I:#W #[fg=#2c323c,bg=#282c34]"
set -g window-status-separator ""

# Right: git branch | current dir | hostname | time
set -g status-right "#[fg=#e5c07b]  #(cd #{pane_current_path} && git branch --show-current 2>/dev/null || echo '-') #[fg=#3e4452]| #[fg=#98c379]  #{b:pane_current_path} #[fg=#3e4452]| #[fg=#c678dd]  #H #[fg=#3e4452]| #[fg=#56b6c2]  %H:%M "

# Message styling
set -g message-style "fg=#282c34,bg=#e5c07b,bold"

# ── DevOps Status Bar ─────────────────────────────────────────
# Looks like:  ⎈ prod-us-east |  staging | 🐳 3   0:zsh  1:k9s     devbox  14:32

set -g status-position top
set -g status-style "fg=#c0c0c0,bg=#1e1e2e"
set -g status-left-length 60
set -g status-right-length 40
set -g status-interval 10

# Left: k8s context | AWS profile | Docker container count
set -g status-left "#[fg=#1e1e2e,bg=#89b4fa,bold] ⎈ #(kubectl config current-context 2>/dev/null || echo 'none') #[fg=#89b4fa,bg=#1e1e2e]#[fg=#45475a] | #[fg=#fab387]  #(echo ${AWS_PROFILE:-default}) #[fg=#45475a] | #[fg=#94e2d5] 🐳 #(docker ps -q 2>/dev/null | wc -l | tr -d ' ') #[fg=#45475a] | "

# Inactive window
set -g window-status-format "#[fg=#6c7086] #I:#W "

# Active window
set -g window-status-current-format "#[fg=#cdd6f4,bg=#313244,bold] #I:#W #[bg=#1e1e2e]"
set -g window-status-separator ""

# Right: hostname | time
set -g status-right "#[fg=#a6adc8]  #H #[fg=#45475a]| #[fg=#f5c2e7]  %H:%M "

set -g message-style "fg=#1e1e2e,bg=#f38ba8,bold"

# Powerline separator characters (require Nerd Font):
#    right arrow solid  (U+E0B0)
#    right arrow thin   (U+E0B1)
#    left arrow solid   (U+E0B2)
#    left arrow thin    (U+E0B3)

# The pattern: set fg to the PREVIOUS block's bg color,
# then set bg to the NEXT block's bg color, then print the separator.

# Example — session name with powerline arrow into status bar:
set -g status-left "\
#[fg=#282c34,bg=#98c379,bold]  #S \
#[fg=#98c379,bg=#282c34]"
#                          ↑
#   fg matches the block we're leaving (#98c379)
#   bg matches the block we're entering (#282c34)
#   the  glyph creates the angled transition

# Active window: bright background with powerline arrows on both sides
set -g window-status-current-format "\
#[fg=#282c34,bg=#61afef]\
#[fg=#282c34,bg=#61afef,bold] #I  #W \
#[fg=#61afef,bg=#282c34]"

# Inactive window: no arrows, subdued text
set -g window-status-format "#[fg=#5c6370,bg=#282c34] #I #W "

# Show a visual prefix indicator — changes color when prefix is active
# (great for knowing if your Ctrl-b actually registered)
set -g status-left "\
#{?client_prefix,#[fg=#282c34 bg=#e06c75 bold],#[fg=#282c34 bg=#61afef bold]}\
  #S \
#[bg=#282c34]\
#{?client_prefix,#[fg=#e06c75],#[fg=#61afef]}"

# Show SYNC label when panes are synchronized (sending keys to all panes)
set -ga status-right "#{?pane_synchronized,#[fg=#e06c75 bold] SYNC ,}"

# Show zoom indicator when a pane is zoomed
set -g window-status-current-format "\
#{?window_zoomed_flag,#[fg=#e5c07b] Z ,}\
#[fg=#61afef,bold] #I:#W "

# Rename windows automatically based on running command
set -g automatic-rename on
set -g automatic-rename-format "#{b:pane_current_command}"

# ── Every status option you might need ─────────────────────
set -g status                on       # on | off | 2 (for double-line)
set -g status-position       bottom   # top | bottom
set -g status-justify        left     # left | centre | right
set -g status-interval       5        # seconds between refresh
set -g status-left-length    40       # max chars for left zone
set -g status-right-length   80       # max chars for right zone

set -g status-style          "fg=white,bg=black"
set -g status-left-style     "bold"
set -g status-right-style    "none"

set -g window-status-style           "fg=grey"
set -g window-status-current-style   "fg=white,bold"
set -g window-status-activity-style  "fg=yellow"
set -g window-status-bell-style      "fg=red,bold"
set -g window-status-separator       " "  # between window tabs

Terminal Emulator  →  $TERM (outside)  →  tmux  →  $TERM (inside)  →  Application
(iTerm2, Kitty...)    (xterm-256color)     server   (tmux-256color)     (Neovim, bat...)

# Tell tmux to advertise tmux-256color to inner apps
set -g default-terminal "tmux-256color"

# Tell tmux that the OUTER terminal (xterm-256color) supports true color
set -as terminal-features ",xterm-256color:RGB"

# Undercurl support (colored wavy underlines for LSP diagnostics)
set -as terminal-overrides ',*:Smulx=\E[4::%p1%dm'
set -as terminal-overrides ',*:Setulc=\E[58::2::%p1%{65536}%/%d::%p1%{256}%/%{255}%&%d::%p1%{255}%&%d%;m'

# Near-zero escape delay — critical for Vim/Neovim mode switching
set -sg escape-time 0

# Enable focus events (lets Neovim detect window focus)
set -g focus-events on

set -g default-terminal "tmux-256color"

# The older Tc (True Color) flag approach
set -ga terminal-overrides ",xterm-256color:Tc"

set -sg escape-time 0
set -g focus-events on

#!/usr/bin/env bash
# truecolor-test.sh — prints a smooth RGB gradient
# If you see banding or discrete color blocks, true color is NOT working.

echo "TERM=$TERM"
echo ""

awk 'BEGIN{
    for (i = 0; i <= 76; i++) {
        r = 255 - (i * 255 / 76);
        g = (i * 510 / 76);
        b = (i * 255 / 76);
        if (g > 255) g = 510 - g;
        printf "\033[48;2;%d;%d;%dm ", r, g, b;
    }
    printf "\033[0m\n";
}'

echo ""
echo "If the bar above is a smooth gradient: true color works."
echo "If you see distinct bands/blocks: only 256 colors are active."

chmod +x truecolor-test.sh
./truecolor-test.sh

# Inside tmux — check the active terminal capabilities
tmux info | grep -i "rgb\|256col\|Tc"

# Check what TERM is set to inside vs outside
echo "Inside tmux: TERM=$TERM"
# Detach, then run:
echo "Outside tmux: TERM=$TERM"

-- Enable undercurl in Neovim inside tmux
vim.cmd([[
  let &t_Cs = "\e[4:3m"
  let &t_Ce = "\e[4:0m"
]])

-- Diagnostic underline styles (uses undercurl when supported)
vim.diagnostic.config({
  underline = true,
  virtual_text = { spacing = 4, prefix = "●" },
})

" Run inside Neovim to test undercurl rendering
:hi TestUndercurl gui=undercurl guisp=Red
:match TestUndercurl /./

Preferences → Profiles → Terminal → Terminal Emulation
  • Report Terminal Type: xterm-256color
  • Enable "Use Unicode version 9+ widths" (optional, helps alignment)

[env]
TERM = "xterm-256color"

# Kitty's default TERM is xterm-kitty, which tmux doesn't know about.
# Override it for tmux compatibility:
term xterm-256color

local wezterm = require("wezterm")
return {
  term = "xterm-256color",
}

// In your Windows Terminal settings.json profile:
{
  "name": "Ubuntu",
  "source": "Windows.Terminal.Wsl",
  "colorScheme": "One Half Dark",
  "cursorShape": "filledBox"
}

git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm

# ── Plugins ──────────────────────────────────────
# TPM itself (required)
set -g @plugin 'tmux-plugins/tpm'

# Sensible defaults everyone agrees on
set -g @plugin 'tmux-plugins/tmux-sensible'

# Save and restore tmux sessions across reboots
set -g @plugin 'tmux-plugins/tmux-resurrect'

# Automatic session saving (depends on resurrect)
set -g @plugin 'tmux-plugins/tmux-continuum'

# ── Plugin options ───────────────────────────────
set -g @resurrect-capture-pane-contents 'on'
set -g @continuum-restore 'on'
set -g @continuum-save-interval '15'

# ── Your other tmux settings go here ─────────────
set -g mouse on
set -g base-index 1

# ── Initialize TPM (MUST be the last line) ───────
run '~/.tmux/plugins/tpm/tpm'

# 1. GitHub shorthand — most common
set -g @plugin 'tmux-plugins/tmux-resurrect'

# 2. Full Git URL — for non-GitHub repos or SSH cloning
set -g @plugin 'git@github.com:user/plugin'
set -g @plugin 'https://gitlab.com/user/tmux-plugin.git'

# 3. Pin to a specific tag or branch
set -g @plugin 'tmux-plugins/tmux-resurrect#v4.0.0'
set -g @plugin 'tmux-plugins/tmux-continuum#main'

# Declare the plugin
set -g @plugin 'tmux-plugins/tmux-resurrect'

# Configure it (before the run line)
set -g @resurrect-strategy-vim 'session'
set -g @resurrect-capture-pane-contents 'on'
set -g @resurrect-save-shell-history 'on'

# Dracula theme options
set -g @plugin 'dracula/tmux'
set -g @dracula-show-powerline true
set -g @dracula-plugins "cpu-usage ram-usage weather"
set -g @dracula-show-left-icon session

# ... other config ...

# TPM bootstrap — ALWAYS last
run '~/.tmux/plugins/tpm/tpm'

# Install all plugins declared in .tmux.conf
~/.tmux/plugins/tpm/bin/install_plugins

# Update all installed plugins
~/.tmux/plugins/tpm/bin/update_plugins all

# Update a specific plugin
~/.tmux/plugins/tpm/bin/update_plugins tmux-resurrect

# Clean up removed plugins
~/.tmux/plugins/tpm/bin/clean_plugins

#!/usr/bin/env bash
set -euo pipefail

TPM_DIR="$HOME/.tmux/plugins/tpm"

# Install TPM if it's not already present
if [ ! -d "$TPM_DIR" ]; then
    echo "Installing TPM..."
    git clone https://github.com/tmux-plugins/tpm "$TPM_DIR"
else
    echo "TPM already installed, pulling latest..."
    git -C "$TPM_DIR" pull --quiet
fi

# Symlink your tmux.conf from your dotfiles repo
DOTFILES_DIR="$(cd "$(dirname "$0")/.." && pwd)"
ln -sf "$DOTFILES_DIR/tmux.conf" "$HOME/.tmux.conf"

# Install all plugins (works even without a running tmux server)
"$TPM_DIR/bin/install_plugins"

echo "✓ tmux setup complete"

# Auto-install TPM if missing
if "test ! -d ~/.tmux/plugins/tpm" \
   "run 'git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm && ~/.tmux/plugins/tpm/bin/install_plugins'"

# Initialize TPM (last line)
run '~/.tmux/plugins/tpm/tpm'

# List installed plugins
ls ~/.tmux/plugins/

# Expected output for the config above:
# tmux-continuum  tmux-resurrect  tmux-sensible  tpm

# Find the .tmux entry point for a plugin
ls -la ~/.tmux/plugins/tmux-resurrect/*.tmux

# Verify it's executable (must have the x flag)
# -rwxr-xr-x 1 user staff 1234 Jan 1 00:00 resurrect.tmux

# Fix permissions if needed
chmod +x ~/.tmux/plugins/tmux-resurrect/*.tmux

# Reload the config and watch for error messages
tmux source-file ~/.tmux.conf

# Manually run a plugin's entry point to see errors
~/.tmux/plugins/tmux-resurrect/resurrect.tmux

# Check if the plugin registered its key bindings
tmux list-keys | grep resurrect

# Install
set -g @plugin 'tmux-plugins/tmux-resurrect'

# Restore neovim sessions (requires vim-obsession or similar)
set -g @resurrect-strategy-nvim 'session'

# Also capture and restore pane contents (scrollback)
set -g @resurrect-capture-pane-contents 'on'

# Restore additional programs beyond the defaults
# Default: vi vim nvim emacs man less more tail top htop irssi weechat mutt
set -g @resurrect-processes 'ssh psql mysql sqlite3 "~yarn watch"' 

# Install (requires tmux-resurrect)
set -g @plugin 'tmux-plugins/tmux-continuum'

# Auto-restore when tmux server starts
set -g @continuum-restore 'on'

# Save interval in minutes (default: 15)
set -g @continuum-save-interval '15'

# Optional: auto-start tmux when your terminal opens (macOS)
# set -g @continuum-boot 'on'
# set -g @continuum-boot-options 'iterm' 

# Install — no config needed
set -g @plugin 'tmux-plugins/tmux-sensible' 

# Install
set -g @plugin 'tmux-plugins/tmux-yank'

# Stay in copy mode after yanking (don't jump back to prompt)
set -g @yank_action 'copy-pipe-no-clear'

# Use 'clipboard' selection instead of 'primary' on Linux
set -g @yank_selection_mouse 'clipboard'
set -g @yank_selection 'clipboard' 

# Install
set -g @plugin 'tmux-plugins/tmux-open'

# Override the editor-open key (default: Ctrl-o)
set -g @open-editor 'C-o'

# Customize the search engine for 'S' key
set -g @open-S 'https://www.google.com/search?q=' 

# Install (requires fzf to be installed on your system)
set -g @plugin 'sainnhe/tmux-fzf'

# Change the trigger key (default: prefix + F)
TMUX_FZF_LAUNCH_KEY="f"

# Show in a popup window instead of a pane (tmux 3.2+)
TMUX_FZF_POPUP=1
TMUX_FZF_POPUP_HEIGHT="80%"
TMUX_FZF_POPUP_WIDTH="70%"

# Order of menu items
TMUX_FZF_ORDER="session|window|pane|command|keybinding|clipboard|process" 

# Install (binary is compiled via cargo or downloaded automatically)
set -g @plugin 'fcsonline/tmux-thumbs'

# Run thumbs setup
run-shell ~/.tmux/plugins/tmux-thumbs/tmux-thumbs.tmux

# Trigger key (default: prefix + Space)
set -g @thumbs-key Space

# Copy to system clipboard
set -g @thumbs-command 'echo -n {} | pbcopy'           # macOS
# set -g @thumbs-command 'echo -n {} | xclip -sel clip' # Linux

# What to do on uppercase hint (paste into current pane)
set -g @thumbs-upcase-command 'tmux set-buffer -- {} && tmux paste-buffer'

# Add custom regex patterns (e.g., MAC addresses)
set -g @thumbs-regexp-1 '[a-f0-9]{2}:[a-f0-9]{2}:[a-f0-9]{2}:[a-f0-9]{2}:[a-f0-9]{2}:[a-f0-9]{2}' 

# Install
set -g @plugin 'Morantron/tmux-fingers'

# Trigger key (default: prefix + F)
set -g @fingers-key F

# Custom patterns
set -g @fingers-pattern-0 'git rebase --(abort|continue)'
set -g @fingers-pattern-1 'https?://\S+'

# Hint position: left or right of the match
set -g @fingers-hint-position 'right'

# Customize the hint highlight style
set -g @fingers-highlight-format '#[fg=green,bold]%s' 

# -- Plugins -----------------------------------------------
set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-sensible'
set -g @plugin 'tmux-plugins/tmux-resurrect'
set -g @plugin 'tmux-plugins/tmux-continuum'
set -g @plugin 'tmux-plugins/tmux-yank'
set -g @plugin 'tmux-plugins/tmux-open'
set -g @plugin 'sainnhe/tmux-fzf'
set -g @plugin 'fcsonline/tmux-thumbs'

# -- Plugin Config -----------------------------------------
# Resurrect
set -g @resurrect-strategy-nvim 'session'
set -g @resurrect-capture-pane-contents 'on'

# Continuum
set -g @continuum-restore 'on'
set -g @continuum-save-interval '15'

# Yank
set -g @yank_action 'copy-pipe-no-clear'
set -g @yank_selection 'clipboard'

# Thumbs -- set explicit key to avoid fzf conflict
set -g @thumbs-key Space

# Fzf
TMUX_FZF_LAUNCH_KEY="f"

# -- TPM bootstrap (keep at the very bottom) ---------------
run '~/.tmux/plugins/tpm/tpm' 

tmux-project-switcher/
├── project-switcher.tmux    # Entry point — TPM runs this
├── scripts/
│   └── switch.sh            # The actual fzf picker logic
├── README.md
└── LICENSE

#!/usr/bin/env bash

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

# Read user options with defaults
default_key="f"
default_base_path="$HOME/projects"
default_depth="1"

# tmux show-option -gqv reads a global user option; returns "" if unset
key=$(tmux show-option -gqv @project-switcher-key)
key="${key:-$default_key}"

base_path=$(tmux show-option -gqv @project-switcher-path)
base_path="${base_path:-$default_base_path}"

depth=$(tmux show-option -gqv @project-switcher-depth)
depth="${depth:-$default_depth}"

# Bind the key to run the switcher script in a display-popup
tmux bind-key "$key" display-popup -E -w 60% -h 60% \
    "$CURRENT_DIR/scripts/switch.sh '$base_path' '$depth'"

#!/usr/bin/env bash
set -euo pipefail

BASE_PATH="$1"
DEPTH="${2:-1}"

# Bail out if fzf isn't installed
if ! command -v fzf &> /dev/null; then
    echo "fzf is required but not installed." >&2
    exit 1
fi

# List directories and let the user pick one
selected=$(find "$BASE_PATH" -mindepth 1 -maxdepth "$DEPTH" \
    -type d | sort | fzf --prompt="project > " --reverse)

# Exit silently if the user pressed Escape
[ -z "$selected" ] && exit 0

# Derive a session name from the directory name (replace dots with underscores)
session_name=$(basename "$selected" | tr '.' '_')

# Create session if it doesn't exist (detached)
if ! tmux has-session -t "=$session_name" 2>/dev/null; then
    tmux new-session -d -s "$session_name" -c "$selected"
fi

# Switch to the session
tmux switch-client -t "$session_name"

chmod +x project-switcher.tmux
chmod +x scripts/switch.sh

# Plugin options — set BEFORE the plugin manager runs
set -g @project-switcher-key "f"
set -g @project-switcher-path "$HOME/code"
set -g @project-switcher-depth "2"

# Load the plugin via TPM
set -g @plugin 'your-github-user/tmux-project-switcher'
run '~/.tmux/plugins/tpm/tpm'

# Pattern: read option with a fallback default
value=$(tmux show-option -gqv @your-plugin-option)
value="${value:-default_value}"

# Symlink your dev directory into TPM's plugin path
ln -sf ~/code/tmux-project-switcher ~/.tmux/plugins/tmux-project-switcher

# Source the plugin directly to test (no restart needed)
~/.tmux/plugins/tmux-project-switcher/project-switcher.tmux

# Or reload the entire tmux config
tmux source-file ~/.tmux.conf

cd ~/code/tmux-project-switcher
git init
git add -A
git commit -m "Initial release of tmux-project-switcher"
git remote add origin git@github.com:youruser/tmux-project-switcher.git
git push -u origin main

#!/usr/bin/env bash
CURRENT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

key=$(tmux show-option -gqv @project-switcher-key)
base_path=$(tmux show-option -gqv @project-switcher-path)
depth=$(tmux show-option -gqv @project-switcher-depth)

tmux bind-key "${key:-f}" display-popup -E -w 60% -h 60% \
    "$CURRENT_DIR/scripts/switch.sh '${base_path:-$HOME/projects}' '${depth:-1}'"

#!/usr/bin/env bash
set -euo pipefail

BASE_PATH="$1"
DEPTH="${2:-1}"

command -v fzf &> /dev/null || { echo "fzf required" >&2; exit 1; }

selected=$(find "$BASE_PATH" -mindepth 1 -maxdepth "$DEPTH" \
    -type d | sort | fzf --prompt="project > " --reverse)
[ -z "$selected" ] && exit 0

session_name=$(basename "$selected" | tr '.' '_')

tmux has-session -t "=$session_name" 2>/dev/null || \
    tmux new-session -d -s "$session_name" -c "$selected"

tmux switch-client -t "$session_name"

# 1. From the shell (outside or inside tmux)
tmux split-window -h

# 2. From .tmux.conf (no "tmux" prefix needed)
split-window -h

# 3. From the tmux command prompt (prefix + :)
# Just type: split-window -h

# Create a detached session (won't attach your terminal)
tmux new-session -d -s myproject

# Create a new window inside that session
tmux new-window -t myproject -n logs

# Split the current pane horizontally (side by side)
tmux split-window -h -t myproject

# Split the current pane vertically (top and bottom)
tmux split-window -v -t myproject

# Send keystrokes to a pane (simulates typing)
tmux send-keys -t myproject 'npm run dev' Enter

# Select a specific pane
tmux select-pane -t myproject:0.1

# Apply a preset layout
tmux select-layout -t myproject main-horizontal

# Resize the active pane
tmux resize-pane -t myproject -D 10   # down 10 rows
tmux resize-pane -t myproject -R 20   # right 20 columns

# Create session, split, and send commands — one line
tmux new-session -d -s work \; \
  split-window -h \; \
  send-keys -t work:0.0 'vim' Enter \; \
  send-keys -t work:0.1 'htop' Enter

# Print the current session name
tmux display-message -p '#{session_name}'

# Capture it into a shell variable
SESSION=$(tmux display-message -p '#{session_name}')
echo "Currently in: $SESSION"

# Get the current pane's working directory
PANE_DIR=$(tmux display-message -p '#{pane_current_path}')

# Show window and pane index
tmux display-message -p 'Window: #{window_index}, Pane: #{pane_index}'

# Useful for debugging: list all panes with details
tmux list-panes -a -F '#{session_name}:#{window_index}.#{pane_index} #{pane_current_path}'

SESSION="myproject"

# has-session exits 0 if it exists, 1 if not
if tmux has-session -t "$SESSION" 2>/dev/null; then
    echo "Session '$SESSION' already exists. Attaching..."
    tmux attach-session -t "$SESSION"
    exit 0
fi

# Session doesn't exist — create it
tmux new-session -d -s "$SESSION"
# ... build your layout here ...

# In pane 0: run a build, then signal when done
tmux send-keys -t dev:0.0 \
  'npm run build && tmux wait-for -S build-done' Enter

# In your script: block until the signal arrives
tmux wait-for build-done

# Now it's safe to start the dependent process
tmux send-keys -t dev:0.1 'npm run test' Enter

#!/usr/bin/env bash
set -euo pipefail

SESSION="webapp"
PROJECT_DIR="$HOME/projects/webapp"

# ── Idempotent: attach if session already exists ──
if tmux has-session -t "$SESSION" 2>/dev/null; then
    tmux attach-session -t "$SESSION"
    exit 0
fi

# ── Create detached session with first window named "editor" ──
tmux new-session -d -s "$SESSION" -n editor -c "$PROJECT_DIR"

# ── Window 1: Editor (left=vim, right=git) ──
tmux send-keys -t "$SESSION:editor" 'vim .' Enter
tmux split-window -h -t "$SESSION:editor" -c "$PROJECT_DIR"
tmux send-keys -t "$SESSION:editor.1" 'git status' Enter
tmux resize-pane -t "$SESSION:editor.0" -R 15

# ── Window 2: Server + Logs ──
tmux new-window -t "$SESSION" -n server -c "$PROJECT_DIR"
tmux send-keys -t "$SESSION:server" 'npm run dev' Enter
tmux split-window -v -t "$SESSION:server" -c "$PROJECT_DIR"
tmux send-keys -t "$SESSION:server.1" 'tail -f logs/app.log' Enter

# ── Window 3: Free terminal ──
tmux new-window -t "$SESSION" -n shell -c "$PROJECT_DIR"

# ── Focus on editor window, left pane ──
tmux select-window -t "$SESSION:editor"
tmux select-pane -t "$SESSION:editor.0"

# ── Attach ──
tmux attach-session -t "$SESSION"

#!/usr/bin/env bash
SESSION="my-project"
PROJECT_DIR="$HOME/projects/my-project"

# Attach if session already exists
tmux has-session -t "$SESSION" 2>/dev/null && {
    tmux attach-session -t "$SESSION"
    exit 0
}

# Create session detached (-d) with a named first window
tmux new-session -d -s "$SESSION" -n "editor" -c "$PROJECT_DIR"

# Split panes, create windows, send commands...
tmux split-window -v -t "$SESSION:editor" -c "$PROJECT_DIR"
tmux send-keys -t "$SESSION:editor.1" "npm run dev" C-m

# Select the pane you want active on attach
tmux select-pane -t "$SESSION:editor.0"

# Attach to the session
tmux attach-session -t "$SESSION"

#!/usr/bin/env bash
# =============================================================================
# tmux-webdev.sh — Web Development Session Bootstrap
# Usage: ./tmux-webdev.sh [project-dir]
#        ./tmux-webdev.sh --teardown
# Layout:
#   Window 1 "code":
#     ┌─────────────────────────┐
#     │        editor (nvim)    │
#     ├──────────────┬──────────┤
#     │  dev server  │ git log  │
#     └──────────────┴──────────┘
#   Window 2 "shell"  |  Window 3 "tests"
# =============================================================================
set -euo pipefail

PROJECT_DIR="${1:-$(pwd)}"
SESSION_NAME="$(basename "$PROJECT_DIR" | tr '.' '-')"

# --teardown flag: destroy the session and exit
if [[ "${1:-}" == "--teardown" ]]; then
    tmux kill-session -t "$SESSION_NAME" 2>/dev/null && \
        echo "Removed session: $SESSION_NAME" || \
        echo "No session named: $SESSION_NAME"
    exit 0
fi

# Validate project directory
if [[ ! -d "$PROJECT_DIR" ]]; then
    echo "Error: Directory '$PROJECT_DIR' does not exist." >&2
    exit 1
fi
PROJECT_DIR="$(cd "$PROJECT_DIR" && pwd)"

# Attach if session already exists
if tmux has-session -t "$SESSION_NAME" 2>/dev/null; then
    echo "Session '$SESSION_NAME' exists. Attaching..."
    exec tmux attach-session -t "$SESSION_NAME"
fi

# ── Create session with first window: "code" ────────────────────────────
tmux new-session -d -s "$SESSION_NAME" -n "code" -c "$PROJECT_DIR"

# Split bottom pane for dev server (30% height)
tmux split-window -v -l 30% -t "$SESSION_NAME:code" -c "$PROJECT_DIR"
# Split bottom-right pane for git log
tmux split-window -h -l 40% -t "$SESSION_NAME:code.1" -c "$PROJECT_DIR"

# Send commands to each pane
tmux send-keys -t "$SESSION_NAME:code.0" "nvim ." C-m
tmux send-keys -t "$SESSION_NAME:code.1" "npm run dev" C-m
tmux send-keys -t "$SESSION_NAME:code.2" \
    "git log --oneline --graph --decorate --all -30" C-m

# Focus the editor pane
tmux select-pane -t "$SESSION_NAME:code.0"

# ── Window 2: clean shell ───────────────────────────────────────────
tmux new-window -t "$SESSION_NAME" -n "shell" -c "$PROJECT_DIR"

# ── Window 3: test runner ───────────────────────────────────────────
tmux new-window -t "$SESSION_NAME" -n "tests" -c "$PROJECT_DIR"
tmux send-keys -t "$SESSION_NAME:tests" "npm test -- --watch" C-m

# ── Select first window and attach ──────────────────────────────────
tmux select-window -t "$SESSION_NAME:code"
exec tmux attach-session -t "$SESSION_NAME"

#!/usr/bin/env bash
# =============================================================================
# tmux-devops.sh — DevOps / Infrastructure Session
# Usage: ./tmux-devops.sh [infra-repo-dir]
#        ./tmux-devops.sh --teardown
# =============================================================================
set -euo pipefail

INFRA_DIR="${1:-$(pwd)}"
SESSION_NAME="devops"
K8S_NAMESPACE="${K8S_NAMESPACE:-default}"

if [[ "${1:-}" == "--teardown" ]]; then
    tmux kill-session -t "$SESSION_NAME" 2>/dev/null && \
        echo "Removed session: $SESSION_NAME" || \
        echo "No session named: $SESSION_NAME"
    exit 0
fi

[[ ! -d "$INFRA_DIR" ]] && { echo "Error: '$INFRA_DIR' not found" >&2; exit 1; }
INFRA_DIR="$(cd "$INFRA_DIR" && pwd)"

if tmux has-session -t "$SESSION_NAME" 2>/dev/null; then
    exec tmux attach-session -t "$SESSION_NAME"
fi

# ── Window 1: Kubernetes cluster overview (2x2 grid) ────────────────
tmux new-session -d -s "$SESSION_NAME" -n "cluster" -c "$INFRA_DIR"
tmux split-window -h -t "$SESSION_NAME:cluster" -c "$INFRA_DIR"
tmux split-window -v -t "$SESSION_NAME:cluster.0" -c "$INFRA_DIR"
tmux split-window -v -t "$SESSION_NAME:cluster.1" -c "$INFRA_DIR"

# Top-left: watch pods
tmux send-keys -t "$SESSION_NAME:cluster.0" \
    "watch -n5 kubectl get pods -n $K8S_NAMESPACE -o wide" C-m
# Bottom-left: watch services
tmux send-keys -t "$SESSION_NAME:cluster.2" \
    "watch -n10 kubectl get svc,ing -n $K8S_NAMESPACE" C-m
# Top-right: stream logs (edit the deployment name)
tmux send-keys -t "$SESSION_NAME:cluster.1" \
    "# kubectl logs -f deploy/your-app -n $K8S_NAMESPACE" Enter
# Bottom-right: watch events
tmux send-keys -t "$SESSION_NAME:cluster.3" \
    "kubectl get events -n $K8S_NAMESPACE -w --sort-by=.lastTimestamp" C-m

# ── Window 2: Terraform ─────────────────────────────────────────────
TF_DIR="$INFRA_DIR/terraform"
[[ ! -d "$TF_DIR" ]] && TF_DIR="$INFRA_DIR"

tmux new-window -t "$SESSION_NAME" -n "terraform" -c "$TF_DIR"
tmux send-keys -t "$SESSION_NAME:terraform" \
    "terraform init 2>/dev/null; terraform workspace list" C-m
tmux split-window -h -l 40% -t "$SESSION_NAME:terraform" -c "$TF_DIR"
tmux send-keys -t "$SESSION_NAME:terraform.1" \
    "# terraform plan -out=tfplan" Enter
tmux select-pane -t "$SESSION_NAME:terraform.0"

# ── Window 3: Monitoring ────────────────────────────────────────────
tmux new-window -t "$SESSION_NAME" -n "monitoring" -c "$INFRA_DIR"
tmux send-keys -t "$SESSION_NAME:monitoring" \
    "# k9s  OR  kubectl top pods -n $K8S_NAMESPACE" Enter

# ── Window 4: SSH ────────────────────────────────────────────────────────
tmux new-window -t "$SESSION_NAME" -n "ssh" -c "$HOME"

# ── Attach ─────────────────────────────────────────────────────────
tmux select-window -t "$SESSION_NAME:cluster"
exec tmux attach-session -t "$SESSION_NAME"

#!/usr/bin/env bash
# =============================================================================
# tmux-datasci.sh — Data Science Session
# Usage: ./tmux-datasci.sh [project-dir]
#        ./tmux-datasci.sh --teardown
# =============================================================================
set -euo pipefail

PROJECT_DIR="${1:-$(pwd)}"
SESSION_NAME="datasci-$(basename "$PROJECT_DIR" | tr '.' '-')"
VENV_DIR="$PROJECT_DIR/.venv"
DATA_DIR="$PROJECT_DIR/data"

if [[ "${1:-}" == "--teardown" ]]; then
    tmux kill-session -t "$SESSION_NAME" 2>/dev/null && \
        echo "Removed session: $SESSION_NAME" || \
        echo "No session named: $SESSION_NAME"
    exit 0
fi

[[ ! -d "$PROJECT_DIR" ]] && { echo "Error: not found" >&2; exit 1; }
PROJECT_DIR="$(cd "$PROJECT_DIR" && pwd)"

if tmux has-session -t "$SESSION_NAME" 2>/dev/null; then
    exec tmux attach-session -t "$SESSION_NAME"
fi

# Activate virtualenv if present
ACTIVATE=""
[[ -f "$VENV_DIR/bin/activate" ]] && ACTIVATE="source $VENV_DIR/bin/activate"

# ── Window 1: Jupyter + REPL ──────────────────────────────────────────
tmux new-session -d -s "$SESSION_NAME" -n "notebook" -c "$PROJECT_DIR"

# Top pane: Jupyter server
[[ -n "$ACTIVATE" ]] && \
    tmux send-keys -t "$SESSION_NAME:notebook.0" "$ACTIVATE" C-m
tmux send-keys -t "$SESSION_NAME:notebook.0" \
    "jupyter lab --no-browser --port=8888" C-m

# Bottom pane: Python REPL
tmux split-window -v -l 50% -t "$SESSION_NAME:notebook" -c "$PROJECT_DIR"
[[ -n "$ACTIVATE" ]] && \
    tmux send-keys -t "$SESSION_NAME:notebook.1" "$ACTIVATE" C-m
tmux send-keys -t "$SESSION_NAME:notebook.1" \
    "command -v ipython >/dev/null && ipython || python3" C-m

# ── Window 2: Editor + Data Explorer ────────────────────────────────
tmux new-window -t "$SESSION_NAME" -n "explore" -c "$PROJECT_DIR"
[[ -n "$ACTIVATE" ]] && \
    tmux send-keys -t "$SESSION_NAME:explore.0" "$ACTIVATE" C-m
tmux send-keys -t "$SESSION_NAME:explore.0" "nvim ." C-m

tmux split-window -h -l 35% -t "$SESSION_NAME:explore" \
    -c "${DATA_DIR:-$PROJECT_DIR}"

if [[ -d "$DATA_DIR" ]]; then
    tmux send-keys -t "$SESSION_NAME:explore.1" "ls -lhS" C-m
else
    tmux send-keys -t "$SESSION_NAME:explore.1" \
        "echo 'No data/ dir — create it or symlink.'" C-m
fi

# ── Window 3: Shell ──────────────────────────────────────────────────────
tmux new-window -t "$SESSION_NAME" -n "shell" -c "$PROJECT_DIR"
[[ -n "$ACTIVATE" ]] && \
    tmux send-keys -t "$SESSION_NAME:shell" "$ACTIVATE" C-m

# ── Attach ─────────────────────────────────────────────────────────
tmux select-window -t "$SESSION_NAME:notebook"
tmux select-pane -t "$SESSION_NAME:notebook.1"
exec tmux attach-session -t "$SESSION_NAME"

#!/usr/bin/env bash
# =============================================================================
# tmux-microservices.sh — Microservices Session
# Usage: ./tmux-microservices.sh <mono-repo-root>
#        ./tmux-microservices.sh --teardown
# Expects: repo/services/api-gateway/, repo/services/user-service/, ...
# =============================================================================
set -euo pipefail

REPO_DIR="${1:-$(pwd)}"
SESSION_NAME="microservices"
SERVICES_DIR="$REPO_DIR/services"

if [[ "${1:-}" == "--teardown" ]]; then
    tmux kill-session -t "$SESSION_NAME" 2>/dev/null && \
        echo "Removed session: $SESSION_NAME" || \
        echo "No session named: $SESSION_NAME"
    exit 0
fi

[[ ! -d "$REPO_DIR" ]] && { echo "Error: '$REPO_DIR' not found" >&2; exit 1; }
REPO_DIR="$(cd "$REPO_DIR" && pwd)"

if tmux has-session -t "$SESSION_NAME" 2>/dev/null; then
    exec tmux attach-session -t "$SESSION_NAME"
fi

# ── Auto-detect run command per service ─────────────────────────────
detect_run_cmd() {
    local dir="$1"
    if   [[ -f "$dir/package.json" ]];  then echo "npm run dev"
    elif [[ -f "$dir/Makefile" ]];       then echo "make run"
    elif [[ -f "$dir/main.go" ]];        then echo "go run ."
    elif [[ -f "$dir/Cargo.toml" ]];     then echo "cargo run"
    elif [[ -f "$dir/manage.py" ]];      then echo "python manage.py runserver"
    else echo "echo 'No project file found — start manually.'"
    fi
}

# ── Window 1: Docker Compose ─────────────────────────────────────────
tmux new-session -d -s "$SESSION_NAME" -n "docker" -c "$REPO_DIR"
tmux send-keys -t "$SESSION_NAME:docker" \
    "docker compose ps 2>/dev/null || echo 'compose not running'" C-m

tmux split-window -v -l 40% -t "$SESSION_NAME:docker" -c "$REPO_DIR"
tmux send-keys -t "$SESSION_NAME:docker.1" \
    "# docker compose up -d && docker compose logs -f" Enter

# ── One window per service ───────────────────────────────────────────
if [[ -d "$SERVICES_DIR" ]]; then
    for svc_dir in "$SERVICES_DIR"/*/; do
        [[ ! -d "$svc_dir" ]] && continue
        svc_name="$(basename "$svc_dir")"
        run_cmd="$(detect_run_cmd "$svc_dir")"

        tmux new-window -t "$SESSION_NAME" -n "$svc_name" -c "$svc_dir"
        tmux send-keys -t "$SESSION_NAME:$svc_name.0" "nvim ." C-m

        tmux split-window -v -l 35% \
            -t "$SESSION_NAME:$svc_name" -c "$svc_dir"
        tmux send-keys -t "$SESSION_NAME:$svc_name.1" "$run_cmd" C-m
        tmux select-pane -t "$SESSION_NAME:$svc_name.0"
    done
else
    echo "Warning: $SERVICES_DIR not found" >&2
    tmux new-window -t "$SESSION_NAME" -n "app" -c "$REPO_DIR"
fi

tmux select-window -t "$SESSION_NAME:docker"
exec tmux attach-session -t "$SESSION_NAME"

# .tmux-project — Drop this in any project root
# Format: window_name:split_type:pane0_cmd:pane1_cmd[:pane2_cmd...]
#   split_type: "horizontal" (side-by-side) or "vertical" (top/bottom)
#   Use "none" for a single-pane window
#   Use "-" for an empty pane (no command sent)

code:vertical:nvim .:npm run dev
tests:none:npm test -- --watch
shell:none:-
docs:horizontal:nvim README.md:grip --browser false

#!/usr/bin/env bash
# =============================================================================
# tmux-smart.sh — Reads .tmux-project files to build sessions
# Usage: tmux-smart.sh [directory]
#        tmux-smart.sh [directory] --teardown
# =============================================================================
set -euo pipefail

PROJECT_DIR="${1:-$(pwd)}"
SESSION_NAME="$(basename "$PROJECT_DIR" | tr './ ' '---')"

if [[ "${2:-}" == "--teardown" || "${1:-}" == "--teardown" ]]; then
    tmux kill-session -t "$SESSION_NAME" 2>/dev/null && \
        echo "Removed session: $SESSION_NAME" || \
        echo "No session named: $SESSION_NAME"
    exit 0
fi

[[ ! -d "$PROJECT_DIR" ]] && { echo "Error: not found" >&2; exit 1; }
PROJECT_DIR="$(cd "$PROJECT_DIR" && pwd)"
CONFIG_FILE="$PROJECT_DIR/.tmux-project"

if tmux has-session -t "$SESSION_NAME" 2>/dev/null; then
    exec tmux attach-session -t "$SESSION_NAME"
fi

# ── Window builder function ──────────────────────────────────────────
# Args: $1=window_name  $2=split_type  $3+=pane commands
build_window() {
    local win_name="$1" split_type="$2"
    shift 2
    local pane_cmds=("$@")

    if [[ "$FIRST_WINDOW" == "true" ]]; then
        tmux rename-window -t "$SESSION_NAME:0" "$win_name"
        FIRST_WINDOW="false"
    else
        tmux new-window -t "$SESSION_NAME" -n "$win_name" -c "$PROJECT_DIR"
    fi

    # First pane command
    local first_cmd="${pane_cmds[0]}"
    if [[ "$first_cmd" != "-" && -n "$first_cmd" ]]; then
        tmux send-keys -t "$SESSION_NAME:$win_name.0" "$first_cmd" C-m
    fi

    # Additional panes
    local pane_idx=1
    for cmd in "${pane_cmds[@]:1}"; do
        if [[ "$split_type" == "horizontal" ]]; then
            tmux split-window -h -t "$SESSION_NAME:$win_name" -c "$PROJECT_DIR"
        else
            tmux split-window -v -t "$SESSION_NAME:$win_name" -c "$PROJECT_DIR"
        fi
        if [[ "$cmd" != "-" && -n "$cmd" ]]; then
            tmux send-keys -t "$SESSION_NAME:$win_name.$pane_idx" "$cmd" C-m
        fi
        ((pane_idx++))
    done

    # Balance panes
    if [[ "$split_type" == "horizontal" ]]; then
        tmux select-layout -t "$SESSION_NAME:$win_name" even-horizontal
    elif [[ "${#pane_cmds[@]}" -gt 1 ]]; then
        tmux select-layout -t "$SESSION_NAME:$win_name" even-vertical
    fi
    tmux select-pane -t "$SESSION_NAME:$win_name.0"
}

# ── Create session and parse config ─────────────────────────────────
tmux new-session -d -s "$SESSION_NAME" -c "$PROJECT_DIR"
FIRST_WINDOW="true"

if [[ -f "$CONFIG_FILE" ]]; then
    echo "Reading: $CONFIG_FILE"
    while IFS= read -r line || [[ -n "$line" ]]; do
        [[ "$line" =~ ^[[:space:]]*# ]] && continue
        [[ -z "${line// /}" ]] && continue

        IFS=':' read -r win_name split_type rest <<< "$line"
        IFS=':' read -ra cmds <<< "$rest"

        if [[ "$split_type" == "none" ]]; then
            build_window "$win_name" "vertical" "${cmds[@]}"
        else
            build_window "$win_name" "$split_type" "${cmds[@]}"
        fi
    done < "$CONFIG_FILE"
else
    echo "No .tmux-project found — creating default session."
    tmux rename-window -t "$SESSION_NAME:0" "shell"
fi

tmux select-window -t "$SESSION_NAME:{start}"
exec tmux attach-session -t "$SESSION_NAME"

# .tmux-project — Go API service
code:vertical:nvim .:go run ./cmd/server
tests:none:go test ./... -v -count=1
db:horizontal:psql $DATABASE_URL:redis-cli
logs:none:tail -f /var/log/myapp/app.log

# 1. Create a bin directory for your tmux scripts
mkdir -p ~/.local/bin/tmux-scripts

# 2. Move scripts there and make them executable
cp tmux-webdev.sh tmux-devops.sh tmux-datasci.sh \
   tmux-microservices.sh tmux-smart.sh ~/.local/bin/tmux-scripts/
chmod +x ~/.local/bin/tmux-scripts/*

# 3. Add to PATH (in .bashrc or .zshrc)
echo 'export PATH="$HOME/.local/bin/tmux-scripts:$PATH"' >> ~/.zshrc

# 4. Create short aliases
cat >> ~/.zshrc << 'EOF'
alias tw='tmux-webdev.sh'
alias td='tmux-devops.sh'
alias tds='tmux-datasci.sh'
alias tms='tmux-microservices.sh'
alias ts='tmux-smart.sh'

# Universal: cd into a project and auto-start its session
tp() { cd "$1" && tmux-smart.sh "$(pwd)"; }
EOF

# macOS (Homebrew)
brew install tmuxinator

# Any system with Ruby / RubyGems
gem install tmuxinator

# Verify
tmuxinator version

# Creates and opens ~/.config/tmuxinator/myapp.yml in $EDITOR
tmuxinator new myapp

name: myapp                  # Session name in tmux
root: ~/projects/myapp       # Every pane cds here first

# Run in every pane before pane-specific commands
pre_window: nvm use 18

# tmux options (optional)
startup_window: editor       # Focus this window on launch
startup_pane: 0              # Focus this pane within the window

windows:
  - editor:                  # Window name
      layout: main-vertical  # tmux layout preset
      panes:
        - vim .              # Pane 1 command
        - guard              # Pane 2 command

  - server: rails server     # Single-pane window (shorthand)

  - logs:
      layout: even-horizontal
      panes:
        - tail -f log/development.log
        - tail -f log/sidekiq.log

name: webapp
root: ~/code/webapp
pre_window: export RAILS_ENV=development
startup_window: code

windows:
  - code:
      layout: main-vertical
      panes:
        - vim .
        - # empty shell for git / file ops

  - servers:
      layout: even-horizontal
      panes:
        - cd backend && rails server -p 3000
        - cd frontend && npm run dev

  - console:
      panes:
        - rails console

  - logs:
      layout: even-vertical
      panes:
        - tail -f log/development.log
        - cd frontend && npm run lint -- --watch

name: platform
root: ~/code/platform

windows:
  - gateway:
      root: ~/code/platform/api-gateway
      panes:
        - go run ./cmd/server
        - go test ./... -v --count=1

  - auth-service:
      root: ~/code/platform/auth-svc
      panes:
        - cargo watch -x run
        - cargo watch -x test

  - infra:
      layout: tiled
      panes:
        - docker compose up
        - docker compose logs -f postgres
        - redis-cli monitor
        - k9s

name: datascience
root: ~/research/nlp-project
pre_window: conda activate nlp-env

windows:
  - notebook:
      panes:
        - jupyter lab --no-browser --port 8888

  - code:
      layout: main-vertical
      panes:
        - vim src/
        - python -m pytest tests/ -x --tb=short

  - gpu:
      panes:
        - watch -n 2 nvidia-smi

# Launch a project
tmuxinator start webapp

# Launch with a different root directory
tmuxinator start webapp --root=~/code/webapp-v2

# Stop a project (kills the tmux session)
tmuxinator stop webapp

# List all configured projects
tmuxinator list

# Edit an existing project config
tmuxinator edit webapp

# Delete a project config
tmuxinator delete webapp

# Via pip (Python 3.8+)
pip install tmuxp

# Via pipx (isolated install — recommended)
pipx install tmuxp

# macOS
brew install tmuxp

# Verify
tmuxp --version

session_name: myapp
start_directory: ~/projects/myapp

# Environment variables (optional)
environment:
  NODE_ENV: development

windows:
  - window_name: editor
    layout: main-vertical
    panes:
      - shell_command:
          - vim .
      - shell_command:
          - git status

  - window_name: server
    panes:
      - shell_command:
          - npm run dev

  - window_name: logs
    layout: even-horizontal
    panes:
      - shell_command:
          - tail -f /var/log/app.log
      - shell_command:
          - tail -f /var/log/worker.log

session_name: webapp
start_directory: ~/code/webapp
environment:
  RAILS_ENV: development

windows:
  - window_name: code
    layout: main-vertical
    focus: true
    panes:
      - shell_command:
          - vim .
      - # empty shell

  - window_name: servers
    layout: even-horizontal
    panes:
      - shell_command:
          - cd backend && rails server -p 3000
      - shell_command:
          - cd frontend && npm run dev

  - window_name: console
    panes:
      - shell_command:
          - rails console

  - window_name: logs
    layout: even-vertical
    panes:
      - shell_command:
          - tail -f log/development.log
      - shell_command:
          - cd frontend && npm run lint -- --watch

session_name: platform
start_directory: ~/code/platform

windows:
  - window_name: gateway
    start_directory: ~/code/platform/api-gateway
    panes:
      - shell_command:
          - go run ./cmd/server
      - shell_command:
          - go test ./... -v --count=1

  - window_name: auth-service
    start_directory: ~/code/platform/auth-svc
    panes:
      - shell_command:
          - cargo watch -x run
      - shell_command:
          - cargo watch -x test

  - window_name: infra
    layout: tiled
    panes:
      - shell_command:
          - docker compose up
      - shell_command:
          - docker compose logs -f postgres
      - shell_command:
          - redis-cli monitor
      - shell_command:
          - k9s

session_name: datascience
start_directory: ~/research/nlp-project

windows:
  - window_name: notebook
    panes:
      - shell_command:
          - conda activate nlp-env
          - jupyter lab --no-browser --port 8888

  - window_name: code
    layout: main-vertical
    panes:
      - shell_command:
          - conda activate nlp-env
          - vim src/
      - shell_command:
          - conda activate nlp-env
          - python -m pytest tests/ -x --tb=short

  - window_name: gpu
    panes:
      - shell_command:
          - watch -n 2 nvidia-smi

# Freeze the current session to a YAML file
tmuxp freeze my-session -o ~/frozen-session.yaml

# Review the generated config, then reload it
tmuxp load ~/frozen-session.yaml

# Load a config (from ~/.config/tmuxp/ or any path)
tmuxp load webapp.yaml

# Load and attach immediately (skip confirmation prompt)
tmuxp load webapp.yaml -y

# Load from current directory (.tmuxp.yaml)
tmuxp load .

# Freeze a running session
tmuxp freeze my-session

# List available configs in default directory
ls ~/.config/tmuxp/

# Tmuxinator aliases
alias mux="tmuxinator"
alias muxs="tmuxinator start"
alias muxe="tmuxinator edit"
alias muxl="tmuxinator list"

# tmuxp aliases
alias tp="tmuxp load"
alias tpf="tmuxp freeze"

# Quick project launchers
alias work="tmuxinator start webapp"
alias data="tmuxp load datascience.yaml -y"

# Load tmuxinator from a project-local file
tmuxinator start --project-config=./tmux/dev.yml

# Load tmuxp from a project-local file
tmuxp load ./tmux/dev.yaml -y

# Typical project structure:
# myproject/
# ├── .tmuxinator.yml   <- tmuxinator auto-detects this
# ├── .tmuxp.yaml       <- tmuxp loads with `tmuxp load .`
# ├── src/
# └── README.md

# macOS
brew install fzf

# Ubuntu/Debian
sudo apt install fzf

# From source (any Linux)
git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
~/.fzf/install

#!/usr/bin/env bash
# tmux-sessionizer v1: basic session switcher

session=$(tmux list-sessions -F "#{session_name}" 2>/dev/null | \
    fzf --height=40% --reverse --prompt="Switch session: ")

# Exit if nothing was selected (user pressed Esc)
[[ -z "$session" ]] && exit 0

# If we're inside tmux, switch client. Otherwise, attach.
if [[ -n "$TMUX" ]]; then
    tmux switch-client -t "$session"
else
    tmux attach-session -t "$session"
fi

chmod +x ~/.local/bin/tmux-sessionizer

#!/usr/bin/env bash
# tmux-sessionizer v2: with preview pane

session=$(tmux list-sessions -F "#{session_name}" 2>/dev/null | \
    fzf --height=60% --reverse \
        --prompt="Switch session: " \
        --preview="tmux list-windows -t {} -F '  #{window_index}: #{window_name} [#{window_layout}] #{?window_active,(active),}'" \
        --preview-window=right:50%)

[[ -z "$session" ]] && exit 0

if [[ -n "$TMUX" ]]; then
    tmux switch-client -t "$session"
else
    tmux attach-session -t "$session"
fi

#!/usr/bin/env bash
# tmux-sessionizer v3: sessions + project directories

# ── Configuration ──
PROJECT_DIRS=(~/projects ~/work ~/personal)

# ── Gather candidates ──
# Existing tmux sessions
existing=$(tmux list-sessions -F "#{session_name}" 2>/dev/null)

# Project directories (one level deep)
projects=""
for dir in "${PROJECT_DIRS[@]}"; do
    [[ -d "$dir" ]] && projects+=$(find "$dir" -mindepth 1 -maxdepth 1 -type d)$'\n'
done

# ── Present unified picker ──
selected=$(printf "%s\n%s" "$existing" "$projects" | \
    sed '/^$/d' | \
    fzf --height=60% --reverse \
        --prompt="Session/Project: " \
        --preview='if tmux has-session -t {##*/} 2>/dev/null; then
            tmux list-windows -t {##*/} -F "  #{window_index}: #{window_name} [#{window_layout}]"
        else
            ls -la {} 2>/dev/null || echo "tmux session: {}"
        fi' \
        --preview-window=right:50%)

[[ -z "$selected" ]] && exit 0

# ── Derive session name (directory basename, dots replaced) ──
session_name=$(basename "$selected" | tr '.' '_')

# ── Create session if it doesn't exist ──
if ! tmux has-session -t="$session_name" 2>/dev/null; then
    if [[ -d "$selected" ]]; then
        tmux new-session -d -s "$session_name" -c "$selected"
    else
        tmux new-session -d -s "$session_name"
    fi
fi

# ── Switch or attach ──
if [[ -n "$TMUX" ]]; then
    tmux switch-client -t "$session_name"
else
    tmux attach-session -t "$session_name"
fi

#!/usr/bin/env bash
# tmux-sessionizer v4: with session destroy mode (ctrl-x)

PROJECT_DIRS=(~/projects ~/work ~/personal)
DESTROY_MODE=false

# Parse flags
while [[ "${1:-}" == "--destroy" ]]; do DESTROY_MODE=true; shift; done

if $DESTROY_MODE; then
    # ── Destroy mode: multi-select existing sessions ──
    sessions=$(tmux list-sessions -F "#{session_name}" 2>/dev/null | \
        fzf --multi --height=40% --reverse \
            --prompt="Destroy sessions (Tab=select, Enter=confirm): " \
            --header="Select sessions to destroy" \
            --preview="tmux list-windows -t {} -F '  #{window_index}: #{window_name}'")

    [[ -z "$sessions" ]] && exit 0

    while IFS= read -r s; do
        tmux kill-session -t "$s" && echo "Destroyed: $s"
    done <<< "$sessions"
    exit 0
fi

# ── Normal mode (same as v3) ──
existing=$(tmux list-sessions -F "#{session_name}" 2>/dev/null)
projects=""
for dir in "${PROJECT_DIRS[@]}"; do
    [[ -d "$dir" ]] && projects+=$(find "$dir" -mindepth 1 -maxdepth 1 -type d)$'\n'
done

selected=$(printf "%s\n%s" "$existing" "$projects" | \
    sed '/^$/d' | \
    fzf --height=60% --reverse \
        --prompt="Session/Project: " \
        --header="ctrl-x: destroy sessions" \
        --bind="ctrl-x:execute(tmux-sessionizer --destroy)+abort" \
        --preview='if tmux has-session -t {##*/} 2>/dev/null; then
            tmux list-windows -t {##*/} -F "  #{window_index}: #{window_name} [#{window_layout}]"
        else
            ls -la {} 2>/dev/null || echo "tmux session: {}"
        fi' \
        --preview-window=right:50%)

[[ -z "$selected" ]] && exit 0

session_name=$(basename "$selected" | tr '.' '_')

if ! tmux has-session -t="$session_name" 2>/dev/null; then
    if [[ -d "$selected" ]]; then
        tmux new-session -d -s "$session_name" -c "$selected"
    else
        tmux new-session -d -s "$session_name"
    fi
fi

if [[ -n "$TMUX" ]]; then
    tmux switch-client -t "$session_name"
else
    tmux attach-session -t "$session_name"
fi

#!/usr/bin/env bash
# tmux-sessionizer v5 — the complete session manager
# Dependencies: fzf, zoxide (optional)
set -euo pipefail

PROJECT_DIRS=(~/projects ~/work ~/personal)

# ── Destroy mode ──
if [[ "${1:-}" == "--destroy" ]]; then
    sessions=$(tmux list-sessions -F "#{session_name}" 2>/dev/null | \
        fzf --multi --height=40% --reverse \
            --prompt="Destroy (Tab=select): " \
            --preview="tmux list-windows -t {} -F '  #{window_index}: #{window_name}'")
    [[ -z "$sessions" ]] && exit 0
    while IFS= read -r s; do
        tmux kill-session -t "$s" && echo "Destroyed: $s"
    done <<< "$sessions"
    exit 0
fi

# ── Gather existing sessions ──
existing=$(tmux list-sessions -F "⚡ #{session_name}" 2>/dev/null || true)

# ── Gather project directories ──
projects=""
if command -v zoxide &>/dev/null; then
    # Zoxide: frecency-sorted directories (filter to project dirs)
    for dir in "${PROJECT_DIRS[@]}"; do
        [[ -d "$dir" ]] && projects+=$(zoxide query -l | grep "^${dir}" | head -20)$'\n'
    done
else
    # Fallback: flat directory scan
    for dir in "${PROJECT_DIRS[@]}"; do
        [[ -d "$dir" ]] && projects+=$(find "$dir" -mindepth 1 -maxdepth 1 -type d | sort)$'\n'
    done
fi
# Prefix project dirs for visual distinction
projects=$(echo "$projects" | sed '/^$/d' | while read -r p; do echo "📁 $p"; done)

# ── Unified picker ──
selected=$(printf "%s\n%s" "$existing" "$projects" | sed '/^$/d' | \
    fzf --height=70% --reverse --ansi \
        --prompt="  " \
        --header="Enter=switch/create | ctrl-x=destroy | ctrl-r=refresh" \
        --bind="ctrl-x:execute(tmux-sessionizer --destroy)+abort" \
        --bind="ctrl-r:reload(tmux list-sessions -F '⚡ #{session_name}' 2>/dev/null)" \
        --preview='
            name=$(echo {} | sed "s/^[^ ]* //")
            if tmux has-session -t "${name##*/}" 2>/dev/null; then
                echo "── Session: ${name##*/} ──"
                tmux list-windows -t "${name##*/}" \
                    -F "  #{window_index}:#{window_name} #{window_panes} panes [#{window_layout}] #{?window_active,<- active,}"
                echo ""
                echo "── Pane Tree ──"
                tmux list-panes -t "${name##*/}" \
                    -F "  #{window_index}.#{pane_index}: #{pane_current_command} (#{pane_width}x#{pane_height})"
            elif [[ -d "$name" ]]; then
                echo "── Project: $name ──"
                ls -1 "$name" | head -30
            fi
        ' \
        --preview-window=right:50%:wrap)

[[ -z "$selected" ]] && exit 0

# ── Strip the emoji prefix, extract path or name ──
selected=$(echo "$selected" | sed 's/^[^ ]* //')
session_name=$(basename "$selected" | tr './ ' '___')

# ── Create if needed ──
if ! tmux has-session -t="$session_name" 2>/dev/null; then
    if [[ -d "$selected" ]]; then
        tmux new-session -d -s "$session_name" -c "$selected"
    else
        tmux new-session -d -s "$session_name"
    fi
fi

# ── Switch or attach ──
if [[ -n "${TMUX:-}" ]]; then
    tmux switch-client -t "$session_name"
else
    tmux attach-session -t "$session_name"
fi

# Session manager — prefix + f
bind-key f run-shell "tmux neww ~/.local/bin/tmux-sessionizer"

# Destroy mode shortcut — prefix + K
bind-key K run-shell "tmux neww ~/.local/bin/tmux-sessionizer --destroy"

# Floating popup — feels much snappier
bind-key f display-popup -E -w 80% -h 80% "~/.local/bin/tmux-sessionizer"

# Ctrl+f → tmux session manager
bindkey -s '^f' 'tmux-sessionizer\n'    # zsh
# bind -x '"\C-f": tmux-sessionizer'    # bash alternative

# Rename session: Ctrl-n prompts for new name
--bind='ctrl-n:execute(
    read -p "New name: " name;
    tmux rename-session -t {##*/} "$name"
)+reload(tmux list-sessions -F "#{session_name}")'

# Git branch in preview: append to the preview block
echo "── Git ──"
git -C "$name" branch --show-current 2>/dev/null
git -C "$name" log --oneline -5 2>/dev/null

# Use fd instead of find (much faster on large dirs)
projects+=$(fd -t d --max-depth 1 . "$dir")$'\n'

-- In your lazy.nvim plugin spec (e.g., lua/plugins/navigation.lua)
return {
  "christoomey/vim-tmux-navigator",
  cmd = {
    "TmuxNavigateLeft",
    "TmuxNavigateDown",
    "TmuxNavigateUp",
    "TmuxNavigateRight",
    "TmuxNavigatePrevious",
  },
  keys = {
    { "<C-h>", "<cmd>TmuxNavigateLeft<cr>",  desc = "Navigate left" },
    { "<C-j>", "<cmd>TmuxNavigateDown<cr>",  desc = "Navigate down" },
    { "<C-k>", "<cmd>TmuxNavigateUp<cr>",    desc = "Navigate up" },
    { "<C-l>", "<cmd>TmuxNavigateRight<cr>", desc = "Navigate right" },
  },
}

" In your .vimrc
Plug 'christoomey/vim-tmux-navigator'

" The plugin sets these mappings automatically:
"   <C-h> => TmuxNavigateLeft
"   <C-j> => TmuxNavigateDown
"   <C-k> => TmuxNavigateUp
"   <C-l> => TmuxNavigateRight

# Get process state + command name for the pane's PID
ps -o state= -o comm= -t '#{pane_tty}'

# Example output when vim is running:
# S+ vim
# S+ nvim

# ~/.tmux.conf — vim-tmux-navigator integration

# Pattern that matches vim/neovim process names
is_vim="ps -o state= -o comm= -t '#{pane_tty}' \
    | grep -iqE '^[^TXZ ]+ +(\\S+\\/)?g?(view|l?n?vim?x?|fzf)(diff)?$'"

# Bind Ctrl-h/j/k/l with conditional logic:
#   if vim → forward the key to vim (send-keys)
#   if not → tmux handles pane navigation (select-pane)
bind-key -n 'C-h' if-shell "$is_vim" 'send-keys C-h'  'select-pane -L'
bind-key -n 'C-j' if-shell "$is_vim" 'send-keys C-j'  'select-pane -D'
bind-key -n 'C-k' if-shell "$is_vim" 'send-keys C-k'  'select-pane -U'
bind-key -n 'C-l' if-shell "$is_vim" 'send-keys C-l'  'select-pane -R'

# Also handle Ctrl-\ for "previous pane" navigation
tmux_version='$(tmux -V | sed -En "s/^tmux ([0-9]+(.[0-9]+)?).*/\1/p")'
if-shell -b '[ "$(echo "$tmux_version >= 3.0" | bc)" = 1 ]' \
    "bind-key -n 'C-\\' if-shell \"$is_vim\" 'send-keys C-\\\\'  'select-pane -l'"

# IMPORTANT: Also bind in copy-mode so scrolling doesn't break navigation
bind-key -T copy-mode-vi 'C-h' select-pane -L
bind-key -T copy-mode-vi 'C-j' select-pane -D
bind-key -T copy-mode-vi 'C-k' select-pane -U
bind-key -T copy-mode-vi 'C-l' select-pane -R

# ~/.tmux.conf — using TPM
set -g @plugin 'christoomey/vim-tmux-navigator'

# Then reload: prefix + I to install

# Extended pattern: also match ssh connections
is_vim="ps -o state= -o comm= -t '#{pane_tty}' \
    | grep -iqE '^[^TXZ ]+ +(\\S+\\/)?g?(view|l?n?vim?x?|fzf|ssh)(diff)?$'"

# Match vim, fzf, ssh, AND docker
is_vim="ps -o state= -o comm= -t '#{pane_tty}' \
    | grep -iqE '^[^TXZ ]+ +(\\S+\\/)?g?(view|l?n?vim?x?|fzf|ssh|docker)(diff)?$'"

# Run this in a tmux pane to see what tmux sees:
ps -o state= -o comm= -t "$(tmux display-message -p '#{pane_tty}')"

# Expected output when nvim is running:
# S+ nvim
# S+ zsh

# Test the full grep match:
ps -o state= -o comm= -t "$(tmux display-message -p '#{pane_tty}')" \
    | grep -iqE '^[^TXZ ]+ +(\\S+\\/)?g?(view|l?n?vim?x?|fzf)(diff)?$' \
    && echo "MATCH: would send-keys to vim" \
    || echo "NO MATCH: would select-pane"

# ~/.tmux.conf — enable OSC 52 clipboard
set -g set-clipboard on

# Allow tmux to pass through OSC 52 sequences to the terminal
set -g allow-passthrough on

-- In your init.lua
-- Neovim 0.10+ has built-in OSC 52 support
vim.g.clipboard = {
  name = "OSC 52",
  copy = {
    ["+"] = require("vim.ui.clipboard.osc52").copy("+"),
    ["*"] = require("vim.ui.clipboard.osc52").copy("*"),
  },
  paste = {
    ["+"] = require("vim.ui.clipboard.osc52").paste("+"),
    ["*"] = require("vim.ui.clipboard.osc52").paste("*"),
  },
}

# ~/.tmux.conf — clipboard integration (macOS)
set -g set-clipboard off
bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "pbcopy"

# Linux (X11)
# bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "xclip -sel clip"

# Linux (Wayland)
# bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "wl-copy"

-- Sync Neovim's unnamed register with system clipboard
vim.opt.clipboard = "unnamedplus"

# Basic syntax
tmux display-popup [options] [shell-command]

# Key flags
#   -E           Close the popup automatically when the command exits
#   -w 80%       Width  (percentage or absolute columns)
#   -h 60%       Height (percentage or absolute rows)
#   -d "#{pane_current_path}"   Working directory
#   -T "Title"   Title shown in the popup border
#   -S fg=green  Style the popup border
#   -s bg=black  Style the popup body background

#!/usr/bin/env bash
# ~/.local/bin/tmux-fzf-open — file finder popup helper

FILE=$(fd --type f --hidden --exclude .git | fzf \
  --preview 'bat --color=always --line-range :50 {}' \
  --header '  Enter: open in vim  |  Ctrl-c: cancel')

[ -n "$FILE" ] && tmux send-keys -t ! "vim $FILE" Enter

# ~/.tmux.conf
bind f display-popup -E -w 80% -h 60% -d "#{pane_current_path}" \
  -T " Find File " "~/.local/bin/tmux-fzf-open"

#!/usr/bin/env bash
# ~/.local/bin/tmux-fzf-kill — process killer popup

PID=$(ps -ef | sed 1d | fzf \
  --header 'Select process to kill (Tab to multi-select)' \
  --multi \
  --preview 'echo {}' \
  --preview-window down:3:wrap | awk '{print $2}')

if [ -n "$PID" ]; then
  echo "$PID" | xargs kill -9
  tmux display-message "Killed PID(s): $PID"
fi

# ~/.tmux.conf
bind K display-popup -E -w 70% -h 50% \
  -T " Kill Process " "~/.local/bin/tmux-fzf-kill"

#!/usr/bin/env bash
# ~/.local/bin/tmux-fzf-branch — git branch switcher

BRANCH=$(git branch --all --sort=-committerdate \
  --format='%(refname:short)' | \
  fzf --header 'Switch git branch' \
      --preview 'git log --oneline --graph --color=always -15 {}' \
      --preview-window right:50%)

if [ -n "$BRANCH" ]; then
  # Handle remote branches: origin/feature-x → feature-x
  BRANCH=${BRANCH#origin/}
  tmux send-keys -t ! "git checkout $BRANCH" Enter
fi

# ~/.tmux.conf
bind B display-popup -E -w 75% -h 60% -d "#{pane_current_path}" \
  -T " Git Branches " "~/.local/bin/tmux-fzf-branch"

#!/usr/bin/env bash
# ~/.local/bin/tmux-fzf-man — man page browser

PAGE=$(man -k . 2>/dev/null | \
  fzf --header 'Open man page' \
      --prompt 'man> ' \
      --preview 'echo {} | awk "{print \$1}" | xargs man 2>/dev/null | head -80' \
      --preview-window right:60%:wrap | \
  awk '{print $1}')

[ -n "$PAGE" ] && tmux send-keys -t ! "man $PAGE" Enter

# ~/.tmux.conf
bind M display-popup -E -w 80% -h 70% \
  -T " Man Pages " "~/.local/bin/tmux-fzf-man"

#!/usr/bin/env bash
# ~/.local/bin/tmux-fzf-ssh — SSH host picker

HOST=$(awk '/^Host / && !/\*/ {print $2}' ~/.ssh/config | sort -u | \
  fzf --header 'SSH into host' \
      --prompt 'ssh> ' \
      --preview 'awk "/^Host {}/,/^Host [^*]/" ~/.ssh/config | head -20' \
      --preview-window right:40%:wrap)

if [ -n "$HOST" ]; then
  # Open SSH in a new tmux window named after the host
  tmux new-window -n "$HOST" "ssh $HOST"
fi

# ~/.tmux.conf
bind S display-popup -E -w 60% -h 50% \
  -T " SSH Hosts " "~/.local/bin/tmux-fzf-ssh"

# Border style: -S sets border style, -s sets body style
bind f display-popup -E -w 80% -h 60% \
  -S 'fg=#7aa2f7,bg=default' \
  -s 'bg=#1a1b26' \
  -T " Find File " \
  -d "#{pane_current_path}" \
  "~/.local/bin/tmux-fzf-open"

# Global popup defaults (tmux 3.4+)
set -g popup-border-style 'fg=#565f89'
set -g popup-style 'bg=#1a1b26'

# Centered positioning (default), or specify offsets
# -x and -y control popup position (C = center)
bind f display-popup -E -w 80% -h 60% -x C -y C "..."

# fzf-tmux opens fzf in a split pane instead of a popup
# -p flag: use popup if available, fall back to pane if not (fzf 0.35+)
# -w/-h: width/height (same as display-popup)

# File finder using fzf-tmux with popup mode
fd --type f | fzf-tmux -p 80%,60% \
  --header 'Find file' \
  --preview 'bat --color=always {}'

# Without popup support, use split direction flags:
#   -d 40%     bottom pane, 40% height
#   -u 40%     top pane
#   -l 50%     right pane
#   -r 50%     left pane
fd --type f | fzf-tmux -d 40%

#!/usr/bin/env bash
# tmux-fzf-wrapper — use popup if available, split if not

TMUX_VERSION=$(tmux -V | sed 's/[^0-9.]//g')
MAJOR=$(echo "$TMUX_VERSION" | cut -d. -f1)
MINOR=$(echo "$TMUX_VERSION" | cut -d. -f2)

if [ "$MAJOR" -gt 3 ] || { [ "$MAJOR" -eq 3 ] && [ "$MINOR" -ge 2 ]; }; then
  # tmux 3.2+: use native popup
  tmux display-popup -E -w 80% -h 60% \
    -d "#{pane_current_path}" \
    "fd --type f | fzf --preview 'bat --color=always {}'"
else
  # Older tmux: use fzf-tmux split pane
  SELECTED=$(fd --type f | fzf-tmux -d 40% \
    --preview 'bat --color=always {}')
  [ -n "$SELECTED" ] && tmux send-keys "vim $SELECTED" Enter
fi

# ── FZF Popup Recipes ───────────────────────────────
# Requires: tmux 3.2+, fzf, fd, bat

# Prefix + f  →  Find & open file in vim
bind f display-popup -E -w 80% -h 60% \
  -d "#{pane_current_path}" \
  -T " Find File " "~/.local/bin/tmux-fzf-open"

# Prefix + K  →  Kill process
bind K display-popup -E -w 70% -h 50% \
  -T " Kill Process " "~/.local/bin/tmux-fzf-kill"

# Prefix + B  →  Switch git branch
bind B display-popup -E -w 75% -h 60% \
  -d "#{pane_current_path}" \
  -T " Git Branches " "~/.local/bin/tmux-fzf-branch"

# Prefix + M  →  Browse man pages
bind M display-popup -E -w 80% -h 70% \
  -T " Man Pages " "~/.local/bin/tmux-fzf-man"

# Prefix + S  →  SSH to host
bind S display-popup -E -w 60% -h 50% \
  -T " SSH Hosts " "~/.local/bin/tmux-fzf-ssh"

# SSH into the server
ssh deploy@prod-server

# Create a new named session (or attach if it exists)
tmux new-session -A -s work

# ... do your work, deploy, tail logs, etc.

# Detach cleanly when done (Prefix + d)
# Or just close your laptop — the session survives

# Local tmux: use Ctrl-a as prefix
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# Remote tmux: keep default Ctrl-b
# (no change needed — this is the default)

# Press Ctrl-b Ctrl-b to send prefix to inner tmux
bind C-b send-prefix

# ── F12: Toggle local tmux off/on for nested sessions ──

# Colors for visual feedback
color_status_active="colour39"   # Blue — local tmux is active
color_status_remote="colour202"  # Orange — passthrough to remote

# Default status bar style (local active)
set -g status-style "bg=$color_status_active,fg=colour232"

# F12 turns OFF local prefix: all keys go to inner (remote) tmux
bind -T root F12 \
    set prefix None \;\
    set key-table off \;\
    set status-style "bg=$color_status_remote,fg=colour232" \;\
    set window-status-current-style "bg=colour196,fg=colour232,bold" \;\
    if -F '#{pane_in_mode}' 'send-keys -X cancel' \;\
    refresh-client -S

# F12 again turns ON local prefix: back to normal
bind -T off F12 \
    set -u prefix \;\
    set -u key-table \;\
    set -u status-style \;\
    set -u window-status-current-style \;\
    refresh-client -S

# Keep SSH_AUTH_SOCK updated when reattaching
set -g update-environment "SSH_AUTH_SOCK SSH_CONNECTION DISPLAY"

#!/bin/bash
# Create a stable symlink for the SSH agent socket
if [ -S "$SSH_AUTH_SOCK" ]; then
    ln -sf "$SSH_AUTH_SOCK" ~/.ssh/agent_sock
fi

# Point to the stable symlink instead of the ephemeral socket
export SSH_AUTH_SOCK=~/.ssh/agent_sock

#!/usr/bin/env bash
# ssht — SSH into a host and attach to a tmux session
# Usage: ssht user@host [session-name]

set -euo pipefail

HOST="${1:?Usage: ssht user@host [session-name]}"
SESSION="${2:-main}"

echo "Connecting to $HOST, tmux session: $SESSION"

ssh -A -t "$HOST" \
    "tmux new-session -A -s '$SESSION'"

# Make it executable and use it
chmod +x ~/bin/ssht

# Connect to prod server, default "main" session
ssht deploy@prod-server

# Connect with a named session for a specific task
ssht deploy@prod-server deploy-v2.1

# Open lazygit in a centered popup (90% of terminal size)
# -E closes the popup when lazygit exits
# -d sets the working directory to the current pane's path
bind g display-popup -E -w 90% -h 90% -d "#{pane_current_path}" lazygit

# Show git diff --stat in a 30% bottom split pane
# The pane closes automatically when you press q (less exits)
bind D split-window -v -l 30% -d -c "#{pane_current_path}" \
  'git diff --stat --color=always | less -R'

# Variant: full diff with syntax highlighting via delta
bind d split-window -v -l 50% -d -c "#{pane_current_path}" \
  'git diff --color=always | delta --paging=always'

#!/usr/bin/env bash
# tmux-worktree: fzf picker to switch between git worktree sessions
# Each worktree gets a dedicated tmux session named after its branch.

set -euo pipefail

# Get the bare repo root (works for both bare and non-bare repos)
git_root=$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)
git_root="${git_root%/.git}"  # strip /.git suffix if present

# List all worktrees, extract path and branch
worktrees=$(git worktree list --porcelain | awk '
  /^worktree / { path = $2 }
  /^branch /   { gsub("refs/heads/", "", $2); print path "|" $2 }
')

if [[ -z "$worktrees" ]]; then
  echo "No worktrees found. Create one with: git worktree add ../branch-name branch-name"
  exit 1
fi

# Use fzf to pick a worktree
selected=$(echo "$worktrees" | \
  column -t -s '|' | \
  fzf --prompt="Switch worktree> " \
      --header="PATH | BRANCH" \
      --reverse \
      --height=40%)

# Parse selection
wt_path=$(echo "$selected" | awk '{print $1}')
wt_branch=$(echo "$selected" | awk '{print $2}')

# Sanitize branch name for tmux session name (replace dots/colons)
session_name="${wt_branch//[.:]/-}"

# Create or attach to the session for this worktree
if ! tmux has-session -t "=$session_name" 2>/dev/null; then
  tmux new-session -d -s "$session_name" -c "$wt_path"
  tmux send-keys -t "$session_name" "echo 'Worktree: $wt_branch'" Enter
fi

# Switch to session (works whether called from inside or outside tmux)
if [[ -n "${TMUX:-}" ]]; then
  tmux switch-client -t "=$session_name"
else
  tmux attach-session -t "=$session_name"
fi

# Open worktree picker in a popup
bind W display-popup -E -w 60% -h 60% "tmux-worktree"

# Auto-rename tmux window to git branch (or directory name if not in a repo)
tmux_auto_rename() {
  # Only run inside tmux
  [[ -n "${TMUX:-}" ]] || return

  local branch
  branch=$(git branch --show-current 2>/dev/null)

  if [[ -n "$branch" ]]; then
    tmux rename-window "$branch"
  else
    # Fall back to the current directory name
    tmux rename-window "${PWD##*/}"
  fi
}

# For zsh: hook into precmd
if [[ -n "$ZSH_VERSION" ]]; then
  autoload -Uz add-zsh-hook
  add-zsh-hook precmd tmux_auto_rename
fi

# For bash: use PROMPT_COMMAND
if [[ -n "$BASH_VERSION" ]]; then
  PROMPT_COMMAND="tmux_auto_rename;${PROMPT_COMMAND:-}"
fi

# Let tmux auto-rename windows and show git branch via shell command
set -g automatic-rename on
set -g automatic-rename-format \
  '#{?#{==:#{pane_current_command},zsh},#(git -C "#{pane_current_path}" branch --show-current 2>/dev/null || echo "#{b:pane_current_path}"),#{pane_current_command}}'

# Refresh status bar every 5 seconds to keep branch names current
set -g status-interval 5

#!/usr/bin/env bash
# tmux-pr-review: Create a tmux layout for reviewing a PR/branch diff
# Usage: tmux-pr-review [base-branch]
#   base-branch defaults to "main"

set -euo pipefail

BASE="${1:-main}"
BRANCH=$(git branch --show-current)
REPO_ROOT=$(git rev-parse --show-toplevel)
SESSION="review/${BRANCH}"

# Sanitize session name
SESSION="${SESSION//[.:]/-}"

if tmux has-session -t "=$SESSION" 2>/dev/null; then
  echo "Review session '$SESSION' already exists. Attaching..."
  if [[ -n "${TMUX:-}" ]]; then
    tmux switch-client -t "=$SESSION"
  else
    tmux attach-session -t "=$SESSION"
  fi
  exit 0
fi

# Create session — first pane shows changed files list
tmux new-session -d -s "$SESSION" -c "$REPO_ROOT" \
  -x "$(tput cols)" -y "$(tput lines)"

# Pane 0 (top-left): Changed files list with stats
tmux send-keys -t "$SESSION" \
  "echo '=== Files changed: $BRANCH vs $BASE ===' && git diff --stat --color=always ${BASE}...HEAD | less -R" Enter

# Pane 1 (top-right): Full diff with syntax highlighting
tmux split-window -h -t "$SESSION" -c "$REPO_ROOT" \
  -l 60%
tmux send-keys -t "$SESSION" \
  "git diff --color=always ${BASE}...HEAD | less -R" Enter

# Pane 2 (bottom): Editor for making notes or changes
tmux split-window -v -t "$SESSION" -c "$REPO_ROOT" \
  -l 35%
tmux send-keys -t "$SESSION" \
  "${EDITOR:-vim} ." Enter

# Select the diff pane as the active one
tmux select-pane -t "$SESSION:.0"

# Apply a descriptive layout name
tmux rename-window -t "$SESSION" "PR: ${BRANCH}"

# Attach
if [[ -n "${TMUX:-}" ]]; then
  tmux switch-client -t "=$SESSION"
else
  tmux attach-session -t "=$SESSION"
fi

┌──────────────────┬─────────────────────────────────┐
│                  │                                 │
│  Changed Files   │         Full Diff               │
│  (git diff       │     (git diff BASE...HEAD)      │
│    --stat)       │                                 │
│                  │                                 │
│                  ├─────────────────────────────────┤
│                  │                                 │
│                  │   Editor ($EDITOR)              │
│                  │                                 │
└──────────────────┴─────────────────────────────────┘

# Launch PR review session (defaults to diffing against main)
bind R display-popup -E -w 40% -h 30% \
  'read -p "Base branch [main]: " base; tmux-pr-review "${base:-main}"'

# ── Git Integration ──────────────────────────────────

# Recipe 1: Lazygit popup
bind g display-popup -E -w 90% -h 90% -d "#{pane_current_path}" lazygit

# Recipe 2: Quick diff stat / full diff
bind D split-window -v -l 30% -d -c "#{pane_current_path}" \
  'git diff --stat --color=always | less -R'
bind d split-window -v -l 50% -d -c "#{pane_current_path}" \
  'git diff --color=always | delta --paging=always'

# Recipe 3: Worktree session picker
bind W display-popup -E -w 60% -h 60% "tmux-worktree"

# Recipe 4: Auto-rename windows to git branch
set -g automatic-rename on
set -g status-interval 5

# Recipe 5: PR review layout
bind R display-popup -E -w 40% -h 30% \
  'read -p "Base branch [main]: " base; tmux-pr-review "${base:-main}"'

# Global hook — applies to all sessions
set-hook -g after-new-session 'command-to-run'

# Session-specific hook — only this session
set-hook after-split-window 'command-to-run'

# Append multiple hooks to the same event (use -a)
set-hook -ga after-new-window 'run-shell "echo window created"'

# Remove a hook
set-hook -gu after-new-session

# Auto-name session after the working directory
set-hook -g after-new-session \
  'run-shell "tmux rename-session $(basename \"#{pane_current_path}\")"'

# Auto-tile after every split
set-hook -g after-split-window 'select-layout tiled'

# Or only apply main-vertical when 3+ panes exist
set-hook -g after-split-window \
  'if-shell "[ #{window_panes} -ge 3 ]" "select-layout main-vertical"'

# Log attach/detach events with timestamp
set-hook -g client-attached \
  'run-shell "echo \"$(date +%Y-%m-%dT%H:%M:%S) ATTACH #{session_name}\" >> ~/.tmux-activity.log"'

set-hook -g client-detached \
  'run-shell "echo \"$(date +%Y-%m-%dT%H:%M:%S) DETACH #{session_name}\" >> ~/.tmux-activity.log"'

# Debug format strings interactively with display -p
tmux display -p '#{session_name}'               # → my-api
tmux display -p '#{window_index}:#{pane_index}'  # → 0:1
tmux display -p '#{pane_current_command}'        # → vim
tmux display -p '#{pane_current_path}'           # → /home/user/projects
tmux display -p '#{client_prefix}'               # → 0 (or 1 if prefix held)
tmux display -p '#{window_panes}'                # → 3

# Basic ternary: #{?condition,if-true,if-false}
# The condition is "truthy" if the variable is nonzero/nonempty

# Show "PREFIX" when prefix is pressed, nothing otherwise
#{?client_prefix,PREFIX,}

# String comparison with #{==:left,right}
#{==:#{pane_current_command},vim}   # → 1 if running vim

# Logical AND with #{&&:cond1,cond2}
#{&&:#{client_prefix},#{pane_in_mode}}  # → 1 if both true

# Logical OR with #{||:cond1,cond2}
#{||:#{window_bell_flag},#{window_activity_flag}}

# Nesting — compose conditions inside ternary
#{?#{==:#{pane_current_command},vim}, EDITOR , SHELL }

# Status bar turns red when prefix is pressed, green otherwise
set -g status-style "bg=default"
set -g status-left \
  "#{?client_prefix,#[bg=red#,fg=white#,bold] PREFIX ,#[bg=green#,fg=black] #S }"

# Right side: show COPY when in copy mode
set -g status-right \
  "#{?pane_in_mode,#[bg=yellow#,fg=black] COPY ,} %H:%M %d-%b"

# Show editor label when in vim, directory basename otherwise
set -g window-status-current-format \
  " #{?#{==:#{pane_current_command},vim},VIM #{pane_current_command},#I:#{b:pane_current_path}} "

# #{b:pane_current_path} is a built-in modifier that returns the basename

# Show remote indicator when SSH is active in the pane
set -g status-right \
  "#{?#{==:#{pane_current_command},ssh},#[fg=red] SSH: #{pane_title} ,#[fg=green] LOCAL } %H:%M"

# if-shell "test-command" "true-command" "false-command"
# The false branch is optional

if-shell "command -v fzf" "bind f run-shell 'tmux-fzf'"
#         ^ test           ^ runs only if fzf is installed

# macOS clipboard
if-shell "uname | grep -q Darwin" \
  "bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel 'pbcopy'"

# Linux clipboard (X11)
if-shell "uname | grep -q Linux" \
  "bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel 'xclip -selection clipboard'"

# set-clipboard was added in tmux 3.2
# Use sort -V for reliable version comparison
if-shell '[ "$(printf "%s\n" "3.2" "$(tmux -V | cut -d" " -f2)" \
  | sort -V | head -1)" = "3.2" ]' \
  'set -g set-clipboard on'

# A cleaner approach using awk
if-shell 'tmux -V | awk "{split(\$2,v,\".\"); \
  if (v[1]>3 || (v[1]==3 && v[2]>=2)) exit 0; exit 1}"' \
  'set -g set-clipboard on'

# Only bind fzf shortcuts if fzf is actually installed
if-shell "command -v fzf >/dev/null 2>&1" {
  bind C-f run-shell "tmux list-sessions -F '#{session_name}' \
    | fzf-tmux | xargs tmux switch-client -t"
  bind C-w run-shell "tmux list-windows \
    -F '#{window_index}: #{window_name}' \
    | fzf-tmux | cut -d: -f1 | xargs tmux select-window -t"
}

# Only load TPM if the directory exists
if-shell "test -d ~/.tmux/plugins/tpm" \
  "run '~/.tmux/plugins/tpm/tpm'"

# === Basics =============================================
set -g default-terminal "tmux-256color"
set -g mouse on
set -g base-index 1
setw -g pane-base-index 1

# === Portable Clipboard =================================
# Detect clipboard: pbcopy (macOS), wl-copy (Wayland),
# xclip (X11), or fallback to tmux built-in set-clipboard
if-shell "command -v pbcopy >/dev/null" {
  set -g copy-command "pbcopy"
  bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "pbcopy"
} {
  if-shell "command -v wl-copy >/dev/null" {
    bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "wl-copy"
  } {
    if-shell "command -v xclip >/dev/null" {
      bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel \
        "xclip -sel clip"
    } {
      set -g set-clipboard on
    }
  }
}

# === Smart Status Bar ===================================
set -g status-left-length 40
set -g status-right-length 80

# Left: session name with prefix indicator
set -g status-left \
  "#{?client_prefix,#[bg=colour196#,fg=white#,bold] PREFIX ,#[bg=colour238#,fg=colour248] #S } "

# Right: SSH vs local + copy mode + clock
set -g status-right \
  "#{?pane_in_mode,#[bg=colour214#,fg=black] COPY ,}"\
  "#{?#{==:#{pane_current_command},ssh},#[fg=colour196] SSH: #{pane_title},#[fg=colour114] #{host_short}} "\
  "#[fg=colour248]| %H:%M "

# Window tabs
setw -g window-status-format " #I:#{b:pane_current_path} "
setw -g window-status-current-format \
  "#[fg=colour114#,bold] #I:#{b:pane_current_path} "

# === Hooks ==============================================
# Auto-name sessions from working directory
set-hook -g after-new-session \
  'run-shell "tmux rename-session \"$(basename #{pane_current_path})\""'  

# Auto-tile when a window hits 3+ panes
set-hook -g after-split-window \
  'if-shell "[ #{window_panes} -ge 3 ]" "select-layout tiled"'

# Log session attach/detach for time tracking
set-hook -g client-attached \
  'run-shell "echo \"$(date +%%F\\ %%T) IN  #{session_name}\" >> ~/.tmux-activity.log"'
set-hook -g client-detached \
  'run-shell "echo \"$(date +%%F\\ %%T) OUT #{session_name}\" >> ~/.tmux-activity.log"'

# === Conditional Plugin Loading =========================
if-shell "test -d ~/.tmux/plugins/tpm" \
  "run '~/.tmux/plugins/tpm/tpm'"

# 1. Test any format string interactively
tmux display -p '#{pane_current_command}'
tmux display -p '#{?client_prefix,YES,NO}'

# 2. Check all current hooks
tmux show-hooks -g

# 3. Start tmux with verbose logging to trace errors
tmux -vv new-session
# Then inspect: ~/.tmux-server-*.log

# 4. Test if-shell conditions manually
tmux if-shell "command -v fzf" \
  "display 'fzf found'" "display 'fzf missing'"

# 5. Dump all format variables for the current pane
tmux display -p \
  'sid=#{session_id} wid=#{window_id} pid=#{pane_id} cmd=#{pane_current_command}'

#!/usr/bin/env bash
# tmux-monitor.sh — 4-pane monitoring dashboard
# Usage: ./tmux-monitor.sh [logfile]
# Layout:
#   ┌──────────┬──────────┐
#   │   htop   │  docker  │
#   │          │  stats   │
#   ├──────────┼──────────┤
#   │ tail -f  │ kubectl  │
#   │   logs   │  pods    │
#   └──────────┴──────────┘

SESSION="monitor"
LOGFILE="${1:-/var/log/syslog}"

# Tear down any existing session with this name
tmux kill-session -t "$SESSION" 2>/dev/null

# Create session with htop in the first pane
tmux new-session -d -s "$SESSION" \
    -x "$(tput cols)" -y "$(tput lines)" "htop"

# Top-right: docker stats
tmux split-window -h -t "$SESSION" \
    "docker stats --format 'table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}'"

# Bottom-left: tail logs
tmux split-window -v -t "$SESSION:0.0" "tail -f $LOGFILE"

# Bottom-right: kubectl watch pods
tmux split-window -v -t "$SESSION:0.1" \
    "kubectl get pods --all-namespaces --watch"

# Even out the layout
tmux select-layout -t "$SESSION" tiled

# Attach to the session
tmux attach-session -t "$SESSION"

#!/usr/bin/env bash
# tmux-db.sh — Database split-pane session
# Usage: ./tmux-db.sh [postgres|mysql] [dbname]
# Layout:
#   ┌─────────────────┬──────────────────┐
#   │                 │  query reference  │
#   │   psql / mysql  │  (vim scratchpad) │
#   │                 │                   │
#   └─────────────────┴──────────────────┘

DB_TYPE="${1:-postgres}"
DB_NAME="${2:-mydb}"
SESSION="db-${DB_NAME}"
SCRATCH="/tmp/tmux-db-scratch-${DB_NAME}.sql"

# Create a cheat-sheet scratchpad file
cat > "$SCRATCH" << 'SQL'
-- ═══ Common Query Reference ═══

-- List all tables (PostgreSQL)
\dt

-- Table schema
\d+ table_name

-- Row counts per table
SELECT schemaname, relname, n_live_tup
FROM pg_stat_user_tables
ORDER BY n_live_tup DESC;

-- Active connections
SELECT pid, usename, application_name, state
FROM pg_stat_activity
WHERE datname = current_database();

-- Slow queries (running > 5s)
SELECT pid, now() - query_start AS duration, query
FROM pg_stat_activity
WHERE state != 'idle'
  AND now() - query_start > interval '5 seconds';

-- Table sizes
SELECT relname,
       pg_size_pretty(pg_total_relation_size(relid))
FROM pg_catalog.pg_statio_user_tables
ORDER BY pg_total_relation_size(relid) DESC;
SQL

tmux kill-session -t "$SESSION" 2>/dev/null

# Choose the correct client command
case "$DB_TYPE" in
    postgres|pg) DB_CMD="psql -d $DB_NAME" ;;
    mysql|my)    DB_CMD="mysql $DB_NAME" ;;
    *)           echo "Unknown DB type: $DB_TYPE"; exit 1 ;;
esac

# Left pane: live database client (60% width)
tmux new-session -d -s "$SESSION" "$DB_CMD"

# Right pane: query scratchpad in vim (40% width)
tmux split-window -h -t "$SESSION" -l 40% "vim $SCRATCH"

# Focus the database pane
tmux select-pane -t "$SESSION:0.0"

tmux attach-session -t "$SESSION"

#!/usr/bin/env bash
# tmux-pomodoro.sh — Pomodoro timer in the tmux status bar
# Usage:
#   tmux-pomodoro.sh            # Start 25min/5min cycle
#   tmux-pomodoro.sh 45 10      # Custom work/break minutes
#   tmux-pomodoro.sh stop       # Stop the running timer

WORK="${1:-25}"
BREAK="${2:-5}"
STATE_FILE="/tmp/tmux-pomodoro"
PID_FILE="/tmp/tmux-pomodoro.pid"

# ─── Stop command ────────────────────────────────────────
if [ "$1" = "stop" ]; then
    if [ -f "$PID_FILE" ]; then
        TIMER_PID=$(cat "$PID_FILE")
        # Send TERM signal to the running timer process
        /bin/kill -TERM "$TIMER_PID" 2>/dev/null
        rm -f "$PID_FILE" "$STATE_FILE"
        tmux display-message "🍅 Pomodoro stopped"
    else
        tmux display-message "No timer running"
    fi
    exit 0
fi

# ─── Countdown function ─────────────────────────────────
countdown() {
    local label="$1" minutes="$2" emoji="$3"
    local total=$((minutes * 60))

    for ((s = total; s >= 0; s--)); do
        printf "%s %s %02d:%02d" \
            "$emoji" "$label" "$((s/60))" "$((s%60))" \
            > "$STATE_FILE"
        sleep 1
    done
}

# ─── Main loop ──────────────────────────────────────────
echo $$ > "$PID_FILE"
trap 'rm -f "$PID_FILE" "$STATE_FILE"' EXIT

while true; do
    tmux display-message "🍅 Focus: ${WORK}min — GO!"
    countdown "FOCUS" "$WORK" "🍅"

    tmux display-message "✅ Done! Take a ${BREAK}min break."
    countdown "BREAK" "$BREAK" "☕"

    tmux display-message "🍅 Break over — next cycle starting"
    echo "🍅 READY" > "$STATE_FILE"
    sleep 3
done

# Show pomodoro countdown in status bar (refresh every second)
set -g status-interval 1
set -g status-right "#(cat /tmp/tmux-pomodoro 2>/dev/null)  %H:%M %d-%b"

# Prefix + P → start timer | Prefix + Alt+p → stop timer
bind-key P run-shell "~/.local/bin/tmux-pomodoro.sh &"
bind-key M-p run-shell "~/.local/bin/tmux-pomodoro.sh stop"

#!/usr/bin/env bash
# tmux-autossh.sh — Auto-reconnecting SSH in a tmux session
# Usage: ./tmux-autossh.sh user@hostname [ssh-options...]
#
# Features:
#   - Reconnects automatically on disconnect
#   - SSH keepalive detects dead connections fast
#   - Color-coded status messages
#   - Ctrl+C during retry delay to exit cleanly

HOST="$1"
shift
SSH_OPTS="$*"

if [ -z "$HOST" ]; then
    echo "Usage: $0 user@hostname [ssh-options...]"
    exit 1
fi

# Sanitize hostname for use as a tmux session name
SESSION="ssh-${HOST//[@.]/-}"
RETRY_DELAY=5

tmux kill-session -t "$SESSION" 2>/dev/null

# Build the reconnect loop as a temp script
PANE_SCRIPT=$(mktemp /tmp/tmux-autossh-XXXX.sh)
chmod +x "$PANE_SCRIPT"

cat > "$PANE_SCRIPT" << INNEREOF
#!/usr/bin/env bash
attempt=0

while true; do
    attempt=\$((attempt + 1))
    echo -e "\033[1;34m━━━ Connecting to $HOST (attempt #\$attempt) ━━━\033[0m"
    echo ""

    ssh -o ServerAliveInterval=30 \\
        -o ServerAliveCountMax=3 \\
        -o ConnectTimeout=10 \\
        -o ConnectionAttempts=1 \\
        $SSH_OPTS "$HOST"

    EXIT_CODE=\$?
    echo ""

    if [ \$EXIT_CODE -eq 0 ]; then
        echo -e "\033[1;33m━━━ Session closed cleanly ━━━\033[0m"
    else
        echo -e "\033[1;31m━━━ Connection lost (exit: \$EXIT_CODE) ━━━\033[0m"
    fi

    echo "Reconnecting in ${RETRY_DELAY}s... (Ctrl+C to stop)"
    sleep "$RETRY_DELAY" || break
done

rm -f "$PANE_SCRIPT"
INNEREOF

tmux new-session -d -s "$SESSION" "bash $PANE_SCRIPT"
tmux attach-session -t "$SESSION"

#!/usr/bin/env bash
# tmux-logs.sh — Tail multiple logs in tiled panes
# Usage: ./tmux-logs.sh file1.log file2.log ...
#        TMUX_LOG_SYNC=on ./tmux-logs.sh *.log
#
# Features:
#   - Auto-tiles panes to fit all log files
#   - Color-coded header per pane
#   - Prefix + S toggles synchronized scrolling

SESSION="logs"
SYNC="${TMUX_LOG_SYNC:-off}"

if [ $# -eq 0 ]; then
    echo "Usage: $0 logfile1 [logfile2 ...]"
    echo ""
    echo "Examples:"
    echo "  $0 /var/log/syslog /var/log/auth.log"
    echo "  $0 ./services/*/logs/app.log"
    echo ""
    echo "Set TMUX_LOG_SYNC=on for synchronized scrolling"
    exit 1
fi

# ANSI colors for pane differentiation
COLORS=(31 32 33 34 35 36 91 92 93 94 95 96)

tmux kill-session -t "$SESSION" 2>/dev/null

# First file creates the session
FIRST_FILE="$1"
C="${COLORS[0]}"
tmux new-session -d -s "$SESSION" \
    "printf '\033[1;${C}m━━━ %s ━━━\033[0m\n' '$FIRST_FILE'; \
     tail -f '$FIRST_FILE'"
shift

# Each additional file gets its own pane
IDX=1
for FILE in "$@"; do
    C="${COLORS[$((IDX % ${#COLORS[@]}))]}"

    tmux split-window -t "$SESSION" \
        "printf '\033[1;${C}m━━━ %s ━━━\033[0m\n' '$FILE'; \
         tail -f '$FILE'"

    # Re-tile after every split to prevent "no space" errors
    tmux select-layout -t "$SESSION" tiled
    IDX=$((IDX + 1))
done

# Set initial sync mode
tmux set-option -t "$SESSION" synchronize-panes "$SYNC"

# Bind Prefix + S to toggle sync within this session
tmux bind-key -T prefix S \
    set-option synchronize-panes \; \
    display-message "Sync #{?synchronize-panes,ON,OFF}"

tmux attach-session -t "$SESSION"

# Tail all service logs at once
./tmux-logs.sh \
    ./services/api/logs/app.log \
    ./services/auth/logs/app.log \
    ./services/worker/logs/app.log \
    ./services/gateway/logs/access.log

# Sync-scroll system logs
TMUX_LOG_SYNC=on ./tmux-logs.sh /var/log/{syslog,auth.log,kern.log}

#!/usr/bin/env bash
# tmux-dev.sh — Detect project type, launch appropriate tmux layout
# Usage: cd /path/to/project && tmux-dev.sh
#        tmux-dev.sh /path/to/project
#
# Detected project types:
#   package.json         → Node.js / TypeScript
#   Cargo.toml           → Rust
#   go.mod               → Go
#   pyproject.toml       → Python
#   Gemfile              → Ruby
#   docker-compose.yml   → Docker Compose
#   (fallback)           → Generic 3-pane layout

PROJECT_DIR="${1:-$(pwd)}"
PROJECT_NAME="$(basename "$PROJECT_DIR")"
SESSION="dev-${PROJECT_NAME}"

cd "$PROJECT_DIR" || { echo "Not found: $PROJECT_DIR"; exit 1; }

# ─── Detection ───────────────────────────────────────────
detect_project() {
    if   [ -f "package.json" ];       then echo "node"
    elif [ -f "Cargo.toml" ];         then echo "rust"
    elif [ -f "go.mod" ];             then echo "go"
    elif [ -f "pyproject.toml" ] ||
         [ -f "requirements.txt" ];   then echo "python"
    elif [ -f "Gemfile" ];            then echo "ruby"
    elif [ -f "docker-compose.yml" ] ||
         [ -f "compose.yml" ];        then echo "docker"
    else echo "generic"
    fi
}

PROJECT_TYPE="$(detect_project)"
tmux kill-session -t "$SESSION" 2>/dev/null

# ─── Node.js ─────────────────────────────────────────────
setup_node() {
    # Detect package manager
    if   [ -f "pnpm-lock.yaml" ]; then PM="pnpm"
    elif [ -f "yarn.lock" ];      then PM="yarn"
    elif [ -f "bun.lockb" ];      then PM="bun"
    else PM="npm"; fi

    #   ┌────────────┬─────────────┐
    #   │            │  dev server  │
    #   │   editor   ├─────────────┤
    #   │            │  test watch  │
    #   └────────────┴─────────────┘
    tmux new-session -d -s "$SESSION" -c "$PROJECT_DIR"
    tmux send-keys "echo '📦 Node ($PM) — $PROJECT_NAME'" Enter
    tmux split-window -h -t "$SESSION" -c "$PROJECT_DIR" \
        "$PM run dev 2>&1 || echo 'No dev script'"
    tmux split-window -v -t "$SESSION:0.1" -c "$PROJECT_DIR" \
        "$PM test -- --watch 2>&1 || echo 'No test script'"
    tmux select-pane -t "$SESSION:0.0"
}

# ─── Rust ─────────────────────────────────────────────────
setup_rust() {
    tmux new-session -d -s "$SESSION" -c "$PROJECT_DIR"
    tmux send-keys "echo '🦀 Rust — $PROJECT_NAME'" Enter
    tmux split-window -h -t "$SESSION" -c "$PROJECT_DIR" \
        "cargo watch -x 'check --color=always' 2>&1 || cargo check"
    tmux split-window -v -t "$SESSION:0.1" -c "$PROJECT_DIR" \
        "cargo watch -x 'test --color=always' 2>&1 || cargo test"
    tmux select-pane -t "$SESSION:0.0"
}

# ─── Go ───────────────────────────────────────────────────
setup_go() {
    local MAIN_PKG="."
    [ -d "cmd" ] && MAIN_PKG="./cmd/..."

    tmux new-session -d -s "$SESSION" -c "$PROJECT_DIR"
    tmux send-keys "echo '🐹 Go — $PROJECT_NAME'" Enter
    tmux split-window -h -t "$SESSION" -c "$PROJECT_DIR"
    tmux send-keys -t "$SESSION:0.1" "go run $MAIN_PKG" Enter
    tmux split-window -v -t "$SESSION:0.1" -c "$PROJECT_DIR"
    tmux send-keys -t "$SESSION:0.2" "go test ./... -v" Enter
    tmux select-pane -t "$SESSION:0.0"
}

# ─── Python ───────────────────────────────────────────────
setup_python() {
    local ACT=""
    if   [ -d ".venv" ]; then ACT="source .venv/bin/activate && "
    elif [ -d "venv" ];  then ACT="source venv/bin/activate && "
    fi

    tmux new-session -d -s "$SESSION" -c "$PROJECT_DIR"
    tmux send-keys "${ACT}echo '🐍 Python — $PROJECT_NAME'" Enter
    tmux split-window -h -t "$SESSION" -c "$PROJECT_DIR"
    tmux send-keys -t "$SESSION:0.1" "${ACT}python" Enter
    tmux split-window -v -t "$SESSION:0.1" -c "$PROJECT_DIR"
    tmux send-keys -t "$SESSION:0.2" \
        "${ACT}ptw --clear 2>/dev/null || pytest -v" Enter
    tmux select-pane -t "$SESSION:0.0"
}

# ─── Ruby ─────────────────────────────────────────────────
setup_ruby() {
    tmux new-session -d -s "$SESSION" -c "$PROJECT_DIR"
    tmux send-keys "echo '💎 Ruby — $PROJECT_NAME'" Enter
    tmux split-window -h -t "$SESSION" -c "$PROJECT_DIR" \
        "bundle exec rails server 2>/dev/null || irb"
    tmux split-window -v -t "$SESSION:0.1" -c "$PROJECT_DIR" \
        "bundle exec rspec 2>/dev/null || echo 'No specs'"
    tmux select-pane -t "$SESSION:0.0"
}

# ─── Docker Compose ───────────────────────────────────────
setup_docker() {
    tmux new-session -d -s "$SESSION" -c "$PROJECT_DIR"
    tmux send-keys "echo '🐳 Docker Compose — $PROJECT_NAME'" Enter
    tmux split-window -h -t "$SESSION" -c "$PROJECT_DIR" \
        "docker compose logs -f --tail=50"
    tmux split-window -v -t "$SESSION:0.1" -c "$PROJECT_DIR" \
        "watch -n2 'docker compose ps'"
    tmux select-pane -t "$SESSION:0.0"
}

# ─── Generic fallback ────────────────────────────────────
setup_generic() {
    tmux new-session -d -s "$SESSION" -c "$PROJECT_DIR"
    tmux send-keys "echo '📁 $PROJECT_NAME'" Enter
    tmux split-window -h -t "$SESSION" -c "$PROJECT_DIR"
    tmux split-window -v -t "$SESSION:0.1" -c "$PROJECT_DIR" \
        "watch -n5 'git status --short 2>/dev/null || ls -la'"
    tmux select-pane -t "$SESSION:0.0"
}

# ─── Project-level override ──────────────────────────────
if [ -f ".tmux-dev.sh" ]; then
    echo "🔧 Found .tmux-dev.sh — using project config"
    source ".tmux-dev.sh"
else
    echo "🔍 Detected: $PROJECT_TYPE"
    case "$PROJECT_TYPE" in
        node)    setup_node ;;
        rust)    setup_rust ;;
        go)      setup_go ;;
        python)  setup_python ;;
        ruby)    setup_ruby ;;
        docker)  setup_docker ;;
        *)       setup_generic ;;
    esac
fi

tmux rename-window -t "$SESSION" "$PROJECT_NAME"
echo "📐 Session '$SESSION' ready"
tmux attach-session -t "$SESSION"

# Quick-launch tmux dev environment for current directory
alias td='~/.local/bin/tmux-dev.sh'

# Or for specific projects
alias td-api='~/.local/bin/tmux-dev.sh ~/projects/api-server'
alias td-web='~/.local/bin/tmux-dev.sh ~/projects/web-app' 

# ╔══════════════════════════════════════════════════════════════════╗
# ║  Production-Grade .tmux.conf                                    ║
# ║  Tested on: tmux 3.2+ (graceful fallbacks for 3.0+)            ║
# ║  Philosophy: vim-centric, quiet, fast, predictable              ║
# ╚══════════════════════════════════════════════════════════════════╝


# ──────────────────────────────────────────────────────────────────
# 1. SERVER & SESSION OPTIONS
# ──────────────────────────────────────────────────────────────────
# These affect the tmux server and session-level behavior. They run
# once and shape how every session behaves by default.

# Start window and pane numbering at 1 instead of 0.
# Reason: the 0 key is far from the left hand on most keyboards.
# Window 1 maps to prefix+1, which is faster to reach.
set -g base-index 1
setw -g pane-base-index 1

# When you close window 3 out of [1,2,3,4], renumber so you get
# [1,2,3] instead of [1,2,4]. Prevents gaps that break muscle memory.
set -g renumber-windows on

# Increase scrollback buffer from the default 2000 lines.
# 50k is enough to capture most build logs without eating too much RAM.
# Each pane gets its own buffer, so 10 panes = ~5MB. That's nothing.
set -g history-limit 50000

# Reduce the delay after pressing Escape. The default (500ms) makes
# vim/neovim feel laggy inside tmux because tmux waits to see if
# Escape is part of a longer key sequence. 10ms is effectively instant
# but still long enough for terminal escape sequences to arrive.
set -sg escape-time 10

# How often tmux redraws the status bar. Default is 15 seconds.
# 5 seconds is a good balance — fast enough to feel "live" for clocks
# and git branch indicators, slow enough to not waste CPU.
set -g status-interval 5

# Enable focus events so vim/neovim can detect when you switch panes.
# Required for autoread, gitgutter refresh, and similar features.
# Your terminal must also support this (iTerm2, Alacritty, Kitty do).
set -g focus-events on

# Display pane numbers for 2 seconds (prefix + q). The default 1s
# is too fast to read pane numbers on large layouts.
set -g display-panes-time 2000

# Display status messages for 3 seconds instead of the default 750ms.
set -g display-time 3000


# ──────────────────────────────────────────────────────────────────
# 2. TERMINAL & TRUE COLOR
# ──────────────────────────────────────────────────────────────────
# Getting color right in tmux is notoriously fiddly. This block
# ensures true color (24-bit) works inside tmux for modern terminals.

# Tell tmux to advertise itself as a 256-color terminal.
# tmux-256color is preferred over screen-256color because it supports
# italics, undercurl, and strikethrough.
set -g default-terminal "tmux-256color"

# Pass through true color (RGB) from the outer terminal.
# Without this, vim themes look washed out inside tmux.
set -ag terminal-overrides ",xterm-256color:RGB"
set -ag terminal-overrides ",alacritty:RGB"

# Enable undercurl support (used by nvim for spell/diagnostics).
# Requires tmux 3.0+ and a terminal that supports it.
set -ag terminal-overrides ',*:Smulx=\E[4::%p1%dm'
set -ag terminal-overrides ',*:Setulc=\E[58::2::%p1%{65536}%/%d::%p1%{256}%/%{255}%&%d::%p1%{255}%&%d%;m'


# ──────────────────────────────────────────────────────────────────
# 3. PREFIX & UNBINDS
# ──────────────────────────────────────────────────────────────────
# The default prefix (Ctrl-b) is awkward — your left hand has to
# contort to reach it, and it conflicts with "page up" in vim.
# Ctrl-a is the classic screen prefix, close to the home row.

unbind C-b
set -g prefix C-a
bind C-a send-prefix

# Double-tap Ctrl-a to send a literal Ctrl-a to the inner program.
# Essential when running tmux inside tmux (nested SSH sessions).
bind a send-prefix

# Unbind defaults we are going to replace with better bindings.
unbind '"'     # Default horizontal split
unbind %       # Default vertical split
unbind &       # Default window closer (dangerous without confirmation)
unbind ,       # Rename window (we will rebind it)


# ──────────────────────────────────────────────────────────────────
# 4. WINDOW & PANE OPTIONS
# ──────────────────────────────────────────────────────────────────

# Enable mouse support. Controversial choice — some purists disable
# it to force keyboard-only habits. But mouse is genuinely useful for:
# - Scrolling through logs (way faster than PageUp)
# - Resizing panes by dragging borders
# - Clicking to select panes in complex layouts
# Keyboard bindings still work, so this does not cost anything.
set -g mouse on

# Do not let programs rename your windows. When you name a window
# "api-server", you want it to stay "api-server" — not change to
# "vim" every time you open a file. Automatic rename is confusing
# in projects with many windows.
setw -g allow-rename off
setw -g automatic-rename off

# Activity monitoring — highlight windows that have new output.
# Useful when watching test runners or build processes in other
# windows. The visual bell prevents terminal beeping.
setw -g monitor-activity on
set -g visual-activity off

# Aggressive resize: size windows based on the smallest client
# CURRENTLY VIEWING that window, not the smallest client attached
# to the session. This matters for pair programming — your partner's
# small terminal won't shrink YOUR window when they look at a
# different window.
setw -g aggressive-resize on


# ──────────────────────────────────────────────────────────────────
# 5. KEY BINDINGS — NAVIGATION
# ──────────────────────────────────────────────────────────────────
# Navigation should feel like vim. h/j/k/l for panes, capital H/L
# for windows. No thinking, no reaching for arrow keys.

# Pane navigation with vim keys (prefix + h/j/k/l)
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

# Window navigation — prefix + H/L to move left/right.
# The -r flag makes these repeatable without re-pressing prefix.
bind -r H previous-window
bind -r L next-window
bind -r C-h previous-window
bind -r C-l next-window

# Smart pane switching with awareness of vim splits.
# Requires the vim-tmux-navigator plugin on the vim side.
# Ctrl+h/j/k/l moves seamlessly between vim splits AND tmux panes.
is_vim="ps -o state= -o comm= -t '#{pane_tty}'     | grep -iqE '^[^TXZ ]+ +(\\S+\\/)?g?(view|l?n?vim?x?|fzf)(diff)?$'"
bind -n 'C-h' if-shell "" 'send-keys C-h' 'select-pane -L'
bind -n 'C-j' if-shell "" 'send-keys C-j' 'select-pane -D'
bind -n 'C-k' if-shell "" 'send-keys C-k' 'select-pane -U'
bind -n 'C-l' if-shell "" 'send-keys C-l' 'select-pane -R'

# Swap panes — move the current pane up/down in the layout.
bind -r J swap-pane -D
bind -r K swap-pane -U

# Switch to last active window (like Ctrl-^ in vim).
bind Space last-window

# Cycle through sessions.
bind -r ) switch-client -n
bind -r ( switch-client -p


# ──────────────────────────────────────────────────────────────────
# 6. KEY BINDINGS — SPLITS, CREATION & MANAGEMENT
# ──────────────────────────────────────────────────────────────────
# Splits use | and - because they visually represent the split
# direction. Much more intuitive than the defaults % and ".

# Splits — open new panes in the CURRENT directory, not /Users/ashutoshmaheshwari.
# The -c "#{pane_current_path}" is critical; without it, every new
# pane starts in whatever directory tmux was originally launched from.
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"
bind \\ split-window -h -c "#{pane_current_path}"  # No shift needed
bind _ split-window -v -c "#{pane_current_path}"    # Full-height variant

# New window also inherits current path.
bind c new-window -c "#{pane_current_path}"

# Resize panes with prefix + arrow keys. The -r flag makes these
# repeatable — hold prefix, then tap arrow keys multiple times.
# 5-cell increments feel right for most terminal sizes.
bind -r Left  resize-pane -L 5
bind -r Down  resize-pane -D 5
bind -r Up    resize-pane -U 5
bind -r Right resize-pane -R 5

# Zoom toggle (already default prefix+z, but worth documenting).
# Zooms the current pane to fill the entire window. Press again
# to restore. Essential for temporarily maximizing a pane to
# read a stack trace, then popping back to your layout.
# bind z resize-pane -Z  # (default — listed for documentation)

# Close pane without confirmation (prefix + x).
# Default prompts you every time, which gets tedious fast.
bind x kill-pane

# Close window with confirmation (prefix + X).
bind X confirm-before -p "Close window #W? (y/n)" kill-window

# Rename window and session.
bind r command-prompt -I "#W" "rename-window '%%'"
bind R command-prompt -I "#S" "rename-session '%%'"

# Reload config — the single most useful binding while tweaking.

# Break pane out to its own window.
bind b break-pane

# Join a pane from another window into the current window.
# Prompts for the source pane in "window.pane" format.
bind V command-prompt -p "Join pane from:" "join-pane -s '%%'"


# ──────────────────────────────────────────────────────────────────
# 7. KEY BINDINGS — UTILITY (POPUPS & SCRIPTS)
# ──────────────────────────────────────────────────────────────────
# tmux 3.2+ popup windows are game-changing for quick lookups.
# They float above your panes and disappear when done.

# Quick popup terminal (prefix + t). Great for running a one-off
# command without leaving your current context.
if-shell "tmux -V | awk '{print ($2 >= 3.2)}' | grep -q 1" \
    "bind t display-popup -E -w 80% -h 70% -d '#{pane_current_path}'"

# Popup with lazygit — the fastest way to stage, commit, and push.
# Falls back to a regular split on tmux < 3.2.
if-shell "tmux -V | awk '{print ($2 >= 3.2)}' | grep -q 1" \
    "bind g display-popup -E -w 90% -h 85% -d '#{pane_current_path}' 'lazygit'" \
    "bind g split-window -h -c '#{pane_current_path}' 'lazygit'"

# Popup with htop for quick system monitoring.
if-shell "tmux -V | awk '{print ($2 >= 3.2)}' | grep -q 1" \
    "bind m display-popup -E -w 90% -h 85% 'htop'" \
    "bind m split-window -h 'htop'"

# FZF session switcher — fuzzy-find across all sessions.
if-shell "tmux -V | awk '{print ($2 >= 3.2)}' | grep -q 1" \
    "bind s display-popup -E -w 60% -h 50% 'tmux list-sessions -F #{session_name} | fzf --reverse --header=Switch | xargs tmux switch-client -t'" \
    "bind s split-window -v 'tmux list-sessions | fzf --reverse | cut -d: -f1 | xargs tmux switch-client -t'"


# ──────────────────────────────────────────────────────────────────
# 8. COPY MODE
# ──────────────────────────────────────────────────────────────────
# Copy mode should work like vim visual mode. Enter with prefix+[,
# select with v, yank with y, paste with prefix+].

# Use vi keys in copy mode (the single most important setting here).
setw -g mode-keys vi

# Enter copy mode with prefix+Escape (more natural than prefix+[).
bind Escape copy-mode

# v starts selection (like vim visual mode).
bind -T copy-mode-vi v send-keys -X begin-selection

# V starts line selection.
bind -T copy-mode-vi V send-keys -X select-line

# Ctrl-v toggles block/rectangle selection.
bind -T copy-mode-vi C-v send-keys -X rectangle-toggle

# y yanks selection to tmux buffer AND system clipboard.
# Platform-specific clipboard commands are set in section 11 below.
bind -T copy-mode-vi y send-keys -X copy-selection-and-cancel

# MouseDragEnd copies selection without leaving copy mode.
# Select text with the mouse and it is immediately in the clipboard.
bind -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-selection -x

# Incremental search in copy mode (like / in vim).
bind -T copy-mode-vi / command-prompt -i -p "Search:" \
    "send -X search-forward-incremental '%%'"
bind -T copy-mode-vi ? command-prompt -i -p "Search backward:" \
    "send -X search-backward-incremental '%%'"

# Paste from tmux buffer.
bind p paste-buffer
bind P choose-buffer    # Pick from the buffer list


# ──────────────────────────────────────────────────────────────────
# 9. STATUS BAR DESIGN
# ──────────────────────────────────────────────────────────────────
# A clean, informative status bar that tells you what you need
# without stealing attention. Session name on the left, window list
# in the center, git branch and time on the right.

set -g status-position top
set -g status-justify centre

set -g status-left-length 40
set -g status-right-length 60

# Left: session name in brackets.
set -g status-left "#[fg=colour4,bold] [#S] "

# Right: current git branch, hostname, and clock.
set -g status-right "#[fg=colour8]#(cd #{pane_current_path}; git rev-parse --abbrev-ref HEAD 2>/dev/null || echo '-') #[fg=colour7]│ #H │ %H:%M "

# Window list format — current window is highlighted.
setw -g window-status-format "#[fg=colour8] #I:#W "
setw -g window-status-current-format "#[fg=colour4,bold] #I:#W* "
setw -g window-status-activity-style "fg=colour3"
setw -g window-status-separator ""


# ──────────────────────────────────────────────────────────────────
# 10. COLORS & VISUAL STYLE
# ──────────────────────────────────────────────────────────────────
# Minimal theme using terminal palette colors (colour0-colour15)
# so it adapts to whatever scheme you are running — Catppuccin,
# Gruvbox, Tokyo Night, etc.

# Status bar — transparent background, blends with terminal.
set -g status-style "bg=default,fg=colour7"

# Pane borders — subtle, not distracting.
set -g pane-border-style "fg=colour8"
set -g pane-active-border-style "fg=colour4"

# Message bar.
set -g message-style "bg=colour0,fg=colour4,bold"
set -g message-command-style "bg=colour0,fg=colour4"

# Copy mode highlight color.
setw -g mode-style "bg=colour4,fg=colour0"

# Clock mode color.
setw -g clock-mode-colour colour4

# Pane number display (prefix + q).
set -g display-panes-active-colour colour4
set -g display-panes-colour colour8


# ──────────────────────────────────────────────────────────────────
# 11. PLATFORM-SPECIFIC — macOS vs Linux
# ──────────────────────────────────────────────────────────────────
# System clipboard integration differs between platforms.
# if-shell checks run at config load time — zero runtime overhead.

# macOS: use pbcopy/pbpaste for clipboard.
if-shell "uname | grep -q Darwin" {
    bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "pbcopy"
    bind -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe "pbcopy"
    bind ] run "pbpaste | tmux load-buffer - && tmux paste-buffer"
    bind -T copy-mode-vi o send-keys -X copy-pipe-and-cancel "xargs open"
}

# Linux: use xclip (X11) or wl-copy (Wayland) for clipboard.
if-shell "uname | grep -q Linux" {
    if-shell "command -v wl-copy" {
        bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "wl-copy"
        bind -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe "wl-copy"
    } {
        bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel \
            "xclip -selection clipboard -i"
        bind -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe \
            "xclip -selection clipboard -i"
    }
    bind ] run "xclip -selection clipboard -o | tmux load-buffer - \
        && tmux paste-buffer"
    bind -T copy-mode-vi o send-keys -X copy-pipe-and-cancel "xargs xdg-open"
}


# ──────────────────────────────────────────────────────────────────
# 12. PLUGINS (via TPM — Tmux Plugin Manager)
# ──────────────────────────────────────────────────────────────────
# Install TPM first:
#   git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm
# Then press prefix + I (capital I) to install plugins.

set -g @plugin 'tmux-plugins/tpm'

# Sensible defaults — fills in anything this config might miss.
set -g @plugin 'tmux-plugins/tmux-sensible'

# Persist tmux sessions across system restarts.
# prefix + Ctrl-s to save, prefix + Ctrl-r to restore.
set -g @plugin 'tmux-plugins/tmux-resurrect'
set -g @resurrect-capture-pane-contents 'on'
set -g @resurrect-strategy-nvim 'session'

# Auto-save sessions every 15 min (builds on tmux-resurrect).
set -g @plugin 'tmux-plugins/tmux-continuum'
set -g @continuum-restore 'on'
set -g @continuum-save-interval '15'

# Yank to system clipboard — safety net for clipboard integration.
set -g @plugin 'tmux-plugins/tmux-yank'

# FZF-based URL picker — prefix + u opens URLs found in the pane.
set -g @plugin 'wfxr/tmux-fzf-url'

# Initialize TPM (MUST be the very last line in the plugin section).
run '~/.tmux/plugins/tpm/tpm'


# ──────────────────────────────────────────────────────────────────
# 13. LOCAL OVERRIDES
# ──────────────────────────────────────────────────────────────────
# Source a machine-specific config if it exists. Put settings that
# differ between work laptop, home desktop, and remote servers here.
#
# Examples of what goes in .tmux.conf.local:
#   - Work-specific status bar (VPN status, k8s context)
#   - Different color scheme per machine
#   - Override prefix key for nested remote sessions
if-shell '[ -f ~/.tmux.conf.local ]' 'source-file ~/.tmux.conf.local'

# ─── Navigation ───────────────────────────────────
# prefix + h/j/k/l     Move between panes (vim-style)
# Ctrl + h/j/k/l       Move between panes AND vim splits (no prefix)
# prefix + H/L          Previous/next window
# prefix + Space        Toggle last window
# prefix + (/)          Previous/next session

# ─── Splits & Windows ─────────────────────────────
# prefix + |  or  \     Vertical split (in current dir)
# prefix + -  or  _     Horizontal split (in current dir)
# prefix + c            New window (in current dir)
# prefix + Arrow keys   Resize pane (repeatable)
# prefix + z            Zoom/unzoom pane

# ─── Management ───────────────────────────────────
# prefix + x            Close pane (no confirmation)
# prefix + X            Close window (with confirmation)
# prefix + r            Rename window
# prefix + R            Rename session
# prefix + Alt-r        Reload config
# prefix + b            Break pane to its own window
# prefix + V            Join pane from another window
# prefix + J/K          Swap pane down/up

# ─── Copy Mode ────────────────────────────────────
# prefix + [  or  Esc   Enter copy mode
# v                     Begin selection
# V                     Select line
# Ctrl-v                Rectangle selection
# y                     Yank to clipboard
# prefix + p            Paste
# prefix + P            Choose from buffer list
# / and ?               Search forward/backward

# ─── Utility Popups ───────────────────────────────
# prefix + t            Popup terminal
# prefix + g            Popup lazygit
# prefix + m            Popup htop
# prefix + s            FZF session switcher

# ─── Plugins ──────────────────────────────────────
# prefix + I            Install plugins (TPM)
# prefix + Ctrl-s       Save session (resurrect)
# prefix + Ctrl-r       Restore session (resurrect)
# prefix + u            Open URLs in pane (fzf-url)

# Step 1: Check if tmux knows about true color
tmux info | grep -i "Tc\|RGB\|colors"

# Step 2: Check your TERM value inside tmux
echo $TERM
# Should output: tmux-256color (NOT screen-256color or xterm-256color)

# Tell tmux to advertise itself as a 256-color terminal
set -g default-terminal "tmux-256color"

# Tell tmux that the OUTSIDE terminal supports true color
set -as terminal-features ',xterm-256color:RGB'

# For older tmux versions (< 3.2), use terminal-overrides instead:
# set -as terminal-overrides ',xterm-256color:Tc' 

# Print a smooth gradient — should show no banding
awk 'BEGIN{for(i=0;i<256;i++)printf "\033[48;2;%d;0;0m ",i;print "\033[0m"}' 

# Eliminate escape key delay — essential for Vim users
set -sg escape-time 0

# tmux 3.2+ (recommended)
set -s copy-command 'pbcopy'  # macOS — change per platform

# Older tmux: bind yank in copy mode to pipe to clipboard
bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel 'pbcopy' 

# Check tmux internal buffer
tmux show-buffer

# Verify system clipboard has the same content (macOS)
pbpaste

# Inspect saved resurrect files
ls -la ~/.tmux/resurrect/

# View the latest save file to see what was captured
cat ~/.tmux/resurrect/last

# Each line represents a pane — format is:
# pane[tab]session[tab]window[tab]pane_index[tab]dir[tab]command

# Enable Vim session restoration via vim-obsession
set -g @resurrect-strategy-vim 'session'
set -g @resurrect-strategy-nvim 'session'

# Restore additional programs beyond the defaults
set -g @resurrect-processes 'vim nvim man less tail top htop' 

# Verify TPM is installed
ls ~/.tmux/plugins/tpm/tpm

# List all installed plugins
ls ~/.tmux/plugins/

# Check plugin scripts are executable
find ~/.tmux/plugins/ -name "*.tmux" -exec ls -la {} \;

# Fix permissions if needed
chmod +x ~/.tmux/plugins/*/*.tmux 2>/dev/null

# Reinstall everything from scratch
rm -rf ~/.tmux/plugins/*
git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm
# Then press prefix + I inside tmux

# 1. General settings
set -g mouse on
set -sg escape-time 0

# 2. Plugin declarations
set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-sensible'
set -g @plugin 'tmux-plugins/tmux-resurrect'

# 3. Plugin options (AFTER declarations, BEFORE run)
set -g @resurrect-strategy-nvim 'session'

# 4. Initialize TPM — THIS MUST BE THE LAST LINE
run '~/.tmux/plugins/tpm/tpm' 

# Double-tap prefix to send it to the nested tmux
bind C-b send-prefix

# Alternative: use a completely different prefix for inner sessions
# On the REMOTE machine's .tmux.conf:
# set -g prefix C-a
# unbind C-b
# bind C-a send-prefix

# Press F12 to disable local prefix (all keys go to inner tmux)
# Press F12 again to re-enable
bind -T root F12 \
    set prefix None \;\
    set key-table off \;\
    set status-style "bg=colour238" \;\
    refresh-client -S

bind -T off F12 \
    set -u prefix \;\
    set -u key-table \;\
    set -u status-style \;\
    refresh-client -S

# See all clients attached to the current session
tmux list-clients

# Detach ALL other clients, keeping only the current one
tmux detach-client -a

# Or attach and detach others in one command
tmux attach -d

# Resize windows based on the smallest client VIEWING that window,
# not the smallest client attached to the session
set -g aggressive-resize on

# Find who stole your keybinding
tmux list-keys | grep "C-l"

# Inspect a specific option current value
tmux show-option -gv status-style

# Debug format strings interactively
tmux display-message -p 'Session: #{session_name}, Window: #{window_index}'

# Start tmux with verbose logging for deep debugging
tmux -vv new-session -d -s debug
# Logs written to: tmux-client-*.log and tmux-server-*.log in CWD

# View tmux server logs (check current directory or /tmp)
ls -la tmux-server-*.log 2>/dev/null