sessionview 0.2.0__tar.gz → 0.3.0__tar.gz

{sessionview-0.2.0 → sessionview-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sessionview
-Version: 0.2.0
+Version: 0.3.0
 Summary: A sidebar for tmux: your projects (sessions) and your agents, here and on remote hosts.
 Project-URL: Homepage, https://github.com/sessionkit/sessionview
 Project-URL: Repository, https://github.com/sessionkit/sessionview
@@ -58,7 +58,7 @@ neomutt and notmuch's index on your machine.
   sidebar's mail, the agent pane menu, and the session, taskmaster and
   voicemode plugins (each lists `message` in its `requires`). Mail is
   sent as you: `$USER`, unless `sessionview-config set mail_from NAME`
-  (or `$SESSIONVIEW_FROM`) names your mail name; `sessionview-from`
+  (or `$SESSIONVIEW_FROM`) names your mail name; `sessionview from`
   prints the name in effect.
 - **neomutt** for the `messages` tab (`bin/sessionview-messages` runs
   `neomutt -R`; the tab exits 2 without it): `brew install neomutt`, built
@@ -287,9 +287,14 @@ and every key in
   error with its traceback). Follow it with
   `tail -f ~/.local/state/sessionview/sessionview.log` when a click
   seems to do nothing.
-- `~/.local/state/sessionview/sidebar-mouse.log`: one line per mouse
-  click the sidebar receives.
-- Both sit under `$SESSIONVIEW_STATE` when it is set. Neither is rotated.
+- **Levels:** `log_level` in your settings (or `$SESSIONVIEW_LOG_LEVEL`
+  for one run). `error`, the default, logs only what went wrong.
+  `timing` adds a line per click or key with its milliseconds, and each
+  command that took 50 ms or more, so a slow click names its slow part.
+  `debug` adds every command and every mouse event (what the old
+  `sidebar-mouse.log` held).
+- It sits under `$SESSIONVIEW_STATE` when that is set. It is not rotated:
+  turn `timing` or `debug` on while you look, then back to `error`.
 - **Health:** `sessionview install --check`: exit 0 and `ready` when
   every requirement is present, exit 1 with each MISSING one named
   otherwise. It checks the machine, not a running sidebar.

{sessionview-0.2.0 → sessionview-0.3.0}/README.md

@@ -41,7 +41,7 @@ neomutt and notmuch's index on your machine.
   sidebar's mail, the agent pane menu, and the session, taskmaster and
   voicemode plugins (each lists `message` in its `requires`). Mail is
   sent as you: `$USER`, unless `sessionview-config set mail_from NAME`
-  (or `$SESSIONVIEW_FROM`) names your mail name; `sessionview-from`
+  (or `$SESSIONVIEW_FROM`) names your mail name; `sessionview from`
   prints the name in effect.
 - **neomutt** for the `messages` tab (`bin/sessionview-messages` runs
   `neomutt -R`; the tab exits 2 without it): `brew install neomutt`, built
@@ -270,9 +270,14 @@ and every key in
   error with its traceback). Follow it with
   `tail -f ~/.local/state/sessionview/sessionview.log` when a click
   seems to do nothing.
-- `~/.local/state/sessionview/sidebar-mouse.log`: one line per mouse
-  click the sidebar receives.
-- Both sit under `$SESSIONVIEW_STATE` when it is set. Neither is rotated.
+- **Levels:** `log_level` in your settings (or `$SESSIONVIEW_LOG_LEVEL`
+  for one run). `error`, the default, logs only what went wrong.
+  `timing` adds a line per click or key with its milliseconds, and each
+  command that took 50 ms or more, so a slow click names its slow part.
+  `debug` adds every command and every mouse event (what the old
+  `sidebar-mouse.log` held).
+- It sits under `$SESSIONVIEW_STATE` when that is set. It is not rotated:
+  turn `timing` or `debug` on while you look, then back to `error`.
 - **Health:** `sessionview install --check`: exit 0 and `ready` when
   every requirement is present, exit 1 with each MISSING one named
   otherwise. It checks the machine, not a running sidebar.

{sessionview-0.2.0 → sessionview-0.3.0}/bin/sessionview

@@ -5,13 +5,15 @@
 #        sessionview COMMAND [ARGS]
 #
 #   sessionview [SESSION]  the frame: sidebar on the left, SESSION attached on
-#                    the right (default main). --sock names its tmux server;
-#                    --width, columns.
+#                    the right (default main; a named SESSION must exist).
+#                    --sock names its tmux server; --width, columns.
 #   sessionview config     settings: no verb opens the screen (get/set/list ...)
 #   sessionview session NAME    open a project session with its standard tabs
 #   sessionview messages PROJECT   a project's mail, read-only, in NeoMutt
 #   sessionview install    check requirements (--app: the macOS Dock app)
 #   sessionview autostart --status   which agent starts when sessionview opens
