1use std::{cmp, ops::ControlFlow, path::PathBuf, process::ExitStatus, sync::Arc, time::Duration};
   2
   3use crate::{
   4    TerminalView, default_working_directory,
   5    persistence::{
   6        SerializedItems, SerializedTerminalPanel, deserialize_terminal_panel, serialize_pane_group,
   7    },
   8};
   9use breadcrumbs::Breadcrumbs;
  10use collections::HashMap;
  11use db::kvp::KEY_VALUE_STORE;
  12use futures::{channel::oneshot, future::join_all};
  13use gpui::{
  14    Action, AnyView, App, AsyncApp, AsyncWindowContext, Context, Corner, Entity, EventEmitter,
  15    ExternalPaths, FocusHandle, Focusable, IntoElement, ParentElement, Pixels, Render, Styled,
  16    Task, WeakEntity, Window, actions,
  17};
  18use itertools::Itertools;
  19use project::{Fs, Project, ProjectEntryId};
  20use search::{BufferSearchBar, buffer_search::DivRegistrar};
  21use settings::{Settings, TerminalDockPosition};
  22use task::{RevealStrategy, RevealTarget, Shell, ShellBuilder, SpawnInTerminal, TaskId};
  23use terminal::{Terminal, terminal_settings::TerminalSettings};
  24use ui::{
  25    ButtonLike, Clickable, ContextMenu, FluentBuilder, PopoverMenu, SplitButton, Toggleable,
  26    Tooltip, prelude::*,
  27};
  28use util::{ResultExt, TryFutureExt};
  29use workspace::{
  30    ActivateNextPane, ActivatePane, ActivatePaneDown, ActivatePaneLeft, ActivatePaneRight,
  31    ActivatePaneUp, ActivatePreviousPane, DraggedSelection, DraggedTab, ItemId, MoveItemToPane,
  32    MoveItemToPaneInDirection, MovePaneDown, MovePaneLeft, MovePaneRight, MovePaneUp, NewTerminal,
  33    Pane, PaneGroup, SplitDirection, SplitDown, SplitLeft, SplitRight, SplitUp, SwapPaneDown,
  34    SwapPaneLeft, SwapPaneRight, SwapPaneUp, ToggleZoom, Workspace,
  35    dock::{DockPosition, Panel, PanelEvent, PanelHandle},
  36    item::SerializableItem,
  37    move_active_item, move_item, pane,
  38};
  39
  40use anyhow::{Result, anyhow};
  41use zed_actions::assistant::InlineAssist;
  42
  43const TERMINAL_PANEL_KEY: &str = "TerminalPanel";
  44
  45actions!(
  46    terminal_panel,
  47    [
  48        /// Toggles the terminal panel.
  49        Toggle,
  50        /// Toggles focus on the terminal panel.
  51        ToggleFocus
  52    ]
  53);
  54
  55pub fn init(cx: &mut App) {
  56    cx.observe_new(
  57        |workspace: &mut Workspace, _window, _: &mut Context<Workspace>| {
  58            workspace.register_action(TerminalPanel::new_terminal);
  59            workspace.register_action(TerminalPanel::open_terminal);
  60            workspace.register_action(|workspace, _: &ToggleFocus, window, cx| {
  61                if is_enabled_in_workspace(workspace, cx) {
  62                    workspace.toggle_panel_focus::<TerminalPanel>(window, cx);
  63                }
  64            });
  65            workspace.register_action(|workspace, _: &Toggle, window, cx| {
  66                if is_enabled_in_workspace(workspace, cx) {
  67                    if !workspace.toggle_panel_focus::<TerminalPanel>(window, cx) {
  68                        workspace.close_panel::<TerminalPanel>(window, cx);
  69                    }
  70                }
  71            });
  72        },
  73    )
  74    .detach();
  75}
  76
  77pub struct TerminalPanel {
  78    pub(crate) active_pane: Entity<Pane>,
  79    pub(crate) center: PaneGroup,
  80    fs: Arc<dyn Fs>,
  81    workspace: WeakEntity<Workspace>,
  82    pub(crate) width: Option<Pixels>,
  83    pub(crate) height: Option<Pixels>,
  84    pending_serialization: Task<Option<()>>,
  85    pending_terminals_to_add: usize,
  86    deferred_tasks: HashMap<TaskId, Task<()>>,
  87    assistant_enabled: bool,
  88    assistant_tab_bar_button: Option<AnyView>,
  89    active: bool,
  90}
  91
  92impl TerminalPanel {
  93    pub fn new(workspace: &Workspace, window: &mut Window, cx: &mut Context<Self>) -> Self {
  94        let project = workspace.project();
  95        let pane = new_terminal_pane(workspace.weak_handle(), project.clone(), false, window, cx);
  96        let center = PaneGroup::new(pane.clone());
  97        let terminal_panel = Self {
  98            center,
  99            active_pane: pane,
 100            fs: workspace.app_state().fs.clone(),
 101            workspace: workspace.weak_handle(),
 102            pending_serialization: Task::ready(None),
 103            width: None,
 104            height: None,
 105            pending_terminals_to_add: 0,
 106            deferred_tasks: HashMap::default(),
 107            assistant_enabled: false,
 108            assistant_tab_bar_button: None,
 109            active: false,
 110        };
 111        terminal_panel.apply_tab_bar_buttons(&terminal_panel.active_pane, cx);
 112        terminal_panel
 113    }
 114
 115    pub fn set_assistant_enabled(&mut self, enabled: bool, cx: &mut Context<Self>) {
 116        self.assistant_enabled = enabled;
 117        if enabled {
 118            let focus_handle = self
 119                .active_pane
 120                .read(cx)
 121                .active_item()
 122                .map(|item| item.item_focus_handle(cx))
 123                .unwrap_or(self.focus_handle(cx));
 124            self.assistant_tab_bar_button = Some(
 125                cx.new(move |_| InlineAssistTabBarButton { focus_handle })
 126                    .into(),
 127            );
 128        } else {
 129            self.assistant_tab_bar_button = None;
 130        }
 131        for pane in self.center.panes() {
 132            self.apply_tab_bar_buttons(pane, cx);
 133        }
 134    }
 135
 136    fn apply_tab_bar_buttons(&self, terminal_pane: &Entity<Pane>, cx: &mut Context<Self>) {
 137        let assistant_tab_bar_button = self.assistant_tab_bar_button.clone();
 138        terminal_pane.update(cx, |pane, cx| {
 139            pane.set_render_tab_bar_buttons(cx, move |pane, window, cx| {
 140                let split_context = pane
 141                    .active_item()
 142                    .and_then(|item| item.downcast::<TerminalView>())
 143                    .map(|terminal_view| terminal_view.read(cx).focus_handle.clone());
 144                if !pane.has_focus(window, cx) && !pane.context_menu_focused(window, cx) {
 145                    return (None, None);
 146                }
 147                let focus_handle = pane.focus_handle(cx);
 148                let right_children = h_flex()
 149                    .gap(DynamicSpacing::Base02.rems(cx))
 150                    .child(
 151                        PopoverMenu::new("terminal-tab-bar-popover-menu")
 152                            .trigger_with_tooltip(
 153                                IconButton::new("plus", IconName::Plus).icon_size(IconSize::Small),
 154                                Tooltip::text("New…"),
 155                            )
 156                            .anchor(Corner::TopRight)
 157                            .with_handle(pane.new_item_context_menu_handle.clone())
 158                            .menu(move |window, cx| {
 159                                let focus_handle = focus_handle.clone();
 160                                let menu = ContextMenu::build(window, cx, |menu, _, _| {
 161                                    menu.context(focus_handle.clone())
 162                                        .action(
 163                                            "New Terminal",
 164                                            workspace::NewTerminal.boxed_clone(),
 165                                        )
 166                                        // We want the focus to go back to terminal panel once task modal is dismissed,
 167                                        // hence we focus that first. Otherwise, we'd end up without a focused element, as
 168                                        // context menu will be gone the moment we spawn the modal.
 169                                        .action(
 170                                            "Spawn task",
 171                                            zed_actions::Spawn::modal().boxed_clone(),
 172                                        )
 173                                });
 174
 175                                Some(menu)
 176                            }),
 177                    )
 178                    .children(assistant_tab_bar_button.clone())
 179                    .child(
 180                        PopoverMenu::new("terminal-pane-tab-bar-split")
 181                            .trigger_with_tooltip(
 182                                IconButton::new("terminal-pane-split", IconName::Split)
 183                                    .icon_size(IconSize::Small),
 184                                Tooltip::text("Split Pane"),
 185                            )
 186                            .anchor(Corner::TopRight)
 187                            .with_handle(pane.split_item_context_menu_handle.clone())
 188                            .menu({
 189                                move |window, cx| {
 190                                    ContextMenu::build(window, cx, |menu, _, _| {
 191                                        menu.when_some(
 192                                            split_context.clone(),
 193                                            |menu, split_context| menu.context(split_context),
 194                                        )
 195                                        .action("Split Right", SplitRight.boxed_clone())
 196                                        .action("Split Left", SplitLeft.boxed_clone())
 197                                        .action("Split Up", SplitUp.boxed_clone())
 198                                        .action("Split Down", SplitDown.boxed_clone())
 199                                    })
 200                                    .into()
 201                                }
 202                            }),
 203                    )
 204                    .child({
 205                        let zoomed = pane.is_zoomed();
 206                        IconButton::new("toggle_zoom", IconName::Maximize)
 207                            .icon_size(IconSize::Small)
 208                            .toggle_state(zoomed)
 209                            .selected_icon(IconName::Minimize)
 210                            .on_click(cx.listener(|pane, _, window, cx| {
 211                                pane.toggle_zoom(&workspace::ToggleZoom, window, cx);
 212                            }))
 213                            .tooltip(move |window, cx| {
 214                                Tooltip::for_action(
 215                                    if zoomed { "Zoom Out" } else { "Zoom In" },
 216                                    &ToggleZoom,
 217                                    window,
 218                                    cx,
 219                                )
 220                            })
 221                    })
 222                    .into_any_element()
 223                    .into();
 224                (None, right_children)
 225            });
 226        });
 227    }
 228
 229    fn serialization_key(workspace: &Workspace) -> Option<String> {
 230        workspace
 231            .database_id()
 232            .map(|id| i64::from(id).to_string())
 233            .or(workspace.session_id())
 234            .map(|id| format!("{:?}-{:?}", TERMINAL_PANEL_KEY, id))
 235    }
 236
 237    pub async fn load(
 238        workspace: WeakEntity<Workspace>,
 239        mut cx: AsyncWindowContext,
 240    ) -> Result<Entity<Self>> {
 241        let mut terminal_panel = None;
 242
 243        if let Some((database_id, serialization_key)) = workspace
 244            .read_with(&cx, |workspace, _| {
 245                workspace
 246                    .database_id()
 247                    .zip(TerminalPanel::serialization_key(workspace))
 248            })
 249            .ok()
 250            .flatten()
 251            && let Some(serialized_panel) = cx
 252                .background_spawn(async move { KEY_VALUE_STORE.read_kvp(&serialization_key) })
 253                .await
 254                .log_err()
 255                .flatten()
 256                .map(|panel| serde_json::from_str::<SerializedTerminalPanel>(&panel))
 257                .transpose()
 258                .log_err()
 259                .flatten()
 260            && let Ok(serialized) = workspace
 261                .update_in(&mut cx, |workspace, window, cx| {
 262                    deserialize_terminal_panel(
 263                        workspace.weak_handle(),
 264                        workspace.project().clone(),
 265                        database_id,
 266                        serialized_panel,
 267                        window,
 268                        cx,
 269                    )
 270                })?
 271                .await
 272        {
 273            terminal_panel = Some(serialized);
 274        }
 275
 276        let terminal_panel = if let Some(panel) = terminal_panel {
 277            panel
 278        } else {
 279            workspace.update_in(&mut cx, |workspace, window, cx| {
 280                cx.new(|cx| TerminalPanel::new(workspace, window, cx))
 281            })?
 282        };
 283
 284        if let Some(workspace) = workspace.upgrade() {
 285            workspace
 286                .update(&mut cx, |workspace, _| {
 287                    workspace.set_terminal_provider(TerminalProvider(terminal_panel.clone()))
 288                })
 289                .ok();
 290        }
 291
 292        // Since panels/docks are loaded outside from the workspace, we cleanup here, instead of through the workspace.
 293        if let Some(workspace) = workspace.upgrade() {
 294            let cleanup_task = workspace.update_in(&mut cx, |workspace, window, cx| {
 295                let alive_item_ids = terminal_panel
 296                    .read(cx)
 297                    .center
 298                    .panes()
 299                    .into_iter()
 300                    .flat_map(|pane| pane.read(cx).items())
 301                    .map(|item| item.item_id().as_u64() as ItemId)
 302                    .collect();
 303                workspace.database_id().map(|workspace_id| {
 304                    TerminalView::cleanup(workspace_id, alive_item_ids, window, cx)
 305                })
 306            })?;
 307            if let Some(task) = cleanup_task {
 308                task.await.log_err();
 309            }
 310        }
 311
 312        if let Some(workspace) = workspace.upgrade() {
 313            let should_focus = workspace
 314                .update_in(&mut cx, |workspace, window, cx| {
 315                    workspace.active_item(cx).is_none()
 316                        && workspace
 317                            .is_dock_at_position_open(terminal_panel.position(window, cx), cx)
 318                })
 319                .unwrap_or(false);
 320
 321            if should_focus {
 322                terminal_panel
 323                    .update_in(&mut cx, |panel, window, cx| {
 324                        panel.active_pane.update(cx, |pane, cx| {
 325                            pane.focus_active_item(window, cx);
 326                        });
 327                    })
 328                    .ok();
 329            }
 330        }
 331        Ok(terminal_panel)
 332    }
 333
 334    fn handle_pane_event(
 335        &mut self,
 336        pane: &Entity<Pane>,
 337        event: &pane::Event,
 338        window: &mut Window,
 339        cx: &mut Context<Self>,
 340    ) {
 341        match event {
 342            pane::Event::ActivateItem { .. } => self.serialize(cx),
 343            pane::Event::RemovedItem { .. } => self.serialize(cx),
 344            pane::Event::Remove { focus_on_pane } => {
 345                let pane_count_before_removal = self.center.panes().len();
 346                let _removal_result = self.center.remove(pane);
 347                if pane_count_before_removal == 1 {
 348                    self.center.first_pane().update(cx, |pane, cx| {
 349                        pane.set_zoomed(false, cx);
 350                    });
 351                    cx.emit(PanelEvent::Close);
 352                } else if let Some(focus_on_pane) =
 353                    focus_on_pane.as_ref().or_else(|| self.center.panes().pop())
 354                {
 355                    focus_on_pane.focus_handle(cx).focus(window);
 356                }
 357            }
 358            pane::Event::ZoomIn => {
 359                for pane in self.center.panes() {
 360                    pane.update(cx, |pane, cx| {
 361                        pane.set_zoomed(true, cx);
 362                    })
 363                }
 364                cx.emit(PanelEvent::ZoomIn);
 365                cx.notify();
 366            }
 367            pane::Event::ZoomOut => {
 368                for pane in self.center.panes() {
 369                    pane.update(cx, |pane, cx| {
 370                        pane.set_zoomed(false, cx);
 371                    })
 372                }
 373                cx.emit(PanelEvent::ZoomOut);
 374                cx.notify();
 375            }
 376            pane::Event::AddItem { item } => {
 377                if let Some(workspace) = self.workspace.upgrade() {
 378                    workspace.update(cx, |workspace, cx| {
 379                        item.added_to_pane(workspace, pane.clone(), window, cx)
 380                    })
 381                }
 382                self.serialize(cx);
 383            }
 384            &pane::Event::Split {
 385                direction,
 386                clone_active_item,
 387            } => {
 388                if clone_active_item {
 389                    let fut = self.new_pane_with_cloned_active_terminal(window, cx);
 390                    let pane = pane.clone();
 391                    cx.spawn_in(window, async move |panel, cx| {
 392                        let Some(new_pane) = fut.await else {
 393                            return;
 394                        };
 395                        panel
 396                            .update_in(cx, |panel, window, cx| {
 397                                panel.center.split(&pane, &new_pane, direction).log_err();
 398                                window.focus(&new_pane.focus_handle(cx));
 399                            })
 400                            .ok();
 401                    })
 402                    .detach();
 403                } else {
 404                    let Some(item) = pane.update(cx, |pane, cx| pane.take_active_item(window, cx))
 405                    else {
 406                        return;
 407                    };
 408                    let Ok(project) = self
 409                        .workspace
 410                        .update(cx, |workspace, _| workspace.project().clone())
 411                    else {
 412                        return;
 413                    };
 414                    let new_pane =
 415                        new_terminal_pane(self.workspace.clone(), project, false, window, cx);
 416                    new_pane.update(cx, |pane, cx| {
 417                        pane.add_item(item, true, true, None, window, cx);
 418                    });
 419                    self.center.split(&pane, &new_pane, direction).log_err();
 420                    window.focus(&new_pane.focus_handle(cx));
 421                }
 422            }
 423            pane::Event::Focus => {
 424                self.active_pane = pane.clone();
 425            }
 426            pane::Event::ItemPinned | pane::Event::ItemUnpinned => {
 427                self.serialize(cx);
 428            }
 429
 430            _ => {}
 431        }
 432    }
 433
 434    fn new_pane_with_cloned_active_terminal(
 435        &mut self,
 436        window: &mut Window,
 437        cx: &mut Context<Self>,
 438    ) -> Task<Option<Entity<Pane>>> {
 439        let Some(workspace) = self.workspace.upgrade() else {
 440            return Task::ready(None);
 441        };
 442        let workspace = workspace.read(cx);
 443        let database_id = workspace.database_id();
 444        let weak_workspace = self.workspace.clone();
 445        let project = workspace.project().clone();
 446        let active_pane = &self.active_pane;
 447        let terminal_view = active_pane
 448            .read(cx)
 449            .active_item()
 450            .and_then(|item| item.downcast::<TerminalView>());
 451        let working_directory = terminal_view
 452            .as_ref()
 453            .and_then(|terminal_view| {
 454                terminal_view
 455                    .read(cx)
 456                    .terminal()
 457                    .read(cx)
 458                    .working_directory()
 459            })
 460            .or_else(|| default_working_directory(workspace, cx));
 461        let is_zoomed = active_pane.read(cx).is_zoomed();
 462        cx.spawn_in(window, async move |panel, cx| {
 463            let terminal = project
 464                .update(cx, |project, cx| match terminal_view {
 465                    Some(view) => project.clone_terminal(
 466                        &view.read(cx).terminal.clone(),
 467                        cx,
 468                        working_directory,
 469                    ),
 470                    None => project.create_terminal_shell(working_directory, cx),
 471                })
 472                .ok()?
 473                .await
 474                .log_err()?;
 475
 476            panel
 477                .update_in(cx, move |terminal_panel, window, cx| {
 478                    let terminal_view = Box::new(cx.new(|cx| {
 479                        TerminalView::new(
 480                            terminal.clone(),
 481                            weak_workspace.clone(),
 482                            database_id,
 483                            project.downgrade(),
 484                            window,
 485                            cx,
 486                        )
 487                    }));
 488                    let pane = new_terminal_pane(weak_workspace, project, is_zoomed, window, cx);
 489                    terminal_panel.apply_tab_bar_buttons(&pane, cx);
 490                    pane.update(cx, |pane, cx| {
 491                        pane.add_item(terminal_view, true, true, None, window, cx);
 492                    });
 493                    Some(pane)
 494                })
 495                .ok()
 496                .flatten()
 497        })
 498    }
 499
 500    pub fn open_terminal(
 501        workspace: &mut Workspace,
 502        action: &workspace::OpenTerminal,
 503        window: &mut Window,
 504        cx: &mut Context<Workspace>,
 505    ) {
 506        let Some(terminal_panel) = workspace.panel::<Self>(cx) else {
 507            return;
 508        };
 509
 510        terminal_panel
 511            .update(cx, |panel, cx| {
 512                panel.add_terminal_shell(
 513                    Some(action.working_directory.clone()),
 514                    RevealStrategy::Always,
 515                    window,
 516                    cx,
 517                )
 518            })
 519            .detach_and_log_err(cx);
 520    }
 521
 522    pub fn spawn_task(
 523        &mut self,
 524        task: &SpawnInTerminal,
 525        window: &mut Window,
 526        cx: &mut Context<Self>,
 527    ) -> Task<Result<WeakEntity<Terminal>>> {
 528        let Some(workspace) = self.workspace.upgrade() else {
 529            return Task::ready(Err(anyhow!("failed to read workspace")));
 530        };
 531
 532        let project = workspace.read(cx).project().read(cx);
 533
 534        if project.is_via_collab() {
 535            return Task::ready(Err(anyhow!("cannot spawn tasks as a guest")));
 536        }
 537
 538        let remote_client = project.remote_client();
 539        let is_windows = project.path_style(cx).is_windows();
 540        let remote_shell = remote_client
 541            .as_ref()
 542            .and_then(|remote_client| remote_client.read(cx).shell());
 543
 544        let shell = if let Some(remote_shell) = remote_shell
 545            && task.shell == Shell::System
 546        {
 547            Shell::Program(remote_shell)
 548        } else {
 549            task.shell.clone()
 550        };
 551
 552        let builder = ShellBuilder::new(&shell, is_windows);
 553        let command_label = builder.command_label(task.command.as_deref().unwrap_or(""));
 554        let (command, args) = builder.build(task.command.clone(), &task.args);
 555
 556        let task = SpawnInTerminal {
 557            command_label,
 558            command: Some(command),
 559            args,
 560            ..task.clone()
 561        };
 562
 563        if task.allow_concurrent_runs && task.use_new_terminal {
 564            return self.spawn_in_new_terminal(task, window, cx);
 565        }
 566
 567        let mut terminals_for_task = self.terminals_for_task(&task.full_label, cx);
 568        let Some(existing) = terminals_for_task.pop() else {
 569            return self.spawn_in_new_terminal(task, window, cx);
 570        };
 571
 572        let (existing_item_index, task_pane, existing_terminal) = existing;
 573        if task.allow_concurrent_runs {
 574            return self.replace_terminal(
 575                task,
 576                task_pane,
 577                existing_item_index,
 578                existing_terminal,
 579                window,
 580                cx,
 581            );
 582        }
 583
 584        let (tx, rx) = oneshot::channel();
 585
 586        self.deferred_tasks.insert(
 587            task.id.clone(),
 588            cx.spawn_in(window, async move |terminal_panel, cx| {
 589                wait_for_terminals_tasks(terminals_for_task, cx).await;
 590                let task = terminal_panel.update_in(cx, |terminal_panel, window, cx| {
 591                    if task.use_new_terminal {
 592                        terminal_panel.spawn_in_new_terminal(task, window, cx)
 593                    } else {
 594                        terminal_panel.replace_terminal(
 595                            task,
 596                            task_pane,
 597                            existing_item_index,
 598                            existing_terminal,
 599                            window,
 600                            cx,
 601                        )
 602                    }
 603                });
 604                if let Ok(task) = task {
 605                    tx.send(task.await).ok();
 606                }
 607            }),
 608        );
 609
 610        cx.spawn(async move |_, _| rx.await?)
 611    }
 612
 613    fn spawn_in_new_terminal(
 614        &mut self,
 615        spawn_task: SpawnInTerminal,
 616        window: &mut Window,
 617        cx: &mut Context<Self>,
 618    ) -> Task<Result<WeakEntity<Terminal>>> {
 619        let reveal = spawn_task.reveal;
 620        let reveal_target = spawn_task.reveal_target;
 621        match reveal_target {
 622            RevealTarget::Center => self
 623                .workspace
 624                .update(cx, |workspace, cx| {
 625                    Self::add_center_terminal(workspace, window, cx, |project, cx| {
 626                        project.create_terminal_task(spawn_task, cx)
 627                    })
 628                })
 629                .unwrap_or_else(|e| Task::ready(Err(e))),
 630            RevealTarget::Dock => self.add_terminal_task(spawn_task, reveal, window, cx),
 631        }
 632    }
 633
 634    /// Create a new Terminal in the current working directory or the user's home directory
 635    fn new_terminal(
 636        workspace: &mut Workspace,
 637        _: &workspace::NewTerminal,
 638        window: &mut Window,
 639        cx: &mut Context<Workspace>,
 640    ) {
 641        let Some(terminal_panel) = workspace.panel::<Self>(cx) else {
 642            return;
 643        };
 644
 645        terminal_panel
 646            .update(cx, |this, cx| {
 647                this.add_terminal_shell(
 648                    default_working_directory(workspace, cx),
 649                    RevealStrategy::Always,
 650                    window,
 651                    cx,
 652                )
 653            })
 654            .detach_and_log_err(cx);
 655    }
 656
 657    fn terminals_for_task(
 658        &self,
 659        label: &str,
 660        cx: &mut App,
 661    ) -> Vec<(usize, Entity<Pane>, Entity<TerminalView>)> {
 662        let Some(workspace) = self.workspace.upgrade() else {
 663            return Vec::new();
 664        };
 665
 666        let pane_terminal_views = |pane: Entity<Pane>| {
 667            pane.read(cx)
 668                .items()
 669                .enumerate()
 670                .filter_map(|(index, item)| Some((index, item.act_as::<TerminalView>(cx)?)))
 671                .filter_map(|(index, terminal_view)| {
 672                    let task_state = terminal_view.read(cx).terminal().read(cx).task()?;
 673                    if &task_state.spawned_task.full_label == label {
 674                        Some((index, terminal_view))
 675                    } else {
 676                        None
 677                    }
 678                })
 679                .map(move |(index, terminal_view)| (index, pane.clone(), terminal_view))
 680        };
 681
 682        self.center
 683            .panes()
 684            .into_iter()
 685            .cloned()
 686            .flat_map(pane_terminal_views)
 687            .chain(
 688                workspace
 689                    .read(cx)
 690                    .panes()
 691                    .iter()
 692                    .cloned()
 693                    .flat_map(pane_terminal_views),
 694            )
 695            .sorted_by_key(|(_, _, terminal_view)| terminal_view.entity_id())
 696            .collect()
 697    }
 698
 699    fn activate_terminal_view(
 700        &self,
 701        pane: &Entity<Pane>,
 702        item_index: usize,
 703        focus: bool,
 704        window: &mut Window,
 705        cx: &mut App,
 706    ) {
 707        pane.update(cx, |pane, cx| {
 708            pane.activate_item(item_index, true, focus, window, cx)
 709        })
 710    }
 711
 712    pub fn add_center_terminal(
 713        workspace: &mut Workspace,
 714        window: &mut Window,
 715        cx: &mut Context<Workspace>,
 716        create_terminal: impl FnOnce(
 717            &mut Project,
 718            &mut Context<Project>,
 719        ) -> Task<Result<Entity<Terminal>>>
 720        + 'static,
 721    ) -> Task<Result<WeakEntity<Terminal>>> {
 722        if !is_enabled_in_workspace(workspace, cx) {
 723            return Task::ready(Err(anyhow!(
 724                "terminal not yet supported for remote projects"
 725            )));
 726        }
 727        let project = workspace.project().downgrade();
 728        cx.spawn_in(window, async move |workspace, cx| {
 729            let terminal = project.update(cx, create_terminal)?.await?;
 730
 731            workspace.update_in(cx, |workspace, window, cx| {
 732                let terminal_view = cx.new(|cx| {
 733                    TerminalView::new(
 734                        terminal.clone(),
 735                        workspace.weak_handle(),
 736                        workspace.database_id(),
 737                        workspace.project().downgrade(),
 738                        window,
 739                        cx,
 740                    )
 741                });
 742                workspace.add_item_to_active_pane(Box::new(terminal_view), None, true, window, cx);
 743            })?;
 744            Ok(terminal.downgrade())
 745        })
 746    }
 747
 748    pub fn add_terminal_task(
 749        &mut self,
 750        task: SpawnInTerminal,
 751        reveal_strategy: RevealStrategy,
 752        window: &mut Window,
 753        cx: &mut Context<Self>,
 754    ) -> Task<Result<WeakEntity<Terminal>>> {
 755        let workspace = self.workspace.clone();
 756        cx.spawn_in(window, async move |terminal_panel, cx| {
 757            if workspace.update(cx, |workspace, cx| !is_enabled_in_workspace(workspace, cx))? {
 758                anyhow::bail!("terminal not yet supported for remote projects");
 759            }
 760            let pane = terminal_panel.update(cx, |terminal_panel, _| {
 761                terminal_panel.pending_terminals_to_add += 1;
 762                terminal_panel.active_pane.clone()
 763            })?;
 764            let project = workspace.read_with(cx, |workspace, _| workspace.project().clone())?;
 765            let terminal = project
 766                .update(cx, |project, cx| project.create_terminal_task(task, cx))?
 767                .await?;
 768            let result = workspace.update_in(cx, |workspace, window, cx| {
 769                let terminal_view = Box::new(cx.new(|cx| {
 770                    TerminalView::new(
 771                        terminal.clone(),
 772                        workspace.weak_handle(),
 773                        workspace.database_id(),
 774                        workspace.project().downgrade(),
 775                        window,
 776                        cx,
 777                    )
 778                }));
 779
 780                match reveal_strategy {
 781                    RevealStrategy::Always => {
 782                        workspace.focus_panel::<Self>(window, cx);
 783                    }
 784                    RevealStrategy::NoFocus => {
 785                        workspace.open_panel::<Self>(window, cx);
 786                    }
 787                    RevealStrategy::Never => {}
 788                }
 789
 790                pane.update(cx, |pane, cx| {
 791                    let focus = pane.has_focus(window, cx)
 792                        || matches!(reveal_strategy, RevealStrategy::Always);
 793                    pane.add_item(terminal_view, true, focus, None, window, cx);
 794                });
 795
 796                Ok(terminal.downgrade())
 797            })?;
 798            terminal_panel.update(cx, |terminal_panel, cx| {
 799                terminal_panel.pending_terminals_to_add =
 800                    terminal_panel.pending_terminals_to_add.saturating_sub(1);
 801                terminal_panel.serialize(cx)
 802            })?;
 803            result
 804        })
 805    }
 806
 807    fn add_terminal_shell(
 808        &mut self,
 809        cwd: Option<PathBuf>,
 810        reveal_strategy: RevealStrategy,
 811        window: &mut Window,
 812        cx: &mut Context<Self>,
 813    ) -> Task<Result<WeakEntity<Terminal>>> {
 814        let workspace = self.workspace.clone();
 815
 816        cx.spawn_in(window, async move |terminal_panel, cx| {
 817            if workspace.update(cx, |workspace, cx| !is_enabled_in_workspace(workspace, cx))? {
 818                anyhow::bail!("terminal not yet supported for collaborative projects");
 819            }
 820            let pane = terminal_panel.update(cx, |terminal_panel, _| {
 821                terminal_panel.pending_terminals_to_add += 1;
 822                terminal_panel.active_pane.clone()
 823            })?;
 824            let project = workspace.read_with(cx, |workspace, _| workspace.project().clone())?;
 825            let terminal = project
 826                .update(cx, |project, cx| project.create_terminal_shell(cwd, cx))?
 827                .await;
 828
 829            match terminal {
 830                Ok(terminal) => {
 831                    let result = workspace.update_in(cx, |workspace, window, cx| {
 832                        let terminal_view = Box::new(cx.new(|cx| {
 833                            TerminalView::new(
 834                                terminal.clone(),
 835                                workspace.weak_handle(),
 836                                workspace.database_id(),
 837                                workspace.project().downgrade(),
 838                                window,
 839                                cx,
 840                            )
 841                        }));
 842
 843                        match reveal_strategy {
 844                            RevealStrategy::Always => {
 845                                workspace.focus_panel::<Self>(window, cx);
 846                            }
 847                            RevealStrategy::NoFocus => {
 848                                workspace.open_panel::<Self>(window, cx);
 849                            }
 850                            RevealStrategy::Never => {}
 851                        }
 852
 853                        pane.update(cx, |pane, cx| {
 854                            let focus = pane.has_focus(window, cx)
 855                                || matches!(reveal_strategy, RevealStrategy::Always);
 856                            pane.add_item(terminal_view, true, focus, None, window, cx);
 857                        });
 858
 859                        Ok(terminal.downgrade())
 860                    })?;
 861                    terminal_panel.update(cx, |terminal_panel, cx| {
 862                        terminal_panel.pending_terminals_to_add =
 863                            terminal_panel.pending_terminals_to_add.saturating_sub(1);
 864                        terminal_panel.serialize(cx)
 865                    })?;
 866                    result
 867                }
 868                Err(error) => {
 869                    pane.update_in(cx, |pane, window, cx| {
 870                        let focus = pane.has_focus(window, cx);
 871                        let failed_to_spawn = cx.new(|cx| FailedToSpawnTerminal {
 872                            error: error.to_string(),
 873                            focus_handle: cx.focus_handle(),
 874                        });
 875                        pane.add_item(Box::new(failed_to_spawn), true, focus, None, window, cx);
 876                    })?;
 877                    Err(error)
 878                }
 879            }
 880        })
 881    }
 882
 883    fn serialize(&mut self, cx: &mut Context<Self>) {
 884        let height = self.height;
 885        let width = self.width;
 886        let Some(serialization_key) = self
 887            .workspace
 888            .read_with(cx, |workspace, _| {
 889                TerminalPanel::serialization_key(workspace)
 890            })
 891            .ok()
 892            .flatten()
 893        else {
 894            return;
 895        };
 896        self.pending_serialization = cx.spawn(async move |terminal_panel, cx| {
 897            cx.background_executor()
 898                .timer(Duration::from_millis(50))
 899                .await;
 900            let terminal_panel = terminal_panel.upgrade()?;
 901            let items = terminal_panel
 902                .update(cx, |terminal_panel, cx| {
 903                    SerializedItems::WithSplits(serialize_pane_group(
 904                        &terminal_panel.center,
 905                        &terminal_panel.active_pane,
 906                        cx,
 907                    ))
 908                })
 909                .ok()?;
 910            cx.background_spawn(
 911                async move {
 912                    KEY_VALUE_STORE
 913                        .write_kvp(
 914                            serialization_key,
 915                            serde_json::to_string(&SerializedTerminalPanel {
 916                                items,
 917                                active_item_id: None,
 918                                height,
 919                                width,
 920                            })?,
 921                        )
 922                        .await?;
 923                    anyhow::Ok(())
 924                }
 925                .log_err(),
 926            )
 927            .await;
 928            Some(())
 929        });
 930    }
 931
 932    fn replace_terminal(
 933        &self,
 934        spawn_task: SpawnInTerminal,
 935        task_pane: Entity<Pane>,
 936        terminal_item_index: usize,
 937        terminal_to_replace: Entity<TerminalView>,
 938        window: &mut Window,
 939        cx: &mut Context<Self>,
 940    ) -> Task<Result<WeakEntity<Terminal>>> {
 941        let reveal = spawn_task.reveal;
 942        let reveal_target = spawn_task.reveal_target;
 943        let task_workspace = self.workspace.clone();
 944        cx.spawn_in(window, async move |terminal_panel, cx| {
 945            let project = terminal_panel.update(cx, |this, cx| {
 946                this.workspace
 947                    .update(cx, |workspace, _| workspace.project().clone())
 948            })??;
 949            let new_terminal = project
 950                .update(cx, |project, cx| {
 951                    project.create_terminal_task(spawn_task, cx)
 952                })?
 953                .await?;
 954            terminal_to_replace.update_in(cx, |terminal_to_replace, window, cx| {
 955                terminal_to_replace.set_terminal(new_terminal.clone(), window, cx);
 956            })?;
 957
 958            match reveal {
 959                RevealStrategy::Always => match reveal_target {
 960                    RevealTarget::Center => {
 961                        task_workspace.update_in(cx, |workspace, window, cx| {
 962                            let did_activate = workspace.activate_item(
 963                                &terminal_to_replace,
 964                                true,
 965                                true,
 966                                window,
 967                                cx,
 968                            );
 969
 970                            anyhow::ensure!(did_activate, "Failed to retrieve terminal pane");
 971
 972                            anyhow::Ok(())
 973                        })??;
 974                    }
 975                    RevealTarget::Dock => {
 976                        terminal_panel.update_in(cx, |terminal_panel, window, cx| {
 977                            terminal_panel.activate_terminal_view(
 978                                &task_pane,
 979                                terminal_item_index,
 980                                true,
 981                                window,
 982                                cx,
 983                            )
 984                        })?;
 985
 986                        cx.spawn(async move |cx| {
 987                            task_workspace
 988                                .update_in(cx, |workspace, window, cx| {
 989                                    workspace.focus_panel::<Self>(window, cx)
 990                                })
 991                                .ok()
 992                        })
 993                        .detach();
 994                    }
 995                },
 996                RevealStrategy::NoFocus => match reveal_target {
 997                    RevealTarget::Center => {
 998                        task_workspace.update_in(cx, |workspace, window, cx| {
 999                            workspace.active_pane().focus_handle(cx).focus(window);
1000                        })?;
1001                    }
1002                    RevealTarget::Dock => {
1003                        terminal_panel.update_in(cx, |terminal_panel, window, cx| {
1004                            terminal_panel.activate_terminal_view(
1005                                &task_pane,
1006                                terminal_item_index,
1007                                false,
1008                                window,
1009                                cx,
1010                            )
1011                        })?;
1012
1013                        cx.spawn(async move |cx| {
1014                            task_workspace
1015                                .update_in(cx, |workspace, window, cx| {
1016                                    workspace.open_panel::<Self>(window, cx)
1017                                })
1018                                .ok()
1019                        })
1020                        .detach();
1021                    }
1022                },
1023                RevealStrategy::Never => {}
1024            }
1025
1026            Ok(new_terminal.downgrade())
1027        })
1028    }
1029
1030    fn has_no_terminals(&self, cx: &App) -> bool {
1031        self.active_pane.read(cx).items_len() == 0 && self.pending_terminals_to_add == 0
1032    }
1033
1034    pub fn assistant_enabled(&self) -> bool {
1035        self.assistant_enabled
1036    }
1037
1038    fn is_enabled(&self, cx: &App) -> bool {
1039        self.workspace
1040            .upgrade()
1041            .is_some_and(|workspace| is_enabled_in_workspace(workspace.read(cx), cx))
1042    }
1043
1044    fn activate_pane_in_direction(
1045        &mut self,
1046        direction: SplitDirection,
1047        window: &mut Window,
1048        cx: &mut Context<Self>,
1049    ) {
1050        if let Some(pane) = self
1051            .center
1052            .find_pane_in_direction(&self.active_pane, direction, cx)
1053        {
1054            window.focus(&pane.focus_handle(cx));
1055        } else {
1056            self.workspace
1057                .update(cx, |workspace, cx| {
1058                    workspace.activate_pane_in_direction(direction, window, cx)
1059                })
1060                .ok();
1061        }
1062    }
1063
1064    fn swap_pane_in_direction(&mut self, direction: SplitDirection, cx: &mut Context<Self>) {
1065        if let Some(to) = self
1066            .center
1067            .find_pane_in_direction(&self.active_pane, direction, cx)
1068            .cloned()
1069        {
1070            self.center.swap(&self.active_pane, &to);
1071            cx.notify();
1072        }
1073    }
1074
1075    fn move_pane_to_border(&mut self, direction: SplitDirection, cx: &mut Context<Self>) {
1076        if self
1077            .center
1078            .move_to_border(&self.active_pane, direction)
1079            .unwrap()
1080        {
1081            cx.notify();
1082        }
1083    }
1084}
1085
1086fn is_enabled_in_workspace(workspace: &Workspace, cx: &App) -> bool {
1087    workspace.project().read(cx).supports_terminal(cx)
1088}
1089
1090pub fn new_terminal_pane(
1091    workspace: WeakEntity<Workspace>,
1092    project: Entity<Project>,
1093    zoomed: bool,
1094    window: &mut Window,
1095    cx: &mut Context<TerminalPanel>,
1096) -> Entity<Pane> {
1097    let is_local = project.read(cx).is_local();
1098    let terminal_panel = cx.entity();
1099    let pane = cx.new(|cx| {
1100        let mut pane = Pane::new(
1101            workspace.clone(),
1102            project.clone(),
1103            Default::default(),
1104            None,
1105            NewTerminal.boxed_clone(),
1106            false,
1107            window,
1108            cx,
1109        );
1110        pane.set_zoomed(zoomed, cx);
1111        pane.set_can_navigate(false, cx);
1112        pane.display_nav_history_buttons(None);
1113        pane.set_should_display_tab_bar(|_, _| true);
1114        pane.set_zoom_out_on_close(false);
1115
1116        let split_closure_terminal_panel = terminal_panel.downgrade();
1117        pane.set_can_split(Some(Arc::new(move |pane, dragged_item, _window, cx| {
1118            if let Some(tab) = dragged_item.downcast_ref::<DraggedTab>() {
1119                let is_current_pane = tab.pane == cx.entity();
1120                let Some(can_drag_away) = split_closure_terminal_panel
1121                    .read_with(cx, |terminal_panel, _| {
1122                        let current_panes = terminal_panel.center.panes();
1123                        !current_panes.contains(&&tab.pane)
1124                            || current_panes.len() > 1
1125                            || (!is_current_pane || pane.items_len() > 1)
1126                    })
1127                    .ok()
1128                else {
1129                    return false;
1130                };
1131                if can_drag_away {
1132                    let item = if is_current_pane {
1133                        pane.item_for_index(tab.ix)
1134                    } else {
1135                        tab.pane.read(cx).item_for_index(tab.ix)
1136                    };
1137                    if let Some(item) = item {
1138                        return item.downcast::<TerminalView>().is_some();
1139                    }
1140                }
1141            }
1142            false
1143        })));
1144
1145        let buffer_search_bar = cx.new(|cx| {
1146            search::BufferSearchBar::new(Some(project.read(cx).languages().clone()), window, cx)
1147        });
1148        let breadcrumbs = cx.new(|_| Breadcrumbs::new());
1149        pane.toolbar().update(cx, |toolbar, cx| {
1150            toolbar.add_item(buffer_search_bar, window, cx);
1151            toolbar.add_item(breadcrumbs, window, cx);
1152        });
1153
1154        let drop_closure_project = project.downgrade();
1155        let drop_closure_terminal_panel = terminal_panel.downgrade();
1156        pane.set_custom_drop_handle(cx, move |pane, dropped_item, window, cx| {
1157            let Some(project) = drop_closure_project.upgrade() else {
1158                return ControlFlow::Break(());
1159            };
1160            if let Some(tab) = dropped_item.downcast_ref::<DraggedTab>() {
1161                let this_pane = cx.entity();
1162                let item = if tab.pane == this_pane {
1163                    pane.item_for_index(tab.ix)
1164                } else {
1165                    tab.pane.read(cx).item_for_index(tab.ix)
1166                };
1167                if let Some(item) = item {
1168                    if item.downcast::<TerminalView>().is_some() {
1169                        let source = tab.pane.clone();
1170                        let item_id_to_move = item.item_id();
1171
1172                        let Ok(new_split_pane) = pane
1173                            .drag_split_direction()
1174                            .map(|split_direction| {
1175                                drop_closure_terminal_panel.update(cx, |terminal_panel, cx| {
1176                                    let is_zoomed = if terminal_panel.active_pane == this_pane {
1177                                        pane.is_zoomed()
1178                                    } else {
1179                                        terminal_panel.active_pane.read(cx).is_zoomed()
1180                                    };
1181                                    let new_pane = new_terminal_pane(
1182                                        workspace.clone(),
1183                                        project.clone(),
1184                                        is_zoomed,
1185                                        window,
1186                                        cx,
1187                                    );
1188                                    terminal_panel.apply_tab_bar_buttons(&new_pane, cx);
1189                                    terminal_panel.center.split(
1190                                        &this_pane,
1191                                        &new_pane,
1192                                        split_direction,
1193                                    )?;
1194                                    anyhow::Ok(new_pane)
1195                                })
1196                            })
1197                            .transpose()
1198                        else {
1199                            return ControlFlow::Break(());
1200                        };
1201
1202                        match new_split_pane.transpose() {
1203                            // Source pane may be the one currently updated, so defer the move.
1204                            Ok(Some(new_pane)) => cx
1205                                .spawn_in(window, async move |_, cx| {
1206                                    cx.update(|window, cx| {
1207                                        move_item(
1208                                            &source,
1209                                            &new_pane,
1210                                            item_id_to_move,
1211                                            new_pane.read(cx).active_item_index(),
1212                                            true,
1213                                            window,
1214                                            cx,
1215                                        );
1216                                    })
1217                                    .ok();
1218                                })
1219                                .detach(),
1220                            // If we drop into existing pane or current pane,
1221                            // regular pane drop handler will take care of it,
1222                            // using the right tab index for the operation.
1223                            Ok(None) => return ControlFlow::Continue(()),
1224                            err @ Err(_) => {
1225                                err.log_err();
1226                                return ControlFlow::Break(());
1227                            }
1228                        };
1229                    } else if let Some(project_path) = item.project_path(cx)
1230                        && let Some(entry_path) = project.read(cx).absolute_path(&project_path, cx)
1231                    {
1232                        add_paths_to_terminal(pane, &[entry_path], window, cx);
1233                    }
1234                }
1235            } else if let Some(selection) = dropped_item.downcast_ref::<DraggedSelection>() {
1236                let project = project.read(cx);
1237                let paths_to_add = selection
1238                    .items()
1239                    .map(|selected_entry| selected_entry.entry_id)
1240                    .filter_map(|entry_id| project.path_for_entry(entry_id, cx))
1241                    .filter_map(|project_path| project.absolute_path(&project_path, cx))
1242                    .collect::<Vec<_>>();
1243                if !paths_to_add.is_empty() {
1244                    add_paths_to_terminal(pane, &paths_to_add, window, cx);
1245                }
1246            } else if let Some(&entry_id) = dropped_item.downcast_ref::<ProjectEntryId>() {
1247                if let Some(entry_path) = project
1248                    .read(cx)
1249                    .path_for_entry(entry_id, cx)
1250                    .and_then(|project_path| project.read(cx).absolute_path(&project_path, cx))
1251                {
1252                    add_paths_to_terminal(pane, &[entry_path], window, cx);
1253                }
1254            } else if is_local && let Some(paths) = dropped_item.downcast_ref::<ExternalPaths>() {
1255                add_paths_to_terminal(pane, paths.paths(), window, cx);
1256            }
1257
1258            ControlFlow::Break(())
1259        });
1260
1261        pane
1262    });
1263
1264    cx.subscribe_in(&pane, window, TerminalPanel::handle_pane_event)
1265        .detach();
1266    cx.observe(&pane, |_, _, cx| cx.notify()).detach();
1267
1268    pane
1269}
1270
1271async fn wait_for_terminals_tasks(
1272    terminals_for_task: Vec<(usize, Entity<Pane>, Entity<TerminalView>)>,
1273    cx: &mut AsyncApp,
1274) {
1275    let pending_tasks = terminals_for_task.iter().filter_map(|(_, _, terminal)| {
1276        terminal
1277            .update(cx, |terminal_view, cx| {
1278                terminal_view
1279                    .terminal()
1280                    .update(cx, |terminal, cx| terminal.wait_for_completed_task(cx))
1281            })
1282            .ok()
1283    });
1284    join_all(pending_tasks).await;
1285}
1286
1287fn add_paths_to_terminal(
1288    pane: &mut Pane,
1289    paths: &[PathBuf],
1290    window: &mut Window,
1291    cx: &mut Context<Pane>,
1292) {
1293    if let Some(terminal_view) = pane
1294        .active_item()
1295        .and_then(|item| item.downcast::<TerminalView>())
1296    {
1297        window.focus(&terminal_view.focus_handle(cx));
1298        let mut new_text = paths.iter().map(|path| format!(" {path:?}")).join("");
1299        new_text.push(' ');
1300        terminal_view.update(cx, |terminal_view, cx| {
1301            terminal_view.terminal().update(cx, |terminal, _| {
1302                terminal.paste(&new_text);
1303            });
1304        });
1305    }
1306}
1307
1308struct FailedToSpawnTerminal {
1309    error: String,
1310    focus_handle: FocusHandle,
1311}
1312
1313impl Focusable for FailedToSpawnTerminal {
1314    fn focus_handle(&self, _: &App) -> FocusHandle {
1315        self.focus_handle.clone()
1316    }
1317}
1318
1319impl Render for FailedToSpawnTerminal {
1320    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
1321        let popover_menu = PopoverMenu::new("settings-popover")
1322            .trigger(
1323                IconButton::new("icon-button-popover", IconName::ChevronDown)
1324                    .icon_size(IconSize::XSmall),
1325            )
1326            .menu(move |window, cx| {
1327                Some(ContextMenu::build(window, cx, |context_menu, _, _| {
1328                    context_menu
1329                        .action("Open Settings", zed_actions::OpenSettings.boxed_clone())
1330                        .action(
1331                            "Edit settings.json",
1332                            zed_actions::OpenSettingsFile.boxed_clone(),
1333                        )
1334                }))
1335            })
1336            .anchor(Corner::TopRight)
1337            .offset(gpui::Point {
1338                x: px(0.0),
1339                y: px(2.0),
1340            });
1341
1342        v_flex()
1343            .track_focus(&self.focus_handle)
1344            .size_full()
1345            .p_4()
1346            .items_center()
1347            .justify_center()
1348            .bg(cx.theme().colors().editor_background)
1349            .child(
1350                v_flex()
1351                    .max_w_112()
1352                    .items_center()
1353                    .justify_center()
1354                    .text_center()
1355                    .child(Label::new("Failed to spawn terminal"))
1356                    .child(
1357                        Label::new(self.error.to_string())
1358                            .size(LabelSize::Small)
1359                            .color(Color::Muted)
1360                            .mb_4(),
1361                    )
1362                    .child(SplitButton::new(
1363                        ButtonLike::new("open-settings-ui")
1364                            .child(Label::new("Edit Settings").size(LabelSize::Small))
1365                            .on_click(|_, window, cx| {
1366                                window.dispatch_action(zed_actions::OpenSettings.boxed_clone(), cx);
1367                            }),
1368                        popover_menu.into_any_element(),
1369                    )),
1370            )
1371    }
1372}
1373
1374impl EventEmitter<()> for FailedToSpawnTerminal {}
1375
1376impl workspace::Item for FailedToSpawnTerminal {
1377    type Event = ();
1378
1379    fn tab_content_text(&self, _detail: usize, _cx: &App) -> SharedString {
1380        SharedString::new_static("Failed to spawn terminal")
1381    }
1382}
1383
1384impl EventEmitter<PanelEvent> for TerminalPanel {}
1385
1386impl Render for TerminalPanel {
1387    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
1388        let mut registrar = DivRegistrar::new(
1389            |panel, _, cx| {
1390                panel
1391                    .active_pane
1392                    .read(cx)
1393                    .toolbar()
1394                    .read(cx)
1395                    .item_of_type::<BufferSearchBar>()
1396            },
1397            cx,
1398        );
1399        BufferSearchBar::register(&mut registrar);
1400        let registrar = registrar.into_div();
1401        self.workspace
1402            .update(cx, |workspace, cx| {
1403                registrar.size_full().child(self.center.render(
1404                    workspace.zoomed_item(),
1405                    &workspace::PaneRenderContext {
1406                        follower_states: &HashMap::default(),
1407                        active_call: workspace.active_call(),
1408                        active_pane: &self.active_pane,
1409                        app_state: workspace.app_state(),
1410                        project: workspace.project(),
1411                        workspace: &workspace.weak_handle(),
1412                    },
1413                    window,
1414                    cx,
1415                ))
1416            })
1417            .ok()
1418            .map(|div| {
1419                div.on_action({
1420                    cx.listener(|terminal_panel, _: &ActivatePaneLeft, window, cx| {
1421                        terminal_panel.activate_pane_in_direction(SplitDirection::Left, window, cx);
1422                    })
1423                })
1424                .on_action({
1425                    cx.listener(|terminal_panel, _: &ActivatePaneRight, window, cx| {
1426                        terminal_panel.activate_pane_in_direction(
1427                            SplitDirection::Right,
1428                            window,
1429                            cx,
1430                        );
1431                    })
1432                })
1433                .on_action({
1434                    cx.listener(|terminal_panel, _: &ActivatePaneUp, window, cx| {
1435                        terminal_panel.activate_pane_in_direction(SplitDirection::Up, window, cx);
1436                    })
1437                })
1438                .on_action({
1439                    cx.listener(|terminal_panel, _: &ActivatePaneDown, window, cx| {
1440                        terminal_panel.activate_pane_in_direction(SplitDirection::Down, window, cx);
1441                    })
1442                })
1443                .on_action(
1444                    cx.listener(|terminal_panel, _action: &ActivateNextPane, window, cx| {
1445                        let panes = terminal_panel.center.panes();
1446                        if let Some(ix) = panes
1447                            .iter()
1448                            .position(|pane| **pane == terminal_panel.active_pane)
1449                        {
1450                            let next_ix = (ix + 1) % panes.len();
1451                            window.focus(&panes[next_ix].focus_handle(cx));
1452                        }
1453                    }),
1454                )
1455                .on_action(cx.listener(
1456                    |terminal_panel, _action: &ActivatePreviousPane, window, cx| {
1457                        let panes = terminal_panel.center.panes();
1458                        if let Some(ix) = panes
1459                            .iter()
1460                            .position(|pane| **pane == terminal_panel.active_pane)
1461                        {
1462                            let prev_ix = cmp::min(ix.wrapping_sub(1), panes.len() - 1);
1463                            window.focus(&panes[prev_ix].focus_handle(cx));
1464                        }
1465                    },
1466                ))
1467                .on_action(
1468                    cx.listener(|terminal_panel, action: &ActivatePane, window, cx| {
1469                        let panes = terminal_panel.center.panes();
1470                        if let Some(&pane) = panes.get(action.0) {
1471                            window.focus(&pane.read(cx).focus_handle(cx));
1472                        } else {
1473                            let future =
1474                                terminal_panel.new_pane_with_cloned_active_terminal(window, cx);
1475                            cx.spawn_in(window, async move |terminal_panel, cx| {
1476                                if let Some(new_pane) = future.await {
1477                                    _ = terminal_panel.update_in(
1478                                        cx,
1479                                        |terminal_panel, window, cx| {
1480                                            terminal_panel
1481                                                .center
1482                                                .split(
1483                                                    &terminal_panel.active_pane,
1484                                                    &new_pane,
1485                                                    SplitDirection::Right,
1486                                                )
1487                                                .log_err();
1488                                            let new_pane = new_pane.read(cx);
1489                                            window.focus(&new_pane.focus_handle(cx));
1490                                        },
1491                                    );
1492                                }
1493                            })
1494                            .detach();
1495                        }
1496                    }),
1497                )
1498                .on_action(cx.listener(|terminal_panel, _: &SwapPaneLeft, _, cx| {
1499                    terminal_panel.swap_pane_in_direction(SplitDirection::Left, cx);
1500                }))
1501                .on_action(cx.listener(|terminal_panel, _: &SwapPaneRight, _, cx| {
1502                    terminal_panel.swap_pane_in_direction(SplitDirection::Right, cx);
1503                }))
1504                .on_action(cx.listener(|terminal_panel, _: &SwapPaneUp, _, cx| {
1505                    terminal_panel.swap_pane_in_direction(SplitDirection::Up, cx);
1506                }))
1507                .on_action(cx.listener(|terminal_panel, _: &SwapPaneDown, _, cx| {
1508                    terminal_panel.swap_pane_in_direction(SplitDirection::Down, cx);
1509                }))
1510                .on_action(cx.listener(|terminal_panel, _: &MovePaneLeft, _, cx| {
1511                    terminal_panel.move_pane_to_border(SplitDirection::Left, cx);
1512                }))
1513                .on_action(cx.listener(|terminal_panel, _: &MovePaneRight, _, cx| {
1514                    terminal_panel.move_pane_to_border(SplitDirection::Right, cx);
1515                }))
1516                .on_action(cx.listener(|terminal_panel, _: &MovePaneUp, _, cx| {
1517                    terminal_panel.move_pane_to_border(SplitDirection::Up, cx);
1518                }))
1519                .on_action(cx.listener(|terminal_panel, _: &MovePaneDown, _, cx| {
1520                    terminal_panel.move_pane_to_border(SplitDirection::Down, cx);
1521                }))
1522                .on_action(
1523                    cx.listener(|terminal_panel, action: &MoveItemToPane, window, cx| {
1524                        let Some(&target_pane) =
1525                            terminal_panel.center.panes().get(action.destination)
1526                        else {
1527                            return;
1528                        };
1529                        move_active_item(
1530                            &terminal_panel.active_pane,
1531                            target_pane,
1532                            action.focus,
1533                            true,
1534                            window,
1535                            cx,
1536                        );
1537                    }),
1538                )
1539                .on_action(cx.listener(
1540                    |terminal_panel, action: &MoveItemToPaneInDirection, window, cx| {
1541                        let source_pane = &terminal_panel.active_pane;
1542                        if let Some(destination_pane) = terminal_panel
1543                            .center
1544                            .find_pane_in_direction(source_pane, action.direction, cx)
1545                        {
1546                            move_active_item(
1547                                source_pane,
1548                                destination_pane,
1549                                action.focus,
1550                                true,
1551                                window,
1552                                cx,
1553                            );
1554                        };
1555                    },
1556                ))
1557            })
1558            .unwrap_or_else(|| div())
1559    }
1560}
1561
1562impl Focusable for TerminalPanel {
1563    fn focus_handle(&self, cx: &App) -> FocusHandle {
1564        self.active_pane.focus_handle(cx)
1565    }
1566}
1567
1568impl Panel for TerminalPanel {
1569    fn position(&self, _window: &Window, cx: &App) -> DockPosition {
1570        match TerminalSettings::get_global(cx).dock {
1571            TerminalDockPosition::Left => DockPosition::Left,
1572            TerminalDockPosition::Bottom => DockPosition::Bottom,
1573            TerminalDockPosition::Right => DockPosition::Right,
1574        }
1575    }
1576
1577    fn position_is_valid(&self, _: DockPosition) -> bool {
1578        true
1579    }
1580
1581    fn set_position(
1582        &mut self,
1583        position: DockPosition,
1584        _window: &mut Window,
1585        cx: &mut Context<Self>,
1586    ) {
1587        settings::update_settings_file(self.fs.clone(), cx, move |settings, _| {
1588            let dock = match position {
1589                DockPosition::Left => TerminalDockPosition::Left,
1590                DockPosition::Bottom => TerminalDockPosition::Bottom,
1591                DockPosition::Right => TerminalDockPosition::Right,
1592            };
1593            settings.terminal.get_or_insert_default().dock = Some(dock);
1594        });
1595    }
1596
1597    fn size(&self, window: &Window, cx: &App) -> Pixels {
1598        let settings = TerminalSettings::get_global(cx);
1599        match self.position(window, cx) {
1600            DockPosition::Left | DockPosition::Right => {
1601                self.width.unwrap_or(settings.default_width)
1602            }
1603            DockPosition::Bottom => self.height.unwrap_or(settings.default_height),
1604        }
1605    }
1606
1607    fn set_size(&mut self, size: Option<Pixels>, window: &mut Window, cx: &mut Context<Self>) {
1608        match self.position(window, cx) {
1609            DockPosition::Left | DockPosition::Right => self.width = size,
1610            DockPosition::Bottom => self.height = size,
1611        }
1612        cx.notify();
1613        cx.defer_in(window, |this, _, cx| {
1614            this.serialize(cx);
1615        })
1616    }
1617
1618    fn is_zoomed(&self, _window: &Window, cx: &App) -> bool {
1619        self.active_pane.read(cx).is_zoomed()
1620    }
1621
1622    fn set_zoomed(&mut self, zoomed: bool, _: &mut Window, cx: &mut Context<Self>) {
1623        for pane in self.center.panes() {
1624            pane.update(cx, |pane, cx| {
1625                pane.set_zoomed(zoomed, cx);
1626            })
1627        }
1628        cx.notify();
1629    }
1630
1631    fn set_active(&mut self, active: bool, window: &mut Window, cx: &mut Context<Self>) {
1632        let old_active = self.active;
1633        self.active = active;
1634        if !active || old_active == active || !self.has_no_terminals(cx) {
1635            return;
1636        }
1637        cx.defer_in(window, |this, window, cx| {
1638            let Ok(kind) = this
1639                .workspace
1640                .update(cx, |workspace, cx| default_working_directory(workspace, cx))
1641            else {
1642                return;
1643            };
1644
1645            this.add_terminal_shell(kind, RevealStrategy::Always, window, cx)
1646                .detach_and_log_err(cx)
1647        })
1648    }
1649
1650    fn icon_label(&self, _window: &Window, cx: &App) -> Option<String> {
1651        let count = self
1652            .center
1653            .panes()
1654            .into_iter()
1655            .map(|pane| pane.read(cx).items_len())
1656            .sum::<usize>();
1657        if count == 0 {
1658            None
1659        } else {
1660            Some(count.to_string())
1661        }
1662    }
1663
1664    fn persistent_name() -> &'static str {
1665        "TerminalPanel"
1666    }
1667
1668    fn panel_key() -> &'static str {
1669        TERMINAL_PANEL_KEY
1670    }
1671
1672    fn icon(&self, _window: &Window, cx: &App) -> Option<IconName> {
1673        if (self.is_enabled(cx) || !self.has_no_terminals(cx))
1674            && TerminalSettings::get_global(cx).button
1675        {
1676            Some(IconName::TerminalAlt)
1677        } else {
1678            None
1679        }
1680    }
1681
1682    fn icon_tooltip(&self, _window: &Window, _cx: &App) -> Option<&'static str> {
1683        Some("Terminal Panel")
1684    }
1685
1686    fn toggle_action(&self) -> Box<dyn gpui::Action> {
1687        Box::new(ToggleFocus)
1688    }
1689
1690    fn pane(&self) -> Option<Entity<Pane>> {
1691        Some(self.active_pane.clone())
1692    }
1693
1694    fn activation_priority(&self) -> u32 {
1695        1
1696    }
1697}
1698
1699struct TerminalProvider(Entity<TerminalPanel>);
1700
1701impl workspace::TerminalProvider for TerminalProvider {
1702    fn spawn(
1703        &self,
1704        task: SpawnInTerminal,
1705        window: &mut Window,
1706        cx: &mut App,
1707    ) -> Task<Option<Result<ExitStatus>>> {
1708        let terminal_panel = self.0.clone();
1709        window.spawn(cx, async move |cx| {
1710            let terminal = terminal_panel
1711                .update_in(cx, |terminal_panel, window, cx| {
1712                    terminal_panel.spawn_task(&task, window, cx)
1713                })
1714                .ok()?
1715                .await;
1716            match terminal {
1717                Ok(terminal) => {
1718                    let exit_status = terminal
1719                        .read_with(cx, |terminal, cx| terminal.wait_for_completed_task(cx))
1720                        .ok()?
1721                        .await?;
1722                    Some(Ok(exit_status))
1723                }
1724                Err(e) => Some(Err(e)),
1725            }
1726        })
1727    }
1728}
1729
1730struct InlineAssistTabBarButton {
1731    focus_handle: FocusHandle,
1732}
1733
1734impl Render for InlineAssistTabBarButton {
1735    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
1736        let focus_handle = self.focus_handle.clone();
1737        IconButton::new("terminal_inline_assistant", IconName::ZedAssistant)
1738            .icon_size(IconSize::Small)
1739            .on_click(cx.listener(|_, _, window, cx| {
1740                window.dispatch_action(InlineAssist::default().boxed_clone(), cx);
1741            }))
1742            .tooltip(move |window, cx| {
1743                Tooltip::for_action_in(
1744                    "Inline Assist",
1745                    &InlineAssist::default(),
1746                    &focus_handle,
1747                    window,
1748                    cx,
1749                )
1750            })
1751    }
1752}
1753
1754#[cfg(test)]
1755mod tests {
1756    use std::num::NonZero;
1757
1758    use super::*;
1759    use gpui::{TestAppContext, UpdateGlobal as _};
1760    use pretty_assertions::assert_eq;
1761    use project::FakeFs;
1762    use settings::SettingsStore;
1763
1764    #[gpui::test]
1765    async fn test_spawn_an_empty_task(cx: &mut TestAppContext) {
1766        init_test(cx);
1767
1768        let fs = FakeFs::new(cx.executor());
1769        let project = Project::test(fs, [], cx).await;
1770        let workspace = cx.add_window(|window, cx| Workspace::test_new(project, window, cx));
1771
1772        let (window_handle, terminal_panel) = workspace
1773            .update(cx, |workspace, window, cx| {
1774                let window_handle = window.window_handle();
1775                let terminal_panel = cx.new(|cx| TerminalPanel::new(workspace, window, cx));
1776                (window_handle, terminal_panel)
1777            })
1778            .unwrap();
1779
1780        let task = window_handle
1781            .update(cx, |_, window, cx| {
1782                terminal_panel.update(cx, |terminal_panel, cx| {
1783                    terminal_panel.spawn_task(&SpawnInTerminal::default(), window, cx)
1784                })
1785            })
1786            .unwrap();
1787
1788        let terminal = task.await.unwrap();
1789        let expected_shell = util::get_system_shell();
1790        terminal
1791            .update(cx, |terminal, _| {
1792                let task_metadata = terminal
1793                    .task()
1794                    .expect("When spawning a task, should have the task metadata")
1795                    .spawned_task
1796                    .clone();
1797                assert_eq!(task_metadata.env, HashMap::default());
1798                assert_eq!(task_metadata.cwd, None);
1799                assert_eq!(task_metadata.shell, task::Shell::System);
1800                assert_eq!(
1801                    task_metadata.command,
1802                    Some(expected_shell.clone()),
1803                    "Empty tasks should spawn a -i shell"
1804                );
1805                assert_eq!(task_metadata.args, Vec::<String>::new());
1806                assert_eq!(
1807                    task_metadata.command_label, expected_shell,
1808                    "We show the shell launch for empty commands"
1809                );
1810            })
1811            .unwrap();
1812    }
1813
1814    #[gpui::test]
1815    async fn test_bypass_max_tabs_limit(cx: &mut TestAppContext) {
1816        init_test(cx);
1817
1818        let fs = FakeFs::new(cx.executor());
1819        let project = Project::test(fs, [], cx).await;
1820        let workspace = cx.add_window(|window, cx| Workspace::test_new(project, window, cx));
1821
1822        let (window_handle, terminal_panel) = workspace
1823            .update(cx, |workspace, window, cx| {
1824                let window_handle = window.window_handle();
1825                let terminal_panel = cx.new(|cx| TerminalPanel::new(workspace, window, cx));
1826                (window_handle, terminal_panel)
1827            })
1828            .unwrap();
1829
1830        set_max_tabs(cx, Some(3));
1831
1832        for _ in 0..5 {
1833            let task = window_handle
1834                .update(cx, |_, window, cx| {
1835                    terminal_panel.update(cx, |panel, cx| {
1836                        panel.add_terminal_shell(None, RevealStrategy::Always, window, cx)
1837                    })
1838                })
1839                .unwrap();
1840            task.await.unwrap();
1841        }
1842
1843        cx.run_until_parked();
1844
1845        let item_count =
1846            terminal_panel.read_with(cx, |panel, cx| panel.active_pane.read(cx).items_len());
1847
1848        assert_eq!(
1849            item_count, 5,
1850            "Terminal panel should bypass max_tabs limit and have all 5 terminals"
1851        );
1852    }
1853
1854    // A complex Unix command won't be properly parsed by the Windows terminal hence omit the test there.
1855    #[cfg(unix)]
1856    #[gpui::test]
1857    async fn test_spawn_script_like_task(cx: &mut TestAppContext) {
1858        init_test(cx);
1859
1860        let fs = FakeFs::new(cx.executor());
1861        let project = Project::test(fs, [], cx).await;
1862        let workspace = cx.add_window(|window, cx| Workspace::test_new(project, window, cx));
1863
1864        let (window_handle, terminal_panel) = workspace
1865            .update(cx, |workspace, window, cx| {
1866                let window_handle = window.window_handle();
1867                let terminal_panel = cx.new(|cx| TerminalPanel::new(workspace, window, cx));
1868                (window_handle, terminal_panel)
1869            })
1870            .unwrap();
1871
1872        let user_command = r#"REPO_URL=$(git remote get-url origin | sed -e \"s/^git@\\(.*\\):\\(.*\\)\\.git$/https:\\/\\/\\1\\/\\2/\"); COMMIT_SHA=$(git log -1 --format=\"%H\" -- \"${ZED_RELATIVE_FILE}\"); echo \"${REPO_URL}/blob/${COMMIT_SHA}/${ZED_RELATIVE_FILE}#L${ZED_ROW}-$(echo $(($(wc -l <<< \"$ZED_SELECTED_TEXT\") + $ZED_ROW - 1)))\" | xclip -selection clipboard"#.to_string();
1873
1874        let expected_cwd = PathBuf::from("/some/work");
1875        let task = window_handle
1876            .update(cx, |_, window, cx| {
1877                terminal_panel.update(cx, |terminal_panel, cx| {
1878                    terminal_panel.spawn_task(
1879                        &SpawnInTerminal {
1880                            command: Some(user_command.clone()),
1881                            cwd: Some(expected_cwd.clone()),
1882                            ..SpawnInTerminal::default()
1883                        },
1884                        window,
1885                        cx,
1886                    )
1887                })
1888            })
1889            .unwrap();
1890
1891        let terminal = task.await.unwrap();
1892        let shell = util::get_system_shell();
1893        terminal
1894            .update(cx, |terminal, _| {
1895                let task_metadata = terminal
1896                    .task()
1897                    .expect("When spawning a task, should have the task metadata")
1898                    .spawned_task
1899                    .clone();
1900                assert_eq!(task_metadata.env, HashMap::default());
1901                assert_eq!(task_metadata.cwd, Some(expected_cwd));
1902                assert_eq!(task_metadata.shell, task::Shell::System);
1903                assert_eq!(task_metadata.command, Some(shell.clone()));
1904                assert_eq!(
1905                    task_metadata.args,
1906                    vec!["-i".to_string(), "-c".to_string(), user_command.clone(),],
1907                    "Use command should have been moved into the arguments, as we're spawning a new -i shell",
1908                );
1909                assert_eq!(
1910                    task_metadata.command_label,
1911                    format!("{shell} {interactive}-c '{user_command}'", interactive = if cfg!(windows) {""} else {"-i "}),
1912                    "We want to show to the user the entire command spawned");
1913            })
1914            .unwrap();
1915    }
1916
1917    #[gpui::test]
1918    async fn renders_error_if_default_shell_fails(cx: &mut TestAppContext) {
1919        init_test(cx);
1920
1921        cx.update(|cx| {
1922            SettingsStore::update_global(cx, |store, cx| {
1923                store.update_user_settings(cx, |settings| {
1924                    settings.terminal.get_or_insert_default().project.shell =
1925                        Some(settings::Shell::Program("asdf".to_owned()));
1926                });
1927            });
1928        });
1929
1930        let fs = FakeFs::new(cx.executor());
1931        let project = Project::test(fs, [], cx).await;
1932        let workspace = cx.add_window(|window, cx| Workspace::test_new(project, window, cx));
1933
1934        let (window_handle, terminal_panel) = workspace
1935            .update(cx, |workspace, window, cx| {
1936                let window_handle = window.window_handle();
1937                let terminal_panel = cx.new(|cx| TerminalPanel::new(workspace, window, cx));
1938                (window_handle, terminal_panel)
1939            })
1940            .unwrap();
1941
1942        window_handle
1943            .update(cx, |_, window, cx| {
1944                terminal_panel.update(cx, |terminal_panel, cx| {
1945                    terminal_panel.add_terminal_shell(None, RevealStrategy::Always, window, cx)
1946                })
1947            })
1948            .unwrap()
1949            .await
1950            .unwrap_err();
1951
1952        window_handle
1953            .update(cx, |_, _, cx| {
1954                terminal_panel.update(cx, |terminal_panel, cx| {
1955                    assert!(
1956                        terminal_panel
1957                            .active_pane
1958                            .read(cx)
1959                            .items()
1960                            .any(|item| item.downcast::<FailedToSpawnTerminal>().is_some()),
1961                        "should spawn `FailedToSpawnTerminal` pane"
1962                    );
1963                })
1964            })
1965            .unwrap();
1966    }
1967
1968    fn set_max_tabs(cx: &mut TestAppContext, value: Option<usize>) {
1969        cx.update_global(|store: &mut SettingsStore, cx| {
1970            store.update_user_settings(cx, |settings| {
1971                settings.workspace.max_tabs = value.map(|v| NonZero::new(v).unwrap())
1972            });
1973        });
1974    }
1975
1976    pub fn init_test(cx: &mut TestAppContext) {
1977        cx.update(|cx| {
1978            let store = SettingsStore::test(cx);
1979            cx.set_global(store);
1980            theme::init(theme::LoadThemes::JustBase, cx);
1981            client::init_settings(cx);
1982            language::init(cx);
1983            Project::init_settings(cx);
1984            workspace::init_settings(cx);
1985            editor::init(cx);
1986            crate::init(cx);
1987        });
1988    }
1989}