WezTerm Sessionizer

[keturiosakys]

Since moving from tmux to WezTerm native multiplexer the only thing I missed was the tmux-sessionizer script from ThePrimeagen that I have adopted as core to my workflow. So I rebuilt it in Lua in WezTerm natively.

How it works

It's basically a carbon clone of the original tmux-sessionizer script with a couple of notable exceptions:

1. It uses fd as the underlying search engine (it's faster than find).
2. It looks for folders that are .git repositories (including worktrees) as opposed to folders at a certain level of nesting. I found that git repositories are my basic unit of work.

Installing

In your ~/.config/wezterm folder create a sessionizer.lua and make sure to update the fd and rootPath values according to your system.

-- ~.config/wezterm/sessionizer.lua
local wezterm = require("wezterm")
local act = wezterm.action

local M = {}

local fd = "/usr/local/bin/fd"

M.toggle = function(window, pane)
	local projects = {}

	local success, stdout, stderr = wezterm.run_child_process({
		fd,
		"-HI",
		"^.git$",
		"--max-depth=4",
		"--prune",
		os.getenv("HOME") .. "/Code"
	})

	if not success then
		wezterm.log_error("Failed to run fd: " .. stderr)
		return
	end

	for line in stdout:gmatch("([^\n]*)\n?") do
		local project = line:gsub("/.git.*$", "")
		local label = project
		local id = project:gsub(".*/", "")
		table.insert(projects, { label = tostring(label), id = tostring(id) })
	end

	window:perform_action(
		act.InputSelector({
			action = wezterm.action_callback(function(win, _, id, label)
				if not id and not label then
					wezterm.log_info("Cancelled")
				else
					wezterm.log_info("Selected " .. label)
					win:perform_action(
						act.SwitchToWorkspace({ name = id, spawn = { cwd = label } }),
						pane
					)
				end
			end),
			fuzzy = true,
			title = "Select project",
			choices = projects,
		}),
		pane
	)
end

return M

And then in your main wezterm.lua config require the sessionizer.lua and assign keybindings of your preference. Example:

-- ~.config/wezterm/wezterm.lua

local wezterm = require("wezterm")
local sessionizer = require("sessionizer")

return {
  -- ...
  keys = {
    -- ...
    { key = "f", mods = "LEADER", action = wezterm.action_callback(sessionizer.toggle) },
  },
}

[wez]

Neat! Consider using https://wezfurlong.org/wezterm/config/lua/wezterm/GLOBAL.html for the cache; read that page for more details on why!

[keturiosakys]

oh nice, thank you! Wasn't aware of the wezterm.GLOBAL - will update the script to use it

[keturiosakys]

Just FYI, ran into a little issue with tables in wezterm.GLOBAL - submitted it here: #4802

[FrancescElies]

Thanks for sharing this!

If fd gets slow you can also tell it to stop after a certain depth --max-depth=3 (3 worked fine for me) and then remove resetCacheAndToggle, that way you won't have to worry about managing the cache.

[FrancescElies]

Since I just stole this script from @keturiosakys and modified it to my needs, this might help others as well to do their own thing.

This one differs from the previous one:

• Works without cache, uses maxdepth to keep fd snappy
• Shows git cloned bare repositories branches checked out via git-worktrees, this assumes certain naming convention see code below.
  This allows you not only to jump to the repository but also jump directly to the branch you need assuming you already checked it out previously using e.g. git worktree add -b emergency-fix ./worktrees/emergency-fix master (./worktrees folder matters for sessionizer to later on find those branches).
• Handles annoying backslashes in windows.

Show me the code (click me)

-- platform.lua
local w = require 'wezterm'

local M = {}

return {
  is_win = string.find(w.target_triple, 'windows') ~= nil,
  is_linux = string.find(w.target_triple, 'linux') ~= nil,
  is_mac = string.find(w.target_triple, 'apple') ~= nil,
}

-- sessionizer.lua
local w = require 'wezterm'
local platform = require 'platform'
local act = w.action

local M = {}

-- TODO: make sure paths exist
local fd = w.home_dir .. '/bin/fd'
local srcPath = w.home_dir .. '/src'

M.toggle = function(window, pane)
  local projects = {}

  -- assumes  ~/src/www, ~/src/work to exist
  -- ~/src
  --  ├──kickstart.nvim       # toplevel config stuff
  --  ├──nushell-config
  --  ├──wezterm-config
  --  ├──work                 # work stuff
  --    └──work/project.git   # git bare clones marked with .git at the end
  --  │ └───31 unlisted
  --  └──www                  # 3rd party project
  --     └──103 unlisted
  local success, stdout, stderr = w.run_child_process {
    fd,
    '-HI',
    '-td',
    '--max-depth=1',
    '.',
    srcPath,
    srcPath .. '/work',
    srcPath .. '/www',
  }

  if not success then
    w.log_error('Failed to run fd: ' .. stderr)
    return
  end

  for line in stdout:gmatch '([^\n]*)\n?' do
    local project = platform.is_win and line:gsub('\\', '/') or line -- handles Windows backslash
    local label = project
    local id = project

    -- handle git bare repositories,
    -- assuming following name convention `myproject.git`
    if string.match(project, '%.git/$') then
      w.log_info('found .git ' .. tostring(project))
      local success, stdout, stderr = w.run_child_process { fd, '-HI', '-td', '--max-depth=1', '.', project .. '/worktrees' }
      if success then
        for wt_line in stdout:gmatch '([^\n]*)\n?' do
          local wt_project = platform.is_win and wt_line:gsub('\\', '/') or wt_line -- handles Windows backslash
          local wt_label = wt_project
          local wt_id = wt_project
          table.insert(projects, { label = tostring(wt_label), id = tostring(wt_id) })
        end
      else
        w.log_error('Failed to run fd: ' .. stderr)
      end
    end

    table.insert(projects, { label = tostring(label), id = tostring(id) })
  end

  window:perform_action(
    act.InputSelector {
      action = w.action_callback(function(win, _, id, label)
        if not id and not label then
          w.log_info 'Cancelled'
        else
          w.log_info('Selected ' .. label)
          win:perform_action(act.SwitchToWorkspace { name = id, spawn = { cwd = label } }, pane)
        end
      end),
      fuzzy = true,
      title = 'Select project',
      choices = projects,
    },
    pane
  )
end

return M

-- ~.config/wezterm/wezterm.lua

local w = require("wezterm")
local sessionizer = require("sessionizer")

return {
  -- ...
  keys = {
    -- ...
    { key = "f", mods = "LEADER", action = w.action_callback(sessionizer.toggle) },
   },
}

[akthe-at]

Thanks @FrancescElies ! I was just wondering about git work trees....This new one might have a typo ?
local wt_id = wtproject

[FrancescElies]

Thanks, typo fixed.
I guess something could be done with git worktree list instead but I didn't bother.

[FrancescElies]

Honestly I thought it was a copy paste problem bu I had the same problem on my local copy, not sure why the thing still worked despite that typo, it looks like this id was not playing a big role on the whole thing.

[keturiosakys]

limiting --max-depth= (I needed 4 but it still works) is much better than the cache option I came up with, thanks for sharing!

[keturiosakys]

@FrancescElies shared a good tip for making fd work fast without the cache using a --max-depth flag.

Here's the most up to date simplified script I ended up settling with:

local wezterm = require("wezterm")
local act = wezterm.action

local M = {}

local fd = "/path/to/fd"
local rootPath = "/full/path/to/search"

M.toggle = function(window, pane)
  local projects = {}

  local success, stdout, stderr = wezterm.run_child_process({
    fd,
    "-HI",
    "-td",
    "^.git$",
    "--max-depth=4",
    rootPath,
    -- add more paths here
  })

  if not success then
    wezterm.log_error("Failed to run fd: " .. stderr)
    return
  end

  for line in stdout:gmatch("([^\n]*)\n?") do
    local project = line:gsub("/.git/$", "")
    local label = project
    local id = project:gsub(".*/", "")
    table.insert(projects, { label = tostring(label), id = tostring(id) })
  end

  window:perform_action(
    act.InputSelector({
      action = wezterm.action_callback(function(win, _, id, label)
        if not id and not label then
          wezterm.log_info("Cancelled")
        else
          wezterm.log_info("Selected " .. label)
          win:perform_action(
            act.SwitchToWorkspace({ name = id, spawn = { cwd = label } }),
            pane
          )
        end
      end),
      fuzzy = true,
      title = "Select project",
      choices = projects,
    }),
    pane
  )
end

return M

[mikkasendke]

Hey for anyone doing this add --prune to the fd command to improve performance. Behaves the same as long as you don't have a git repo in a .git directory (I don't see why one would have that)