+#   sessionview from       the name your mail is sent as (mail_from, else $USER)
+#   sessionview sidebar-toggle   hide the sidebar, or show it again
 #   sessionview sidebar    the sidebar under its supervisor (the frame's left
 #                    pane runs this). In it: q reloads, Q quits.
 #
@@ -25,9 +27,11 @@
 # without the comment marks, so the help reads cleanly.
 SESSIONVIEW_ROOT="${SESSIONVIEW_ROOT:-$(cd "$(dirname "$(readlink -f "$0" 2>/dev/null || echo "$0")")/.." && pwd)}"
 SESSIONVIEW_STATE="${SESSIONVIEW_STATE:-$HOME/.local/state/sessionview}"; . "$SESSIONVIEW_ROOT/lib/state.sh"; . "$SESSIONVIEW_ROOT/lib/python.sh"; export SESSIONVIEW_ROOT SESSIONVIEW_STATE
+# The header above is the usage: -h prints it, and so does an unknown word.
+usage() { sed -n '2,22p' "$0" | sed 's/^# \{0,1\}//'; }
 case "${1:-}" in
-  -h|--help|help) sed -n '2,20p' "$0" | sed 's/^# \{0,1\}//'; exit 0;;
-  config|session|messages|install|autostart|terminal|usermail)
+  -h|--help|help) usage; exit 0;;
+  config|session|messages|install|autostart|terminal|usermail|from|sidebar-toggle)
     sub="$1"; shift; exec "$SESSIONVIEW_ROOT/bin/sessionview-$sub" "$@";;
   sidebar)
     # The supervisor: q = exit 0 = reload (picks up an edited tmux-sidebar or
@@ -44,4 +48,28 @@ case "${1:-}" in
     done
     exit 0;;
 esac
+# Anything else is the frame. A word that names no subcommand opens a frame
+# ONLY on a session that already exists on the server the frame will use
+# (--sock, else this tmux's own server when run inside one, else default):
+# a typo or a probe word must not mean "open a frame on a new session named
+# after it". Read-only check; on a miss, usage and exit 2, nothing touched.
+# A new named session is `sessionview session NAME`. No word = main, as before.
+word=""; sock=""; prev=""
+for a in "$@"; do
+  case "$prev" in --sock) sock="$a"; prev=""; continue;; --width) prev=""; continue;; esac
+  case "$a" in --sock|--width) prev="$a";; -*) ;; *) word="$a";; esac
+done
+if [ -n "$word" ]; then
+  extra=""
+  if [ -z "$sock" ]; then
+    if [ -n "${TMUX:-}" ]; then sock="$(printf %s "${TMUX%%,*}")"; sock="${sock##*/}"; extra=1; else sock=default; fi
+  fi
+  if ! tmux -L "$sock" has-session -t "=$word" 2>/dev/null; then
+    echo "sessionview: no command or session named '$word' (on tmux server $sock); a new session is: sessionview session $word" >&2
+    usage >&2
+    exit 2
+  fi
+  # the frame looks where this checked: inside tmux, the caller's own server
+  [ -n "$extra" ] && set -- "$@" --sock "$sock"
+fi
 exec "$SESSIONVIEW_ROOT/bin/sessionview-frame" "$@"

{sessionview-0.2.0 → sessionview-0.3.0}/bin/sessionview-frame

@@ -31,6 +31,13 @@ while [ $# -gt 0 ]; do case "$1" in
   -*) echo "sessionview-frame: unknown flag $1" >&2; exit 2;;
   *) SESSION="$1"; GIVEN=1;;
 esac; shift; done
+# The frame takes over the terminal it runs in, so it needs one: a script or
+# an agent's shell (stdin/stdout not a tty) is refused and nothing is touched.
+# Every refusal is one line on stderr, exit 2.
+refuse() { echo "sessionview: refused: $1" >&2; exit 2; }
+if [ ! -t 0 ] || [ ! -t 1 ]; then
+  refuse "not a terminal: run it from a terminal (stdin and stdout must be a tty)"
+fi
 # Already inside a tmux client? Attaching a frame here nests a client in a
 # pane: a terminal that auto-attaches tmux at login would run sessionview
 # inside itself, a loop of frames in frames. Better to deal with it, for
@@ -42,15 +49,21 @@ esac; shift; done
 #    "run shell-command to replace the client"). The session the user was
 #    in stays alive and becomes the frame's right pane unless SESSION was
 #    given; its server becomes --sock. (-E was measured to do this.)
