Replication of tmux sessions to kitty (2 flavours - os windows or tabs)

[megalithic]

Hi!

Like many of you, I've been looking for ways to mimick certain functionality of tmux, but within kitty (effectively ditching tmux completely from my flow -- well, sort of -- more on that later).

I've based this off of the incredible work of @muchzill4 to provide a pre-created list of sessions and select via fzf (his version was an up/down arrow native selector thingy -- i'm so used to fzf'ing all the things):

import os
import subprocess
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Generic, Iterable, Iterator, List, Optional, Sequence, TypeVar, Union

from kittens.tui.handler import Handler
from kittens.tui.loop import Loop, debug
from kittens.tui.operations import styled
from kitty.boss import Boss
from kitty.fast_data_types import get_options
from kitty.key_encoding import KeyEvent
from kitty.session import create_sessions
# note, I had to copy pyfzf and place it in my kitty config folder for this to work, i could not get the correct site-package paths to register for me to use the `pip3` installed version.
from pyfzf import FzfPrompt 


@dataclass
class KittySession:
    path: Path

    def __str__(self):
        return self.path.stem


def find_session_files(directory: str) -> Iterable[Path]:
    return Path(directory).expanduser().glob("*.conf")


def main(args: List[str]) -> str:
    session_files = [KittySession(path) for path in find_session_files(args[1])]
    if session_files:
        fzf = FzfPrompt("/usr/local/bin/fzf")
        selected_session = fzf.prompt(
            session_files,
            '--prompt=" new or existing session  " --bind="enter:replace-query+print-query"',
        )
        if selected_session:
            selected_path = "{}/{}.conf".format(args[1], selected_session[0])
            return str(selected_path)
    raise SystemExit(1)


def handle_result(
    args: List[str], session_path: str, target_window_id: int, boss: Boss
) -> None:
    startup_session = next(create_sessions(get_options(), default_session=session_path))

    boss.add_os_window(startup_session)

This will only spawn "session" files as new os_windows.

What's left, is to have it determine if one is already launched, and instead, switch to it, instead of launching a new one all the time. I'll need to figure out how to parse kitty @ ls to get the wm_class/wm_names and even the window_platform_ids for comparison and later use with hammerspoon.

Lastly, you might be asking "what about the getting rid of tmux completely, sort of"?

I still use tmux for attaching/detaching to long-running process that might need to be shared between "kitty session launches"; for me that includes weechat, and expo, and my slack script's output. So I just have a separate script (tmux-launch) in my dotfiles that handles this particular behaviour.

If I can just get the "switch to already open os_window" part going, I'll be close (though, I hate having multiple OS windows going like this; as it clutters things in a weird way).

Many folks to thank in this community.

[kovidgoyal]

You dont need to use kitty @ ls, you can just do for os_window in boss.list_os_windows(): os_window is a dict with the wm_class, id etc keys

[kovidgoyal]

Oh and if you dont want new os windows, you can use the detach_tab function to move them into an existing one.

[megalithic]

OOH, Kovid, is there a way to do this as part of the call to boss.add_os_window(startup_session)? https://github.com/megalithic/dotfiles/blob/a648880eb188da88ac2ad133911116a7f64d9a62/config/kitty/sessioner.py#L49

[kovidgoyal]

Not as part of it. You would call add_os_window(startup_session). Then get any newly created os windows (there can be more of them than one depending ont he session file contents) from self.os_window_map, then iterate over the tabs in the windows, like this:

for tab in tuple(self.os_window_map[new_osw_id]):
    self._move_tab_to(tab, target_os_window_id)

[muchzill4]

@megalithic you might've just made my day with the mention. ❤️

For what it's worth, I've been exploring another session management solution. Perhaps it'll fit your needs, perhaps not.
I eventually realised that the thing I was really missing from tmux was a namespace for each area of interest (project). Personally, I don't mind managing namespace processes by hand - usually it's no more than two. However, having an easy way to switch between the namespaces is desirable.

