zed/crates/debugger_ui/src/attach_modal.rs

use dap::{DapRegistry, DebugRequest};
use futures::channel::oneshot;
use fuzzy::{StringMatch, StringMatchCandidate};
use gpui::{AppContext, DismissEvent, Entity, EventEmitter, Focusable, Render, Task, TaskExt};
use gpui::{Subscription, WeakEntity};
use picker::{Picker, PickerDelegate};
use project::Project;
use rpc::proto;
use task::ZedDebugConfig;
use util::debug_panic;

use std::sync::Arc;

use sysinfo::{ProcessRefreshKind, RefreshKind, System, UpdateKind};
use ui::{Context, Tooltip, prelude::*};
use ui::{ListItem, ListItemSpacing};
use workspace::{ModalView, Workspace};

use crate::debugger_panel::DebugPanel;

#[derive(Debug, Clone)]
pub(super) struct Candidate {
    pub(super) pid: u32,
    pub(super) name: SharedString,
    pub(super) command: Vec<String>,
}

pub(crate) enum ModalIntent {
    ResolveProcessId(Option<oneshot::Sender<Option<i32>>>),
    AttachToProcess(ZedDebugConfig),
}

pub(crate) struct AttachModalDelegate {
    selected_index: usize,
    matches: Vec<StringMatch>,
    placeholder_text: Arc<str>,
    pub(crate) intent: ModalIntent,
    workspace: WeakEntity<Workspace>,
    candidates: Arc<[Candidate]>,
}

impl AttachModalDelegate {
    fn new(
        workspace: WeakEntity<Workspace>,
        intent: ModalIntent,
        candidates: Arc<[Candidate]>,
    ) -> Self {
        Self {
            workspace,
            candidates,
            intent,
            selected_index: 0,
            matches: Vec::default(),
            placeholder_text: Arc::from("Select the process you want to attach the debugger to"),
        }
    }
}

pub struct AttachModal {
    _subscription: Subscription,
    pub(crate) picker: Entity<Picker<AttachModalDelegate>>,
}

impl AttachModal {
    pub(crate) fn new(
        intent: ModalIntent,
        workspace: WeakEntity<Workspace>,
        project: Entity<Project>,
        modal: bool,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> Self {
        let processes_task = get_processes_for_project(&project, cx);

        let modal = Self::with_processes(workspace, Arc::new([]), modal, intent, window, cx);

        cx.spawn_in(window, async move |this, cx| {
            let processes = processes_task.await;
            this.update_in(cx, |modal, window, cx| {
                modal.picker.update(cx, |picker, cx| {
                    picker.delegate.candidates = processes;
                    picker.refresh(window, cx);
                });
            })?;
            anyhow::Ok(())
        })
        .detach_and_log_err(cx);

        modal
    }

    pub(super) fn with_processes(
        workspace: WeakEntity<Workspace>,
        processes: Arc<[Candidate]>,
        modal: bool,
        intent: ModalIntent,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> Self {
        let picker = cx.new(|cx| {
            Picker::uniform_list(
                AttachModalDelegate::new(workspace, intent, processes),
                window,
                cx,
            )
            .when(!modal, |picker| picker.embedded())
        });
        Self {
            _subscription: cx.subscribe(&picker, |_, _, _, cx| {
                cx.emit(DismissEvent);
            }),
            picker,
        }
    }
}

impl Render for AttachModal {
    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl ui::IntoElement {
        v_flex()
            .key_context("AttachModal")
            .track_focus(&self.focus_handle(cx))
            .child(self.picker.clone())
    }
}

impl EventEmitter<DismissEvent> for AttachModal {}

impl Focusable for AttachModal {
    fn focus_handle(&self, cx: &App) -> gpui::FocusHandle {
        self.picker.read(cx).focus_handle(cx)
    }
}

impl ModalView for AttachModal {}

impl PickerDelegate for AttachModalDelegate {
    type ListItem = ListItem;

    fn name() -> &'static str {
        "attach modal"
    }

    fn match_count(&self) -> usize {
        self.matches.len()
    }

    fn selected_index(&self) -> usize {
        self.selected_index
    }

    fn set_selected_index(
        &mut self,
        ix: usize,
        _window: &mut Window,
        _: &mut Context<Picker<Self>>,
    ) {
        self.selected_index = ix;
    }

    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> std::sync::Arc<str> {
        self.placeholder_text.clone()
    }

    fn update_matches(
        &mut self,
        query: String,
        _window: &mut Window,
        cx: &mut Context<Picker<Self>>,
    ) -> gpui::Task<()> {
        cx.spawn(async move |this, cx| {
            let Some(processes) = this
                .read_with(cx, |this, _| this.delegate.candidates.clone())
                .ok()
            else {
                return;
            };

            let matches = fuzzy::match_strings(
                &processes
                    .iter()
                    .enumerate()
                    .map(|(id, candidate)| {
                        StringMatchCandidate::new(
                            id,
                            format!(
                                "{} {} {}",
                                candidate.command.join(" "),
                                candidate.pid,
                                candidate.name
                            )
                            .as_str(),
                        )
                    })
                    .collect::<Vec<_>>(),
                &query,
                true,
                true,
                100,
                &Default::default(),
                cx.background_executor().clone(),
            )
            .await;

            this.update(cx, |this, _| {
                let delegate = &mut this.delegate;

                delegate.matches = matches;

                if delegate.matches.is_empty() {
                    delegate.selected_index = 0;
                } else {
                    delegate.selected_index =
                        delegate.selected_index.min(delegate.matches.len() - 1);
                }
            })
            .ok();
        })
    }

    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
        let candidate = self
            .matches
            .get(self.selected_index())
            .and_then(|current_match| {
                let ix = current_match.candidate_id;
                self.candidates.get(ix)
            });

        match &mut self.intent {
            ModalIntent::ResolveProcessId(sender) => {
                cx.emit(DismissEvent);

                if let Some(sender) = sender.take() {
                    sender
                        .send(candidate.map(|candidate| candidate.pid as i32))
                        .ok();
                }
            }
            ModalIntent::AttachToProcess(definition) => {
                let Some(candidate) = candidate else {
                    return cx.emit(DismissEvent);
                };

                match &mut definition.request {
                    DebugRequest::Attach(config) => {
                        config.process_id = Some(candidate.pid);
                    }
                    DebugRequest::Launch(_) => {
                        debug_panic!("Debugger attach modal used on launch debug config");
                        return;
                    }
                }

                let workspace = self.workspace.clone();
                let Some(panel) = workspace
                    .update(cx, |workspace, cx| workspace.panel::<DebugPanel>(cx))
                    .ok()
                    .flatten()
                else {
                    return;
                };

                let Some(adapter) = cx.read_global::<DapRegistry, _>(|registry, _| {
                    registry.adapter(&definition.adapter)
                }) else {
                    return;
                };

                let definition = definition.clone();
                cx.spawn_in(window, async move |this, cx| {
                    let Ok(scenario) = adapter.config_from_zed_format(definition).await else {
                        return;
                    };

                    panel
                        .update_in(cx, |panel, window, cx| {
                            panel.start_session(
                                scenario,
                                Default::default(),
                                None,
                                None,
                                window,
                                cx,
                            );
                        })
                        .ok();
                    this.update(cx, |_, cx| {
                        cx.emit(DismissEvent);
                    })
                    .ok();
                })
                .detach();
            }
        }
    }

    fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
        self.selected_index = 0;

        match &mut self.intent {
            ModalIntent::ResolveProcessId(sender) => {
                if let Some(sender) = sender.take() {
                    sender.send(None).ok();
                }
            }
            ModalIntent::AttachToProcess(_) => {}
        }

        cx.emit(DismissEvent);
    }

    fn render_match(
        &self,
        ix: usize,
        selected: bool,
        _window: &mut Window,
        _: &mut Context<Picker<Self>>,
    ) -> Option<Self::ListItem> {
        let hit = &self.matches.get(ix)?;
        let candidate = self.candidates.get(hit.candidate_id)?;

        Some(
            ListItem::new(format!("process-entry-{ix}"))
                .inset(true)
                .spacing(ListItemSpacing::Sparse)
                .toggle_state(selected)
                .child(
                    v_flex()
                        .items_start()
                        .child(Label::new(format!("{} {}", candidate.name, candidate.pid)))
                        .child(
                            div()
                                .id(format!("process-entry-{ix}-command"))
                                .tooltip(Tooltip::text(
                                    candidate
                                        .command
                                        .clone()
                                        .into_iter()
                                        .collect::<Vec<_>>()
                                        .join(" "),
                                ))
                                .child(
                                    Label::new(format!(
                                        "{} {}",
                                        candidate.name,
                                        candidate
                                            .command
                                            .clone()
                                            .into_iter()
                                            .skip(1)
                                            .collect::<Vec<_>>()
                                            .join(" ")
                                    ))
                                    .size(LabelSize::Small)
                                    .color(Color::Muted),
                                ),
                        ),
                ),
        )
    }
}

fn get_processes_for_project(project: &Entity<Project>, cx: &mut App) -> Task<Arc<[Candidate]>> {
    let project = project.read(cx);

    if let Some(remote_client) = project.remote_client() {
        let proto_client = remote_client.read(cx).proto_client();
        cx.background_spawn(async move {
            let response = proto_client
                .request(proto::GetProcesses {
                    project_id: proto::REMOTE_SERVER_PROJECT_ID,
                })
                .await
                .unwrap_or_else(|_| proto::GetProcessesResponse {
                    processes: Vec::new(),
                });

            let mut processes: Vec<Candidate> = response
                .processes
                .into_iter()
                .map(|p| Candidate {
                    pid: p.pid,
                    name: p.name.into(),
                    command: p.command,
                })
                .collect();

            processes.sort_by_key(|k| k.name.clone());
            Arc::from(processes.into_boxed_slice())
        })
    } else {
        let refresh_kind = RefreshKind::nothing().with_processes(
            ProcessRefreshKind::nothing()
                .without_tasks()
                .with_cmd(UpdateKind::Always),
        );
        let mut processes: Box<[_]> = System::new_with_specifics(refresh_kind)
            .processes()
            .values()
            .map(|process| {
                let name = process.name().to_string_lossy().into_owned();
                Candidate {
                    name: name.into(),
                    pid: process.pid().as_u32(),
                    command: process
                        .cmd()
                        .iter()
                        .map(|s| s.to_string_lossy().into_owned())
                        .collect::<Vec<_>>(),
                }
            })
            .collect();
        processes.sort_by_key(|k| k.name.clone());
        let processes = processes.into_iter().collect();
        Task::ready(processes)
    }
}

#[cfg(test)]
pub(crate) fn set_candidates(
    modal: &AttachModal,
    candidates: Arc<[Candidate]>,
    window: &mut Window,
    cx: &mut Context<AttachModal>,
) {
    modal.picker.update(cx, |picker, cx| {
        picker.delegate.candidates = candidates;
        picker.refresh(window, cx);
    });
}

#[cfg(test)]
pub(crate) fn process_names(modal: &AttachModal, cx: &mut Context<AttachModal>) -> Vec<String> {
    modal.picker.read_with(cx, |picker, _| {
        picker
            .delegate
            .matches
            .iter()
            .map(|hit| hit.string.clone())
            .collect::<Vec<_>>()
    })
}