+# "This client" is the CALLER's own, and only that: lib/client.sh proves it
+# (this tty is $TMUX_PANE's, and exactly one client shows its session) or
+# refuses. An untargeted `display -p '#{client_tty}'` once answered with
+# another terminal's client on the same server, and the detach replaced it.
 if [ -n "${TMUX:-}" ]; then
-  ctty="$(tmux display -p '#{client_tty}' 2>/dev/null)"
+  . "$SESSIONVIEW_ROOT/lib/client.sh"
+  sv_own_client || refuse "$SV_REFUSAL"
+  ctty="$SV_CLIENT"
   if tmux -L "$FRAME_SOCK" list-panes -a -F '#{pane_tty}' 2>/dev/null | grep -qx "$ctty"; then
     echo "sessionview: already inside a sessionview frame (client $ctty) - the sidebar is on the left; a frame in a frame is the loop" >&2
     exit 1
   fi
-  here_sock="$(printf %s "$TMUX" | cut -d, -f1)"; here_sock="${here_sock##*/}"
+  here_path="${TMUX%%,*}"; here_sock="${here_path##*/}"
   if [ -z "$GIVEN" ]; then
-    SESSION="$(tmux display -p '#{session_name}')"; SOCK="$here_sock"
+    SESSION="$SV_SESSION"; SOCK="$here_sock"
   fi
   q() { printf "'%s'" "$(printf %s "$1" | sed "s/'/'\\\\''/g")"; }
   # -E runs the command with the CLIENT's environment, not this shell's
@@ -60,7 +73,7 @@ if [ -n "${TMUX:-}" ]; then
   cmd="$cmd SESSIONVIEW_FRAME_SOCK=$(q "$FRAME_SOCK") TMUX="
   cmd="$cmd exec $(q "$0") $(q "$SESSION") --sock $(q "$SOCK")"
   [ -n "$WIDTH" ] && cmd="$cmd --width $(q "$WIDTH")"
-  exec tmux detach-client -E "$cmd"
+  exec tmux -S "$here_path" detach-client -t "$ctty" -E "$cmd"
 fi
 if [ -z "$WIDTH" ]; then
   WIDTH="$("$SESSIONVIEW_ROOT/bin/sessionview-config" get width 2>/dev/null || true)"

{sessionview-0.2.0 → sessionview-0.3.0}/bin/sessionview-session

@@ -38,7 +38,7 @@
 #   shell    the root - the fallback when nothing else applies; pin it
 #            (auto: true) and every session gets one
 # {editor} is VISUAL, else EDITOR, else nvim; when it is nvim it LISTENS on the
-# socket show-me looks for (<socket dir>/nvim-show-pane-<pane id>).
+# socket show-me looks for (<socket dir>/nvim-show-<server key>-pane-<pane number>).
 # Every window is a SHELL with the tool typed into it, so quitting nvim or
 # lazygit leaves a prompt in the right directory. An entry's `when` is a NAME
 # this script tests (always | has_repo | has_projdir | has_mail | fallback) and
@@ -207,6 +207,10 @@ show_socket_dir() {   # show-me's get_socket_dir(), verbatim in spirit
   elif [ -n "${XDG_RUNTIME_DIR:-}" ] && [ -d "$XDG_RUNTIME_DIR" ]; then echo "${XDG_RUNTIME_DIR%/}"
   else mkdir -p "$HOME/.local/run" && chmod 700 "$HOME/.local/run"; echo "$HOME/.local/run"; fi
 }
+show_server_key() {   # show-me's show_server_key(): the cksum of a tmux server's socket path.
+  # Pane ids count per SERVER, so a socket named by pane id alone collides across servers.
+  printf '%s' "$1" | cksum | awk '{print $1}'
+}
 say "session=$NAME socket=$SOCK store=$STORE root=$ROOT repo=${REPO:-NONE} projdir=${PROJDIR:-NONE} store_id=${STOREID:-$([ "$STOREMISS" = 1 ] && echo UNREGISTERED || echo NONE)} profile=$([ "$PLAIN" = 1 ] && echo off || echo on)$([ -n "$STOREVIEW" ] && echo " store_view=$STOREVIEW store_project=${STOREPROJ:-NONE} fresh=$FRESH")"
 
 # -- cascading config: built-in > host > store > project, all JSON (JSON
@@ -288,19 +292,21 @@ dir_of() {  # dir_of CWD -> the path, or "" when that dir is unknown for this pr
   esac
 }
 editor_for() {  # editor_for WINDOW -> what {editor} becomes there. nvim LISTENS on the socket
-  # show-me looks for (<socket dir>/nvim-show-pane-<pane id>): a code window opened
-  # with neovim has the socket running, so show-me can reach it;
+  # show-me looks for (<socket dir>/nvim-show-<server key>-pane-<pane number>): a code
+  # window opened with neovim has the socket running, so show-me can reach it;
   # any other editor is typed as it is. No window yet (--list-windows): the bare name.
-  local pid
+  local pid key pane
   case "$(basename "${ED%% *}")" in
     nvim) [ -n "$1" ] || { printf '%s' "$ED"; return; }
