spawn new window in current workspace (without explicitly naming the workspace)

[tjex]

Currently, there are only the build-in options to spawn a new window in the default workspace or a named workspace:

wezterm cli spawn --new-window -- top # spawns in default workspace
wezterm cli spawn --new-window --workspace foo -- top # spawns in 'foo' workspace

It would be great to spawn in the current workspace, perhaps like this:

wezterm cli spawn --new-window --workspace current -- top

I've tried get_active_workspace() within the launcher (see below), but get_active_workspace() will retrieve whatever workspace I'm in when the config is loaded (either at startup or on a config reload).

I've been having a look at spawn_command.rs, but I've never touched rust before.

This feature is enough for me to run my own fork of it, so if anyone had any pointers as to how to replace the default workspace in unwrap_or() with the current workspace, I'd be very grateful (and would then work into a PR).

It is very useful to be able to spawn a program into the current workspace without having to name it (debugger, email, top, even just another shell).

        let workspace = self
            .workspace
            .as_deref()
            .unwrap_or(
                config
                    .default_workspace
                    .as_deref()
                    .unwrap_or(mux::DEFAULT_WORKSPACE),
            )
            .to_string();

        let size = config.initial_size(0, None);

        let spawned = client
            .spawn_v2(codec::SpawnV2 {
                domain: self
                    .domain_name
                    .map_or(SpawnTabDomain::DefaultDomain, |name| {
                        SpawnTabDomain::DomainName(name)
                    }),
                window_id,
                command: if self.prog.is_empty() {
                    None
                } else {
                    let builder = CommandBuilder::from_argv(self.prog);
                    Some(builder)
                },
                command_dir: resolve_relative_cwd(self.cwd)?,
                size,
                workspace,
            })
            .await?;

[tjex]

another idea I had was to update the config.default_workspace in the actual call to open the launcher. Something along the lines of the following, but had no luck:

		{
			key = "k",
			mods = "SUPER",
			action = wezterm.action_callback(function()
                          -- update.wezterm.default_workspace.here
                          return act.ShowLauncherArgs({ flags = "FUZZY|LAUNCH_MENU_ITEMS" }),
                        end)
		},

[tjex]

Trying to get the current active workspace, but the workspace that's returned is whichever workspace is active when wezterm starts up or reloads the config.

local function spawn_window(label, path, workspace, cmd)
	if workspace == "current" then
		workspace = wezterm.mux.get_active_workspace()
	end
	local args = { "wezterm", "cli", "spawn", "--new-window", "--workspace", workspace, "--" }
	for _, c in ipairs(cmd) do
		table.insert(args, c)
		print(args)
	end

	return {
		label = label,
		cwd = path,
		set_environment_variables = {
			PATH = env_paths,
		},
		args = args,
	}
end

config.launch_menu = { 		
    spawn_window("posts", tjex_site .. "src/content", "current", { "zk", "list" }),
}

[tjex]

We're also so close, considering there is already SpawnCommandInNewWindow, which spawns in the same workspace. It needs to be returned to action though, so it can't work at all with the launcher, as the launcher only takes an args field, and not an action field like keybinds.

		{
			key = "e",
			mods = "LEADER",
			action = act.SpawnCommandInNewWindow({
				args = { "aerc" },
			}),
		},

[tjex]

Baked an intermediary solution, but it can't handle more complex envocations yet, like nvim $(fd . -t f ~/.config | fzf)

As far as I know theres no way to pass cwd to the spawn command in this input selector paradigm either.

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

local paths = require("paths")
local env_paths = paths.env_paths()

local M = {}

local choices = {
	{ id = "aerc", label = "aerc" },
	{ id = "zk list", label = "zk list" },
}

local function split_on_whitespace(input)
	local result = {}
	for word in string.gmatch(input, "%S+") do
		table.insert(result, word)
	end
	return result
end

M.launch_in_current_workspace = function(window, pane)
	window:perform_action(
		act.InputSelector({
			action = wezterm.action_callback(function(inner_window, inner_pane, id, label)
				if not id and not label then
					wezterm.log_info("cancelled")
				else
					local cmd = split_on_whitespace(id) -- convert string to table
					wezterm.log_info("you selected ", id, label)
					inner_window:perform_action(
						act.SpawnCommandInNewWindow({
							set_environment_variables = {
								PATH = env_paths,
							},
							args = cmd,
						}),
						inner_pane
					)
				end
			end),
			choices = choices,
			fuzzy = true,
			fuzzy_description = "Launch in current workspace.",
		}),
		pane
	)
end

return M

[tjex]

Creating a command from splitting on white space breaks a command like this:

local choices = {
	{ id = "zsh -c -l nvim $(fd -t -f /home/tjex/.config/nvim | fzf)", label = "poo" },
}

Workaround is to just execute a script that does the same thing:

#!/usr/bin/env bash

# ~/.scripts/launchers/conf-nvim.sh

cd ${XDG_CONFIG_HOME}/nvim

nvim $(fd . -t f | fzf)

local choices = {
	{ id = "/home/tjex/.scripts/launchers/conf-nvim.sh", label = "nvim" },
}

[tjex]

Or catch the label and insert a cwd string and args table.

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

local paths = require("paths")
local env_paths = paths.env_paths()

local M = {}

local choices = {
	{ label = "nvim" },
}

local function nvim_conf()
	return "/home/tjex/.config/nvim", { "zsh", "-c", "nvim $(fd -t f | fzf)" }
end

M.launch_in_current_workspace = function(window, pane)
	window:perform_action(
		act.InputSelector({
			action = wezterm.action_callback(function(inner_window, inner_pane, _, label)
				if not label then
					wezterm.log_info("cancelled")
				else
					local cwd = ""
					local args = {}
					if label == "nvim" then
						cwd, args = nvim_conf()
					end
					wezterm.log_info("cwd / args", cwd, args)
					inner_window:perform_action(
						act.SpawnCommandInNewWindow({
							set_environment_variables = {
								PATH = env_paths,
							},
							-- cwd = cwd,
							args = args,
						}),
						inner_pane
					)
				end
			end),
			choices = choices,
			fuzzy = true,
			fuzzy_description = "Launch in current workspace.",
		}),
		pane
	)
end

return M

[tjex]

final solution is posted here

#6395