I do like fzf too. The idea is to use tabs as namespaces, instead of windows:

• make fzf list all possible namespaces (for me, it's all directories under ~/Dev)
• upon selection it should either:
  • open a new, correctly named kitty tab (ex.: work/foo for ~/Dev/work/foo) which of course is rooted in selected projects directory
  • focus an existing tab, if a match is found for given namespace
• rely heavily on layout management within a tab to focus what's relevant at any given moment

---

Yolo'd fish function, which is usually invoked by pressing cmd+p in kitty:

function kt -d "kitty tab from ~/Dev/*"
  set -l path $HOME/Dev
  set -l selected_dir (
    find $path/* -maxdepth 1 -mindepth 1 -type d |
      sed "s~$path/~~" |
      fzf-tmux -p --cycle --layout=reverse --prompt 't> ' |
      sed "s~^~$path/~"
  )

  if test -n "$selected_dir"
    set -l tab_name (echo $selected_dir | sed "s~$path/~~")
    kitty @ focus-tab --match title:$tab_name 2>/dev/null || kitty @ new-window --new-tab --tab-title $tab_name --cwd $selected_dir
  end
end

[tg0h]

I have been trying to build a session management workflow in kitty. In addition to creating/going to a namespace tab, I also display certain namespace tabs on the right of the kitty tab bar. This helps to provide an additional level of organization when there are too many tabs and I lose track of which tab does what.

[megalithic]

@muchzill4 i'd love to be able to just go the single tab per project/layout/session route, but i have too many inter-related processes and things going on for each project that a single tab is too restrictive (for my workflow and needs). i'm trying to decide if i want to bite the bullet and start rolling with more neovim-based terminals for a lot of this so i could/can just stick to a tab-per-project/session/layout. i just wish so bad that there was an structure and pattern already setup for some of this. I know tmux is much maligned here in this discussions, it DOES have some value for even jsut the session management and long-running-process multiplexing (not just on remote servers).

[megalithic]

MINOR UPDATE: for anyone following along and wishing i'd get this thing wrapped up (me included); i've hit a roadblock and not able to debug the suggestions from Mr. Goyal. I'll have to come back around to it later when I get some time to do some more reading on python things.

[megalithic]

Ok, I've gotten it to where it will kill the current os_window and open the newly selected one; i do use tmux, as mentioned, for some of the long running processes, so, while this isn't perfect, it's usable. I'd still like to investigate a workflow similar to @muchzill4 and @tg0h where you have a tab in a single os_window to represent a "session" of sorts.

Here's the latest version of sessioner.py (as mentioned, it requires pyfzf to be installed -- or better yet, to sit in your kitty config path): https://github.com/megalithic/dotfiles/blob/main/config/kitty/sessioner.py

I know kitty will never have multiplexing capabilities, so this is a workable solution to use your own session files and flip between sessions with fzf (i plan on adding session management to neovim to bring me back to the last editing state, since my solution destroys the current os_window before opening your session to the new one). You can also use @guysherman's kittymux project to do selection based upon window/tabs too (i only ever jump to sessions, then ctrl + 1-9 for tabs in that os window).

Finally, one could also use yabai or hammerspoon to manage windows now that they get a name/class and also has an os window id, too.

Hope that helps someone!

[megalithic]

ok ONE more update; i've gone back to both @muchzill4 and @tg0h's usages of "tabs" as sessions/workspaces/etc.. while it's not perfect, it has avoided certain overheads and oddities.. so, with that said, we have a modified version of @muchzill4's fish function:

https://github.com/megalithic/dotfiles/blob/main/bin/kt

It does a lot of the same things, but moves to using launch api, and executes a shell script of the same "tab" name to have it run stuff for you. Since my work environment is on a remote server, this will set up some things for me.

I'm then using some additional nvim plugins/behaviours to let me bring the rest of my terminal interactions into nvim splits and stuff (and us their session managment and workspace functionality)