-          if [ "$PRINT" = 1 ]; then pid='<pane>'; else pid="$(tmux display-message -p -t "=$NAME:$1" '#{pane_id}')"; fi
+          if [ "$PRINT" = 1 ]; then pid='<pane>'; key='<server>'
+          else pane="$(tmux display-message -p -t "=$NAME:$1" '#{pane_id} #{socket_path}')"
+               pid="${pane%% *}"; key="$(show_server_key "${pane#* }")"; fi
           # and ROOTS at the window's cwd: LazyVim's <leader>e opens neo-tree at LazyVim.root(),
           # which walks up to .git - in the project window that is the STORE, not the project
           # (the project directory should be the root). -c, not --cmd: LazyVim's own
           # options.lua overwrites vim.g.root_spec at load.
           # Only nvims this script opens get it; the user's config is untouched.
-          printf '%s --listen %s -c %s' "$ED" "$(printf %q "$(show_socket_dir)/nvim-show-pane-${pid#%}")" "$(printf %q 'lua vim.g.root_spec={"cwd"}')";;
+          printf '%s --listen %s -c %s' "$ED" "$(printf %q "$(show_socket_dir)/nvim-show-$key-pane-${pid#%}")" "$(printf %q 'lua vim.g.root_spec={"cwd"}')";;
     *) printf '%s' "$ED";;
   esac
 }

{sessionview-0.2.0 → sessionview-0.3.0}/bin/sessionview-sidebar-toggle

@@ -1,12 +1,16 @@
 #!/bin/sh
 # sessionview-sidebar-toggle - hide the sidebar, or show it again.
 #
-#   sessionview-sidebar-toggle                  from INSIDE the inner tmux (the
-#                                               tab-bar glyph, a key, a shell):
+#   sessionview sidebar-toggle                  from a shell INSIDE the inner tmux:
 #                                               finds the frame by the client's tty
-#   sessionview-sidebar-toggle --frame SOCK:SESSION   name the frame (tests, the sidebar)
-#   sessionview-sidebar-toggle --tty /dev/ttysNNN    the clicking client (the tab-bar glyph)
-#   sessionview-sidebar-toggle --hide | --show  one direction only (default: toggle)
+#   sessionview sidebar-toggle --hide | --show  one direction only (default: toggle)
+#   sessionview sidebar-toggle --frame SOCK:SESSION   name the frame (tests, the sidebar)
+#   sessionview sidebar-toggle --tty /dev/ttysNNN    the clicking client (the tab-bar glyph)
+#
+# The tab-bar glyph and the tmux bindings run this file by path
+# ($SESSIONVIEW_ROOT/bin/sessionview-sidebar-toggle); from a shell, the
+# `sessionview` front door runs it, so it works from a package install too.
+# -h prints the usage above.
 #
 # On a small laptop screen the sidebar needs a way to hide and show again, a
 # little glyph. That is table stakes, not icing: a sidebar that cannot get out
@@ -32,14 +36,23 @@ while [ $# -gt 0 ]; do
     --tty)   TTY="$2"; shift 2;;          # the clicking client's tty, from the tab-bar binding
     --hide)  MODE="hide"; shift;;
     --show)  MODE="show"; shift;;
+    -h|--help) sed -n '2,8p' "$0" | sed 's/^# \{0,1\}//'; exit 0;;
     *) echo "sessionview-sidebar-toggle: unknown argument '$1'" >&2; exit 2;;
   esac
 done
 if [ -n "$FRAME" ]; then
   FSOCK="${FRAME%%:*}"; F="${FRAME#*:}"
 else
-  tty="${TTY:-$(tmux display-message -p '#{client_tty}' 2>/dev/null || true)}"
-  [ -n "$tty" ] || { echo "sessionview-sidebar-toggle: not inside tmux and no --frame" >&2; exit 1; }
+  tty="$TTY"
+  if [ -z "$tty" ]; then
+    # no --tty: the CALLER's own client, proven (lib/client.sh) or refused. An
+    # untargeted `display -p '#{client_tty}'` answers with another terminal's
+    # client when this session has none, or has two - and toggled THAT frame.
+    SESSIONVIEW_ROOT="${SESSIONVIEW_ROOT:-$(cd "$(dirname "$(readlink -f "$0" 2>/dev/null || echo "$0")")/.." && pwd)}"
+    . "$SESSIONVIEW_ROOT/lib/client.sh"
+    sv_own_client || { echo "sessionview-sidebar-toggle: refused: $SV_REFUSAL" >&2; exit 2; }
+    tty="$SV_CLIENT"
+  fi
   F="$(tmux -L "$FSOCK" list-panes -a -F '#{pane_tty} #{session_name}' 2>/dev/null | awk -v t="$tty" '$1 == t {print $2; exit}')"
   [ -n "$F" ] || { echo "sessionview-sidebar-toggle: no frame shows this client ($tty) on server $FSOCK" >&2; exit 1; }
 fi