[keturiosakys]

nice one thanks!

[FrancescElies]

@keturiosakys I also ended up modifying mine too and changed how I handled bare repositories and some stuff for windows.

Below mine in case it helps, feedback appreciated.

--platform.lua
local w = require 'wezterm'

local M = {}

return {
  is_win = string.find(w.target_triple, 'windows') ~= nil,
  is_linux = string.find(w.target_triple, 'linux') ~= nil,
  is_mac = string.find(w.target_triple, 'apple') ~= nil,
}

--sessionizer.lua
local w = require 'wezterm'
local platform = require 'platform'
local act = w.action

local M = {}

--- Converts Windows backslash to forwardslash
---@param path string
local function normalize_path(path) return platform.is_win and path:gsub('\\', '/') or path end

local home = normalize_path(w.home_dir)

--- If name nil or false print err_message
---@param name string|boolean|nil
---@param err_message string
local function err_if_not(name, err_message)
  if not name then
    w.log_error(err_message)
  end
end
--
--- path if file or directory exists nil otherwise
---@param path string
local function file_exists(path)
  if path == nil then
    return nil
  end
  local f = io.open(path, 'r')
  -- io.open won't work to check if directories exist,
  -- but works for symlinks and regular files
  if f ~= nil then
    w.log_info(path .. ' file or symlink found')
    io.close(f)
    return path
  end
  return nil
