Skip to content

A modern terminal with a built-in multiplexer: close it and your sessions keep running. Run shells and tons of AI agents across your machines, then pick them up from desktop, browser, TUI and more. Written in Rust with no UI framework: interface drawn straight on the GPU. No Electron, GPUI or webview.

6.5 KB
Raw Blame
use anyhow::{anyhow, bail, Context};
use config::keyassignment::SpawnCommand;
use config::TermConfig;
use mux::activity::Activity;
use mux::domain::SplitSource;
use mux::tab::SplitRequest;
use mux::window::WindowId as MuxWindowId;
use mux::Mux;
use portable_pty::CommandBuilder;
use std::sync::Arc;
use wezterm_term::TerminalSize;
use window::WindowOps;

pub type SpawnSuccessAction = Box<dyn FnOnce(&mut crate::termwindow::TermWindow) + Send + Sync>;

#[derive(Copy, Debug, Clone, Eq, PartialEq)]
pub enum SpawnWhere {
    NewWindow,
    NewTab,
    NewTabAt(usize),
    SplitPane(SplitRequest),
}

pub fn spawn_command_impl(
    spawn: &SpawnCommand,
    spawn_where: SpawnWhere,
    size: TerminalSize,
    src_window_id: Option<MuxWindowId>,
    term_config: Arc<TermConfig>,
    completion_window: Option<::window::Window>,
    layout_mutation_reason: Option<&'static str>,
    success_action: Option<SpawnSuccessAction>,
) {
    let spawn = spawn.clone();
    let opening = matches!(spawn_where, SpawnWhere::NewWindow)
        .then(|| crate::frontend::front_end().opening_a_window());

    promise::spawn::spawn(async move {
        match spawn_command_internal(spawn, spawn_where, size, src_window_id, term_config).await {
            Ok(()) => {
                if opening.is_some() {
                    crate::frontend::front_end().opening_succeeded();
                }
                if let Some(window) = completion_window {
                    window.notify(crate::termwindow::TermWindowNotif::Apply(Box::new(
                        move |tw| {
                            if let Some(action) = success_action {
                                action(tw);
                            }
                            if let Some(reason) = layout_mutation_reason {
                                tw.sync_active_tab_geometry_now();
                                tw.persist_workspace_layout_after_mutation(reason);
                            }
                        },
                    )));
                }
            }
            Err(err) => {
                if let Some(latch_was_armed) = opening {
                    crate::frontend::front_end().opening_failed(latch_was_armed);
                }
                log::error!("Failed to spawn: {:#}", err);
            }
        }
    })
    .detach();
}

pub async fn spawn_command_internal(
    spawn: SpawnCommand,
    spawn_where: SpawnWhere,
    size: TerminalSize,
    src_window_id: Option<MuxWindowId>,
    term_config: Arc<TermConfig>,
) -> anyhow::Result<()> {
    let mux = Mux::get();
    let activity = Activity::new();

    let current_pane_id = match src_window_id {
        Some(window_id) => {
            if let Some(tab) = mux.get_active_tab_for_window(window_id) {
                tab.get_active_pane().map(|p| p.pane_id())
            } else {
                None
            }
        }
        None => None,
    };

    let cwd = if let Some(cwd) = spawn.cwd.as_ref() {
        Some(cwd.to_str().map(|s| s.to_owned()).ok_or_else(|| {
            anyhow!(
                "Domain::spawn requires that the cwd be unicode in {:?}",
                cwd
            )
        })?)
    } else {
        None
    };

    let cmd_builder = match (
        spawn.args.as_ref(),
        spawn.cwd.as_ref(),
        spawn.set_environment_variables.is_empty(),
    ) {
        (None, None, true) => None,
        _ => {
            let mut builder = spawn
                .args
                .as_ref()
                .map(|args| CommandBuilder::from_argv(args.iter().map(Into::into).collect()))
                .unwrap_or_else(CommandBuilder::new_default_prog);
            for (k, v) in spawn.set_environment_variables.iter() {
                builder.env(k, v);
            }
            if let Some(cwd) = &spawn.cwd {
                builder.cwd(cwd);
            }
            Some(builder)
        }
    };

    let workspace = mux.active_workspace().clone();

    match spawn_where {
        SpawnWhere::SplitPane(direction) => {
            let src_window_id = match src_window_id {
                Some(id) => id,
                None => anyhow::bail!("no src window when splitting a pane?"),
            };
            if let Some(tab) = mux.get_active_tab_for_window(src_window_id) {
                let pane = tab
                    .get_active_pane()
                    .ok_or_else(|| anyhow!("tab to have a pane"))?;

                log::trace!("doing split_pane");
                let (pane, _size) = mux
                    .split_pane(
                        // tab.tab_id(),
                        pane.pane_id(),
                        direction,
                        SplitSource::Spawn {
                            command: cmd_builder,
                            command_dir: cwd,
                        },
                        spawn.domain,
                    )
                    .await
                    .context("split_pane")?;
                pane.set_config(term_config);
            } else {
                bail!("there is no active tab while splitting pane!?");
            }
        }
        _ => {
            let (tab, pane, window_id) = mux
                .spawn_tab_or_window(
                    match spawn_where {
                        SpawnWhere::NewWindow => None,
                        _ => src_window_id,
                    },
                    spawn.domain,
                    cmd_builder,
                    cwd,
                    size,
                    current_pane_id,
                    workspace,
                    spawn.position,
                )
                .await
                .context("spawn_tab_or_window")?;

            // If it was created in this window, it copies our handlers.
            // Otherwise, we'll pick them up when we later respond to
            // the new window being created.
            if Some(window_id) == src_window_id {
                pane.set_config(term_config);

                if let SpawnWhere::NewTabAt(insert_idx) = spawn_where {
                    if let Some(mut window) = mux.get_window_mut(window_id) {
                        if let Some(tab_idx) = window.idx_by_id(tab.tab_id()) {
                            let tab_inst = window.remove_by_idx(tab_idx);
                            let insert_idx = insert_idx.min(window.len());
                            window.insert(insert_idx, &tab_inst);
                            window.set_active_without_saving(insert_idx);
                        }
                    }
                }
            }
        }
    };

    drop(activity);

    Ok(())
}