{sessionview-0.2.0 → sessionview-0.3.0}/bin/tmux-sidebar

@@ -162,16 +162,34 @@ _migrate_state()
 os.makedirs(SESSIONVIEW_STATE, exist_ok=True)
 def state(name): return os.path.join(SESSIONVIEW_STATE, name)
 
-def log_err(where, text):
-    """ONE log for everything that goes wrong: ~/.local/state/sessionview/sessionview.log,
-    every error in a single log. A
-    line a person can read: time, socket, where, what. Never raises."""
+LOG_LEVELS = ("error", "timing", "debug")
+LOG_LEVEL = "error"     # set from `log_level` once the config is read (below CFG)
+
+def log_at(level):
+    """True when LEVEL's lines are written. Each level holds the ones before
+    it: errors always, timing at timing or debug, debug at debug only."""
+    return LOG_LEVELS.index(level) <= LOG_LEVELS.index(LOG_LEVEL)
+
+def log(level, where, text):
+    """ONE log for everything: ~/.local/state/sessionview/sessionview.log.
+    A line a person can read: time, socket, where, what. An error line is
+    exactly as it always was; a timing or debug line names its level after
+    the socket (`sock=X timing run: ...`), so the errors stay easy to grep.
+    Written only when `log_level` lets LEVEL through. Never raises."""
+    if not log_at(level):
+        return
+    tag = "" if level == "error" else level + " "
+    sock = globals().get("SOCK", "-")   # a line written before SOCK is known still lands
     try:
         with open(state("sessionview.log"), "a") as lg:
-            lg.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} sock={SOCK} {where}: {text}\n")
+            lg.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} sock={sock} {tag}{where}: {text}\n")
     except Exception:
         pass
 
+def log_err(where, text):
+    """An error line in the one log: written at every level."""
+    log("error", where, text)
+
 def run_checked(cmd, where):
     """subprocess.run that LOGS a non-zero exit with its stderr instead of
     swallowing it; returns the CompletedProcess. The + popup's new-window
@@ -249,6 +267,40 @@ def load_config():
         cfg["refresh"] = float(os.environ["SIDEBAR_REFRESH"])
     return cfg
 CFG = load_config()
+
+def log_level():
+    """`log_level` from the config, $SESSIONVIEW_LOG_LEVEL over it (for one
+    run). error (the default) logs only what went wrong; timing adds a line
+    per click or key with its milliseconds, and each command that took
+    TIMING_MIN_MS or more; debug adds every command and every mouse event.
+    An unknown word is error, and the log says so once."""
+    raw = os.environ.get("SESSIONVIEW_LOG_LEVEL") or CFG.get("log_level") or "error"
+    v = str(raw).strip().lower()
+    if v in LOG_LEVELS:
+        return v
+    log_err("log_level", f"unknown level {raw!r}: using error (one of {', '.join(LOG_LEVELS)})")
+    return "error"
+LOG_LEVEL = log_level()
+
+TIMING_MIN_MS = 50      # timing: a command this slow or slower gets its line
+_RUN = subprocess.run
+def _timed_run(*args, **kw):
+    """subprocess.run, timed: the command and its milliseconds go to the log
+    (timing when it took TIMING_MIN_MS or more, else debug). Installed only
+    when the level is timing or debug, so at error it costs nothing. Every
+    tm, tmux, git and sessionview-session call goes through here, the
+    worker threads' too: the slow one in a slow click is named."""
+    t0 = time.monotonic()
+    try:
+        return _RUN(*args, **kw)
+    finally:
+        ms = (time.monotonic() - t0) * 1000
+        cmd = args[0] if args else kw.get("args", "")
+        if isinstance(cmd, (list, tuple)):
+            cmd = " ".join(str(c) for c in cmd)
+        log("timing" if ms >= TIMING_MIN_MS else "debug", "run", f"{ms:.0f}ms {cmd}"[:300])
+if LOG_LEVEL != "error":
+    subprocess.run = _timed_run
 def wants_context(fmt):
     """A format that shows context, or the model (the scan is where the model
     id comes from), pays the transcript read; nothing else does."""