end

-------------------------------------------------------
-- PATHS
--
local fd = (
  file_exists(home .. '/bin/fd')
  or file_exists 'usr/bin/fd'
  or file_exists(home .. '/bin/fd.exe')
  or file_exists '/ProgramData/chocolatey/bin/fd.exe'
)
err_if_not(fd, 'fd not found')

local git = (file_exists '/usr/bin/git' or file_exists '/Program Files/Git/cmd/git.exe')
err_if_not(git, 'git not found')

local srcPath = home .. '/src'
err_if_not(srcPath, srcPath .. ' not found')

local search_folders = {
  srcPath,
  srcPath .. '/work',
  srcPath .. '/other',
}
-------------------------------------------------------

--- Merge numeric tables
---@param t1 table
---@param t2 table
---@return table
local function merge_tables(t1, t2)
  local result = {}
  for index, value in ipairs(t1) do
    result[index] = value
  end
  for index, value in ipairs(t2) do
    result[#t1 + index] = value
  end
  return result
end

M.start = function(window, pane)
  local projects = {}

  -- assumes  ~/src/www, ~/src/work to exist
  -- ~/src
  --  ├──nushell-config       # toplevel config stuff
  --  ├──wezterm-config
  --  ├──work                    # work stuff
  --    ├──work/project.git      # git bare clones marked with .git at the end
  --    ├──work/project-bugfix   # worktree of project.git
  --    ├──work/project-feature  # worktree of project.git
  --  │ └───31 unlisted
  --  └──other                # 3rd party project
  --     └──103 unlisted
  local cmd = merge_tables({ fd, '-HI', '-td', '--max-depth=1', '.' }, search_folders)
  w.log_info 'cmd: '
  w.log_info(cmd)

  for _, value in ipairs(cmd) do
    w.log_info(value)
  end
  local success, stdout, stderr = w.run_child_process(cmd)

  if not success then
    w.log_error('Failed to run fd: ' .. stderr)
    return
  end

  for line in stdout:gmatch '([^\n]*)\n?' do
    local project = normalize_path(line)
    local label = project
    local id = project
    table.insert(projects, { label = tostring(label), id = tostring(id) })
  end

  window:perform_action(
    act.InputSelector {
      action = w.action_callback(function(win, _, id, label)
        if not id and not label then
          w.log_info 'Cancelled'
        else
          w.log_info('Selected ' .. label)
          win:perform_action(act.SwitchToWorkspace { name = id, spawn = { cwd = label } }, pane)
        end
      end),
      fuzzy = true,
      title = 'Select project',
      choices = projects,
    },
    pane
  )
end

return M

[akthe-at]

@FrancescElies How do you trigger this?

[akthe-at]

Nevermind, i see that you are using "start" instead of toggle.

[FrancescElies]

Sorry for the rename :/

[tjex]

For those who don't need to worry about windows compatibility, I modified the above iteration further, which includes:

• a fix for the id not being extracted by gsub
• labels for directory paths are displayed as relative from ~

Here in my dotfiles

[tjex]

Optimized further to work with regular and bare repos.
@FrancescElies solution above searched for directories in the worktrees folder to populate the launcher menu. In my case, cding into the repo.git/worktrees/x dir wasn't useful, so the below edit removes them from the launcher menu.

My edit, searches for files or folders named ".git". This allows fd to find worktree's project directories themselves as they have a ".git" file in them which points to the relative worktree within the bare repo.

This means you can cd directly into the project worktree itself or the bare git repo (for editing config / creating a new worktree / etc).
If you'd prefer to exclude the bare git repo itself, just change the fd flag: ".git$" to "^.git$". As this will ignore project.git directories. This is however only going to work if you keep your worktrees outside the bare git repo itself (which is the recommended way as per git documentation).

eg, ~/repos/zk:

.
├── docs
├── tjex
└── zk.git

Additionally a bit of path cleaning, so labels are shown as relative paths from $HOME

local wezterm = require("wezterm")
local act = wezterm.action

local M = {}

local fd = "/opt/homebrew/bin/fd"
local lsrc = "/Users/tjex/.local/src"
local dev = "/Users/tjex/dev"

-- from https://github.com/wez/wezterm/discussions/4796
M.open = function(window, pane)
	local projects = {}
	local home = os.getenv("HOME") .. "/"

	local success, stdout, stderr = wezterm.run_child_process({
		fd,
		"-HI",
		".git$",
		"--max-depth=4",
		"--prune",
		lsrc,
		dev,
		-- add more paths here
	})

	if not success then
		wezterm.log_error("Failed to run fd: " .. stderr)
		return
	end

	-- define variables from from file paths extractions and
	-- fill table with results
	for line in stdout:gmatch("([^\n]*)\n?") do
		-- create label from file path
		local project = line:gsub("/.git.*", "")
		project = project:gsub("/$", "")
		local label = project:gsub(home, "")

		-- extract id. Used for workspace name
		local _, _, id = string.find(project, ".*/(.+)")
		id = id:gsub(".git", "") -- bare repo dirs typically end in .git, remove if so.

		table.insert(projects, { label = tostring(label), id = tostring(id) })
	end

	-- update previous_workspace before changing to new workspace.
	wezterm.GLOBAL.previous_workspace = window:active_workspace()
	window:perform_action(
		act.InputSelector({
			action = wezterm.action_callback(function(win, _, id, label)
				if not id and not label then
					wezterm.log_info("Cancelled")
				else
					wezterm.log_info("Selected " .. label)
					win:perform_action(
						act.SwitchToWorkspace({
							name = id,
							spawn = { cwd = home .. label },
						}),
						pane
					)
				end
			end),
			fuzzy = true,
			title = "Select project",
			choices = projects,
		}),
		pane
	)
end

return M

[ckoehler]

Has anyone managed to then build on the new workspace? I usually open my editor and create a second tab with just a terminal. I can't seem to figure out how to do that with the callback.

[ckoehler]

To answer my own question, this works:

action = wezterm.action_callback(function(child_window, child_pane, id, label)
  if not label then
    return
  end

  local name = label:match("([^/]+)$")
  if has_value(wezterm.mux.get_workspace_names(), name) then
    wezterm.mux.set_active_workspace(name)
    return
  end

  local tab, new_pane, window = wezterm.mux.spawn_window({ workspace = name, cwd = label })
  wezterm.mux.set_active_workspace(name)

  new_pane:send_text("nvim\n")

  local gui_window = window:gui_window()

  gui_window:perform_action(
    wezterm.action.SpawnCommandInNewTab({
      cwd = label,
    }),
    new_pane
  )

  gui_window:perform_action(wezterm.action.ActivateTab(0), new_pane)
end),

[iton0]

Is there a way to set the active tab of a newly created workspace to a default string value? Additionally how would you update the logic to only do this when creating non-existing workspaces and not when switching to already existing workspaces?

[tjex]

My guess would be here:

  window:perform_action(
    act.InputSelector({
      action = wezterm.action_callback(function(win, _, id, label)
        if not id and not label then
          wezterm.log_info('Cancelled')
        else
          wezterm.log_info('Selected ' .. label)
          win:perform_action(
            act.SwitchToWorkspace({
              name = label:match('([^/]+)$'),
              spawn = { cwd = home .. label },
            }),
            pane
          )
          win:active_tab():set_title("your tab title here")
        end
      end),
      fuzzy = true,
      choices = projects,
    }),
    pane
  )

[iton0]

That will update the current workspace tab. Is there a way to do it within the spawn parameter of SwitchToWorkspace? I checked the docs but couldn't find relevant info.

[tjex]

  window:perform_action(
    act.InputSelector({
      action = wezterm.action_callback(function(win, _, id, label)
        if not id and not label then
          wezterm.log_info('Cancelled')
        else
          wezterm.log_info('Selected ' .. label)
          win:perform_action(
            act.SwitchToWorkspace({
              name = label:match('([^/]+)$'),
              spawn = { cwd = home .. label },
            }),
            pane
          )
          win:active_tab():set_title("your tab title here")
        end
      end),
      fuzzy = true,
      choices = projects,
    }),
    pane
    tab -- <- maybe you can access the tab here of the created tab, as above the created pane is being accessed by my understanding
  )

[iton0]

That did not work either. I did find a solution based on @MagicDuck config in #628 (comment). This worked for me:

  local function tab_title(tab_info)
    local title = tab_info.tab_title
    -- if the tab title is explicitly set, take that
    if title and #title > 0 then
      return title
    end
    -- Otherwise, use an single space string for the title
    return ' '
  end

  wezterm.GLOBAL.previous_workspace = window:active_workspace()
  window:perform_action(
    act.InputSelector({
      action = wezterm.action_callback(function(win, _, id, label)
        if not id and not label then
          wezterm.log_info('Cancelled')
        else
          wezterm.log_info('Selected ' .. label)
          win:perform_action(
            act.SwitchToWorkspace({
              name = label:match('([^/]+)$'),
              spawn = { cwd = home .. label },
            }),
            pane
          )
          wezterm.on('format-tab-title', function(tab)
            local title = tab_title(tab)

            return {
              { Text = ' ' .. (tab.tab_index + 1) .. ': ' .. title .. ' ' },
            }
          end)
        end
      end),
      fuzzy = true,
      choices = projects,
    }),
    pane
  )
end

Thank you again @tjex for taking the time to respond and help. I appreciate it!

[tjex]

Great! And thanks for reporting back with a solution and links to source :)

