diff --git a/crates/ide-host/src/mcp/run/agent_tools.rs b/crates/ide-host/src/mcp/run/agent_tools.rs index 73524a6e0..bad153bc7 100644 --- a/crates/ide-host/src/mcp/run/agent_tools.rs +++ b/crates/ide-host/src/mcp/run/agent_tools.rs @@ -128,9 +128,11 @@ pub fn run_command() -> Tool { &format!( "Runs a shell command line in a new or reused tab of OpenIDEA's Run tool window, with the shell of \ Settings › Tools › Terminal. The user is asked first (unless the IDE runs tools without \ -confirmation). Waits up to `timeout` milliseconds (default {RUN_TIMEOUT_MS}) for the command to finish; a command \ -still running then keeps running, and `wait_for_run`, `read_run_output`, `get_run_status`, `send_run_input` and \ -`stop_run` follow it up by name. Returns the tab's status (`state`: starting, running, stopping, succeeded, failed, \ +confirmation). Waits up to `timeout` milliseconds (default {RUN_TIMEOUT_MS}) for the command to finish, or until its \ +output matches `pattern`; a command still running then keeps running, and `wait_for_run`, `read_run_output`, \ +`get_run_status`, `send_run_input` and `stop_run` follow it up by name. A server, watcher or app never finishes: to \ +start one, pass `pattern` for the line it prints once ready (e.g. `Listening on|Started .* in|ready in`) rather than \ +a long `timeout`, so the call returns as soon as it is up. Returns the tab's status (`state`: starting, running, stopping, succeeded, failed, \ crashed, stoppedByAgent, stoppedByUser or startFailed; `exitCode`; `crash` with the signal or exception of a crashed \ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}" ), @@ -152,6 +154,7 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}" }; let env = call.args.get("envs").filter(|v| !v.is_null()).map(|_| call.str_map("envs")).transpose()?; let deadline = deadline(&call, RUN_TIMEOUT_MS)?; + let ready = pattern(&call)?; let host = call.host(); let runs = &host.mcp_agent_runs; if let Some(run) = runs.get(call.root(), &name).filter(|r| r.running()) { @@ -185,7 +188,7 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}" return Err(IdeError::invalid(format!("`{name}` did not start: {error}"))); } let from = run.process_offset(); - let end = run.wait(deadline, None, from, &call.cancel).await?; + let end = run.wait(deadline, ready.as_ref(), from, &call.cancel).await?; let mut extra = output_view(&call, &run, from)?; extra.insert("waitEnded".into(), end.as_str().into()); result(&run, extra) @@ -209,6 +212,12 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}" ParamType::Integer, "Milliseconds to wait for the command to finish before returning (0 returns once it started); the command \ keeps running after it", + )) + .param(Param::optional( + "pattern", + ParamType::String, + "Regular expression that ends the wait when the command's output matches it: the ready line of a server or \ +watcher. `waitEnded` is then `matched`", )) .param(Param::optional("maxLinesCount", ParamType::Integer, MAX_LINES)) .param(Param::optional("truncateMode", ParamType::String, TRUNCATE_MODE)) diff --git a/crates/ide-host/tests/mcp.rs b/crates/ide-host/tests/mcp.rs index 60243d0f8..5e75587b1 100644 --- a/crates/ide-host/tests/mcp.rs +++ b/crates/ide-host/tests/mcp.rs @@ -594,6 +594,31 @@ fn agent_process(h: &Harness, name: &str) -> ide_core::RunId { h.host.processes.list().into_iter().filter(|r| r.config_id == id && r.running).map(|r| r.id).max().unwrap() } +#[cfg(unix)] +#[tokio::test(flavor = "multi_thread")] +async fn run_command_returns_once_a_server_prints_its_ready_line() { + let h = Harness::new(); + h.trust().await; + h.host.mcp_requests.set_ready("main", true); + h.host + .global_settings + .set(ide_workspace::SettingsScope::Global, "mcpServer.runWithoutConfirmation", json!(true)) + .unwrap(); + let _started = run_tool_window(&h); + // A server started with its ready line returns once it prints it, long before the timeout. + let started_at = std::time::Instant::now(); + let up = h + .json( + "run_command", + json!({"name": "web", "command": "sleep 1; echo Listening on 8080; sleep 30", "pattern": "Listening on", "timeout": 60000}), + ) + .await; + assert_eq!((up["waitEnded"].as_str(), up["state"].as_str()), (Some("matched"), Some("running")), "{up}"); + assert!(up["output"].as_str().unwrap().contains("Listening on 8080"), "{up}"); + assert!(started_at.elapsed() < std::time::Duration::from_secs(20), "returned after {:?}", started_at.elapsed()); + h.json("stop_run", json!({"name": "web", "force": true, "timeout": 10000})).await; +} + #[cfg(unix)] #[tokio::test(flavor = "multi_thread")] async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() { diff --git a/docs/en/guide/mcp.mdx b/docs/en/guide/mcp.mdx index 1357ea75e..37863a2ee 100644 --- a/docs/en/guide/mcp.mdx +++ b/docs/en/guide/mcp.mdx @@ -114,6 +114,7 @@ Notes on what they do: As JetBrains IDEs do, the command runs on pipes, not a terminal: programs print plain lines instead of progress bars and redraws. The agent gets that output cleaned of escape sequences and cut to 2000 lines (`maxLinesCount`); beyond that the end stays, or the start or both ends with `truncateMode`. The tab's raw output log stays complete. +- **Servers return once they are up.** The call waits 10 seconds by default for the command to finish. A server, watcher or app never finishes: the agent passes `pattern` with its ready line (`Listening on`, `Started … in`) and gets the answer as soon as the line appears, while the command keeps running. - **One tab per name.** A name whose command finished runs the next command in the same tab. A name whose command is still running is refused, with that command and its last output: the agent has to stop it with `stop_run` first or pick another name. Nothing is stopped behind your back. - **Following a command up.** `wait_for_run` waits for the command to end or for a pattern in its output (a server's "listening" line), `read_run_output` reads the output from any point, `get_run_status` tells whether it is running, succeeded, failed, crashed or was stopped by the agent or by you, and `send_run_input` writes text and Enter to its input; Ctrl+C stops it and Ctrl+D ends its input. - **You can step in.** What you type into the tab's input line, a rerun, a Stop and closing the tab are reported to the agent with their time. A wait ends at once, and the agent is advised to stop what it is doing, tell you it received the intervention and wait for your confirmation. diff --git a/docs/zh/guide/mcp.mdx b/docs/zh/guide/mcp.mdx index d2dbb4be9..73fb107b1 100644 --- a/docs/zh/guide/mcp.mdx +++ b/docs/zh/guide/mcp.mdx @@ -113,6 +113,7 @@ stdio 配置大致如下(路径以你机器上的为准): 和 JetBrains 的 IDE 一样,命令通过管道运行,而不是在终端里运行:程序输出的是普通文本行,不会有进度条和屏幕重绘。智能体拿到的输出会去掉控制字符,并截断到 2000 行(`maxLinesCount`);超出部分默认保留结尾,也可以用 `truncateMode` 改为保留开头或两头。标签页的原始输出日志保持完整。 +- **服务启动好就返回。** 调用默认最多等 10 秒让命令结束。服务器、监视进程或应用不会结束:智能体传入 `pattern`(它就绪时输出的那一行,如 `Listening on`、`Started … in`),这一行一出现就返回,命令继续运行。 - **一个名称对应一个标签。** 名称对应的命令已结束时,下一条命令在同一标签中运行。命令仍在运行时会被拒绝,并返回该命令和它最后的输出:智能体必须先用 `stop_run` 停止它,或者换一个名称。任何进程都不会被悄悄停掉。 - **跟进命令。** `wait_for_run` 等待命令结束,或等待输出中出现指定文本(例如服务器的“正在监听”一行);`read_run_output` 从任意位置读取输出;`get_run_status` 报告命令是在运行、成功、失败、崩溃,还是被智能体或你停止;`send_run_input` 向命令的输入写入文本和 Enter,Ctrl+C 会停止命令,Ctrl+D 结束它的输入。 - **你可以随时干预。** 你在标签输入行中输入的内容、重新运行、停止和关闭标签,都会连同时间一起告诉智能体。正在进行的等待会立即返回,并建议智能体停下手头的工作,回复你已收到干预,等你确认后再继续。