@@ -2204,8 +2256,8 @@ def client_where():
     only, while the pin sat on a store's server attached to demo
     (measured), so the sessionview client was never found and a click on any
     other store's session was refused as view-only, when a click on a
-    tmux session should simply work. Falls back to the most recently
-    active client on the plain socket. Cached 5s; a move clears it."""
+    tmux session should simply work. No pin found = no client (never the
+    most recently active one: another terminal). Cached 5s; a move clears it."""
     now = time.time()
     if _CLIENT.get("t") and now - _CLIENT["t"] < 5:
         return _CLIENT["v"]
@@ -2217,8 +2269,12 @@ def client_where():
         # one of the user's other terminals: a click on
         # demo switched a different window, focusing it in
         # another terminal.
-        me = sh(["tmux", "display-message", "-p", "#{client_tty}"]).strip()
-        v = (attached_socket(), me)
+        # And even INSIDE the popup an untargeted display is not its client:
+        # measured, it answered with the MORE RECENTLY ACTIVE client, not
+        # the one showing the popup. A popup has no pane ($TMUX_PANE is
+        # empty), so its client is the ONE client on $TMUX's session; none
+        # or two = no client known, and a click moves nothing.
+        v = (attached_socket(), popup_client())
     else:
         pin = os.environ.get("SESSIONVIEW_PIN") or state("frame.tty")   # sessionview-frame: its own pin
         tty_ = open(pin).read().strip() if os.path.exists(pin) else ""
@@ -2231,10 +2287,10 @@ def client_where():
                 break
         if found:
             v = (found, tty_)
-        else:
-            out = sh(["tmux", "-L", "default", "list-clients", "-F", "#{client_activity}\t#{client_tty}"])
-            rows = sorted((l.split("\t") for l in out.splitlines() if "\t" in l), reverse=True)
-            v = ("default", rows[0][1] if rows else "")
+        # No pin found: NO client, never "the most recently active client on
+        # the plain socket" - that is whichever terminal was used last,
+        # someone else's, and a click would switch it. With no tty known
+        # move_client moves nothing (a frame recreates its own right pane).
     _CLIENT.update(t=now, v=v)
     return v
 
@@ -2306,6 +2362,18 @@ def frame_attach(frame, sock, session):
             f.write(tty_)
     _CLIENT.clear()
 
+def popup_client():
+    """The tty of the client showing this popup: the ONE client attached to
+    $TMUX's session (socket,pid,session-number), or "" when there are none
+    or several - several cannot be told apart from here, and a guess moves
+    another terminal."""
+    parts = os.environ.get("TMUX", "").split(",")
+    if len(parts) < 3 or not parts[0] or not parts[2].isdigit():
+        return ""
+    out = sh(["tmux", "-S", parts[0], "list-clients", "-t", "$" + parts[2], "-F", "#{client_tty}"])
+    ttys = out.split()
+    return ttys[0] if len(ttys) == 1 else ""
+
 def move_client(sock, session):
     """Show SESSION (on server SOCK) in the sessionview client. Same server:
     switch-client. Another server: `detach-client -E` re-execs the client
@@ -3106,6 +3174,12 @@ def fit():
                          next open is the width chosen. The sidebar once
                          undid every drag on the next redraw.
 
+    Only while a client is attached to the frame. Before the first attach the
+    pane changes inside the same window too: the frame's own split and its
+    resize to the configured width. Nobody can drag a border in a session
+    with no client, so those are put back, never remembered (a new user's
+    first open once wrote width 100, half the window the frame starts in).
+
     A drag below MIN_DRAG is a slip and is put back, not remembered. With
     `fit: auto` the wish itself moves (see wish()); the pane follows it."""
     global WIDTH
@@ -3119,10 +3193,13 @@ def fit():
         WIDTH = max(8, min(wish(), cols))
         return
     fsock = frame.split(":", 1)[0]
-    win = sh(["tmux", "-L", fsock, "display-message", "-p", "-t", pane,
-              "#{window_width}"]).strip()
+    # one call: the window's width, and whether a client is attached to the frame
+    w = sh(["tmux", "-L", fsock, "display-message", "-p", "-t", pane,
+            "#{window_width} #{session_attached}"]).split()
+    win = w[0] if w else ""
+    attached = len(w) > 1 and w[1] != "0"
     known = _FIT["pane"]
-    dragged = (win and win == _FIT["win"] and known is not None and cols != known)
+    dragged = (attached and win and win == _FIT["win"] and known is not None and cols != known)
     if dragged and cols >= MIN_DRAG:
         CFG["width"] = cols                                    # the drag is the wish
         if str(CFG.get("fit", "fixed")) in ("auto", "narrow", "focus"):