Such a bummer when the conversation just stops, and many times a solution was found.

[mikkasendke]

Hey, for anyone interested I created a small plugin that does the essential part of this over at mikkasendke/sessionizer.wezterm. It works for what I need it to but could probably be significantly extended and improved. Feel free to use or contribute if you want to.

[akthe-at]

Anyone able to use this in WSL2 when their wezterm gui/config is in regular windows?

[akthe-at]

@mikkasendke this is definitely helping and I think I'm 90% of the way there now! (Had this working perfectly for just Windows now I need to fix it up to work with wsl2) It's working for the most part just need to fix the cleaning up of paths and workspace names. Would your plugin handle this situation at all?

[mikkasendke]

Unfortunately not easily right now, but stuff like this will be there soon (also stuff like ~ instead of /home/user). Right now if you really wanted to use the plugin you could do the overwrite for the fd command and put something there that strips that but at this point one might just do it themselves.

[mikkasendke]

Hey @akthe-at, right now it is not very that clean yet but you can do the following in your config to have those paths looking like unix style paths.

sessionizer.display_entries = function(entries, window, pane)
    for i, v in pairs(entries) do
        entries[i].label = entries[i].label:gsub("\\\\wsl.localhost\\Ubuntu", "")
        entries[i].label = entries[i].label:gsub("\\", "/")
    end
    local cfg = require "sessionizer.config".get_effective_config(sessionizer.config)
    window:perform_action(require "sessionizer.input_selector".get(cfg, entries), pane)
end

Now if you use weird directory names this could replace them as well but that should not be an issue. (you could also trim them further to a ~ for example). You might have to update the plugin so it will work, also the 2 last lines are the default implementation of the function so yeah probably better to copy the function by value but this is what I did for me. Just wanted to let you know because I remembered. I will do better styling soon

[akthe-at]

@mikkasendke thanks for remembering me! I actually ended up using something very similar like you just posted in my custom sessionizer script that is derived from the previous posts + what you just posted! I will have to give yours a go soon (trying to slim down my config and enjoy taking on more external plugins and less stuff for me to manage personally when in reason).

[mikkasendke]

for anyone looking now it would be better to use sessionizer.use_entry_processor(callback(entries, next))