Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
agent_ui: Basic terminal agent telemetry (#57259)
Ben Brandt58f84cf04101
diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rsindex 309552c1a29..540abc040f2 100644--- a/crates/agent_ui/src/agent_panel.rs+++ b/crates/agent_ui/src/agent_panel.rs@@ -99,6 +99,45 @@ const MIN_PANEL_WIDTH: Pixels = px(300.);const LAST_USED_AGENT_KEY: &str = "agent_panel__last_used_external_agent";const LAST_CREATED_ENTRY_KIND_KEY: &str = "agent_panel__last_created_entry_kind";const TERMINAL_AGENT_TELEMETRY_ID: &str = "terminal";+const KNOWN_TERMINAL_AGENT_COMMANDS: &[&str] = &[+ "agent", // Unfortunately, both Cursor cli + grok+ "agy",+ "aider",+ "amp",+ "claude",+ "codex",+ "copilot",+ "crush",+ "devin",+ "droid",+ "gemini",+ "goose",+ "grok",+ "openhands",+ "opencode",+ "pi",+ "qwen",+];++fn is_known_terminal_agent_command(command: &str) -> bool {+ KNOWN_TERMINAL_AGENT_COMMANDS.contains(&command)+}++fn terminal_program_to_report(+ last_observed_program: &mut Option<String>,+ current_program: Option<String>,+) -> Option<String> {+ let current_program =+ current_program.filter(|program| is_known_terminal_agent_command(program));+ let program_to_report =+ if current_program.is_some() && current_program != *last_observed_program {+ current_program.clone()+ } else {+ None+ };+ *last_observed_program = current_program;+ program_to_report+}/// Maximum number of idle threads kept in the agent panel's retained list./// Set as a GPUI global to override; otherwise defaults to 5.@@ -831,6 +870,7 @@ struct AgentTerminal {title_editor_initial_title: Option<String>,title_editor_subscription: Option<Subscription>,last_known_title: String,+ last_observed_program: Option<String>,working_directory: Option<PathBuf>,created_at: DateTime<Utc>,has_notification: bool,@@ -889,6 +929,34 @@ impl AgentTerminal {fn custom_title(&self, cx: &App) -> Option<SharedString> {self.view.read(cx).custom_title().map(SharedString::from)}++ fn report_started_terminal_program(+ &mut self,+ terminal_id: TerminalId,+ source: AgentThreadSource,+ cx: &App,+ ) {+ let current_program = self+ .view+ .read(cx)+ .terminal()+ .read(cx)+ .foreground_process_command_name();++ if let Some(program) =+ terminal_program_to_report(&mut self.last_observed_program, current_program)+ {+ telemetry::event!(+ "Agent Terminal Program Started",+ agent = TERMINAL_AGENT_TELEMETRY_ID,+ terminal_id = terminal_id.to_key_string(),+ program = program,+ source = source.as_str(),+ side = crate::agent_sidebar_side(cx),+ thread_location = "current_worktree",+ );+ }+ }}enum BaseView {@@ -1900,6 +1968,7 @@ impl AgentPanel {| TerminalEvent::Wakeup| TerminalEvent::BreadcrumbsChanged => {this.refresh_terminal_metadata(terminal_id, cx);+ this.report_terminal_program(terminal_id, source, cx);}TerminalEvent::Bell => this.mark_terminal_notification(terminal_id, window, cx),TerminalEvent::CloseTerminal => {@@ -1920,6 +1989,7 @@ impl AgentPanel {last_known_title: initial_title.map(|title| title.to_string()).unwrap_or_default(),+ last_observed_program: None,working_directory,created_at: created_at.unwrap_or_else(Utc::now),has_notification: false,@@ -1931,9 +2001,10 @@ impl AgentPanel {self.pending_terminal_spawn = None;}terminal.refresh_metadata(cx);+ terminal.report_started_terminal_program(terminal_id, source, cx);self.terminals.insert(terminal_id, terminal);self.persist_terminal_metadata(terminal_id, cx);- self.emit_terminal_thread_started(source, cx);+ self.emit_terminal_thread_started(terminal_id, source, cx);if select {self.set_base_view(BaseView::Terminal { terminal_id }, focus, window, cx);}@@ -2028,10 +2099,16 @@ impl AgentPanel {self.close_terminal_internal(terminal_id, false, metadata, window, cx);}- fn emit_terminal_thread_started(&self, source: AgentThreadSource, cx: &App) {+ fn emit_terminal_thread_started(+ &self,+ terminal_id: TerminalId,+ source: AgentThreadSource,+ cx: &App,+ ) {telemetry::event!("Agent Thread Started",agent = TERMINAL_AGENT_TELEMETRY_ID,+ terminal_id = terminal_id.to_key_string(),source = source.as_str(),side = crate::agent_sidebar_side(cx),thread_location = "current_worktree",@@ -2048,6 +2125,17 @@ impl AgentPanel {}}+ fn report_terminal_program(+ &mut self,+ terminal_id: TerminalId,+ source: AgentThreadSource,+ cx: &mut Context<Self>,+ ) {+ if let Some(terminal) = self.terminals.get_mut(&terminal_id) {+ terminal.report_started_terminal_program(terminal_id, source, cx);+ }+ }+fn persist_all_terminal_metadata(&self, cx: &mut Context<Self>) {let terminal_ids = self.terminals.keys().copied().collect::<Vec<_>>();for terminal_id in terminal_ids {@@ -6240,6 +6328,51 @@ mod tests {use std::sync::Arc;use std::time::Instant;+ #[test]+ fn test_is_known_terminal_agent_command() {+ assert!(is_known_terminal_agent_command("claude"));+ assert!(is_known_terminal_agent_command("codex"));+ assert!(!is_known_terminal_agent_command("cargo"));+ assert!(!is_known_terminal_agent_command("internal-agent"));+ }++ #[test]+ fn test_terminal_program_reports_known_agent_transitions() {+ let mut last_observed_program = None;++ assert_eq!(+ terminal_program_to_report(&mut last_observed_program, Some("codex".to_string())),+ Some("codex".to_string())+ );+ assert_eq!(+ terminal_program_to_report(&mut last_observed_program, Some("codex".to_string())),+ None+ );+ assert_eq!(+ terminal_program_to_report(&mut last_observed_program, Some("zsh".to_string())),+ None+ );+ assert_eq!(+ terminal_program_to_report(+ &mut last_observed_program,+ Some("customer-data-export".to_string())+ ),+ None+ );+ assert_eq!(+ terminal_program_to_report(&mut last_observed_program, Some("codex".to_string())),+ Some("codex".to_string())+ );+ assert_eq!(+ terminal_program_to_report(&mut last_observed_program, None),+ None+ );+ assert_eq!(+ terminal_program_to_report(&mut last_observed_program, Some("codex".to_string())),+ Some("codex".to_string())+ );+ }+#[derive(Clone, Default)]struct SessionTrackingConnection {next_session_number: Arc<Mutex<usize>>,diff --git a/crates/terminal/src/pty_info.rs b/crates/terminal/src/pty_info.rsindex 96908479afe..560a24ca547 100644--- a/crates/terminal/src/pty_info.rs+++ b/crates/terminal/src/pty_info.rs@@ -185,6 +185,11 @@ impl PtyProcessInfo {Some(info)}+ #[cfg(all(test, unix))]+ pub(crate) fn load_for_test(&self) -> Option<ProcessInfo> {+ self.load()+ }+/// Updates the cached process info, emitting a [`Event::TitleChanged`] event if the Zed-relevant info has changedpub fn emit_title_changed_if_changed(self: &Arc<Self>, cx: &mut Context<'_, Terminal>) {if self.task.lock().is_some() {diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rsindex 00aa2cbb01b..271e2df0e9a 100644--- a/crates/terminal/src/terminal.rs+++ b/crates/terminal/src/terminal.rs@@ -60,7 +60,7 @@ use std::{cmp::{self, min},fmt::Display,ops::{Deref, RangeInclusive},- path::PathBuf,+ path::{Path, PathBuf},process::ExitStatus,sync::Arc,time::{Duration, Instant},@@ -2137,6 +2137,18 @@ impl Terminal {}}+ /// Normalizes the command name of the foreground process, if one is known.+ pub fn foreground_process_command_name(&self) -> Option<String> {+ match &self.terminal_type {+ TerminalType::Pty { info, .. } => info+ .current+ .read()+ .as_ref()+ .and_then(|process| foreground_process_command_from_argv(&process.argv)),+ TerminalType::DisplayOnly => None,+ }+ }+/// Returns the working directory of the process that's connected to the PTY./// That means it returns the working directory of the local shell or program/// that's running inside the terminal.@@ -2461,6 +2473,77 @@ impl Drop for Terminal {impl EventEmitter<Event> for Terminal {}+fn normalize_path_command_name(command: &str) -> Option<String> {+ const MAX_COMMAND_NAME_LENGTH: usize = 64;++ let command = command.trim();+ if command.is_empty()+ || command.len() > MAX_COMMAND_NAME_LENGTH+ || command.starts_with('.')+ || command.starts_with('-')+ || command.contains('/')+ || command.contains('\\')+ {+ return None;+ }++ let mut command = command.to_ascii_lowercase();+ for suffix in [".exe", ".cmd", ".bat", ".ps1"] {+ if command.ends_with(suffix) {+ command.truncate(command.len() - suffix.len());+ break;+ }+ }++ if command.is_empty()+ || !command.chars().all(|character| {+ character.is_ascii_alphanumeric() || matches!(character, '-' | '_' | '.')+ })+ {+ return None;+ }++ Some(command)+}++fn foreground_process_command_from_argv(argv: &[String]) -> Option<String> {+ let command = argv+ .first()+ .and_then(|command| normalize_path_command_name(command));++ if !matches!(+ command.as_deref(),+ Some("node" | "python" | "python3" | "bun" | "deno")+ ) {+ return command;+ }++ argv.iter()+ .skip(1)+ .filter_map(|argument| normalize_script_command_name(argument))+ .next()+ .or(command)+}++fn normalize_script_command_name(argument: &str) -> Option<String> {+ let path = Path::new(argument);+ let file_stem = path+ .file_stem()+ .and_then(|file_stem| file_stem.to_str())+ .and_then(normalize_path_command_name)?;++ if file_stem != "index" {+ return Some(file_stem);+ }++ path.parent()+ .and_then(|parent| parent.parent())+ .and_then(|package_path| package_path.file_name())+ .and_then(|package_name| package_name.to_str())+ .and_then(|package_name| package_name.strip_suffix("-cli").or(Some(package_name)))+ .and_then(normalize_path_command_name)+}+fn make_selection(range: &RangeInclusive<AlacPoint>) -> Selection {let mut selection = Selection::new(SelectionType::Simple, *range.start(), AlacDirection::Left);selection.update(*range.end(), AlacDirection::Right);@@ -2597,6 +2680,54 @@ mod tests {use rand::{Rng, distr, rngs::StdRng};use task::{Shell, ShellBuilder};+ #[test]+ fn test_normalize_path_command_name() {+ assert_eq!(normalize_path_command_name("claude"), Some("claude".into()));+ assert_eq!(normalize_path_command_name("Cargo"), Some("cargo".into()));+ assert_eq!(normalize_path_command_name("node.exe"), Some("node".into()));+ assert_eq!(+ normalize_path_command_name("my-agent_cli.1"),+ Some("my-agent_cli.1".into())+ );+ assert_eq!(normalize_path_command_name("./local-agent"), None);+ assert_eq!(normalize_path_command_name("../local-agent"), None);+ assert_eq!(normalize_path_command_name("/usr/local/bin/cargo"), None);+ assert_eq!(+ normalize_path_command_name("target\\debug\\agent.exe"),+ None+ );+ assert_eq!(normalize_path_command_name(".hidden-agent"), None);+ assert_eq!(normalize_path_command_name("agent with spaces"), None);+ assert_eq!(normalize_path_command_name("zsh"), Some("zsh".into()));+ assert_eq!(normalize_path_command_name("-zsh"), None);+ assert_eq!(normalize_path_command_name("pwsh.exe"), Some("pwsh".into()));+ }++ #[test]+ fn test_foreground_process_command_from_interpreter_wrapper() {+ assert_eq!(+ foreground_process_command_from_argv(&[+ "node".to_string(),+ "/opt/homebrew/lib/node_modules/@google/gemini-cli/dist/index.js".to_string(),+ ]),+ Some("gemini".to_string())+ );+ assert_eq!(+ foreground_process_command_from_argv(&[+ "python3".to_string(),+ "/Users/me/.local/bin/codex.py".to_string(),+ ]),+ Some("codex".to_string())+ );+ assert_eq!(+ foreground_process_command_from_argv(&[+ "node".to_string(),+ "/Users/me/private-project/scripts/customer-data-export.js".to_string(),+ ]),+ Some("customer-data-export".to_string())+ );+ }+#[cfg(not(target_os = "windows"))]fn init_test(cx: &mut TestAppContext) {cx.update(|cx| {@@ -2613,10 +2744,18 @@ mod tests {command: &str,args: &[&str],) -> (Entity<Terminal>, Receiver<Option<ExitStatus>>) {- let (completion_tx, completion_rx) = async_channel::unbounded();let args: Vec<String> = args.iter().map(|s| s.to_string()).collect();let (program, args) =ShellBuilder::new(&Shell::System, false).build(Some(command.to_owned()), &args);+ build_test_terminal_with_arguments(cx, program, args).await+ }++ async fn build_test_terminal_with_arguments(+ cx: &mut TestAppContext,+ program: String,+ args: Vec<String>,+ ) -> (Entity<Terminal>, Receiver<Option<ExitStatus>>) {+ let (completion_tx, completion_rx) = async_channel::unbounded();let builder = cx.update(|cx| {TerminalBuilder::new(@@ -2755,6 +2894,23 @@ mod tests {);}+ #[cfg(unix)]+ #[gpui::test]+ async fn test_foreground_process_command_tracks_path_command(cx: &mut TestAppContext) {+ cx.executor().allow_parking();++ let (terminal, completion_rx) =+ build_test_terminal_with_arguments(cx, "sleep".to_string(), vec!["1".to_string()])+ .await;++ assert_foreground_process_command_eventually(&terminal, "sleep", cx).await;++ assert!(+ completion_rx.recv().await.is_ok(),+ "expected terminal completion after sleep exits"+ );+ }+// TODO should be tested on Linux too, but does not work there well#[cfg(target_os = "macos")]#[gpui::test(iterations = 10)]@@ -3359,6 +3515,42 @@ mod tests {panic!("Expected terminal content to contain {expected:?}, got: {content}");}+ #[cfg(unix)]+ async fn assert_foreground_process_command_eventually(+ terminal: &Entity<Terminal>,+ expected: &str,+ cx: &mut TestAppContext,+ ) {+ let mut command_name = None;+ for _ in 0..100 {+ terminal.update(cx, |terminal, _| {+ if let TerminalType::Pty { info, .. } = &terminal.terminal_type {+ info.load_for_test();+ }+ });+ command_name =+ terminal.update(cx, |terminal, _| terminal.foreground_process_command_name());+ if command_name.as_deref() == Some(expected) {+ return;+ }+ cx.background_executor+ .timer(Duration::from_millis(10))+ .await;+ }+ let process_info = terminal.update(cx, |terminal, _| match &terminal.terminal_type {+ TerminalType::Pty { info, .. } => format!(+ "pid={:?}, fallback_pid={:?}, has_current_info={}",+ info.pid(),+ info.pid_getter().fallback_pid(),+ info.current.read().is_some()+ ),+ TerminalType::DisplayOnly => "display-only".to_string(),+ });+ panic!(+ "Expected foreground process command name to be {expected:?}, got {command_name:?}; process info: {process_info:?}"+ );+ }+/// Test that kill_active_task properly terminates both the foreground process/// and the shell, allowing wait_for_completed_task to complete and output to be captured.#[cfg(unix)]