@@ -3154,6 +3231,7 @@ def draw(lines):
     sys.stdout.write("\033[H\033[2J" + "\r\n".join(lines) + "\r")
     sys.stdout.flush()
 
+INPUT = [""]    # what the input being handled was, for its timing line
 def main():
     global GROUPED, MENU, PROMPT, WRITE_TABS, FILTER, ANCHOR
     if "--pick" in sys.argv:                        # the picker alone, in a popup
@@ -3211,6 +3289,9 @@ def main():
             if not r:
                 lines, targets = render(); draw(lines); continue
             buf += os.read(fd, 64).decode(errors="ignore")
+            t_in = time.monotonic()
+            keys_in = MOUSE_RE.sub("", buf).replace("\x1b[O", "").replace("\x1b[I", "")
+            INPUT[0] = f"key {keys_in!r}" if keys_in else ""
             if "\x1b[O" in buf:                    # focus LEFT the sidebar: a click in the main section
                 buf = buf.replace("\x1b[O", "")
                 FOCUS["in"] = False
@@ -3249,12 +3330,11 @@ def main():
                                    int(m.group(3)), m.group(4))
                 if kind != "M":
                     continue
-                try:   # evidence for "my click opened the menu": what button arrived
-                    with open(state("sidebar-mouse.log"), "a") as lg:
-                        lg.write(f"{time.strftime('%H:%M:%S')} btn={btn} x={x} y={y} target={targets.get(y - 1)}\n"[:200])
-                except OSError:
-                    pass
+                # evidence for "my click opened the menu": what button arrived
+                log("debug", "mouse", f"btn={btn} x={x} y={y} target={targets.get(y - 1)}"[:200])
                 t = targets.get(y - 1)
+                if t:
+                    INPUT[0] = (f"click{'' if btn == 0 else f' btn={btn}'} {t[0]} {t[1]}")[:120]
                 ANCHOR = y - 1                    # a menu this click opens sits beside this row
                 if MENU is not None and not (t and t[0] in ("menu-item", "menu-close")):
                     # A click OUTSIDE an open menu closes it and is consumed -
@@ -3338,6 +3418,8 @@ def main():
                         project_menu(current_session())
             ANCHOR = None                         # a keyboard open has no row: centred
             lines, targets = render(); draw(lines)
+            if INPUT[0]:      # a click or a key: how long until you saw the answer
+                log("timing", "input", f"{(time.monotonic() - t_in) * 1000:.0f}ms {INPUT[0]}")
             buf = buf[buf.rfind("\x1b"):] if buf.count("\x1b") and not MOUSE_RE.search(buf[buf.rfind("\x1b"):]) else ""
     finally:
         tab_clear()                                 # no tab-bar glyph outlives us

{sessionview-0.2.0 → sessionview-0.3.0}/config/README.md

@@ -140,6 +140,10 @@ labels.
   tmux call (a new tab that never appeared), a `--window` that refused,
   an uncaught exception, each a line with time, socket, where, what.
   `tail -f` it when something silently does nothing.
+- `log_level` - what that ONE file records: `error` (the default), `timing`
+  (a line per click or key with its ms, and each command of 50 ms or more)
+  or `debug` (every command, every mouse event). `$SESSIONVIEW_LOG_LEVEL`
+  overrides it for one run.
 - `window_pins` - your pins over that list, `{"name": true|false}`,
   written by ^p / right-click in the new-tab picker. A delta, so the list
   keeps flowing to you.

{sessionview-0.2.0 → sessionview-0.3.0}/config/config.json

@@ -9,6 +9,8 @@
   "width_min": 20,
   "width_max": 60,
   "refresh": 2,
+  "_log_level": "What goes in the ONE log, ~/.local/state/sessionview/sessionview.log. error: only what went wrong. timing: also a line per click or key with its milliseconds (from the input arriving to the redraw), and each command that took 50 ms or more. debug: also every command and every mouse event (the old sidebar-mouse.log). $SESSIONVIEW_LOG_LEVEL overrides it for one run. The log is not rotated: leave timing or debug on only while you look.",
+  "log_level": "error",
   "project_two_line": false,
   "project_expand_selected": false,
   "project_gap": 0,

sessionview-0.3.0/lib/client.sh

