From 2e6abec499d25d7df78331d18c88f582869efe21 Mon Sep 17 00:00:00 2001 From: rootiest Date: Tue, 16 Jun 2026 00:52:59 -0400 Subject: [PATCH 1/6] feat(c5): add tmux pipe-pane session logging Starts tmux pipe-pane capture for the current pane whenever fish launches inside a tmux session. Each shell gets a timestamped log in SCROLLBACK_HISTORY_DIR. Toggling __fish_config_op_logging stops or restarts the pipe in all open fish shells via the existing --on-variable event handlers. --- README.md | 2 +- conf.d/tmux-logging.fish | 19 +++++++++++++++++++ docs/fish-config.md | 12 +++++++++++- functions/__fish_config_sync_logging.fish | 19 +++++++++++++++++-- 4 files changed, 48 insertions(+), 4 deletions(-) create mode 100644 conf.d/tmux-logging.fish diff --git a/README.md b/README.md index ee2bf3b..1df7d1b 100644 --- a/README.md +++ b/README.md @@ -178,7 +178,7 @@ If you'd rather set them by hand, each category is controlled by a universal var | `__fish_config_op_autoexec` | Startup side-effects: Fisher bootstrap, theme apply, `paru`/`yay` wrapper generation, auto venv activation, WakaTime hook | | `__fish_config_op_overrides` | Vi mode, `exit`→`smart_exit`, `$PAGER`/`$MANPAGER`/`$CDPATH`, bang-bang history expansion, autopair, puffer, Starship prompt, theme colors | | `__fish_config_op_integrations` | Kitty/WezTerm window abbreviations, `done` notifications, `spwin`/`tab`/`split`, `hist`, `logs`, `upgrade`, WakaTime | -| `__fish_config_op_logging` | Scrollback capture on exit, `paru`/`yay` AUR log wrappers, Kitty watcher capture (sentinel-file coordinated) | +| `__fish_config_op_logging` | Scrollback capture on exit, tmux `pipe-pane` pane logging, `paru`/`yay` AUR log wrappers, Kitty watcher capture (sentinel-file coordinated) | | `__fish_config_op_greeting` | Per-session `fish_greeting` (suppresses distro greetings such as CachyOS fastfetch by overriding with an empty function); first-run welcome banner | | `__fish_config_opinionated` | Master switch — all six categories at once | diff --git a/conf.d/tmux-logging.fish b/conf.d/tmux-logging.fish new file mode 100644 index 0000000..044e8ab --- /dev/null +++ b/conf.d/tmux-logging.fish @@ -0,0 +1,19 @@ +# Copyright (C) 2026 Rootiest +# SPDX-License-Identifier: AGPL-3.0-or-later +# +# C5 — Logging & Capture: starts a pipe-pane log for the current tmux pane +# when fish launches inside a tmux session. Each fish shell gets its own +# timestamped log file in SCROLLBACK_HISTORY_DIR (default: ~/.terminal_history). +# Naming: tmux_-w-p_YYYY-MM-DD_HH-MM-SS.log + +__fish_config_op_enabled __fish_config_op_logging; or exit +status is-interactive; or exit +type -q tmux; or exit +set -q TMUX; or exit + +set -l log_dir (set -q SCROLLBACK_HISTORY_DIR; and echo $SCROLLBACK_HISTORY_DIR; or echo "$HOME/.terminal_history") +set -l pane_id (tmux display-message -p '#{session_name}-w#{window_index}-p#{pane_index}' 2>/dev/null) +set -l timestamp (date "+%Y-%m-%d_%H-%M-%S") + +mkdir -p $log_dir +tmux pipe-pane "cat >> $log_dir/tmux_${pane_id}_${timestamp}.log" 2>/dev/null diff --git a/docs/fish-config.md b/docs/fish-config.md index c936b00..766b0e9 100644 --- a/docs/fish-config.md +++ b/docs/fish-config.md @@ -1678,19 +1678,27 @@ silently failing. #### C5 — Logging and Capture -Three components capture shell output to disk. Disabling +Four components capture shell output to disk. Disabling __fish_config_op_logging skips all capture and removes the logging wrappers. Component What it captures ─────────────────────────────────────────────────────────────────────────── Scrollback capture Terminal session output saved to: ~/.terminal_history/scrollback_YYYY-MM-DD_HH-MM-SS.log + tmux pane capture Continuous pane stream via pipe-pane, saved to: + ~/.terminal_history/tmux_-w-p_YYYY-MM-DD_HH-MM-SS.log paru wrapper All paru/AUR output captured to: ~/.terminal_history/paru_YYYY-MM-DD_HH-MM-SS.log yay wrapper All yay/AUR output captured to: ~/.terminal_history/yay_YYYY-MM-DD_HH-MM-SS.log Kitty watcher watcher.py captures scrollback when Kitty closes +The tmux capture starts automatically when fish launches inside any tmux +pane ($TMUX is set). It uses tmux's native pipe-pane to stream all pane +output directly to disk without an intermediate process. Each fish shell +session gets its own log file; a new log is created on each shell start +(including exec fish and new splits). + Logging coordination via sentinel file C5 uses a sentinel file to synchronize state between the shell and @@ -1705,11 +1713,13 @@ Disabling __fish_config_op_logging: 3. Kitty's watcher.py reads the sentinel on each save attempt and skips capture — no Kitty restart required. 4. smart_exit stops saving scrollback logs. + 5. Stops tmux pipe-pane capture in every open fish shell inside tmux. Re-enabling __fish_config_op_logging: 1. Removes the sentinel in every open shell. 2. Regenerates paru/yay logging wrappers in ~/.local/bin/. 3. Kitty watcher resumes capture on the next session exit. + 4. Restarts tmux pipe-pane capture in every open fish shell inside tmux. Changes propagate to all running shells through an event handler that fires whenever __fish_config_op_logging changes — no shell restart needed. diff --git a/functions/__fish_config_sync_logging.fish b/functions/__fish_config_sync_logging.fish index c41c4af..70fff7f 100644 --- a/functions/__fish_config_sync_logging.fish +++ b/functions/__fish_config_sync_logging.fish @@ -6,8 +6,9 @@ # # DESCRIPTION # Synchronises C5 logging state: creates or removes the Kitty sentinel -# file ($XDG_CONFIG_HOME/fish/.logging_disabled) and generates or removes -# the paru/yay AUR-helper log wrappers based on the combined value of +# file ($XDG_CONFIG_HOME/fish/.logging_disabled), generates or removes the +# paru/yay AUR-helper log wrappers, and starts or stops tmux pipe-pane +# capture for the current pane — all based on the combined value of # __fish_config_opinionated (master) and __fish_config_op_logging (C5). # Called by --on-variable event handlers whenever either variable changes. # Safe to call at any time; wrapper removal only affects files bearing @@ -32,6 +33,15 @@ function __fish_config_sync_logging --description 'Sync C5 logging state: sentin # Logging enabled: remove sentinel and regenerate wrappers if binaries exist rm -f $sentinel + # Restart tmux pipe-pane for the current pane if inside tmux + if set -q TMUX + set -l log_dir (set -q SCROLLBACK_HISTORY_DIR; and echo $SCROLLBACK_HISTORY_DIR; or echo "$HOME/.terminal_history") + set -l pane_id (tmux display-message -p '#{session_name}-w#{window_index}-p#{pane_index}' 2>/dev/null) + set -l timestamp (date "+%Y-%m-%d_%H-%M-%S") + mkdir -p $log_dir + tmux pipe-pane "cat >> $log_dir/tmux_${pane_id}_${timestamp}.log" 2>/dev/null + end + if test -x /usr/bin/paru mkdir -p (dirname $paru_wrapper) printf '%s\n' \ @@ -95,5 +105,10 @@ function __fish_config_sync_logging --description 'Sync C5 logging state: sentin and grep -q "# yay-wrapper-version:" $yay_wrapper 2>/dev/null rm -f $yay_wrapper end + + # Stop tmux pipe-pane for the current pane if inside tmux + if set -q TMUX + tmux pipe-pane 2>/dev/null + end end end From 764f2253f690462a0205374be442a5eb05e7e190 Mon Sep 17 00:00:00 2001 From: rootiest Date: Tue, 16 Jun 2026 00:53:44 -0400 Subject: [PATCH 2/6] fix(c5): update sync_logging function description to mention tmux --- functions/__fish_config_sync_logging.fish | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/functions/__fish_config_sync_logging.fish b/functions/__fish_config_sync_logging.fish index 70fff7f..c500d95 100644 --- a/functions/__fish_config_sync_logging.fish +++ b/functions/__fish_config_sync_logging.fish @@ -19,7 +19,7 @@ # # EXAMPLE # __fish_config_sync_logging -function __fish_config_sync_logging --description 'Sync C5 logging state: sentinel file and paru/yay wrappers' +function __fish_config_sync_logging --description 'Sync C5 logging state: sentinel file, paru/yay wrappers, and tmux pipe-pane' set -l config_home $XDG_CONFIG_HOME if test -z "$config_home" set config_home "$HOME/.config" From 2e1750b5a459f90e65e61424c4b8455af550dbb8 Mon Sep 17 00:00:00 2001 From: rootiest Date: Tue, 16 Jun 2026 00:55:53 -0400 Subject: [PATCH 3/6] fix(c5): use fish-valid variable concatenation in tmux log filename Fish does not support bash-style ${var} brace syntax. Build the log file path in a dedicated variable using quote-splicing instead. --- conf.d/tmux-logging.fish | 3 ++- functions/__fish_config_sync_logging.fish | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/conf.d/tmux-logging.fish b/conf.d/tmux-logging.fish index 044e8ab..bbf54fc 100644 --- a/conf.d/tmux-logging.fish +++ b/conf.d/tmux-logging.fish @@ -14,6 +14,7 @@ set -q TMUX; or exit set -l log_dir (set -q SCROLLBACK_HISTORY_DIR; and echo $SCROLLBACK_HISTORY_DIR; or echo "$HOME/.terminal_history") set -l pane_id (tmux display-message -p '#{session_name}-w#{window_index}-p#{pane_index}' 2>/dev/null) set -l timestamp (date "+%Y-%m-%d_%H-%M-%S") +set -l log_file "$log_dir/tmux_"$pane_id"_"$timestamp".log" mkdir -p $log_dir -tmux pipe-pane "cat >> $log_dir/tmux_${pane_id}_${timestamp}.log" 2>/dev/null +tmux pipe-pane "cat >> $log_file" 2>/dev/null diff --git a/functions/__fish_config_sync_logging.fish b/functions/__fish_config_sync_logging.fish index c500d95..0ee0e08 100644 --- a/functions/__fish_config_sync_logging.fish +++ b/functions/__fish_config_sync_logging.fish @@ -38,8 +38,9 @@ function __fish_config_sync_logging --description 'Sync C5 logging state: sentin set -l log_dir (set -q SCROLLBACK_HISTORY_DIR; and echo $SCROLLBACK_HISTORY_DIR; or echo "$HOME/.terminal_history") set -l pane_id (tmux display-message -p '#{session_name}-w#{window_index}-p#{pane_index}' 2>/dev/null) set -l timestamp (date "+%Y-%m-%d_%H-%M-%S") + set -l log_file "$log_dir/tmux_"$pane_id"_"$timestamp".log" mkdir -p $log_dir - tmux pipe-pane "cat >> $log_dir/tmux_${pane_id}_${timestamp}.log" 2>/dev/null + tmux pipe-pane "cat >> $log_file" 2>/dev/null end if test -x /usr/bin/paru From b998cc652e89f3d9b2516957a6c3c8d688e26b5f Mon Sep 17 00:00:00 2001 From: rootiest Date: Tue, 16 Jun 2026 01:03:54 -0400 Subject: [PATCH 4/6] feat(c5): prune old tmux logs and share pipe-pane helper Extract the tmux pipe-pane setup into functions/_tmux_pipe_log.fish, called by both conf.d/tmux-logging.fish (startup) and __fish_config_sync_logging (C5 re-enable). The helper prunes the oldest tmux_*.log files by mtime to stay within SCROLLBACK_HISTORY_MAX_FILES, matching the paru/yay wrappers. Uses 'command ls' to bypass the eza ls shadow, which injects OSC-8 hyperlink escapes into paths and corrupted the filenames passed to rm. --- conf.d/tmux-logging.fish | 8 +--- docs/fish-config.md | 4 +- functions/__fish_config_sync_logging.fish | 9 +---- functions/_tmux_pipe_log.fish | 45 +++++++++++++++++++++++ 4 files changed, 50 insertions(+), 16 deletions(-) create mode 100644 functions/_tmux_pipe_log.fish diff --git a/conf.d/tmux-logging.fish b/conf.d/tmux-logging.fish index bbf54fc..cc416b4 100644 --- a/conf.d/tmux-logging.fish +++ b/conf.d/tmux-logging.fish @@ -11,10 +11,4 @@ status is-interactive; or exit type -q tmux; or exit set -q TMUX; or exit -set -l log_dir (set -q SCROLLBACK_HISTORY_DIR; and echo $SCROLLBACK_HISTORY_DIR; or echo "$HOME/.terminal_history") -set -l pane_id (tmux display-message -p '#{session_name}-w#{window_index}-p#{pane_index}' 2>/dev/null) -set -l timestamp (date "+%Y-%m-%d_%H-%M-%S") -set -l log_file "$log_dir/tmux_"$pane_id"_"$timestamp".log" - -mkdir -p $log_dir -tmux pipe-pane "cat >> $log_file" 2>/dev/null +_tmux_pipe_log diff --git a/docs/fish-config.md b/docs/fish-config.md index 766b0e9..4c827e5 100644 --- a/docs/fish-config.md +++ b/docs/fish-config.md @@ -1697,7 +1697,9 @@ The tmux capture starts automatically when fish launches inside any tmux pane ($TMUX is set). It uses tmux's native pipe-pane to stream all pane output directly to disk without an intermediate process. Each fish shell session gets its own log file; a new log is created on each shell start -(including exec fish and new splits). +(including exec fish and new splits). Before each new log, the oldest +tmux_*.log files are pruned (by modification time) to keep the total within +SCROLLBACK_HISTORY_MAX_FILES, matching the paru/yay wrapper behaviour. Logging coordination via sentinel file diff --git a/functions/__fish_config_sync_logging.fish b/functions/__fish_config_sync_logging.fish index 0ee0e08..efc9f41 100644 --- a/functions/__fish_config_sync_logging.fish +++ b/functions/__fish_config_sync_logging.fish @@ -34,14 +34,7 @@ function __fish_config_sync_logging --description 'Sync C5 logging state: sentin rm -f $sentinel # Restart tmux pipe-pane for the current pane if inside tmux - if set -q TMUX - set -l log_dir (set -q SCROLLBACK_HISTORY_DIR; and echo $SCROLLBACK_HISTORY_DIR; or echo "$HOME/.terminal_history") - set -l pane_id (tmux display-message -p '#{session_name}-w#{window_index}-p#{pane_index}' 2>/dev/null) - set -l timestamp (date "+%Y-%m-%d_%H-%M-%S") - set -l log_file "$log_dir/tmux_"$pane_id"_"$timestamp".log" - mkdir -p $log_dir - tmux pipe-pane "cat >> $log_file" 2>/dev/null - end + _tmux_pipe_log if test -x /usr/bin/paru mkdir -p (dirname $paru_wrapper) diff --git a/functions/_tmux_pipe_log.fish b/functions/_tmux_pipe_log.fish new file mode 100644 index 0000000..1693af7 --- /dev/null +++ b/functions/_tmux_pipe_log.fish @@ -0,0 +1,45 @@ +# Copyright (C) 2026 Rootiest +# SPDX-License-Identifier: AGPL-3.0-or-later + +# SYNOPSIS +# _tmux_pipe_log +# +# DESCRIPTION +# Starts tmux pipe-pane capture for the current pane, streaming its output +# to a timestamped log in SCROLLBACK_HISTORY_DIR (default ~/.terminal_history). +# Before starting, prunes the oldest tmux_*.log files so that the total stays +# within SCROLLBACK_HISTORY_MAX_FILES (default 100), leaving room for the new +# log. No-op when not inside a tmux session ($TMUX unset) or tmux is missing. +# Shared by conf.d/tmux-logging.fish (shell startup) and +# __fish_config_sync_logging (C5 re-enable) so both stay in sync. +# +# RETURNS +# 0 Always +# +# EXAMPLE +# _tmux_pipe_log +function _tmux_pipe_log --description 'Start tmux pipe-pane capture for the current pane, with pruning' + set -q TMUX; or return 0 + type -q tmux; or return 0 + + set -l log_dir (set -q SCROLLBACK_HISTORY_DIR; and echo $SCROLLBACK_HISTORY_DIR; or echo "$HOME/.terminal_history") + set -l max_files (set -q SCROLLBACK_HISTORY_MAX_FILES; and echo $SCROLLBACK_HISTORY_MAX_FILES; or echo 100) + set -l pane_id (tmux display-message -p '#{session_name}-w#{window_index}-p#{pane_index}' 2>/dev/null) + set -l timestamp (date "+%Y-%m-%d_%H-%M-%S") + set -l log_file "$log_dir/tmux_"$pane_id"_"$timestamp".log" + + mkdir -p $log_dir + + # Prune oldest logs, leaving room for the one we're about to create. + # Names carry a per-pane prefix, so sort by mtime (command ls -tr = oldest + # first). Use `command ls`: the bare `ls` is shadowed by the eza wrapper, + # which injects OSC-8 escapes into paths and corrupts the filenames. + set -l keep (math max 0, $max_files - 1) + set -l logs (command ls -1tr $log_dir/tmux_*.log 2>/dev/null) + if test (count $logs) -gt $keep + set -l excess (math (count $logs) - $keep) + command rm -f $logs[1..$excess] + end + + tmux pipe-pane "cat >> $log_file" 2>/dev/null +end From 5b74fbe42772c3b9d1d204916a01a768016307c9 Mon Sep 17 00:00:00 2001 From: rootiest Date: Tue, 16 Jun 2026 01:16:22 -0400 Subject: [PATCH 5/6] feat(c5): add zellij exit-capture logging and shared prune helper MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Zellij has no live-stream facility like tmux pipe-pane, so capture is a one-shot 'zellij action dump-screen --full' run from a fish_exit handler (conf.d/zellij-logging.fish -> functions/_zellij_dump_log.fish). The C5 guard is checked inside the helper at exit time, so toggling logging needs no sync_logging coordination — there is no persistent stream. Extract pruning into functions/_prune_terminal_logs.fish, shared by both the tmux and zellij helpers. This also fixes a latent bug in the tmux helper: globbing tmux_*.log directly errored with 'No matches for wildcard' on the first log in an empty dir. The shared helper globs via 'set' (tolerates no-match) and uses command ls/rm to bypass the eza and trash C1 shadows. --- README.md | 2 +- conf.d/zellij-logging.fish | 24 +++++++++++++++ docs/fish-config.md | 13 ++++++++- functions/_prune_terminal_logs.fish | 45 +++++++++++++++++++++++++++++ functions/_tmux_pipe_log.fish | 22 ++++---------- functions/_zellij_dump_log.fish | 40 +++++++++++++++++++++++++ 6 files changed, 127 insertions(+), 19 deletions(-) create mode 100644 conf.d/zellij-logging.fish create mode 100644 functions/_prune_terminal_logs.fish create mode 100644 functions/_zellij_dump_log.fish diff --git a/README.md b/README.md index 1df7d1b..63172b0 100644 --- a/README.md +++ b/README.md @@ -178,7 +178,7 @@ If you'd rather set them by hand, each category is controlled by a universal var | `__fish_config_op_autoexec` | Startup side-effects: Fisher bootstrap, theme apply, `paru`/`yay` wrapper generation, auto venv activation, WakaTime hook | | `__fish_config_op_overrides` | Vi mode, `exit`→`smart_exit`, `$PAGER`/`$MANPAGER`/`$CDPATH`, bang-bang history expansion, autopair, puffer, Starship prompt, theme colors | | `__fish_config_op_integrations` | Kitty/WezTerm window abbreviations, `done` notifications, `spwin`/`tab`/`split`, `hist`, `logs`, `upgrade`, WakaTime | -| `__fish_config_op_logging` | Scrollback capture on exit, tmux `pipe-pane` pane logging, `paru`/`yay` AUR log wrappers, Kitty watcher capture (sentinel-file coordinated) | +| `__fish_config_op_logging` | Scrollback capture on exit, tmux `pipe-pane` pane logging, zellij `dump-screen` capture on exit, `paru`/`yay` AUR log wrappers, Kitty watcher capture (sentinel-file coordinated) | | `__fish_config_op_greeting` | Per-session `fish_greeting` (suppresses distro greetings such as CachyOS fastfetch by overriding with an empty function); first-run welcome banner | | `__fish_config_opinionated` | Master switch — all six categories at once | diff --git a/conf.d/zellij-logging.fish b/conf.d/zellij-logging.fish new file mode 100644 index 0000000..31a3b57 --- /dev/null +++ b/conf.d/zellij-logging.fish @@ -0,0 +1,24 @@ +# Copyright (C) 2026 Rootiest +# SPDX-License-Identifier: AGPL-3.0-or-later +# +# C5 — Logging & Capture: registers a fish_exit handler that dumps the current +# Zellij pane's scrollback to a log file when the shell exits. Unlike tmux +# (streamed live via pipe-pane), Zellij has no continuous-capture facility, so +# we snapshot once on exit via `zellij action dump-screen --full`. +# +# The handler is registered whenever fish runs inside Zellij; the C5 logging +# guard is evaluated inside _zellij_dump_log at exit time, so toggling +# __fish_config_op_logging takes effect on the next exit without a restart +# (no sync_logging coordination needed, since there is no live stream to stop). +# +# Event-handler functions must be defined at startup (conf.d) so the --on-event +# binding is registered; autoloaded functions in functions/ never register. + +status is-interactive; or exit +type -q zellij; or exit +set -q ZELLIJ; or exit + +function __zellij_dump_on_exit --on-event fish_exit \ + --description 'C5 event handler: dump Zellij pane scrollback on shell exit' + _zellij_dump_log +end diff --git a/docs/fish-config.md b/docs/fish-config.md index 4c827e5..712c526 100644 --- a/docs/fish-config.md +++ b/docs/fish-config.md @@ -1678,7 +1678,7 @@ silently failing. #### C5 — Logging and Capture -Four components capture shell output to disk. Disabling +Five components capture shell output to disk. Disabling __fish_config_op_logging skips all capture and removes the logging wrappers. Component What it captures @@ -1687,6 +1687,8 @@ __fish_config_op_logging skips all capture and removes the logging wrappers. ~/.terminal_history/scrollback_YYYY-MM-DD_HH-MM-SS.log tmux pane capture Continuous pane stream via pipe-pane, saved to: ~/.terminal_history/tmux_-w-p_YYYY-MM-DD_HH-MM-SS.log + zellij pane capture Pane scrollback snapshot on shell exit, saved to: + ~/.terminal_history/zellij_-p_YYYY-MM-DD_HH-MM-SS.log paru wrapper All paru/AUR output captured to: ~/.terminal_history/paru_YYYY-MM-DD_HH-MM-SS.log yay wrapper All yay/AUR output captured to: @@ -1701,6 +1703,15 @@ session gets its own log file; a new log is created on each shell start tmux_*.log files are pruned (by modification time) to keep the total within SCROLLBACK_HISTORY_MAX_FILES, matching the paru/yay wrapper behaviour. +The zellij capture works differently: Zellij has no live output-streaming +facility like pipe-pane, so the log is taken as a one-shot snapshot when the +shell exits, via `zellij action dump-screen --full`. A fish_exit handler +(registered whenever $ZELLIJ is set) writes the pane's full scrollback and +then prunes old zellij_*.log files the same way. Because the capture happens +at exit, toggling __fish_config_op_logging takes effect on the next exit with +no restart or sentinel coordination needed — the C5 guard is re-checked when +the handler fires. + Logging coordination via sentinel file C5 uses a sentinel file to synchronize state between the shell and diff --git a/functions/_prune_terminal_logs.fish b/functions/_prune_terminal_logs.fish new file mode 100644 index 0000000..f121fbb --- /dev/null +++ b/functions/_prune_terminal_logs.fish @@ -0,0 +1,45 @@ +# Copyright (C) 2026 Rootiest +# SPDX-License-Identifier: AGPL-3.0-or-later + +# SYNOPSIS +# _prune_terminal_logs +# +# DESCRIPTION +# Removes the oldest "_*.log" files in SCROLLBACK_HISTORY_DIR +# (default ~/.terminal_history) so the total count for that prefix stays +# within SCROLLBACK_HISTORY_MAX_FILES (default 100). Files are sorted by +# modification time, so the most recently written logs are kept — actively +# appended logs (e.g. a tmux pipe-pane stream) survive. +# +# Uses `command ls`/`command rm` to bypass the C1 shadows: the bare `ls` is +# the eza wrapper, which injects OSC-8 hyperlink escapes into paths, and the +# bare `rm` is the trash wrapper. The glob is expanded via `set` first so a +# no-match (empty dir / first run) yields an empty list instead of a hard +# "No matches for wildcard" error. +# +# ARGUMENTS +# prefix Log-name prefix to prune (e.g. tmux, zellij) +# +# RETURNS +# 0 Always +# +# EXAMPLE +# _prune_terminal_logs tmux +function _prune_terminal_logs --argument-names prefix --description 'Prune oldest _*.log files beyond the configured max' + set -q prefix[1]; or return 0 + set -l log_dir (set -q SCROLLBACK_HISTORY_DIR; and echo $SCROLLBACK_HISTORY_DIR; or echo "$HOME/.terminal_history") + set -l max_files (set -q SCROLLBACK_HISTORY_MAX_FILES; and echo $SCROLLBACK_HISTORY_MAX_FILES; or echo 100) + test -d $log_dir; or return 0 + + # Glob via `set` so a no-match yields an empty list rather than an error. + set -l logs $log_dir/$prefix"_"*.log + set -q logs[1]; or return 0 + + # Re-sort by mtime, oldest first. Pass explicit files (no glob) so ls can + # never fail on no-match; `command ls` avoids the eza OSC-8 corruption. + set logs (command ls -1tr $logs 2>/dev/null) + if test (count $logs) -gt $max_files + set -l excess (math (count $logs) - $max_files) + command rm -f $logs[1..$excess] + end +end diff --git a/functions/_tmux_pipe_log.fish b/functions/_tmux_pipe_log.fish index 1693af7..feb3594 100644 --- a/functions/_tmux_pipe_log.fish +++ b/functions/_tmux_pipe_log.fish @@ -7,11 +7,10 @@ # DESCRIPTION # Starts tmux pipe-pane capture for the current pane, streaming its output # to a timestamped log in SCROLLBACK_HISTORY_DIR (default ~/.terminal_history). -# Before starting, prunes the oldest tmux_*.log files so that the total stays -# within SCROLLBACK_HISTORY_MAX_FILES (default 100), leaving room for the new -# log. No-op when not inside a tmux session ($TMUX unset) or tmux is missing. -# Shared by conf.d/tmux-logging.fish (shell startup) and -# __fish_config_sync_logging (C5 re-enable) so both stay in sync. +# Old tmux_*.log files are pruned via _prune_terminal_logs to stay within +# SCROLLBACK_HISTORY_MAX_FILES. No-op when not inside a tmux session ($TMUX +# unset) or tmux is missing. Shared by conf.d/tmux-logging.fish (shell +# startup) and __fish_config_sync_logging (C5 re-enable) so both stay in sync. # # RETURNS # 0 Always @@ -23,23 +22,12 @@ function _tmux_pipe_log --description 'Start tmux pipe-pane capture for the curr type -q tmux; or return 0 set -l log_dir (set -q SCROLLBACK_HISTORY_DIR; and echo $SCROLLBACK_HISTORY_DIR; or echo "$HOME/.terminal_history") - set -l max_files (set -q SCROLLBACK_HISTORY_MAX_FILES; and echo $SCROLLBACK_HISTORY_MAX_FILES; or echo 100) set -l pane_id (tmux display-message -p '#{session_name}-w#{window_index}-p#{pane_index}' 2>/dev/null) set -l timestamp (date "+%Y-%m-%d_%H-%M-%S") set -l log_file "$log_dir/tmux_"$pane_id"_"$timestamp".log" mkdir -p $log_dir - - # Prune oldest logs, leaving room for the one we're about to create. - # Names carry a per-pane prefix, so sort by mtime (command ls -tr = oldest - # first). Use `command ls`: the bare `ls` is shadowed by the eza wrapper, - # which injects OSC-8 escapes into paths and corrupts the filenames. - set -l keep (math max 0, $max_files - 1) - set -l logs (command ls -1tr $log_dir/tmux_*.log 2>/dev/null) - if test (count $logs) -gt $keep - set -l excess (math (count $logs) - $keep) - command rm -f $logs[1..$excess] - end + _prune_terminal_logs tmux tmux pipe-pane "cat >> $log_file" 2>/dev/null end diff --git a/functions/_zellij_dump_log.fish b/functions/_zellij_dump_log.fish new file mode 100644 index 0000000..3f4e822 --- /dev/null +++ b/functions/_zellij_dump_log.fish @@ -0,0 +1,40 @@ +# Copyright (C) 2026 Rootiest +# SPDX-License-Identifier: AGPL-3.0-or-later + +# SYNOPSIS +# _zellij_dump_log +# +# DESCRIPTION +# Captures the current Zellij pane's scrollback to a timestamped log in +# SCROLLBACK_HISTORY_DIR (default ~/.terminal_history). Zellij has no live +# output-streaming facility like tmux's pipe-pane, so this performs a one-shot +# `zellij action dump-screen --full` — intended to run on shell exit. Old +# zellij_*.log files are pruned via _prune_terminal_logs to stay within +# SCROLLBACK_HISTORY_MAX_FILES. +# +# The C5 logging guard (__fish_config_op_logging) is evaluated here, at call +# time, so toggling logging takes effect on the next exit without a restart. +# No-op when logging is disabled, not inside Zellij ($ZELLIJ unset), or the +# zellij binary is missing. +# +# RETURNS +# 0 Always +# +# EXAMPLE +# _zellij_dump_log +function _zellij_dump_log --description 'Dump the current Zellij pane scrollback to a log file, with pruning' + __fish_config_op_enabled __fish_config_op_logging; or return 0 + set -q ZELLIJ; or return 0 + type -q zellij; or return 0 + + set -l log_dir (set -q SCROLLBACK_HISTORY_DIR; and echo $SCROLLBACK_HISTORY_DIR; or echo "$HOME/.terminal_history") + set -l session (set -q ZELLIJ_SESSION_NAME; and echo $ZELLIJ_SESSION_NAME; or echo unknown) + set -l pane_id (set -q ZELLIJ_PANE_ID; and echo $ZELLIJ_PANE_ID; or echo unknown) + set -l timestamp (date "+%Y-%m-%d_%H-%M-%S") + set -l log_file "$log_dir/zellij_"$session"-p"$pane_id"_"$timestamp".log" + + mkdir -p $log_dir + zellij action dump-screen --full "$log_file" 2>/dev/null + + _prune_terminal_logs zellij +end From a7e6ae4d214995d4f4b9c1f695d74caef1c05ef1 Mon Sep 17 00:00:00 2001 From: rootiest Date: Tue, 16 Jun 2026 01:27:47 -0400 Subject: [PATCH 6/6] docs(c5): feature session logging prominently with transparency callout Add a Session Logging section and a CAUTION callout to the README, and a matching privacy notice to docs/fish-config.md, making clear that this config logs terminal sessions (Kitty/tmux/zellij/paru/yay) to ~/.terminal_history by default. Point users at both the __fish_config_op_logging variable and the interactive config-toggle TUI for opting out. --- README.md | 62 +++++++++++++++++++++++++++++++++++++++++++++ docs/fish-config.md | 23 ++++++++++++++++- 2 files changed, 84 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 63172b0..735604a 100644 --- a/README.md +++ b/README.md @@ -8,6 +8,7 @@ abbreviation system for keyboard-driven workflows. ## Table of Contents - [Overview](#overview) +- [Session Logging](#session-logging) - [Documentation](#documentation) - [Installation](#installation) - [Personalization](#personalization) @@ -27,10 +28,71 @@ This config layers on top of the CachyOS base Fish configuration and adds: - **Smart CLI wrappers** that prefer modern tools (`eza`, `bat`, `btop`, `dust`, `prettyping`) with graceful fallbacks - **Auto Python venv** activation on directory change (direnv-aware) - **Kitty terminal** deep integration for splits, tabs, and SSH +- **Automatic session logging** — terminal scrollback, multiplexer panes (tmux/zellij), and AUR-helper output are captured to `~/.terminal_history` (see the caution below and [Session Logging](#session-logging)) - **AI workflow** helpers for Claude and Antigravity session management - **WakaTime** shell activity tracking - **Opt-out toggles** for every opinionated component — see [Minimal Mode](#minimal-mode) +> [!CAUTION] +> **This configuration logs your terminal sessions to disk by default.** +> Out of the box it silently captures terminal output to `~/.terminal_history`: +> Kitty scrollback when a window closes, live tmux pane streams, zellij pane +> snapshots on exit, and full `paru`/`yay` output. These logs can contain +> command output, file contents, and anything else printed to your terminal. +> Nothing is sent off your machine, but the files persist locally until pruned. +> +> To turn all logging off, set the C5 category variable: +> +> ```fish +> set -U __fish_config_op_logging off +> ``` +> +> Or run **`config-toggle`** for an interactive menu to flip logging (and any +> other opinionated category) on or off — no variable names to remember. +> +> This takes effect immediately in every open shell. See [Session Logging](#session-logging) +> for exactly what is captured and where, and [Minimal Mode](#minimal-mode) for the +> full set of opt-out toggles. + +--- + +## Session Logging + +This config captures terminal output to `~/.terminal_history` (override with +`$SCROLLBACK_HISTORY_DIR`) so you can search back through past sessions. It is +**on by default**. Five sources feed it: + +| Source | When it captures | Log file | +|---|---|---| +| Kitty scrollback | When a Kitty window/tab closes | `scrollback_.log` | +| tmux pane | Continuously while the pane is open (`pipe-pane`) | `tmux_-w-p_.log` | +| zellij pane | Snapshot taken on shell exit (`dump-screen`) | `zellij_-p_.log` | +| `paru` wrapper | Every `paru` invocation | `paru_.log` | +| `yay` wrapper | Every `yay` invocation | `yay_.log` | + +Old logs are pruned automatically to stay within `$SCROLLBACK_HISTORY_MAX_FILES` +(default 100) per source, and empty/trivial captures are discarded. + +**These logs can contain secrets** — anything printed to your terminal (command +output, file dumps, tokens echoed to stdout) ends up in them. They never leave +your machine, but treat `~/.terminal_history` as sensitive. + +Disable all of it with a single universal variable: + +```fish +set -U __fish_config_op_logging off # disable; takes effect in every open shell +set -Ue __fish_config_op_logging # re-enable (erase the override) +``` + +Prefer an interactive interface? Run **`config-toggle`** for a full-screen +picker that flips logging — and every other opinionated category — on or off +per session or universally, without memorizing variable names. + +Disabling also removes the generated `paru`/`yay` log wrappers and tells the +Kitty watcher to skip capture via a sentinel file — no shell or terminal +restart required. Logging is category **C5** in [Minimal Mode](#minimal-mode); +`set -U __fish_config_opinionated 0` turns it off along with everything else. + --- ## Documentation diff --git a/docs/fish-config.md b/docs/fish-config.md index 712c526..dea563f 100644 --- a/docs/fish-config.md +++ b/docs/fish-config.md @@ -32,12 +32,27 @@ A production-grade Fish shell configuration targeting Fish 4.x. It provides: - Drop-in replacements for common Unix tools (ls, cat, rm, du, ping, less) - Deep Kitty and WezTerm terminal integration: tab/window/pane management from the command line -- Scrollback history snapshots saved to ~/.terminal_history on session exit +- Automatic session logging: terminal scrollback, tmux/zellij panes, and + paru/yay output captured to ~/.terminal_history (on by default; see below) - Automatic Python virtualenv activation on directory change - Cross-platform package management via pkg and fish-deps - AI session helpers for Claude Code and Antigravity - Catppuccin Mocha color theme throughout + ┌───────────────────────────────────────────────────────────────────────────┐ + │ CAUTION - SESSION LOGGING IS ON BY DEFAULT │ + │ │ + │ This configuration silently records terminal output to │ + │ ~/.terminal_history: Kitty scrollback on window close, live tmux pane │ + │ streams, zellij pane snapshots on exit, and full paru/yay output. These │ + │ logs can contain command output, file contents, and secrets printed to │ + │ the terminal. Nothing leaves your machine, but the files persist locally. │ + │ │ + │ Disable all logging with: set -U __fish_config_op_logging off │ + │ Prefer a menu? Run the interactive picker: config-toggle │ + │ See Section 7 (C5 - Logging and Capture) for the full breakdown. │ + └───────────────────────────────────────────────────────────────────────────┘ + The configuration is split across: config.fish Main entry point; sets env vars and PATH @@ -51,6 +66,8 @@ The configuration is split across: logging-events.fish C5 --on-variable event handlers; syncs logging state at startup paru-wrapper.fish Auto-generates ~/.local/bin/paru logging wrapper puffer.fish !! / !$ / ./ expansion (bundled from nickeb96/puffer-fish) + tmux-logging.fish C5 starts tmux pipe-pane capture when fish runs inside tmux + zellij-logging.fish C5 fish_exit handler dumping zellij pane scrollback on exit sponge_privacy.fish Sponge privacy patterns; filters credentials from history starship.fish fish_prompt with OSC 133 shell-integration markers tailscale.fish Tailscale CLI tab completions @@ -1552,6 +1569,10 @@ Examples: set -U __fish_config_op_greeting 1 # (erase both to go back to full-flavor defaults) +For an interactive alternative to setting these variables by hand, run +config-toggle — a full-screen TUI that flips any category (including C5 +logging) on or off, per session or universally. See its entry in Section 5. + Notes: - Command shadows (rm, cat, ls, ...) react immediately; conf.d-level