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(debugger): type input for the program in the debug console (#1614)
l0ng-ai0a47a685d950
diff --git a/Cargo.lock b/Cargo.lockindex 276aeda0a..2f09cd5f7 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4182,6 +4182,7 @@ dependencies = ["ide-language","memchr","parking_lot",+ "portable-pty","serde","serde_json","specta",diff --git a/crates/ide-core/src/event.rs b/crates/ide-core/src/event.rsindex 6cef110cb..298547f89 100644--- a/crates/ide-core/src/event.rs+++ b/crates/ide-core/src/event.rs@@ -229,6 +229,9 @@ pub enum DebugEvent {thread_id: i64,started: bool,},+ /// The program runs in a terminal the IDE gave it (`runInTerminal`): what is typed for it+ /// in the debug console reaches its input.+ ProgramInput,BreakpointsChanged {path: crate::IpcPath,},diff --git a/crates/ide-dap/Cargo.toml b/crates/ide-dap/Cargo.tomlindex a902900b7..9cb2f2a6c 100644--- a/crates/ide-dap/Cargo.toml+++ b/crates/ide-dap/Cargo.toml@@ -16,6 +16,7 @@ specta.workspace = truetokio = { workspace = true, features = ["net"] }parking_lot.workspace = truememchr = "2"+portable-pty.workspace = truetracing.workspace = true[dev-dependencies]diff --git a/crates/ide-dap/src/lib.rs b/crates/ide-dap/src/lib.rsindex 5d3012377..8428ac8d1 100644--- a/crates/ide-dap/src/lib.rs+++ b/crates/ide-dap/src/lib.rs@@ -1266,6 +1266,16 @@ impl DebugManager {Ok(())}+ /// Types `text` into the terminal the session's program runs in (see [`ide_core::event::DebugEvent::ProgramInput`]).+ pub fn send_input(&self, s: DebugSessionId, text: &str) -> IdeResult<()> {+ let session = self.session(s)?;+ let mut program = session.program.lock();+ let program = program+ .as_mut()+ .ok_or_else(|| IdeError::invalid("The program doesn't read input from the debug console"))?;+ program.write(text).map_err(|e| IdeError::internal(format!("cannot write to the program: {e}")))+ }+/// Flutter's DAP adapter: injects the changed sources into the running app./// Not part of the DAP standard; adapters that do not know the request reject it.pub async fn hot_reload(&self, s: DebugSessionId) -> IdeResult<()> {diff --git a/crates/ide-dap/src/session.rs b/crates/ide-dap/src/session.rsindex f7bc69c3b..e7356fbbb 100644--- a/crates/ide-dap/src/session.rs+++ b/crates/ide-dap/src/session.rs@@ -43,6 +43,8 @@ pub(crate) struct Session {pub adapter_process: Mutex<Option<Child>>,/// Processes started for `runInTerminal`.pub debuggees: Mutex<Vec<Child>>,+ /// The terminal a `runInTerminal` program runs in: typed input goes to it.+ pub program: Mutex<Option<ProgramTerminal>>,/// Set once `configurationDone` was sent; breakpoint updates go out live after that.pub configured: AtomicBool,pub initialized: watch::Sender<bool>,@@ -90,6 +92,7 @@ impl Session {caps: Mutex::new(Value::Null),adapter_process: Mutex::new(child),debuggees: Mutex::new(Vec::new()),+ program: Mutex::new(None),configured: AtomicBool::new(false),initialized: watch::channel(false).0,terminated: AtomicBool::new(false),@@ -266,6 +269,9 @@ impl Session {for mut c in std::mem::take(&mut *self.debuggees.lock()) {let _ = c.start_kill();}+ if let Some(mut program) = self.program.lock().take() {+ let _ = program.child.kill();+ }}}@@ -451,8 +457,25 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma}}-/// `runInTerminal`: spawns the debuggee directly and forwards its output to the console.+/// A `runInTerminal` program and the pseudo-terminal it runs in.+pub(crate) struct ProgramTerminal {+ writer: Box<dyn std::io::Write + Send>,+ child: Box<dyn portable_pty::Child + Send + Sync>,+ _master: Box<dyn portable_pty::MasterPty + Send>,+}++impl ProgramTerminal {+ pub(crate) fn write(&mut self, text: &str) -> std::io::Result<()> {+ self.writer.write_all(text.as_bytes())?;+ self.writer.flush()+ }+}++/// `runInTerminal`: starts the debuggee on a pseudo-terminal, as an IDE terminal would (CodeLLDB+/// starts a launcher that gives the program its terminal, and the program reads input only from+/// a terminal), forwards its output to the console, and keeps the terminal for typed input.pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, String> {+ use portable_pty::{CommandBuilder, PtySize, native_pty_system};let argv: Vec<String> = args.get("args").and_then(Value::as_array)@@ -461,16 +484,25 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, Slet Some((program, rest)) = argv.split_first() else {return Err("runInTerminal without args".into());};- let mut cmd = tokio::process::Command::new(program);- ide_core::process::prepare(cmd.as_std_mut());- cmd.args(rest)- .envs(ide_core::process::shell_env())- .stdin(Stdio::null())- .stdout(Stdio::piped())- .stderr(Stdio::piped())- .kill_on_drop(true);- if let Some(cwd) = args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()) {- cmd.current_dir(cwd);+ let pair = native_pty_system()+ .openpty(PtySize { rows: 24, cols: 200, pixel_width: 0, pixel_height: 0 })+ .map_err(|e| format!("cannot open a terminal for {program}: {e}"))?;+ let mut cmd = CommandBuilder::new(program);+ // CodeLLDB's launcher clears the terminal first; the console keeps the session's earlier output.+ cmd.args(rest.iter().filter(|a| *a != "--clear-screen"));+ for (k, v) in ide_core::process::host_env_fixes() {+ match v {+ Some(v) => cmd.env(k, v),+ None => cmd.env_remove(k),+ }+ }+ for (k, v) in ide_core::process::shell_env() {+ cmd.env(k, v);+ }+ cmd.env("TERM", "xterm-256color");+ match args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()) {+ Some(cwd) => cmd.cwd(cwd),+ None => cmd.cwd(&s.spec.cwd),}if let Some(env) = args.get("env").and_then(Value::as_object) {for (k, v) in env {@@ -480,18 +512,53 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S};}}- let mut child = cmd.spawn().map_err(|e| format!("failed to start {program}: {e}"))?;- let pid = child.id();- if let Some(out) = child.stdout.take() {- forward_output(s, out, "stdout");+ let child = pair.slave.spawn_command(cmd).map_err(|e| format!("failed to start {program}: {e}"))?;+ drop(pair.slave);+ let reader = pair.master.try_clone_reader().map_err(|e| format!("terminal of {program}: {e}"))?;+ let writer = pair.master.take_writer().map_err(|e| format!("terminal of {program}: {e}"))?;+ let pid = child.process_id();+ forward_terminal_output(s, reader);+ if let Some(mut previous) = s.program.lock().replace(ProgramTerminal { writer, child, _master: pair.master }) {+ let _ = previous.child.kill();}- if let Some(err) = child.stderr.take() {- forward_output(s, err, "stderr");- }- s.debuggees.lock().push(child);+ s.owner.sink.emit(IdeEvent::Debug { session: s.id, event: DebugEvent::ProgramInput });Ok(json!({ "processId": pid }))}+/// The program's terminal output, as stdout lines (`\r\n` as `\n`; colours are kept).+fn forward_terminal_output(s: &Session, mut reader: Box<dyn std::io::Read + Send>) {+ let session = s.id;+ let sink = s.owner.sink.clone();+ let _ = std::thread::Builder::new().name(format!("openidea-debuggee-{}", session.0)).spawn(move || {+ let mut buf = vec![0u8; 8192];+ let mut pending: Vec<u8> = Vec::new();+ loop {+ match reader.read(&mut buf) {+ Ok(0) | Err(_) => break,+ Ok(n) => pending.extend_from_slice(&buf[..n]),+ }+ // Keep incomplete UTF-8 sequences, and a `\r` that may start a `\r\n`, for the next chunk.+ let mut valid = match std::str::from_utf8(&pending) {+ Ok(_) => pending.len(),+ Err(e) if e.error_len().is_none() => e.valid_up_to(),+ Err(_) => pending.len(),+ };+ if valid > 0 && pending[valid - 1] == b'\r' {+ valid -= 1;+ }+ let output = String::from_utf8_lossy(&pending[..valid]).replace("\r\n", "\n");+ pending.drain(..valid);+ if !output.is_empty() {+ sink.emit(IdeEvent::Debug { session, event: DebugEvent::Output { category: "stdout".into(), output } });+ }+ }+ if !pending.is_empty() {+ let output = String::from_utf8_lossy(&pending).replace("\r\n", "\n");+ sink.emit(IdeEvent::Debug { session, event: DebugEvent::Output { category: "stdout".into(), output } });+ }+ });+}+fn forward_output<R: AsyncRead + Unpin + Send + 'static>(s: &Session, mut stream: R, category: &'static str) {let session = s.id;let sink = s.owner.sink.clone();diff --git a/crates/ide-dap/src/tests.rs b/crates/ide-dap/src/tests.rsindex e1efd7101..e86cb6fc9 100644--- a/crates/ide-dap/src/tests.rs+++ b/crates/ide-dap/src/tests.rs@@ -468,6 +468,40 @@ async fn run_in_terminal_spawns_debuggee() {assert!(response["body"]["processId"].as_u64().unwrap() > 0);}+#[cfg(unix)]+#[tokio::test]+async fn run_in_terminal_program_reads_typed_input() {+ let h = harness(Script {+ // CodeLLDB's launcher asks to clear the terminal; the console keeps its output.+ run_in_terminal: Some(vec![+ "sh".into(),+ "-c".into(),+ "[ -t 0 ] && echo 'name?' && read name && echo \"hello $name\"".into(),+ "--clear-screen".into(),+ ]),+ ..Script::default()+ });+ let session = h.start(config()).await.unwrap();+ h.wait_event(|e| matches!(e, DebugEvent::ProgramInput)).await;+ h.wait_event(|e| matches!(e, DebugEvent::Output { output, .. } if output.contains("name?"))).await;+ h.manager.send_input(session, "Bob\n").unwrap();+ h.wait_event(|e| matches!(e, DebugEvent::Output { output, .. } if output.contains("hello Bob"))).await;+ let output: String = h+ .events+ .lock()+ .iter()+ .filter_map(|e| match e {+ IdeEvent::Debug { event: DebugEvent::Output { category, output }, .. } if category == "stdout" => {+ Some(output.clone())+ }+ _ => None,+ })+ .collect();+ assert!(!output.contains('\r'), "{output:?}");+ h.manager.stop(session).await.unwrap();+ assert!(h.manager.send_input(session, "x\n").is_err());+}+#[test]fn launch_arguments_merge_and_defaults() {let mut c = config();diff --git a/crates/ide-host/src/ops/debug.rs b/crates/ide-host/src/ops/debug.rsindex 827223544..8cf3a44d1 100644--- a/crates/ide-host/src/ops/debug.rs+++ b/crates/ide-host/src/ops/debug.rs@@ -162,6 +162,11 @@ pub async fn debug_pause(host: &Host, _window: &str, session: DebugSessionId, thhost.debugger.pause(session, thread_id).await}+/// Types `text` into the session's program (a `runInTerminal` program).+pub async fn debug_send_input(host: &Host, _window: &str, session: DebugSessionId, text: String) -> IdeResult<()> {+ host.debugger.send_input(session, &text)+}+pub async fn debug_hot_reload(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {host.debugger.hot_reload(session).await}@@ -381,6 +386,9 @@ pub(crate) fn register(d: &mut Dispatcher) {"debug_pause",|c| async move { debug_pause(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await },);+ d.add("debug_send_input", |c| async move {+ debug_send_input(&c.host, &c.window, c.arg("session")?, c.arg("text")?).await+ });d.add("debug_step", |c| async move {debug_step(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?, c.arg("kind")?).await});diff --git a/src-tauri/src/commands/debug.rs b/src-tauri/src/commands/debug.rsindex 522300641..4e7080c98 100644--- a/src-tauri/src/commands/debug.rs+++ b/src-tauri/src/commands/debug.rs@@ -92,6 +92,13 @@ pub async fn debug_resume(state: State<'_, AppState>, session: DebugSessionId, tide_host::ops::debug::debug_resume(&state.host, "", session, thread_id).await}+/// Types `text` into the session's program (a `runInTerminal` program).+#[tauri::command]+#[specta::specta]+pub async fn debug_send_input(state: State<'_, AppState>, session: DebugSessionId, text: String) -> IdeResult<()> {+ ide_host::ops::debug::debug_send_input(&state.host, "", session, text).await+}+#[tauri::command]#[specta::specta]pub async fn debug_pause(state: State<'_, AppState>, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rsindex f4f3dba7c..d5645df75 100644--- a/src-tauri/src/commands/mod.rs+++ b/src-tauri/src/commands/mod.rs@@ -381,6 +381,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {debug::debug_completions,debug::debug_resume,debug::debug_pause,+ debug::debug_send_input,debug::debug_hot_reload,debug::debug_hot_restart,debug::debug_step,diff --git a/src/bindings.ts b/src/bindings.tsindex ae6e9dee2..1c0e231bb 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -735,6 +735,8 @@ export const commands = {debugCompletions: (session: DebugSessionId, frameId: number | null, text: string, line: number, column: number) => typedError<DebugCompletion[], IdeError>(__TAURI_INVOKE("debug_completions", { session, frameId, text, line, column })),debugResume: (session: DebugSessionId, threadId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_resume", { session, threadId })),debugPause: (session: DebugSessionId, threadId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_pause", { session, threadId })),+ /** Types `text` into the session's program (a `runInTerminal` program). */+ debugSendInput: (session: DebugSessionId, text: string) => typedError<null, IdeError>(__TAURI_INVOKE("debug_send_input", { session, text })),debugHotReload: (session: DebugSessionId) => typedError<null, IdeError>(__TAURI_INVOKE("debug_hot_reload", { session })),debugHotRestart: (session: DebugSessionId) => typedError<null, IdeError>(__TAURI_INVOKE("debug_hot_restart", { session })),debugStep: (session: DebugSessionId, threadId: number, kind: StepKind) => typedError<null, IdeError>(__TAURI_INVOKE("debug_step", { session, threadId, kind })),@@ -2855,7 +2857,12 @@ export type DebugEvent =* First event of every session (only build output of a root session's* `cargo` step can precede it). `parent` is set for adapter-started child sessions.*/-{ kind: "started"; name: string; adapter: string; parent: DebugSessionId | null } | { kind: "initialized" } | { kind: "stopped"; threadId: number; reason: string; description: string | null; allThreadsStopped: boolean } | { kind: "continued"; threadId: number; allThreadsContinued: boolean } | { kind: "output"; category: string; output: string } | { kind: "thread"; threadId: number; started: boolean } | { kind: "breakpointsChanged"; path: IpcPath } | { kind: "terminated" } | { kind: "exited"; code: number } |+{ kind: "started"; name: string; adapter: string; parent: DebugSessionId | null } | { kind: "initialized" } | { kind: "stopped"; threadId: number; reason: string; description: string | null; allThreadsStopped: boolean } | { kind: "continued"; threadId: number; allThreadsContinued: boolean } | { kind: "output"; category: string; output: string } | { kind: "thread"; threadId: number; started: boolean } |+/**+ * The program runs in a terminal the IDE gave it (`runInTerminal`): what is typed for it+ * in the debug console reaches its input.+ */+{ kind: "programInput" } | { kind: "breakpointsChanged"; path: IpcPath } | { kind: "terminated" } | { kind: "exited"; code: number } |/*** java-debug's `hotcodereplace` event: `change_type` is `BUILD_COMPLETE` (classes* changed and can be reloaded), `STARTING`, `END`, `WARNING` or `ERROR`.diff --git a/src/features/debugger/state.ts b/src/features/debugger/state.tsindex 1bcbd3dc2..c77fe0fc0 100644--- a/src/features/debugger/state.ts+++ b/src/features/debugger/state.ts@@ -45,6 +45,8 @@ export interface DebugSession {parent: DebugSessionId | null;/** Launch configuration (root sessions), used by Rerun. */launch: LaunchConfig | null;+ /** The program runs in a terminal the IDE gave it: the console types into it while it runs. */+ programInput?: boolean;/** Process the session is attached to (a Run tab's build tool); stopped with the session. */process: RunId | null;status: SessionStatus;@@ -944,6 +946,16 @@ export async function setVariableValue(return result;}+/** Whether the console types into the session's program (it runs, in a terminal the IDE gave it). */+export function readsProgramInput(s: DebugSession): boolean {+ return !!s.programInput && s.status === "running";+}++/** Types `text` into the session's program; its terminal echoes it to the console. */+export async function sendProgramInput(session: DebugSession, text: string): Promise<void> {+ await call(commands.debugSendInput(session.id, text));+}+export async function evaluate(expression: string,context: "repl" | "watch" | "hover" | "clipboard",@@ -1022,6 +1034,9 @@ export function handleDebugEvent(id: DebugSessionId, event: DebugEvent) {case "thread":if (s.status === "paused") void loadThreads(id);break;+ case "programInput":+ patch(id, { programInput: true });+ break;case "breakpointsChanged":void refreshStates(event.path);break;diff --git a/src/features/debugger/ui/DebugConsole.tsx b/src/features/debugger/ui/DebugConsole.tsxindex f791a0537..21f95a2f3 100644--- a/src/features/debugger/ui/DebugConsole.tsx+++ b/src/features/debugger/ui/DebugConsole.tsx@@ -16,7 +16,16 @@ import {type FindOptions,type FindResult,} from "@/ui/consoleFind";-import { appendConsole, clearConsole, evaluate, isLive, useDebug, type DebugSession } from "../state";+import {+ appendConsole,+ clearConsole,+ evaluate,+ isLive,+ readsProgramInput,+ sendProgramInput,+ useDebug,+ type DebugSession,+} from "../state";import { pushHistory, readHistory, setConsoleHistoryBrowser } from "./expressionHistory";import { useExpressionCompletion } from "./ExpressionCompletion";import styles from "./DebugToolWindow.module.css";@@ -245,6 +254,16 @@ export function DebugConsole({ session, interactive = true }: { session: DebugSe}, [findOpen, current, virtualizer]);const submit = async () => {+ if (readsProgramInput(session)) {+ // Like the Run console: the line as typed, empty or not, goes to the program.+ setInput("");+ try {+ await sendProgramInput(session, `${input}\n`);+ } catch (err) {+ appendConsole(session.id, "stderr", `${err instanceof Error ? err.message : String(err)}\n`);+ }+ return;+ }const e = input.trim();if (!e) return;pushHistory("console", e);@@ -466,10 +485,16 @@ export function DebugConsole({ session, interactive = true }: { session: DebugSevalue={input}onChange={(e) => {setInput(e.target.value);- completion.onInput();+ if (!readsProgramInput(session)) completion.onInput();}}onKeyDown={onKeyDown}- placeholder={isLive(session) ? "Evaluate in the debug console" : "Session finished"}+ placeholder={+ !isLive(session)+ ? "Session finished"+ : readsProgramInput(session)+ ? "Input for the program (pause to evaluate)"+ : "Evaluate in the debug console"+ }disabled={!isLive(session)}aria-label={tx("Debug console input")}spellCheck={false}diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.jsonindex d24ee23e7..80a9620a4 100644--- a/src/platform/locales/text/zh.json+++ b/src/platform/locales/text/zh.json@@ -6299,5 +6299,6 @@"Idle": "空闲","Composer dependencies are not installed": "未安装 Composer 依赖","Installed Composer packages differ from composer.lock": "已安装的 Composer 包与 composer.lock 不一致",- "Composer Install": "安装 Composer 依赖"+ "Composer Install": "安装 Composer 依赖",+ "Input for the program (pause to evaluate)": "程序输入(暂停后可计算)"}