@@ -0,0 +1,57 @@
+# lib/client.sh - sourced by an entry script that acts on "the tmux client
+# this was run from": sessionview-frame's hand-over (detach-client -E) and
+# sessionview-sidebar-toggle without --tty. One rule, in one place.
+#
+# sv_own_client sets SV_CLIENT (that client's tty) and SV_SESSION (the
+# session that client shows: the caller's) and returns 0, or sets SV_REFUSAL (one neutral
+# line saying why) and returns 1. It reads tmux and changes nothing.
+#
+# An untargeted `tmux display -p '#{client_tty}'` is NOT the caller's client.
+# tmux answers with the most recently active client of the caller's session,
+# and when that session has no client attached, of the WHOLE server: some
+# other terminal. Even `display -t "$TMUX_PANE"` falls back that way. So:
+#   1. stdin and stdout are terminals, and `tty` names one. A script or an
+#      agent's shell that inherited TMUX and TMUX_PANE has neither.
+#   2. that tty IS the pane's: `#{pane_tty}` of $TMUX_PANE. A process in a
+#      pane has the pane's pty as its terminal (never the client's), so this
+#      proves the caller is the process in that pane.
+#   3. exactly one client is on a session that holds the pane's window. Not
+#      only the session `display -t "$TMUX_PANE"` names: a window can be in
+#      several sessions (a session group, `link-window`), and tmux names the
+#      most recently active of them, so a count over that one session alone
+#      handed over another terminal's client. None: no terminal shows the
+#      pane. More than one: no way to tell which terminal is the caller's,
+#      so refuse rather than guess.
+sv_own_client() {
+  SV_CLIENT=""; SV_SESSION=""; SV_REFUSAL=""
+  if [ ! -t 0 ] || [ ! -t 1 ]; then
+    SV_REFUSAL="not a terminal: run it from a terminal (stdin and stdout must be a tty)"; return 1
+  fi
+  _sv_own="$(tty 2>/dev/null)" || { SV_REFUSAL="not a terminal: run it from a terminal (no controlling tty)"; return 1; }
+  if [ -z "${TMUX:-}" ] || [ -z "${TMUX_PANE:-}" ]; then
+    SV_REFUSAL="not inside a tmux pane (TMUX or TMUX_PANE is empty)"; return 1
+  fi
+  _sv_sock="${TMUX%%,*}"
+  _sv_tab="$(printf '\t')"
+  _sv_info="$(tmux -S "$_sv_sock" display-message -p -t "$TMUX_PANE" "#{pane_tty}$_sv_tab#{window_id}$_sv_tab#{session_name}" 2>/dev/null)" || _sv_info=""
+  _sv_ptty="${_sv_info%%"$_sv_tab"*}"; _sv_rest="${_sv_info#*"$_sv_tab"}"
+  _sv_wid="${_sv_rest%%"$_sv_tab"*}"; _sv_name="${_sv_rest#*"$_sv_tab"}"
+  if [ -z "$_sv_info" ] || [ "$_sv_ptty" != "$_sv_own" ]; then
+    SV_REFUSAL="not this pane's terminal: $_sv_own is not the tty of pane $TMUX_PANE"; return 1
+  fi
+  # every session that holds this pane's window, then the clients on those
+  _sv_sids="$(tmux -S "$_sv_sock" list-windows -a -F "#{window_id}$_sv_tab#{session_id}" 2>/dev/null \
+    | awk -F "$_sv_tab" -v w="$_sv_wid" '$1 == w {printf "%s ", $2}')" || _sv_sids=""
+  _sv_clients="$(tmux -S "$_sv_sock" list-clients -F "#{session_id}$_sv_tab#{client_tty}$_sv_tab#{session_name}" 2>/dev/null \
+    | awk -F "$_sv_tab" -v s="$_sv_sids" 'BEGIN {n = split(s, a, " "); for (i = 1; i <= n; i++) ok[a[i]] = 1}
+                                          ($1 in ok) {print $2 "\t" $3}')" || _sv_clients=""
+  _sv_n="$(printf '%s\n' "$_sv_clients" | grep -c . || true)"
+  if [ "$_sv_n" -eq 0 ]; then
+    SV_REFUSAL="no terminal is attached to this session ($_sv_name)"; return 1
+  fi
+  if [ "$_sv_n" -gt 1 ]; then
+    SV_REFUSAL="this session ($_sv_name) is open in more than one terminal (detach the others, or run it outside tmux)"; return 1
+  fi
+  SV_CLIENT="${_sv_clients%%"$_sv_tab"*}"; SV_SESSION="${_sv_clients#*"$_sv_tab"}"
+  return 0
+}

{sessionview-0.2.0 → sessionview-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sessionview"
-version = "0.2.0"
+version = "0.3.0"
 description = "A sidebar for tmux: your projects (sessions) and your agents, here and on remote hosts."
 readme = "README.md"
 requires-python = ">=3.11,<3.15"

{sessionview-0.2.0 → sessionview-0.3.0}/src/sessionview/__init__.py

@@ -10,7 +10,7 @@ import os
 import sys
 from pathlib import Path
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 DATA = Path(__file__).resolve().parent / "_data"
 PUBLIC = ("sessionview", "sessionview-config", "sessionview-session", "sessionview-messages")