The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(run): keep Stop in effect until the process is really gone (#1763)
misswell438ab158ad11
diff --git a/Cargo.lock b/Cargo.lockindex d04863312..90fc585db 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4216,6 +4216,7 @@ dependencies = ["ide-core","ide-jsonrpc","ide-language",+ "libc","memchr","parking_lot","portable-pty",diff --git a/crates/ide-dap/Cargo.toml b/crates/ide-dap/Cargo.tomlindex 757915cca..b37151c9d 100644--- a/crates/ide-dap/Cargo.toml+++ b/crates/ide-dap/Cargo.toml@@ -20,6 +20,9 @@ memchr = "2"portable-pty.workspace = truetracing.workspace = true+[target.'cfg(unix)'.dependencies]+libc = "0.2"+[dev-dependencies]tracing-subscriber.workspace = truetokio = { workspace = true, features = ["net", "rt-multi-thread", "macros"] }diff --git a/crates/ide-dap/src/lib.rs b/crates/ide-dap/src/lib.rsindex 524c10bea..ad1121178 100644--- a/crates/ide-dap/src/lib.rs+++ b/crates/ide-dap/src/lib.rs@@ -301,6 +301,8 @@ pub struct DebugManager {exception_choices: Mutex<BTreeMap<String, bool>>,function_breakpoints: Mutex<Vec<FunctionBreakpoint>>,data_breakpoints: Mutex<Vec<DataBreakpoint>>,+ /// In-flight stops, by session: a second Stop sets `stop_force`, the waiting one kills.+ stopping: Mutex<HashMap<DebugSessionId, Arc<Session>>>,}/// Whether the debugged project depends on the Flutter SDK, so it must go@@ -587,6 +589,7 @@ impl DebugManager {exception_choices: Mutex::default(),function_breakpoints: Mutex::default(),data_breakpoints: Mutex::default(),+ stopping: Mutex::default(),})}@@ -994,15 +997,62 @@ impl DebugManager {/// Ends a session: `terminate` (when asked and supported) → `disconnect` → kill.pub(crate) async fn shutdown(&self, s: &Arc<Session>, terminate: bool) {+ // java-debug runs the program itself and pipes its stdout over DAP. A `disconnect`+ // ends that DAP session, so every line the program writes while shutting down is lost.+ // Ask the program to exit ourselves and keep the adapter attached until it has drained+ // the console (`terminated`), as IDEA does with the process it owns.+ let pid = s.debuggee_pid.load(Ordering::Acquire);+ let own_terminate = terminate && s.request == "launch" && pid > 0;+ let graceful = terminate && s.request == "launch" && s.supports("supportsTerminateRequest");if !s.conn.is_closed() {- if terminate && s.request == "launch" && s.supports("supportsTerminateRequest") {+ if graceful {let _ = s.conn.request_timeout("terminate", json!({ "restart": false }), SHUTDOWN_TIMEOUT).await;}+ if !graceful && !own_terminate {+ let _ = s+ .conn+ .request_timeout(+ "disconnect",+ json!({ "restart": false, "terminateDebuggee": s.request == "launch" }),+ SHUTDOWN_TIMEOUT,+ )+ .await;+ }+ }+ if own_terminate && !graceful {+ // Signal before anything else: waiting on a request the adapter may not answer+ // would delay the shutdown the console is supposed to show.+ crate::session::signal_debuggee(s, false);+ }+ if graceful {+ // java-debug sends `terminated` only after it has drained the program's console+ // (it waits up to 5 s for the output pump). Close on the process id alone and the+ // last shutdown lines are dropped, so wait for that event here.+ let deadline = std::time::Instant::now() + crate::session::DEBUGGEE_EXIT_WAIT;+ while !s.terminated.load(Ordering::Acquire) && std::time::Instant::now() < deadline {+ tokio::time::sleep(std::time::Duration::from_millis(50)).await;+ }+ }+ // An adapter answers `disconnect` before the program it launched has exited, and that+ // program keeps its port until it is gone. Reporting the session as terminated then+ // lets Run start again into an occupied port, so wait for the program first — with the+ // connection still open, so a second Stop can find the session and kill it.+ crate::session::wait_for_debuggee(s, terminate).await;+ if terminate && s.request == "launch" {+ // The adapter reports `terminated` only after it has drained the program's console+ // (java-debug waits up to 5 s for the pump): closing before that drops the last+ // shutdown lines from the console.+ let deadline = std::time::Instant::now() + std::time::Duration::from_secs(6);+ while !s.terminated.load(Ordering::Acquire) && !s.conn.is_closed() && std::time::Instant::now() < deadline {+ tokio::time::sleep(std::time::Duration::from_millis(50)).await;+ }+ }+ if graceful && !s.conn.is_closed() {let _ = s.conn.request_timeout("disconnect",- json!({ "restart": false, "terminateDebuggee": s.request == "launch" }),+ json!({ "restart": false, "terminateDebuggee": false }),SHUTDOWN_TIMEOUT,).await;@@ -1577,10 +1627,40 @@ impl DebugManager {}}- /// Stops a session and its child sessions.+ /// Stops every debug session started from `root` or below — closing a project stops the+ /// programs it launched even when the session's owner key does not name the window doing+ /// the closing (window groups, auxiliary windows).+ pub async fn stop_under(&self, root: &Path) {+ let ids: Vec<DebugSessionId> =+ self.live_sessions().into_iter().filter(|s| s.spec.cwd.starts_with(root)).map(|s| s.id).collect();+ tracing::info!(root = %root.display(), sessions = ids.len(), "closing project: stopping debug sessions");+ for id in ids {+ if let Err(e) = self.stop(id).await {+ tracing::debug!("debug session {id:?} did not stop: {e}");+ }+ }+ }++ /// Stops a session and its child sessions. A second Stop while the first one waits kills+ /// the program instead of waiting for it — even after the adapter dropped the session.pub async fn stop(&self, s: DebugSessionId) -> IdeResult<()> {+ {+ let in_flight = self.stopping.lock();+ if let Some(session) = in_flight.get(&s) {+ session.stop_force.store(true, Ordering::Release);+ return Ok(());+ }+ }let session = self.session(s)?;- let children: Vec<Arc<Session>> = self.live_sessions().into_iter().filter(|c| c.parent == Some(s)).collect();+ self.stopping.lock().insert(s, session.clone());+ let result = self.stop_tree(session).await;+ self.stopping.lock().remove(&s);+ result+ }++ async fn stop_tree(&self, session: Arc<Session>) -> IdeResult<()> {+ let children: Vec<Arc<Session>> =+ self.live_sessions().into_iter().filter(|c| c.parent == Some(session.id)).collect();for child in children {self.shutdown(&child, true).await;}diff --git a/crates/ide-dap/src/session.rs b/crates/ide-dap/src/session.rsindex e7356fbbb..bc9c81946 100644--- a/crates/ide-dap/src/session.rs+++ b/crates/ide-dap/src/session.rs@@ -13,7 +13,7 @@ use std::path::{Path, PathBuf};use std::process::Stdio;use std::sync::Arc;use std::sync::Weak;-use std::sync::atomic::{AtomicBool, Ordering};+use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};use std::time::Duration;use tokio::io::{AsyncRead, AsyncReadExt};use tokio::process::Child;@@ -49,6 +49,14 @@ pub(crate) struct Session {pub configured: AtomicBool,pub initialized: watch::Sender<bool>,pub terminated: AtomicBool,+ /// Set by a second Stop: the one waiting for the program kills it instead.+ pub stop_force: AtomicBool,+ /// `systemProcessId` from the adapter's `process` event: the program being debugged.+ pub debuggee_pid: AtomicI64,+ /// Pids signalled for the current stop: the reported pid and everything it started (an+ /// adapter may report the launcher shell, whose child is the program).+ #[cfg_attr(not(unix), allow(dead_code))]+ pub stop_pids: parking_lot::Mutex<Vec<i32>>,/// Breakpoints replaced for run to cursor / force stepping, restored on the next stop.pub pending_restore: Mutex<PendingRestore>,/// Adapter breakpoint id → (file, index in the stored list).@@ -96,6 +104,9 @@ impl Session {configured: AtomicBool::new(false),initialized: watch::channel(false).0,terminated: AtomicBool::new(false),+ stop_force: AtomicBool::new(false),+ debuggee_pid: AtomicI64::new(0),+ stop_pids: parking_lot::Mutex::new(Vec::new()),pending_restore: Mutex::default(),breakpoint_ids: Mutex::new(HashMap::new()),resolved_paths: Mutex::new(HashMap::new()),@@ -275,6 +286,108 @@ impl Session {}}+/// How long Stop waits for a launched program to exit before reporting the session ended.+pub(crate) const DEBUGGEE_EXIT_WAIT: Duration = Duration::from_secs(10);++/// The program and everything it started: an adapter may report the launcher shell, whose+/// child is the debugged program, so stopping only the reported pid leaves the program alive.+#[cfg(unix)]+fn process_tree(pid: i32) -> Vec<i32> {+ use std::collections::HashMap;+ let Ok(out) = std::process::Command::new("ps").args(["-A", "-o", "pid=,ppid="]).output() else {+ return vec![pid];+ };+ let mut children: HashMap<i32, Vec<i32>> = HashMap::new();+ for line in String::from_utf8_lossy(&out.stdout).lines() {+ let mut it = line.split_whitespace();+ let (Some(p), Some(parent)) = (it.next(), it.next()) else { continue };+ let (Ok(p), Ok(parent)) = (p.parse::<i32>(), parent.parse::<i32>()) else { continue };+ children.entry(parent).or_default().push(p);+ }+ let mut tree = vec![pid];+ let mut at = 0;+ while at < tree.len() {+ if let Some(kids) = children.get(&tree[at]) {+ tree.extend(kids.iter().copied());+ }+ at += 1;+ }+ tree+}++/// Asks the program itself to exit (`force` = SIGKILL) without ending the adapter session:+/// its output keeps flowing over DAP while it shuts down. The first call remembers the pid+/// tree, because the reported pid may die before its program does.+pub(crate) fn signal_debuggee(s: &Arc<Session>, force: bool) {+ let pid = s.debuggee_pid.load(Ordering::Acquire);+ if pid <= 0 {+ return;+ }+ #[cfg(unix)]+ {+ let mut known = s.stop_pids.lock();+ if known.is_empty() {+ *known = process_tree(pid as i32);+ }+ let signal = if force { libc::SIGKILL } else { libc::SIGTERM };+ // Children first: the shell that started the program would otherwise reparent it.+ for p in known.iter().rev() {+ // SAFETY: plain syscall on the processes this session started.+ unsafe {+ libc::kill(*p, signal);+ }+ }+ }+ #[cfg(windows)]+ {+ let mut cmd = std::process::Command::new("taskkill");+ cmd.args(["/PID", &pid.to_string(), "/T"]);+ if force {+ cmd.arg("/F");+ }+ let _ = cmd.status();+ }+ #[cfg(not(any(unix, windows)))]+ let _ = (pid, force);+}++/// Waits until the program a `launch` session started is gone; a second Stop kills it.+pub(crate) async fn wait_for_debuggee(s: &Arc<Session>, terminate: bool) {+ if !terminate || s.request != "launch" {+ return;+ }+ let pid = s.debuggee_pid.load(Ordering::Acquire);+ if pid <= 0 {+ return;+ }+ tracing::info!(session = s.id.0, pid, "stop: waiting for the debugged program to exit");+ #[cfg(unix)]+ {+ use std::time::Instant;+ let targets = {+ let known = s.stop_pids.lock();+ if known.is_empty() { process_tree(pid as i32) } else { known.clone() }+ };+ let alive = || targets.iter().any(|p| unsafe { libc::kill(*p, 0) } == 0);+ let deadline = Instant::now() + DEBUGGEE_EXIT_WAIT;+ while alive() {+ if s.stop_force.swap(false, Ordering::AcqRel) {+ signal_debuggee(s, true);+ }+ if Instant::now() >= deadline {+ // The program ignored the terminate: do not leave it running.+ signal_debuggee(s, true);+ break;+ }+ tokio::time::sleep(Duration::from_millis(50)).await;+ }+ }+ #[cfg(not(unix))]+ {+ let _ = pid;+ }+}+// java-debug and Windows netcoredbg need native separators for source lookup.// Keep DAP path mode, but normalize Windows drive and UNC paths.fn is_windows_source_path(path: &str) -> bool {@@ -370,8 +483,18 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut boreturn;}let output = str_("output").unwrap_or_default();+ if tracing::enabled!(tracing::Level::DEBUG) && mgr.stopping.lock().contains_key(&s.id) {+ tracing::debug!(session = ?s.id, bytes = output.len(), "output during stop");+ }s.emit(DebugEvent::Output { category, output });}+ // The program the adapter started: Stop must wait for it, not for the adapter's reply.+ // `process` is the DAP event; java-debug announces the same thing as `processid`.+ "process" | "processid" => {+ if let Some(pid) = int("systemProcessId").or_else(|| int("processId")).filter(|p| *p > 0) {+ s.debuggee_pid.store(pid, Ordering::Release);+ }+ }"thread" => s.emit(DebugEvent::Thread {thread_id: int("threadId").unwrap_or(0),started: body.get("reason").and_then(Value::as_str) != Some("exited"),@@ -390,12 +513,18 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo}"exited" => {}"terminated" => {- if !s.terminated.swap(true, Ordering::AcqRel) {- s.emit(DebugEvent::Terminated);- }+ let first = !s.terminated.swap(true, Ordering::AcqRel);let mgr = mgr.clone();let s = s.clone();- tokio::spawn(async move { mgr.shutdown(&s, false).await });+ // Waiting here would stop reading the adapter: it keeps sending the program's last+ // output while the program exits. Wait off the reader task, then report the end.+ tokio::spawn(async move {+ if first {+ wait_for_debuggee(&s, true).await;+ s.emit(DebugEvent::Terminated);+ }+ mgr.shutdown(&s, false).await;+ });}"capabilities" => {if let Some(new) = body.get("capabilities").and_then(Value::as_object) {diff --git a/crates/ide-dap/src/tests.rs b/crates/ide-dap/src/tests.rsindex 2f728a9f3..05fc98ed0 100644--- a/crates/ide-dap/src/tests.rs+++ b/crates/ide-dap/src/tests.rs@@ -5,11 +5,16 @@ use crate::adapter::{AdapterIo, LaunchFuture};use ide_core::IdeEvent;use ide_core::event::DebugEvent;use ide_jsonrpc::framing;+#[cfg(unix)]+use std::sync::atomic::{AtomicBool, Ordering};+use std::time::Duration;+#[cfg(unix)]+use std::time::Instant;use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt, BufReader};type Log = Arc<Mutex<Vec<Value>>>;-#[derive(Clone, Default)]+#[derive(Clone)]struct Script {/// Send a `runInTerminal` reverse request when `launch` arrives.run_in_terminal: Option<Vec<String>>,@@ -17,10 +22,35 @@ struct Script {start_debugging: bool,ignore_configuration_done: bool,source_path: Option<String>,+ /// Report this process id in the adapter's `process` event (the program being debugged).+ debuggee_pid: Option<u32>,+ /// java-debug's spelling of the same event.+ java_process_id: bool,+ /// Send one more output event right after the `terminated` event (a program still logging+ /// while it shuts down).+ output_after_terminate: bool,+ /// Advertise `supportsTerminateRequest` (java-debug does not, so Stop signals the program).+ supports_terminate: bool,/// Answer `setBreakpoints` only once this many are waiting (a client that waits for each never gets one).hold_set_breakpoints: usize,}+impl Default for Script {+ fn default() -> Self {+ Self {+ run_in_terminal: None,+ start_debugging: false,+ ignore_configuration_done: false,+ source_path: None,+ debuggee_pid: None,+ java_process_id: false,+ output_after_terminate: false,+ supports_terminate: true,+ hold_set_breakpoints: 0,+ }+ }+}+struct FakeLauncher {log: Log,script: Script,@@ -77,7 +107,7 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(streamjson!({"supportsConfigurationDoneRequest": true,"supportsCompletionsRequest": true,- "supportsTerminateRequest": true,+ "supportsTerminateRequest": script.supports_terminate,"supportsSetVariable": true,"supportsFunctionBreakpoints": true,"supportsDataBreakpoints": true,@@ -155,6 +185,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(streamif let Some(l) = pending_launch.take() {send!(json!({"type": "response", "request_seq": l, "command": "launch", "success": true}));}+ if let Some(pid) = script.debuggee_pid {+ let event = if script.java_process_id {+ json!({"type": "event", "event": "processid", "body": {"processId": pid, "shellProcessId": pid}})+ } else {+ json!({"type": "event", "event": "process", "body": {"name": "prog", "systemProcessId": pid}})+ };+ send!(event);+ }send!(json!({"type": "event", "event": "output", "body": {"category": "stdout", "output": "hello\n"}}));send!(json!({"type": "event", "event": "stopped", "body": {"reason": "breakpoint", "threadId": 1, "allThreadsStopped": true}})@@ -208,6 +246,11 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream"terminate" => {ok!(msg, Value::Null);send!(json!({"type": "event", "event": "terminated"}));+ if script.output_after_terminate {+ send!(+ json!({"type": "event", "event": "output", "body": {"category": "stdout", "output": "late\n"}})+ );+ }}"disconnect" => {ok!(msg, Value::Null);@@ -1348,6 +1391,201 @@ fn flutter_projects_are_found_from_the_program_or_the_working_directory() {std::fs::remove_dir_all(&root).unwrap();}+#[cfg(unix)]+#[tokio::test]+async fn stop_waits_for_the_launched_program_to_exit() {+ // The adapter answers `disconnect` at once; the program it started is still alive and+ // holds its port for a while. Stop must not report the session as over before it exits.+ // Reaped by a waiting thread: a zombie still "exists" for `kill(pid, 0)`, unlike the+ // program an adapter starts and reaps.+ // Ignores SIGTERM: Stop must wait for the program, not assume the signal ended it.+ let mut child = std::process::Command::new("python3")+ .args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(1)"])+ .spawn()+ .unwrap();+ let pid = child.id();+ std::thread::spawn(move || {+ let _ = child.wait();+ });+ let h = harness(Script { debuggee_pid: Some(pid), ..Default::default() });+ let id = h.start(config()).await.unwrap();+ h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;+ for _ in 0..100 {+ if h.manager.session(id).map(|s| s.debuggee_pid.load(Ordering::Acquire)).ok() == Some(i64::from(pid)) {+ break;+ }+ tokio::time::sleep(Duration::from_millis(10)).await;+ }+ tokio::time::sleep(Duration::from_millis(200)).await; // let the program install its trap+ let started = Instant::now();+ h.manager.stop(id).await.unwrap();+ let elapsed = started.elapsed();+ assert!(elapsed >= Duration::from_millis(800), "stop returned after {elapsed:?}, before the program exited");+ assert!(elapsed < Duration::from_secs(5), "stop waited {elapsed:?} for a program that ended after a second");+ h.wait_event(|e| matches!(e, DebugEvent::Terminated)).await;+}++#[cfg(unix)]+#[tokio::test]+async fn a_second_stop_kills_the_program_instead_of_waiting() {+ let mut child = std::process::Command::new("python3")+ .args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(30)"])+ .spawn()+ .unwrap();+ let pid = child.id();+ let exited = Arc::new(AtomicBool::new(false));+ {+ let exited = exited.clone();+ std::thread::spawn(move || {+ let _ = child.wait();+ exited.store(true, Ordering::Release);+ });+ }+ let h = harness(Script { debuggee_pid: Some(pid), ..Default::default() });+ let id = h.start(config()).await.unwrap();+ h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;+ for _ in 0..100 {+ if h.manager.session(id).map(|s| s.debuggee_pid.load(Ordering::Acquire)).ok() == Some(i64::from(pid)) {+ break;+ }+ tokio::time::sleep(Duration::from_millis(10)).await;+ }+ tokio::time::sleep(Duration::from_millis(400)).await;+ let first = tokio::spawn({+ let manager = h.manager.clone();+ async move { manager.stop(id).await }+ });+ tokio::time::sleep(Duration::from_millis(300)).await;+ assert!(!exited.load(Ordering::Acquire), "the program is still alive while the first Stop waits");+ let started = Instant::now();+ h.manager.stop(id).await.unwrap();+ let first_result = tokio::time::timeout(Duration::from_secs(5), first).await.expect("the first Stop returns");+ first_result.unwrap().unwrap();+ assert!(started.elapsed() < Duration::from_secs(2), "a second Stop does not wait out the program");+ for _ in 0..100 {+ if exited.load(Ordering::Acquire) {+ break;+ }+ tokio::time::sleep(Duration::from_millis(10)).await;+ }+ assert!(exited.load(Ordering::Acquire), "the second Stop killed the program");+}++#[cfg(unix)]+#[tokio::test]+async fn stop_waits_for_the_program_when_the_adapter_uses_javas_processid_event() {+ // Ignores SIGTERM: Stop must wait for the program, not assume the signal ended it.+ let mut child = std::process::Command::new("python3")+ .args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(1)"])+ .spawn()+ .unwrap();+ let pid = child.id();+ std::thread::spawn(move || {+ let _ = child.wait();+ });+ let h = harness(Script { debuggee_pid: Some(pid), java_process_id: true, ..Default::default() });+ let id = h.start(config()).await.unwrap();+ h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;+ for _ in 0..100 {+ if h.manager.session(id).map(|s| s.debuggee_pid.load(Ordering::Acquire)).ok() == Some(i64::from(pid)) {+ break;+ }+ tokio::time::sleep(Duration::from_millis(10)).await;+ }+ tokio::time::sleep(Duration::from_millis(200)).await;+ let started = Instant::now();+ h.manager.stop(id).await.unwrap();+ assert!(+ started.elapsed() >= Duration::from_millis(800),+ "stop returned after {:?}, before the program exited",+ started.elapsed()+ );+}++#[cfg(unix)]+#[tokio::test]+async fn output_keeps_arriving_while_a_stopped_program_is_exiting() {+ // Ignores SIGTERM: Stop must wait for the program, not assume the signal ended it.+ let mut child = std::process::Command::new("python3")+ .args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(1)"])+ .spawn()+ .unwrap();+ let pid = child.id();+ std::thread::spawn(move || {+ let _ = child.wait();+ });+ let h = harness(Script { debuggee_pid: Some(pid), output_after_terminate: true, ..Default::default() });+ let id = h.start(config()).await.unwrap();+ h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;+ for _ in 0..100 {+ if h.manager.session(id).map(|s| s.debuggee_pid.load(Ordering::Acquire)).ok() == Some(i64::from(pid)) {+ break;+ }+ tokio::time::sleep(Duration::from_millis(10)).await;+ }+ let started = Instant::now();+ let stop = tokio::spawn({+ let manager = h.manager.clone();+ async move { manager.stop(id).await }+ });+ // The last line must reach the console while Stop still waits for the program.+ h.wait_event(|e| matches!(e, DebugEvent::Output { output, .. } if output == "late\n")).await;+ assert!(started.elapsed() < Duration::from_millis(800), "output arrived only after the program was gone");+ stop.await.unwrap().unwrap();+}++#[tokio::test]+async fn closing_a_project_stops_the_debug_sessions_it_started() {+ let h = harness(Script::default());+ let id = h.start(config()).await.unwrap();+ h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;+ // The session's cwd is /p, whatever key it was started under.+ h.manager.stop_under(Path::new("/p")).await;+ h.wait_event(|e| matches!(e, DebugEvent::Terminated)).await;+ assert!(h.manager.sessions(None).is_empty(), "session {id:?} is gone");+}++#[cfg(unix)]+#[tokio::test]+async fn stop_kills_the_program_started_by_the_reported_launcher() {+ use std::io::BufRead;+ // java-debug reports the launcher shell; the JVM is its child. Stopping only the reported+ // pid orphans the program, which keeps running (and keeps its ports).+ let mut launcher = std::process::Command::new("sh")+ .args(["-c", "python3 -c 'import time; time.sleep(30)' & echo $!; wait"])+ .stdout(std::process::Stdio::piped())+ .spawn()+ .unwrap();+ let launcher_pid = launcher.id();+ let mut line = String::new();+ std::io::BufReader::new(launcher.stdout.take().unwrap()).read_line(&mut line).unwrap();+ let program: i32 = line.trim().parse().expect("child pid");+ // Reap the launcher: a zombie still "exists" for `kill(pid, 0)`, unlike the shell jdtls reaps.+ std::thread::spawn(move || {+ let _ = launcher.wait();+ });++ let h = harness(Script {+ debuggee_pid: Some(launcher_pid),+ supports_terminate: false, // java-debug does not advertise it+ ..Default::default()+ });+ let id = h.start(config()).await.unwrap();+ h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;+ for _ in 0..100 {+ if h.manager.session(id).map(|s| s.debuggee_pid.load(Ordering::Acquire)).ok() == Some(i64::from(launcher_pid)) {+ break;+ }+ tokio::time::sleep(Duration::from_millis(10)).await;+ }+ h.manager.stop(id).await.unwrap();+ let deadline = Instant::now() + Duration::from_secs(5);+ while unsafe { libc::kill(program, 0) } == 0 {+ assert!(Instant::now() < deadline, "the program the launcher started survived stop");+ tokio::time::sleep(Duration::from_millis(50)).await;+ }+}+#[test]fn delve_leftovers_are_removed_without_touching_other_files() {let dir = std::env::temp_dir().join(format!("openidea-delve-bin-{}", std::process::id()));diff --git a/crates/ide-host/src/lib.rs b/crates/ide-host/src/lib.rsindex 2dad9a5a9..56147fcf5 100644--- a/crates/ide-host/src/lib.rs+++ b/crates/ide-host/src/lib.rs@@ -248,7 +248,7 @@ impl Host {vec![project.notebooks.clone()],project.kotlin_bridge.iter().cloned().collect(),Some(project.lsp.clone()),- Some((self.debugger.clone(), window.to_owned())),+ Some((self.debugger.clone(), window.to_owned(), project.root.clone())),Some(project),))}@@ -261,7 +261,7 @@ impl Host {notebooks: Vec<Arc<notebook::NotebookService>>,bridges: Vec<Arc<kotlin_bridge::KotlinBridge>>,lsp: Option<Arc<ide_lsp::LspManager>>,- debug: Option<(Arc<ide_dap::DebugManager>, String)>,+ debug: Option<(Arc<ide_dap::DebugManager>, String, std::path::PathBuf)>,retired: Option<Arc<Project>>,) -> std::thread::JoinHandle<()> {for bridge in &bridges {@@ -286,8 +286,9 @@ impl Host {if let Some(lsp) = lsp {lsp.shutdown_all().await;}- if let Some((debug, key)) = debug {+ if let Some((debug, key, root)) = debug {debug.stop_key(&key).await;+ debug.stop_under(&root).await;}});if let Some(retired) = retired {diff --git a/crates/ide-run/src/process.rs b/crates/ide-run/src/process.rsindex 9deb76d46..d796884b7 100644--- a/crates/ide-run/src/process.rs+++ b/crates/ide-run/src/process.rs@@ -633,15 +633,18 @@ impl ProcessManager {self.stop_with_grace(id, STOP_GRACE)}- /// [`Self::stop`] with an explicit grace period before the kill. A configuration's- /// stop command runs first; signals follow only if the process outlives it.+ /// [`Self::stop`] with an explicit grace period for the configured stop command. The+ /// first stop only asks the process tree to exit (stop command, then `SIGINT`) and waits;+ /// a second stop kills it.pub fn stop_with_grace(&self, id: RunId, grace: Duration) -> IdeResult<()> {let entry = self.entry(id)?;- if entry.exited.load(Ordering::Acquire) {- return Ok(());- }let already_stopping = entry.stopping.swap(true, Ordering::AcqRel);let Some(pid) = *entry.pid.lock() else { return Ok(()) };+ // A run that ended by itself can leave members of its group behind: a Stop must+ // still be able to reach them.+ if entry.exited.load(Ordering::Acquire) && !group_alive(pid, &entry) {+ return Ok(());+ }if already_stopping {// Second stop request: don't wait out the grace period.kill_tree(pid, true);@@ -671,9 +674,11 @@ impl ProcessManager {}kill_tree(pid, false);}- if !exits_within(grace) {- tracing::debug!(id = %entry.id, pid, "process ignored interrupt; killing");- kill_tree(pid, true);+ // A first Stop only asks the process tree to exit, as IDEA does: it waits for+ // the shutdown to finish (a Spring Boot app can take seconds) and a second Stop+ // is what kills. Killing on a timer here cut shutdown logs off with SIGKILL.+ while group_alive(pid, &entry) {+ std::thread::sleep(Duration::from_millis(50));}}).map_err(|e| IdeError::internal(format!("failed to start stop thread: {e}")))?;@@ -1061,6 +1066,18 @@ fn spawn_pump(if let Some(pty) = &entry.pty {pty.lock().take();}+ // A stopped run is over when the whole process group is gone, not when the child we+ // spawned exits: a shell or `mvn` can end while the application it started keeps its+ // port, and reporting "finished" then would let Run start into an occupied port.+ // A second Stop kills the group, which ends this wait.+ #[cfg(unix)]+ if entry.stopping.load(Ordering::Acquire)+ && let Some(pid) = *entry.pid.lock()+ {+ while group_alive(pid, &entry) {+ std::thread::sleep(Duration::from_millis(50));+ }+ }entry.exited.store(true, Ordering::Release);tracing::debug!(id = %entry.id, ?code, "run exited");sink.emit(IdeEvent::RunExited { run: entry.id, code });diff --git a/crates/ide-run/tests/process.rs b/crates/ide-run/tests/process.rsindex 21524e4f4..20619efe6 100644--- a/crates/ide-run/tests/process.rs+++ b/crates/ide-run/tests/process.rs@@ -204,6 +204,9 @@ fn stop_kills_whole_process_group() {let grandchild: i32 = out.trim().parse().expect("pid");assert!(alive(grandchild));+ // The first Stop only asks the group to exit (and waits); the second one kills it.+ h.pm.stop(id).unwrap();+ std::thread::sleep(Duration::from_millis(200));h.pm.stop(id).unwrap();wait_exit(&h, id, Duration::from_secs(10));let deadline = Instant::now() + Duration::from_secs(8);diff --git a/crates/ide-run/tests/stop_group.rs b/crates/ide-run/tests/stop_group.rsnew file mode 100644index 000000000..8b26ff945--- /dev/null+++ b/crates/ide-run/tests/stop_group.rs@@ -0,0 +1,158 @@+//! A stopped run reports its exit only once the whole process group is gone, so the next+//! start cannot meet a port the previous process still holds.+#![cfg(unix)]++use ide_core::{IdeEvent, RunId, SharedSink};+use ide_run::{ProcessManager, RunConfig, StartOptions};+use parking_lot::Mutex;+use std::collections::BTreeMap;+use std::sync::Arc;+use std::sync::mpsc::{self, Receiver};+use std::time::{Duration, Instant};++fn channel_sink() -> (SharedSink, Receiver<IdeEvent>) {+ let (tx, events) = mpsc::channel();+ let tx = Mutex::new(tx);+ let sink: SharedSink = Arc::new(move |e: IdeEvent| {+ let _ = tx.lock().send(e);+ });+ (sink, events)+}++fn wait_exit(events: &Receiver<IdeEvent>, id: RunId, timeout: Duration) -> Option<i32> {+ let deadline = Instant::now() + timeout;+ loop {+ let left = deadline.saturating_duration_since(Instant::now());+ match events.recv_timeout(left) {+ Ok(IdeEvent::RunExited { run, code }) if run == id => return code,+ Ok(_) => {}+ Err(_) => return None,+ }+ }+}++#[test]+fn a_stopped_run_keeps_its_port_until_the_group_is_gone() {+ let tmp = tempfile::tempdir().unwrap();+ let (sink, events) = channel_sink();+ let pm = ProcessManager::new();+ // The `mvn`-starts-a-JVM shape: the direct child dies on SIGINT while the process it+ // started ignores it and keeps its socket open for a moment.+ let script = tmp.path().join("hold.py");+ std::fs::write(+ &script,+ "import signal, socket, sys, time\n\+ signal.signal(signal.SIGINT, signal.SIG_IGN)\n\+ s = socket.socket(); s.bind(('127.0.0.1', 0)); s.listen()\n\+ open(sys.argv[1], 'w').write(str(s.getsockname()[1]))\n\+ time.sleep(2)\n",+ )+ .unwrap();+ let port_file = tmp.path().join("port");+ let config = RunConfig {+ id: "boot".into(),+ name: "boot".into(),+ kind: "shell".into(),+ command: "/bin/sh".into(),+ args: vec!["-c".into(), format!("python3 {} {} & sleep 60", script.display(), port_file.display())],+ cwd: None,+ env: BTreeMap::new(),+ detected: false,+ is_test: false,+ debug_adapter: None,+ allow_parallel: false,+ extras: Default::default(),+ };+ let info = pm.start(tmp.path(), &config, &StartOptions::default(), sink, Box::new(|_| {})).expect("start");+ let deadline = Instant::now() + Duration::from_secs(10);+ while std::fs::read_to_string(&port_file).is_err() && Instant::now() < deadline {+ std::thread::sleep(Duration::from_millis(20));+ }+ let port: u16 = std::fs::read_to_string(&port_file).expect("port").trim().parse().unwrap();++ let stopped = Instant::now();+ pm.stop(info.id).unwrap();+ let code = wait_exit(&events, info.id, Duration::from_secs(20));+ let elapsed = stopped.elapsed();+ assert!(code.is_some(), "the run reports its exit");+ assert!(elapsed >= Duration::from_millis(1500), "exit came {elapsed:?} after Stop, before the port was free");+ assert!(+ std::net::TcpStream::connect(("127.0.0.1", port)).is_err(),+ "the port is still bound when the run reports finished"+ );+}++#[test]+fn a_first_stop_does_not_kill_a_program_that_is_still_shutting_down() {+ let tmp = tempfile::tempdir().unwrap();+ let (sink, events) = channel_sink();+ let pm = ProcessManager::new();+ // Ignores SIGINT, then exits by itself after 2 s, like a slow Spring Boot shutdown: a first+ // Stop waits for it instead of killing it (exit code 137).+ let script = tmp.path().join("slow.py");+ std::fs::write(+ &script,+ "import signal, sys, time\n\+ signal.signal(signal.SIGINT, signal.SIG_IGN)\n\+ print('ready', flush=True)\n\+ time.sleep(2)\n",+ )+ .unwrap();+ let config = RunConfig {+ id: "slow".into(),+ name: "slow".into(),+ kind: "shell".into(),+ command: "python3".into(),+ args: vec![script.display().to_string()],+ cwd: None,+ env: BTreeMap::new(),+ detected: false,+ is_test: false,+ debug_adapter: None,+ allow_parallel: false,+ extras: Default::default(),+ };+ let info = pm.start(tmp.path(), &config, &StartOptions::default(), sink, Box::new(|_| {})).expect("start");+ std::thread::sleep(Duration::from_millis(500)); // let the program install its handler+ let start = Instant::now();+ pm.stop(info.id).unwrap();+ let code = wait_exit(&events, info.id, Duration::from_secs(10));+ assert_eq!(code, Some(0), "the program exited by itself, not by SIGKILL");+ assert!(start.elapsed() >= Duration::from_millis(1500), "stop waited for the shutdown, not a timer");+}++#[test]+fn a_second_stop_kills_a_program_that_ignores_the_first() {+ let tmp = tempfile::tempdir().unwrap();+ let (sink, events) = channel_sink();+ let pm = ProcessManager::new();+ let script = tmp.path().join("stuck.py");+ std::fs::write(+ &script,+ "import signal, time\n\+ signal.signal(signal.SIGINT, signal.SIG_IGN)\n\+ time.sleep(60)\n",+ )+ .unwrap();+ let config = RunConfig {+ id: "stuck".into(),+ name: "stuck".into(),+ kind: "shell".into(),+ command: "python3".into(),+ args: vec![script.display().to_string()],+ cwd: None,+ env: BTreeMap::new(),+ detected: false,+ is_test: false,+ debug_adapter: None,+ allow_parallel: false,+ extras: Default::default(),+ };+ let info = pm.start(tmp.path(), &config, &StartOptions::default(), sink, Box::new(|_| {})).expect("start");+ std::thread::sleep(Duration::from_millis(500));+ pm.stop(info.id).unwrap();+ std::thread::sleep(Duration::from_millis(200));+ pm.stop(info.id).unwrap();+ let code = wait_exit(&events, info.id, Duration::from_secs(10));+ assert_eq!(code, Some(137), "the second Stop SIGKILLs");+}diff --git a/src/features/app/Termination.module.css b/src/features/app/Termination.module.cssnew file mode 100644index 000000000..e7b375824--- /dev/null+++ b/src/features/app/Termination.module.css@@ -0,0 +1,12 @@+.body {+ display: flex;+ flex-direction: column;+ gap: 10px;+ min-width: 360px;+ padding: 2px 16px 12px;+}++.text {+ color: var(--fg-secondary);+ font-size: 13px;+}diff --git a/src/features/app/__tests__/closeGuard.test.ts b/src/features/app/__tests__/closeGuard.test.tsindex c703c1b9c..23e5952bc 100644--- a/src/features/app/__tests__/closeGuard.test.ts+++ b/src/features/app/__tests__/closeGuard.test.ts@@ -60,6 +60,22 @@ describe("decideClose", () => {expect(asked).toHaveLength(0);});+ it("stops the processes gracefully and waits for them before closing", async () => {+ const { d } = deps([{ button: "terminate", checked: false }]);+ d.terminate = vi.fn(async () => {});+ d.waitForProcesses = vi.fn(async () => {});+ await expect(decideClose({ ...base, confirmTerminate: true, processes: ["app"] }, d)).resolves.toBe(true);+ expect(d.terminate).toHaveBeenCalledWith(false);+ expect(d.waitForProcesses).toHaveBeenCalledOnce();+ });++ it("does not stop anything when the terminate prompt is cancelled", async () => {+ const { d } = deps([{ button: "cancel", checked: false }]);+ d.terminate = vi.fn(async () => {});+ await expect(decideClose({ ...base, confirmTerminate: true, processes: ["app"] }, d)).resolves.toBe(false);+ expect(d.terminate).not.toHaveBeenCalled();+ });+it("asks before terminating a running process", async () => {const { d, asked } = deps([{ button: "terminate", checked: false }]);await expect(decideClose({ ...base, confirmTerminate: true, processes: ["app"] }, d)).resolves.toBe(true);diff --git a/src/features/app/closeGuard.ts b/src/features/app/closeGuard.tsindex dff728230..084fb5244 100644--- a/src/features/app/closeGuard.ts+++ b/src/features/app/closeGuard.ts@@ -16,8 +16,10 @@ import {maybeEditorService,notifications,runningProcesses as liveProcesses,+ stopRunningProcesses,type EditorCloseSession,} from "@/workbench/contributions";+import { beginTermination, endTermination } from "./termination";import { ask, type Ask } from "@/workbench/messages";import { AUX_CLOSED, auxiliaryWindow, closeDocumentWindows, type AuxCloseResult } from "@/platform/auxWindow";@@ -50,6 +52,10 @@ export interface CloseDeps {disableConfirmTerminate: () => Promise<void>;/** Running Run/Debug process names in this window. */runningProcesses: () => Promise<readonly string[]>;+ /** Stops them, gracefully first and SIGKILL when asked, as IDEA's close does. */+ terminate?: (kill: boolean) => Promise<void>;+ /** Resolves once no process of this window is left. */+ waitForProcesses?: () => Promise<void>;onSaveFailed: (e: unknown) => void;/** Stops custom document edits/execution before reading their final dirty state. */prepareClose?: () => Promise<EditorCloseSession | undefined>;@@ -67,6 +73,7 @@ export async function decideClose(input: CloseInput, deps: CloseDeps): Promise<bif (r.button !== "exit") return false;if (r.checked) await deps.disableConfirmExit().catch(() => {});}+ let terminateNames: readonly string[] = [];if (input.confirmTerminate && input.processes.length > 0) {const names = input.processes;const r = await deps.ask({@@ -84,6 +91,8 @@ export async function decideClose(input: CloseInput, deps: CloseDeps): Promise<b});if (r.button !== "terminate") return false;if (r.checked) await deps.disableConfirmTerminate().catch(() => {});+ // Terminated after the save question below, so cancelling that keeps the processes alive.+ terminateNames = names;}let session: EditorCloseSession | undefined;let authorized = false;@@ -104,6 +113,9 @@ export async function decideClose(input: CloseInput, deps: CloseDeps): Promise<belse if (r.button === "discard") await session?.discard();else return false;}+ // IDEA asks, then shows "Terminating 'X'" while the graceful shutdown runs; a Kill button+ // there kills the processes and the close finishes once none is left.+ if (terminateNames.length > 0) await terminateForClose(terminateNames, deps);session?.commit();authorized = true;return true;@@ -130,6 +142,10 @@ const defaultDeps: CloseDeps = {if (r.status === "ok") useProject.setState({ settings: r.data });},runningProcesses: async () => (await liveProcesses()).map((p) => p.name),+ terminate: (kill) => stopRunningProcesses(kill),+ waitForProcesses: async () => {+ while ((await liveProcesses()).length > 0) await new Promise((r) => setTimeout(r, 100));+ },onSaveFailed: (e) =>notifications().notify({level: "error",@@ -138,6 +154,20 @@ const defaultDeps: CloseDeps = {}),};+/** The close waits for the processes, with the progress panel and a Kill escape hatch. */+async function terminateForClose(names: readonly string[], deps: CloseDeps): Promise<void> {+ if (!deps.terminate) return;+ beginTermination(names, () => {+ void deps.terminate?.(true).catch(() => undefined);+ });+ try {+ await deps.terminate(false);+ await deps.waitForProcesses?.();+ } finally {+ endTermination();+ }+}+/** Process names this close would terminate; an unavailable feature list never blocks closing. */async function processNames(deps: CloseDeps): Promise<string[]> {return [...new Set(await deps.runningProcesses().catch(() => []))].filter(Boolean);diff --git a/src/features/app/index.ts b/src/features/app/index.tsindex d86eef2cb..abc6b5667 100644--- a/src/features/app/index.ts+++ b/src/features/app/index.ts@@ -7,6 +7,7 @@ import { AboutOverlay } from "./AboutDialog";import { appActions, updateActions } from "./appActions";import { checkForUpdatesOnStartup } from "./updates";import { installCloseGuard } from "./closeGuard";+import { TerminationOverlay } from "./termination";import { InvalidateCachesOverlay, registerInvalidateCachesActions } from "./InvalidateCaches";import { buildInfo } from "./host";import { KeymapReferenceOverlay } from "./KeymapReference";@@ -34,6 +35,7 @@ export function activate(): () => void {registerOverlay({ id: "app.keymapReference", component: KeymapReferenceOverlay }),registerOverlay({ id: "app.invalidateCaches", component: InvalidateCachesOverlay }),registerOverlay({ id: "app.newProject", component: NewProjectOverlay }),+ registerOverlay({ id: "app.termination", component: TerminationOverlay }),registerStatusItem({id: "app.lightEdit",align: "left",diff --git a/src/features/app/termination.tsx b/src/features/app/termination.tsxnew file mode 100644index 000000000..42bde8774--- /dev/null+++ b/src/features/app/termination.tsx@@ -0,0 +1,44 @@+/** IDEA's "Terminating 'X'" progress: a graceful stop in flight, with a Kill escape hatch. */+import { create } from "zustand";+import { Dialog, ProgressBar } from "@/ui";+import { tx } from "@/platform/i18n";+import styles from "./Termination.module.css";++interface TerminationState {+ names: readonly string[];+ /** Set while the window waits for the processes to disappear. */+ active: boolean;+ kill: () => void;+}++const useTermination = create<TerminationState>(() => ({ names: [], active: false, kill: () => {} }));++/** Shows the progress panel; call [`endTermination`] once every process is gone. */+export function beginTermination(names: readonly string[], kill: () => void) {+ useTermination.setState({ names, active: true, kill });+}++export function endTermination() {+ useTermination.setState({ names: [], active: false, kill: () => {} });+}++export function TerminationOverlay() {+ const { names, active, kill } = useTermination();+ if (!active) return null;+ const title = names.length > 1 ? tx`Terminating ${names.length} processes` : tx`Terminating '${names[0] ?? ""}'`;+ return (+ <Dialog+ open+ // The close is in flight: Escape must not dismiss the only progress the window shows.+ onClose={() => {}}+ title={title}+ width={420}+ buttons={[{ label: tx`Kill process`, role: "default", onClick: kill }]}+ >+ <div className={styles.body}>+ <ProgressBar aria-label={tx`Terminating`} />+ <div className={styles.text}>{tx`Waiting for process detach`}</div>+ </div>+ </Dialog>+ );+}diff --git a/src/features/debugger/state.ts b/src/features/debugger/state.tsindex 2d619c5d4..877e3e30d 100644--- a/src/features/debugger/state.ts+++ b/src/features/debugger/state.ts@@ -34,7 +34,7 @@ import { flashTaskbarForBreakpoint, stopTaskbarFlash } from "./taskbarFlash";import { missingAdapter } from "./missingAdapter";import { startFailureMessage } from "./startFailure";-export type SessionStatus = "starting" | "running" | "paused" | "terminated";+export type SessionStatus = "starting" | "running" | "paused" | "stopping" | "terminated";export interface DebugSession {id: DebugSessionId;@@ -328,6 +328,7 @@ export function publishContext() {configId: session.runConfig?.id ?? null,name: session.runConfig?.name ?? session.name,startedAt: session.startedAt ?? 0,+ status: session.status,paused: !!paused,rerun: session.runConfig || session.launch ? () => void rerunSession(session.id) : null,stop: () => void stopSession(session.id),@@ -663,6 +664,12 @@ export async function stopSession(id: DebugSessionId, options: { stopProcess?: bmarkTerminated(root.id);return;}+ // Between the Stop press and the adapter's terminated event the session is shutting down:+ // keep it live (Run stays disabled) and let the toolbar show the spinner.+ for (const sid of new Set([root.id, s.id])) {+ const target = useDebug.getState().sessions[sid];+ if (target && isLive(target)) patch(sid, { status: "stopping" });+ }try {await call(commands.debugStop(root.id));} catch (e) {diff --git a/src/features/run/Run.module.css b/src/features/run/Run.module.cssindex 7bf99d8fd..890faec31 100644--- a/src/features/run/Run.module.css+++ b/src/features/run/Run.module.css@@ -284,6 +284,16 @@.widgetFilledStop:hover:not(:disabled) {background: var(--danger);}+.widgetStopping {+ display: inline-flex;+ align-items: center;+ justify-content: center;+ padding: 0;+ border: none;+ line-height: 0;+ background: var(--warning);+ color: var(--fg-on-accent);+}.widgetFilled:hover:not(:disabled) {filter: brightness(0.94);}diff --git a/src/features/run/RunView.tsx b/src/features/run/RunView.tsxindex 0d6ddac4a..994e87c39 100644--- a/src/features/run/RunView.tsx+++ b/src/features/run/RunView.tsx@@ -27,6 +27,7 @@ import {useRun,writeTerminal,type RunSession,+ isLive,} from "./store";import { TestTreeView, formatDuration } from "./TestTreeView";import { StackTracePanel, closeStackTrace, useStackTraces, type StackTraceTab } from "./stackTrace";@@ -46,7 +47,7 @@ function failed(s: RunSession): boolean {* configuration's own icon (Services keeps the same model, see services.tsx).*/export function sessionIcon(s: RunSession): string {- if (s.status === "running" || s.status === "starting") return s.config.isTest ? "check" : "run";+ if (isLive(s)) return s.config.isTest ? "check" : "run";if (failed(s)) return "error";// Ended (exit or stop): the configuration's own icon — the green arrow stays "still running".return configIcon(s.config);@@ -74,7 +75,7 @@ export function SessionPanel({const softWrap = wrapOverride ?? defaultWrap;const [selectedTest, setSelectedTest] = useState<string | null>(null);const [findOpen, setFindOpen] = useState(false);- const running = session.status === "running" || session.status === "starting";+ const running = isLive(session);const cwd = runDirectory(session.config.cwd);// Selecting a test with captured output shows just that output (like IDEA).@@ -170,7 +171,7 @@ export function SessionPanel({<IconButtonicon="stop"iconSize={13}- title="Stop"+ title={session.status === "stopping" ? tx`Stopping… (click to kill)` : "Stop"}tone={running || onStop ? "danger" : "default"}disabled={!running && !onStop}onClick={onStop ?? (() => void stopSession(session.id))}diff --git a/src/features/run/RunWidget.test.tsx b/src/features/run/RunWidget.test.tsxindex 858fa3b3e..8fe01e078 100644--- a/src/features/run/RunWidget.test.tsx+++ b/src/features/run/RunWidget.test.tsx@@ -98,6 +98,12 @@ it("targets the selected debug session while npm runs, through buttons and shortexpect(useRun.getState().sessions[0]?.stopped).toBeUndefined();});+it("turns Stop into Kill process while the process is shutting down", () => {+ useRun.setState({ sessions: [{ ...run(app), status: "stopping" }] });+ render(<RunWidget />);+ expect(screen.getByRole("button", { name: "Kill process" })).toBeTruthy();+});+it("lists every running process with Stop All for the Stop shortcut, like IDEA", async () => {const session = debug(app);useRun.setState({ sessions: [run(npm, 3)] });diff --git a/src/features/run/RunWidget.tsx b/src/features/run/RunWidget.tsxindex 2254b24b8..7fb7bb621 100644--- a/src/features/run/RunWidget.tsx+++ b/src/features/run/RunWidget.tsx@@ -1,13 +1,13 @@import { useRef, useState } from "react";import clsx from "clsx";-import { BarButton, Icon, IconButton, Menu, type MenuItem } from "@/ui";+import { BarButton, Icon, IconButton, Menu, Spinner, type MenuItem } from "@/ui";import { executeAction } from "@/platform/actions";import { useTx } from "@/platform/i18n";import { shortcutLabel } from "@/platform/keymap";import { runExecutors, useRunExecutors, useDebugRunSessions } from "@/workbench/contributions";import { configIcon } from "./configs";import { useRemoteLabel } from "./remote";-import { CURRENT_FILE, useRun } from "./store";+import { CURRENT_FILE, useRun, isLive } from "./store";import { compoundTargets, selectedTarget } from "./sessionTargets";import { isDebugOnly } from "./types";import styles from "./Run.module.css";@@ -24,13 +24,17 @@ export function RunWidget() {const currentFile = selectedId === CURRENT_FILE;// Remote JVM Debug and the like: only Debug applies, as in IDEA.const debugOnly = !!selected && isDebugOnly(selected);- const running = sessions.filter((s) => s.status === "running" || s.status === "starting");+ const running = sessions.filter((s) => isLive(s));const debug = useDebugRunSessions((s) => s.sessions);const compoundRunning = compoundTargets(selected, running, debug);const target = selectedTarget(selectedId, running, debug);const debugging = !!target?.debug;const active = !!target || compoundRunning.length > 0;const count = running.length + debug.length;+ const stopping = running.some((s) => s.status === "stopping") || debug.some((s) => s.status === "stopping");+ const targetStopping =+ running.some((s) => s.status === "stopping" && s.config.id === selectedId) ||+ debug.some((s) => s.status === "stopping" && s.configId === selectedId);const stopName = compoundRunning.length? selected?.name: (target?.name ?? running[0]?.config.name ?? debug[0]?.name);@@ -100,7 +104,7 @@ export function RunWidget() {className={clsx(styles.widgetButton, styles.widgetFilled, styles.widgetFilledRun)}title={tx`Rerun '${selected?.name ?? target?.name ?? ""}'`}shortcut={shortcutLabel("run.run")}- disabled={!!target && !target.rerun}+ disabled={!!target && (!target.rerun || targetStopping)}onClick={() => void executeAction("run.run")}/></>@@ -136,17 +140,30 @@ export function RunWidget() {/></>)}- {count > 0 && (- <IconButton- icon="stop-filled"- size="large"- iconSize={16}- className={clsx(styles.widgetButton, styles.widgetFilled, styles.widgetFilledStop)}- title={active || count === 1 ? tx`Stop '${stopName ?? ""}'` : tx`Stop (${count} running)`}- shortcut={shortcutLabel("run.stop")}- onClick={() => void executeAction("run.stop", "widget")}- />- )}+ {count > 0 &&+ (stopping ? (+ // Between Stop and the exit: a spinner says the process is shutting down, and the+ // button kills it on the next click (IDEA's Stop turns into Kill process).+ <button+ type="button"+ className={clsx(styles.widgetButton, styles.widgetFilled, styles.widgetFilledStop, styles.widgetStopping)}+ title={tx`Kill process`}+ aria-label={tx`Kill process`}+ onClick={() => void executeAction("run.stop", "widget")}+ >+ <Spinner size={14} />+ </button>+ ) : (+ <IconButton+ icon="stop-filled"+ size="large"+ iconSize={16}+ className={clsx(styles.widgetButton, styles.widgetFilled, styles.widgetFilledStop)}+ title={active || count === 1 ? tx`Stop '${stopName ?? ""}'` : tx`Stop (${count} running)`}+ shortcut={shortcutLabel("run.stop")}+ onClick={() => void executeAction("run.stop", "widget")}+ />+ ))}<IconButtonref={moreRef}icon="more"diff --git a/src/features/run/applicationUpdate.test.ts b/src/features/run/applicationUpdate.test.tsindex 35ded3f83..437a669b6 100644--- a/src/features/run/applicationUpdate.test.ts+++ b/src/features/run/applicationUpdate.test.ts@@ -102,7 +102,7 @@ describe("Tomcat application updates", () => {it("waits for clean shutdown before restarting a debug server", async () => {await updateTomcat(session, "restart");expect(mocks.stop).toHaveBeenCalledWith("run1");- expect(mocks.wait).toHaveBeenCalledWith(["run1"]);+ expect(mocks.wait).toHaveBeenCalledWith(["run1"], null);expect(mocks.wait.mock.invocationCallOrder[0]).toBeLessThan(mocks.action.mock.invocationCallOrder[0]!);expect(mocks.action).toHaveBeenCalledWith("run.debugConfig", session.config);});diff --git a/src/features/run/applicationUpdate.ts b/src/features/run/applicationUpdate.tsindex 02c52a011..6b8482a86 100644--- a/src/features/run/applicationUpdate.ts+++ b/src/features/run/applicationUpdate.ts@@ -78,7 +78,7 @@ export async function updateApplication(session: UpdateSession, mode: string): Pawait executeAction("run.debugConfig", config);} else if (debugging) {await stopSession(session.id);- await waitForExit([session.id]);+ await waitForExit([session.id], null);await executeAction("run.debugConfig", config);} else await startRun(config, session.id);return;diff --git a/src/features/run/index.ts b/src/features/run/index.tsindex c6c4d3e37..2b8fd024b 100644--- a/src/features/run/index.ts+++ b/src/features/run/index.ts@@ -77,6 +77,7 @@ import {stopSession,trackRecentConfigurations,useRun,+ isLive,} from "./store";import { compoundTargets, selectedTarget } from "./sessionTargets";import { tx } from "@/platform/i18n";@@ -241,7 +242,22 @@ function stopAction(arg?: unknown) {})),...menuGroupItems("stopProcess", { paths: [] }),].filter((i): i is MenuItem & { run: () => void } => "run" in i && !!i.run);- if (items.length === 0) return;+ // A Debug launch has no Run process: with nothing else to stop, the title-bar Stop reaches+ // the debug session itself (the Debug window need not be focused).+ if (items.length === 0) {+ if (debug.length === 0) return;+ if (debug.length === 1) {+ debug[0]!.stop();+ return;+ }+ const anchor = document.querySelector("[data-run-chooser]")?.getBoundingClientRect();+ const at = anchor ? { x: anchor.left, y: anchor.bottom + 4 } : { x: window.innerWidth / 2 - 120, y: 44 };+ showContextMenu(at, [+ { kind: "header", label: "Stop Process" },+ ...debug.map((s): MenuItem => ({ label: s.name, verbatim: true, icon: "debug", run: () => s.stop() })),+ ]);+ return;+ }if (items.length === 1) {items[0]!.run();return;@@ -264,7 +280,7 @@ function rerunActive() {}function useRunningCount(): number | null {- return useRun((s) => s.sessions.filter((x) => x.status === "running" || x.status === "starting").length || null);+ return useRun((s) => s.sessions.filter(isLive).length || null);}const CONFIG_FILES =@@ -304,6 +320,20 @@ export function activate(): () => void {serviceSessions(useRun.getState().sessions, useDebugRunSessions.getState().serviceSessions).filter(liveServiceSession).map((s) => ({ name: s.config.name })),+ // A closing window asks first, then shows the progress while these shut down; `kill`+ // is the second Stop that SIGKILLs instead of waiting.+ stop: (kill) => {+ // The first call asks to stop; with `kill` the second one reaches the backend while+ // the session is already stopping, which turns it into SIGKILL.+ for (const s of useRun.getState().sessions.filter(isLive)) {+ void stopSession(s.id);+ if (kill) void stopSession(s.id);+ }+ for (const d of useDebugRunSessions.getState().sessions) {+ d.stop();+ if (kill) d.stop();+ }+ },}),onWorkflowSettingsChange((w) => w.console, applyConsoleSettings),registerExternalTools(),diff --git a/src/features/run/serviceSessions.test.ts b/src/features/run/serviceSessions.test.tsindex 4bac8b315..35ee54ac6 100644--- a/src/features/run/serviceSessions.test.ts+++ b/src/features/run/serviceSessions.test.ts@@ -11,6 +11,8 @@ const { stopRun, waitForExit, getSession } = vi.hoisted(() => ({}));vi.mock("./store", () => ({stopSession: stopRun,+ // The real predicate: a stopping run is still live.+ isLive: (s: RunSession) => s.status === "running" || s.status === "starting" || s.status === "stopping",waitForExit,useRun: { getState: () => ({ sessions: [getSession()].filter(Boolean) }) },}));diff --git a/src/features/run/serviceSessions.ts b/src/features/run/serviceSessions.tsindex 49f217b7c..743efebc5 100644--- a/src/features/run/serviceSessions.ts+++ b/src/features/run/serviceSessions.ts@@ -1,6 +1,6 @@import type { RunConfig } from "@/platform/ipc";import type { DebugServiceSession } from "@/workbench/contributions";-import { stopSession, useRun, waitForExit, type RunSession } from "./store";+import { stopSession, useRun, waitForExit, type RunSession, isLive } from "./store";/** One execution: a Run process and its attached debuggers, or a direct debug launch. */export interface ServiceSession {@@ -10,7 +10,7 @@ export interface ServiceSession {debug: DebugServiceSession[];}-const running = (s: RunSession) => s.status === "running" || s.status === "starting";+const running = (s: RunSession) => isLive(s);const debugging = (s: DebugServiceSession) => s.status !== "terminated";export function serviceSessions(runs: readonly RunSession[], debug: readonly DebugServiceSession[]): ServiceSession[] {diff --git a/src/features/run/services.tsx b/src/features/run/services.tsxindex 88f700554..7c27f6ea3 100644--- a/src/features/run/services.tsx+++ b/src/features/run/services.tsx@@ -38,6 +38,7 @@ import {stopSession,useRun,type RunSession,+ isLive,} from "./store";import {currentServiceSession,@@ -208,7 +209,7 @@ export async function cleanupRemovedProject(removedRoot: string): Promise<void>// ---------------------------------------------------------------------------// Tree-const busy = (s: RunSession) => s.status === "running" || s.status === "starting";+const busy = (s: RunSession) => isLive(s);export function sessionStatus(s: RunSession | undefined): string | undefined {if (!s) return undefined;diff --git a/src/features/run/sessionTargets.ts b/src/features/run/sessionTargets.tsindex 367a9e37f..6c3c1c46e 100644--- a/src/features/run/sessionTargets.ts+++ b/src/features/run/sessionTargets.ts@@ -1,13 +1,13 @@import { compoundChildren } from "./configs";import type { RunConfig } from "@/platform/ipc";import type { DebugRunSession } from "@/workbench/contributions";-import { rerunSession, sessionsOf, stopSession, useRun, type RunSession } from "./store";+import { rerunSession, sessionsOf, stopSession, useRun, type RunSession, isLive } from "./store";/** Selection, never tool-window focus or an unrelated process, determines the primary target. */export function selectedTarget(selectedId: string | null, runs: RunSession[], debug: DebugRunSession[]) {const candidates = [...runs- .filter((s) => (s.status === "running" || s.status === "starting") && s.config.id === selectedId)+ .filter((s) => isLive(s) && s.config.id === selectedId).map((s) => ({name: s.config.name,startedAt: s.startedAt,diff --git a/src/features/run/stopStatus.test.ts b/src/features/run/stopStatus.test.tsnew file mode 100644index 000000000..08d03f82e--- /dev/null+++ b/src/features/run/stopStatus.test.ts@@ -0,0 +1,74 @@+import { beforeEach, describe, expect, it, vi } from "vitest";+import type { RunConfig } from "@/platform/ipc";++const runStop = vi.hoisted(() => vi.fn(async () => ({ status: "ok" as const, data: null })));+vi.mock("@/platform/ipc", async (importOriginal) => {+ const real = await importOriginal<typeof import("@/platform/ipc")>();+ return {+ ...real,+ isTauri: () => true,+ commands: { ...real.commands, runStop },+ call: async (p: Promise<{ status: "ok"; data: unknown }>) => (await p).data,+ };+});+vi.mock("@/workbench/contributions", async (importOriginal) => {+ const real = await importOriginal<typeof import("@/workbench/contributions")>();+ return { ...real, notifications: () => ({ notify: () => undefined }) };+});++import { isLive, onRunExited, stopSession, useRun, type RunSession } from "./store";++const config: RunConfig = {+ id: "app",+ name: "app",+ kind: "spring-boot",+ command: "java",+ args: [],+ cwd: null,+ env: {},+ detected: false,+ isTest: false,+ debugAdapter: null,+};++const session: RunSession = {+ id: "s1",+ config,+ runId: 7 as RunSession["runId"],+ status: "running",+ exitCode: null,+ startedAt: 0,+ endedAt: null,+ stdinClosed: false,+};++beforeEach(() => {+ runStop.mockClear();+ useRun.setState({ sessions: [session], activeSession: "s1" });+});++describe("Stop keeps the tab live until the process is gone", () => {+ it("a stopping run counts as live", () => {+ for (const status of ["starting", "running", "stopping"] as const) expect(isLive({ status }), status).toBe(true);+ for (const status of ["finished", "failed"] as const) expect(isLive({ status }), status).toBe(false);+ });++ it("stays stopping after the stop request and only finishes on the exit event", async () => {+ await stopSession("s1");+ expect(runStop).toHaveBeenCalledWith(session.runId);+ expect(useRun.getState().sessions[0]).toMatchObject({ status: "stopping", stopped: true });+ // The button stays Stop while the process shuts down: Run must not start again yet.+ expect(isLive(useRun.getState().sessions[0]!)).toBe(true);++ onRunExited(session.runId!, 130);+ await new Promise((r) => setTimeout(r, 10));+ expect(useRun.getState().sessions[0]?.status).toBe("finished");+ expect(isLive(useRun.getState().sessions[0]!)).toBe(false);+ });++ it("a second Stop while stopping asks the server to kill it", async () => {+ await stopSession("s1");+ await stopSession("s1");+ expect(runStop).toHaveBeenCalledTimes(2);+ });+});diff --git a/src/features/run/store.ts b/src/features/run/store.tsindex 8e5162405..97ccc3374 100644--- a/src/features/run/store.ts+++ b/src/features/run/store.ts@@ -63,7 +63,12 @@ import { tx } from "@/platform/i18n";/** The permanent "Current File" pseudo-configuration of the chooser (runs the active file's context). */export const CURRENT_FILE = "current-file";-export type SessionStatus = "starting" | "running" | "finished" | "failed";+export type SessionStatus = "starting" | "running" | "stopping" | "finished" | "failed";++/** Whether the process is alive: starting, running, or shutting down after Stop. */+export function isLive(s: { status: SessionStatus }): boolean {+ return s.status === "starting" || s.status === "running" || s.status === "stopping";+}export interface RunSession {id: string;@@ -385,9 +390,7 @@ export function adoptTemporary(config: RunConfig): RunConfig {return existing;}let temporary = [...state.temporary.filter((id) => id !== config.id), config.id];- const busy = new Set(- state.sessions.filter((x) => x.status === "running" || x.status === "starting").map((x) => x.config.id),- );+ const busy = new Set(state.sessions.filter(isLive).map((x) => x.config.id));for (const session of useDebugRunSessions.getState().sessions) if (session.configId) busy.add(session.configId);while (temporary.length > MAX_TEMPORARY) {const evict = temporary.find((id) => id !== config.id && !busy.has(id)) ?? temporary[0]!;@@ -669,7 +672,7 @@ export async function startRun(}if (!options.launch && !options.prepared && !(await prepareLaunch(config, options.chain))) return null;const state = useRun.getState();- const busy = (s: RunSession) => s.status === "running" || s.status === "starting";+ const busy = (s: RunSession) => isLive(s);let session = reuse ? state.sessions.find((s) => s.id === reuse) : undefined;// As in IDEA, a configuration that doesn't allow parallel// runs asks before stopping its running instances; rerunning a tab restarts it without asking.@@ -690,8 +693,9 @@ export async function startRun(await stopSession(session.id);stopping.push(session.id);}- // The new process starts once the old one is gone (it may still hold a port or a lock).- await waitForExit(stopping);+ // The new process starts once the old one is gone (it may still hold a port or a lock). As in+ // IDEA there is no time limit: a first Stop waits for the shutdown, a second one kills it.+ await waitForExit(stopping, null);session ??= state.sessions.find((s) => s.config.id === config.id && !busy(s));try {@@ -916,7 +920,13 @@ const pendingExits = new Map<RunId, number | null>();function finishSession(sessionId: string, code: number | null) {const rt = runtimes.get(sessionId);const session = getSession(sessionId);- if (!rt || !session) return;+ if (!session) return;+ if (!rt) {+ // Nothing to flush: the run's output runtime is gone already. The exit is still the+ // authority on the process being over, so the tab must not stay "stopping" for ever.+ patchSession(sessionId, { status: "finished", exitCode: code, endedAt: Date.now() });+ return;+ }// Output still on the channel lands before the exit is applied.setTimeout(() => {void (async () => {@@ -1036,11 +1046,14 @@ export async function stopSession(sessionId: string): Promise<void> {await commands.cancelRequest(request.id);return;}- if (session.runId === null || session.status !== "running") return;- patchSession(sessionId, { stopped: true });+ if (session.runId === null || !isLive(session)) return;+ // Stopping keeps the process live (IDEA: the Stop button stays until the process is gone);+ // a second Stop meanwhile skips the grace period and kills it.+ patchSession(sessionId, { stopped: true, status: "stopping" });try {await call(commands.runStop(session.runId));} catch (e) {+ patchSession(sessionId, { status: "running" });notifications().notify({group: "run",level: "error",@@ -1050,12 +1063,12 @@ export async function stopSession(sessionId: string): Promise<void> {}}-/** Resolves once the given sessions' processes exited (or after `timeoutMs`). */-export function waitForExit(sessionIds: readonly string[], timeoutMs = 10_000): Promise<void> {+/** Resolves once the given sessions' processes exited (or after `timeoutMs`, unless `null`). */+export function waitForExit(sessionIds: readonly string[], timeoutMs: number | null = 10_000): Promise<void> {const live = () =>sessionIds.some((id) => {const s = getSession(id);- return !!s && s.runId !== null && s.status === "running";+ return !!s && s.runId !== null && isLive(s);});if (!live()) return Promise.resolve();return new Promise((resolve) => {@@ -1064,7 +1077,7 @@ export function waitForExit(sessionIds: readonly string[], timeoutMs = 10_000):unsubscribe();resolve();};- const timer = setTimeout(done, timeoutMs);+ const timer = timeoutMs === null ? undefined : setTimeout(done, timeoutMs);const unsubscribe = useRun.subscribe(() => {if (!live()) done();});@@ -1121,7 +1134,7 @@ export function failedTests(sessionId: string): string[][] {/** "Rerun Failed Tests": reruns only the failed tests in the same tab. Returns false when unsupported. */export function rerunFailed(sessionId: string): boolean {const session = getSession(sessionId);- if (!session || session.status === "running" || session.status === "starting") return false;+ if (!session || isLive(session)) return false;const base = baseConfigOf(session);const derived = rerunFailedConfig(base, failedTests(sessionId));if (!derived) return false;@@ -1222,7 +1235,7 @@ export function clearConsole(sessionId: string) {export async function closeSessionTab(sessionId: string): Promise<boolean> {const session = getSession(sessionId);if (!session) return false;- const running = session.status === "running" || session.status === "starting";+ const running = isLive(session);if (running && workflowSettings().run.confirmTerminate && !(await confirmTerminate(session.config.name)))return false;closeSession(sessionId);@@ -1232,7 +1245,7 @@ export async function closeSessionTab(sessionId: string): Promise<boolean> {export function closeSession(sessionId: string) {const session = getSession(sessionId);if (!session) return;- if (session.status === "running" || session.status === "starting") void stopSession(sessionId);+ if (isLive(session)) void stopSession(sessionId);const rt = runtimes.get(sessionId);if (rt) cancelFlush(rt);runtimes.delete(sessionId);@@ -1248,7 +1261,7 @@ export function closeSession(sessionId: string) {}export function runningSessions(): RunSession[] {- return useRun.getState().sessions.filter((s) => s.status === "running" || s.status === "starting");+ return useRun.getState().sessions.filter(isLive);}/** Stops everything and forgets sessions (project closed). */diff --git a/src/features/settings/pages/execution.tsx b/src/features/settings/pages/execution.tsxindex eaae115b6..1a438e942 100644--- a/src/features/settings/pages/execution.tsx+++ b/src/features/settings/pages/execution.tsx@@ -314,7 +314,7 @@ export const EXECUTION_PAGES: PageSpec[] = [integer: true,step: 500,unit: "ms",- hint: "After Stop, the process gets this long to exit after the interrupt before it is killed.",+ hint: "After a configuration's stop command, the process gets this long to exit before it is interrupted. Press Stop again to kill a process that doesn't exit.",},],},diff --git a/src/platform/locales/text/es.json b/src/platform/locales/text/es.jsonindex e1274fb80..442e2260f 100644--- a/src/platform/locales/text/es.json+++ b/src/platform/locales/text/es.json@@ -216,7 +216,6 @@"Additional arguments": "Argumentos adicionales","Adjust colors for red-green vision deficiency": "Ajustar colores para deficiencia visual rojo-verde","After Replace": "Después de reemplazar",- "After Stop, the process gets this long to exit after the interrupt before it is killed.": "Después de Detener, el proceso dispone de este tiempo para terminar tras la interrupción antes de ser forzado a cerrar.","Align Changes": "Alinear cambios","All": "Todo","All Places": "Todos los lugares",diff --git a/src/platform/locales/text/fr.json b/src/platform/locales/text/fr.jsonindex 990e299ae..057fe0ee9 100644--- a/src/platform/locales/text/fr.json+++ b/src/platform/locales/text/fr.json@@ -164,7 +164,6 @@"Additional arguments": "Arguments supplémentaires","Adjust colors for red-green vision deficiency": "Ajuster les couleurs pour le daltonisme rouge-vert","After Replace": "Après remplacement",- "After Stop, the process gets this long to exit after the interrupt before it is killed.": "Après un arrêt, délai laissé au processus pour se terminer après l'interruption avant d'être tué.","Align Changes": "Aligner les modifications","All": "Tout","All Places": "Tous les emplacements",diff --git a/src/platform/locales/text/ko.json b/src/platform/locales/text/ko.jsonindex d061836d4..89da00abd 100644--- a/src/platform/locales/text/ko.json+++ b/src/platform/locales/text/ko.json@@ -256,7 +256,6 @@"Additional arguments": "추가 인수","Adjust colors for red-green vision deficiency": "적록 색각 이상자를 위한 색상 조정","After Replace": "바꾼 후",- "After Stop, the process gets this long to exit after the interrupt before it is killed.": "중지 후 프로세스가 강제 종료되기 전까지 인터럽트 후 종료할 수 있는 시간입니다.","Align Changes": "변경 사항 정렬","All": "모두","All Places": "모든 위치",diff --git a/src/platform/locales/text/pl.json b/src/platform/locales/text/pl.jsonindex 3435a68c4..ecc1d63ee 100644--- a/src/platform/locales/text/pl.json+++ b/src/platform/locales/text/pl.json@@ -208,7 +208,6 @@"Additional arguments": "Dodatkowe argumenty","Adjust colors for red-green vision deficiency": "Dostosuj kolory dla zaburzeń rozpoznawania barwy czerwonej i zielonej","After Replace": "Po zastąpieniu",- "After Stop, the process gets this long to exit after the interrupt before it is killed.": "Po zatrzymaniu proces ma tyle czasu na zakończenie po przerwaniu, zanim zostanie wymuszone jego zamknięcie.","Align Changes": "Wyrównaj zmiany","All": "Wszystko","All Places": "Wszystkie miejsca",diff --git a/src/platform/locales/text/pt.json b/src/platform/locales/text/pt.jsonindex 5f01749db..5db18741e 100644--- a/src/platform/locales/text/pt.json+++ b/src/platform/locales/text/pt.json@@ -208,7 +208,6 @@"Additional arguments": "Argumentos adicionais","Adjust colors for red-green vision deficiency": "Ajustar cores para daltonismo vermelho-verde","After Replace": "Após substituição",- "After Stop, the process gets this long to exit after the interrupt before it is killed.": "Após a parada, o processo tem esse tempo para sair após a interrupção antes de ser encerrado à força.","Align Changes": "Alinhar alterações","All": "Tudo","All Places": "Todos os locais",diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.jsonindex 0d87f187e..c70435fb7 100644--- a/src/platform/locales/text/zh.json+++ b/src/platform/locales/text/zh.json@@ -259,7 +259,7 @@"Additional arguments": "附加实参","Adjust colors for red-green vision deficiency": "针对红绿色觉缺陷调整颜色","After Replace": "替换后",- "After Stop, the process gets this long to exit after the interrupt before it is killed.": "停止后,进程在收到中断信号后有这么长时间退出,超时将被强制终止。",+ "After a configuration's stop command, the process gets this long to exit before it is interrupted. Press Stop again to kill a process that doesn't exit.": "配置了停止命令时,进程在停止命令执行后有这么长时间退出,超时后发送中断信号。进程不退出时,再按一次停止可强制终止。","Align Changes": "对齐更改","All": "全部","All Places": "所有位置",@@ -4188,6 +4188,12 @@"Stop ({count} running)": "停止({count} 个正在运行)","Rerun '{name}'": "重新运行 '{name}'","Stop '{name}'": "停止 '{name}'",+ "Terminating {length} processes": "正在终止 {length} 个进程",+ "Terminating '{names}'": "正在终止 '{names}'",+ "Kill process": "强杀进程",+ "Terminating": "正在终止",+ "Waiting for process detach": "等待进程退出",+ "Stopping… (click to kill)": "正在停止…(点击强杀)","Comparison Failure: {name}": "比较失败:{name}","Process '{name}' Is Running": "进程 '{name}' 正在运行","'{name}' is not allowed to run in parallel.\nWould you like to stop {count} running instances?": "'{name}' 不允许并行运行。\n是否停止 {count} 个正在运行的实例?",diff --git a/src/workbench/contributions.ts b/src/workbench/contributions.tsindex e1f03e0e8..4b359b438 100644--- a/src/workbench/contributions.ts+++ b/src/workbench/contributions.ts@@ -1468,6 +1468,8 @@ export interface DebugRunSession {configId: string | null;name: string;startedAt: number;+ /** Set while the session shuts down after Stop. */+ status?: "starting" | "running" | "paused" | "stopping" | "terminated";paused: boolean;rerun: (() => void) | null;stop: () => void;@@ -1479,7 +1481,7 @@ export interface DebugServiceSession {id: number;config: RunConfig;startedAt: number;- status: "starting" | "running" | "paused" | "terminated";+ status: "starting" | "running" | "paused" | "stopping" | "terminated";processId: number | null;/** The debuggee's HTTP port announced on its console (not the JDWP attach port), if known. */httpPort?: number;@@ -1508,6 +1510,11 @@ export interface RunningProcessesProvider {id: string;/** Processes this feature is running in the window right now. */running(): RunningProcess[] | Promise<RunningProcess[]>;+ /**+ * Stops them before a close: graceful first (stop command / SIGINT, as IDEA does), the+ * whole set again when `kill` asks for SIGKILL.+ */+ stop?(kill: boolean): Promise<void> | void;}const runningProcessesProviders = new Map<string, RunningProcessesProvider>();@@ -1519,6 +1526,11 @@ export function registerRunningProcessesProvider(p: RunningProcessesProvider): (};}+/** Asks every provider to stop its processes: graceful, or killed when `kill` is set. */+export async function stopRunningProcesses(kill: boolean): Promise<void> {+ await Promise.all([...runningProcessesProviders.values()].map((p) => p.stop?.(kill)));+}+/** Live processes of every provider, one entry per name. */export async function runningProcesses(): Promise<RunningProcess[]> {const all = (await Promise.all([...runningProcessesProviders.values()].map((p) => p.running()))).flat();diff --git a/src/workbench/runningProcesses.test.ts b/src/workbench/runningProcesses.test.tsindex 8a53c7b22..ffb346ee6 100644--- a/src/workbench/runningProcesses.test.ts+++ b/src/workbench/runningProcesses.test.ts@@ -1,5 +1,5 @@import { expect, it, vi } from "vitest";-import { registerRunningProcessesProvider, runningProcesses } from "./contributions";+import { registerRunningProcessesProvider, runningProcesses, stopRunningProcesses } from "./contributions";it("collects live processes from every provider, one entry per name", async () => {const first = vi.fn(async () => [{ name: "app" }, { name: "worker" }]);@@ -33,3 +33,17 @@ it("keeps a replacement provider registered when its predecessor is disposed", a}expect(await runningProcesses()).toEqual([]);});++it("asks every provider to stop, gracefully and then killed", async () => {+ const stop = vi.fn(async () => {});+ const dispose = registerRunningProcessesProvider({ id: "test.stop", running: () => [{ name: "app" }], stop });+ try {+ await stopRunningProcesses(false);+ expect(stop).toHaveBeenLastCalledWith(false);+ await stopRunningProcesses(true);+ expect(stop).toHaveBeenLastCalledWith(true);+ expect(stop).toHaveBeenCalledTimes(2);+ } finally {+ dispose();+ }+});