Tab activity

[gryf]

I've dug deep for this and found some of the answers, and I'm aware of has_unseen_output attribute for the pane object, although, there is a small issue with it. When it is set, there is no way to distinguish if on inactive tab there is still some activity (which alter/add terminal content) or the activity has stopped. I'm not sure how to exactly implement that in current state, other than exposing timestamps for tab being inactive (not current) and last occurred changes in the pane terminal which user could use to implement lua function for that purpose. I'm trying to achieve something like this: https://github.com/gryf/tabbedalt#features (there is an animgif with colored indicators for activity). Or am I missing something obvious?

[wez]

Hmm, I'm not a fan of tracking timestamps internally for this, but the underlying terminal state that is associated with this is based around sequence numbers. Internally the terminal bumps the seqno any time something changes the model. It also keeps track of the seqno at the point at which focus was lost as lost_focus_seqno. The has_unseen_output condition is then simply !self.focused && self.seqno > self.lost_focus_seqno.

I'm open to the idea of expanding has_unseen_output to include both the current seqno and the last_focus_seqno. Perhaps the lua interface returns a 3-tuple of has_unseen_output, lost_focus_seqno, current_seqno so that it compatible with code that assumes that it returns just the boolean?.

Then your lua logic could keep track of the time and the seqno's to derive the the timing information?

[gryf]

Yeah, I've analyzed how logic behind has_unseen_output is implemented, and noticed that it's simply comparing seqno with lost_focus_seqno. Exposing those internals counters would also be an option, although from end-user perspective it'll be probably better to add something like boolean still_active which potentially could be true-ish in the case there is an activity on the terminal, and together with has_unseen_output could give whole picture on the state for the certain pane.

[gryf]

OTOH, in case still_active would flipping too quickly it might be impossible to catch it does, so exposing seqno might be enough.

[gryf]

I've played a little and with adding get_seqno method to pane mux object:

diff --git a/lua-api-crates/mux/src/pane.rs b/lua-api-crates/mux/src/pane.rs
index f0d919e16..0a16b03d3 100644
--- a/lua-api-crates/mux/src/pane.rs
+++ b/lua-api-crates/mux/src/pane.rs
@@ -409,6 +409,12 @@ impl UserData for MuxPane {
             let pane = this.resolve(&mux)?;
             Ok(pane.tty_name())
         });
+
+        methods.add_method("get_seqno", move |_lua, this, ()| {
+            let mux = Mux::get();
+            let pane = this.resolve(&mux)?;
+            Ok(pane.get_current_seqno())
+        });
     }
 }

I was able to achieve what I want with this (a little bit lenghty) config example:

local wezterm = require 'wezterm'
config = wezterm.config_builder()

-- keep tab and pane activity snapshots (timestamp and pane seqno)
wezterm.GLOBAL.activity = (wezterm.GLOBAL.activity or {})

local function get_seq(pane_id)
    return wezterm.mux.get_pane(pane_id):get_seqno()
end

wezterm.on('format-tab-title', function(tab, tabs, panes, config, hover, max_width)
    local act = wezterm.GLOBAL.activity
    local tid, wid, pid = tostring(tab.tab_id), tostring(tab.window_id)
    act[wid] = (act[wid] or {})
    act[wid][tid] = (act[wid][tid] or {})
    act = act[wid][tid]

    if tab.is_active then
        -- reset timestamp and panes, as they are not relevant for current tab 
        -- state
        act.timestamp = nil
        act.panes = {}
        return {
            {Text = tab.active_pane.title},
        }
    end

    local color
    local has_unseen_output = false
    local seqno
    local ts = os.time()

    for _, pane in ipairs(tab.panes) do
        pid = tostring(pane.pane_id)
        seqno = get_seq(pane.pane_id)
        if act.panes[pid] == nil then
            act.panes[pid] = seqno
        end
        if pane.has_unseen_output then
            has_unseen_output = true
            if act.panes[pid] and act.panes[pid] < seqno then
                act.timestamp = ts
                act.panes[pid] = seqno
            end
        end
    end

    if has_unseen_output then
        if act.timestamp == nil then
            act.timestamp = ts
        end
        -- simple hardcoded values in seconds, it might be also a matter for 
        -- making color transitions instead
        if os.difftime(ts, act.timestamp) > 9 then
            color = '#9989e8' 
        elseif os.difftime(ts, act.timestamp) > 6 then
            color = '#d65fe8' 
        elseif os.difftime(ts, act.timestamp) > 3 then
            color = '#e83ec3' 
        else
            color = '#e8331e' 
        end
        return {
            {Foreground = {Color = color}},
            {Text = tab.active_pane.title}
        }
    end
    return tab.active_pane.title
end
)
return config

[gryf]

Another issue, that I've noticed is, that watching for seqno is not precise enough, as whatever happend to the window containing tabs with panes, makes increase of the seqno, as the repaint (and reflow possibly) need to be done.

Also it's kind of awkward to me, that when issuing wezterm-gui, and then creating second tab with whatever, first tab is always have the has_unseen_output set up to true, even if there is no single line dropped on that pane when the option hide_tab_bar_if_only_one_tab is set to true.