Порівняти коміти

..
Автор SHA1 Повідомлення Дата
l0ng-ai e87495d7b1 fix(debugger): end a program suspended at a breakpoint at once on Stop
For adapters without a terminate request (Delve, java-debug), Stop sends the
program SIGTERM and waits up to 10 s for it to exit. A program suspended in the
debugger cannot act on SIGTERM, and on macOS does not even die of SIGKILL while
debugserver holds it, so Stop sat in "stopping" for the full 10 s and then for
the adapter's terminated event. When the session is suspended, Stop now kills
the program's tree and sends disconnect with terminateDebuggee, which ends it
through the adapter, and skips the wait for shutdown output.
2026-11-16 11:48:34 +08:00
995 змінених файлів з 7918 додано та 61506 видалено

No files matched your search

-7
Переглянути файл
@@ -1,7 +0,0 @@
# Link debug builds for the oldest system we support, so Launch Services
# accepts the bundle on macOS 11. Without this a newer SDK leaves
# LC_BUILD_VERSION.minos at 12.0 and the app is refused (-10825) before main
# can load a newer WebKit. An explicitly exported MACOSX_DEPLOYMENT_TARGET
# still wins: this is only the default for local builds and CI.
[env]
MACOSX_DEPLOYMENT_TARGET = "11.0"
Створено
+44 -59
Переглянути файл
@@ -4144,7 +4144,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
[[package]]
name = "ide-agent"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"blake3",
"dunce",
@@ -4169,7 +4169,7 @@ dependencies = [
[[package]]
name = "ide-analysis"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"ast-grep-core",
"ide-core",
@@ -4183,7 +4183,7 @@ dependencies = [
[[package]]
name = "ide-android"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"ide-core",
"serde",
@@ -4194,7 +4194,7 @@ dependencies = [
[[package]]
name = "ide-build"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"blake3",
"chardetng",
@@ -4212,7 +4212,7 @@ dependencies = [
[[package]]
name = "ide-cli"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"dirs 6.0.0",
"serde",
@@ -4226,7 +4226,7 @@ dependencies = [
[[package]]
name = "ide-clipboard"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"gtk",
"objc2 0.6.5",
@@ -4237,7 +4237,7 @@ dependencies = [
[[package]]
name = "ide-core"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"dunce",
"encoding_rs",
@@ -4254,7 +4254,7 @@ dependencies = [
[[package]]
name = "ide-coverage"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"ide-core",
"ide-run",
@@ -4268,7 +4268,7 @@ dependencies = [
[[package]]
name = "ide-dap"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"base64 0.22.1",
"futures",
@@ -4297,7 +4297,7 @@ dependencies = [
[[package]]
name = "ide-db"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"base64 0.22.1",
"bb8",
@@ -4333,7 +4333,7 @@ dependencies = [
[[package]]
name = "ide-docker"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"ide-core",
"serde",
@@ -4346,7 +4346,7 @@ dependencies = [
[[package]]
name = "ide-extension"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4367,7 +4367,7 @@ dependencies = [
[[package]]
name = "ide-fonts"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"objc2-core-foundation",
"objc2-core-text",
@@ -4379,7 +4379,7 @@ dependencies = [
[[package]]
name = "ide-github"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"ide-core",
"ide-vcs",
@@ -4392,7 +4392,7 @@ dependencies = [
[[package]]
name = "ide-heap"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"criterion",
"ide-core",
@@ -4410,7 +4410,7 @@ dependencies = [
[[package]]
name = "ide-host"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4435,7 +4435,6 @@ dependencies = [
"ide-index",
"ide-jsonrpc",
"ide-jvm-attach",
"ide-jvm-inspect",
"ide-language",
"ide-lsp",
"ide-mcp",
@@ -4448,7 +4447,6 @@ dependencies = [
"ide-search",
"ide-spell",
"ide-ssh",
"ide-streams",
"ide-syntax",
"ide-terminal",
"ide-text",
@@ -4483,7 +4481,7 @@ dependencies = [
[[package]]
name = "ide-http"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"ide-core",
"ide-vfs",
@@ -4502,7 +4500,7 @@ dependencies = [
[[package]]
name = "ide-index"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"blake3",
"criterion",
@@ -4524,7 +4522,7 @@ dependencies = [
[[package]]
name = "ide-jdwp"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"ide-jvm-inspect",
"proptest",
@@ -4536,7 +4534,7 @@ dependencies = [
[[package]]
name = "ide-jsonrpc"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"encoding_rs",
"futures",
@@ -4553,7 +4551,7 @@ dependencies = [
[[package]]
name = "ide-jvm-attach"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"libc",
"tempfile",
@@ -4562,7 +4560,7 @@ dependencies = [
[[package]]
name = "ide-jvm-inspect"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"futures",
"serde",
@@ -4573,7 +4571,7 @@ dependencies = [
[[package]]
name = "ide-language"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"blake3",
"criterion",
@@ -4631,7 +4629,7 @@ dependencies = [
[[package]]
name = "ide-lsp"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"dunce",
"encoding_rs",
@@ -4659,7 +4657,7 @@ dependencies = [
[[package]]
name = "ide-mcp"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"bytes",
"dunce",
@@ -4678,7 +4676,7 @@ dependencies = [
[[package]]
name = "ide-notebook"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"futures",
"ide-core",
@@ -4701,7 +4699,7 @@ dependencies = [
[[package]]
name = "ide-plugin"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"blake3",
"dunce",
@@ -4724,7 +4722,7 @@ dependencies = [
[[package]]
name = "ide-profiler"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"ide-core",
"ide-jvm-attach",
@@ -4738,7 +4736,7 @@ dependencies = [
[[package]]
name = "ide-remote"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"dunce",
"futures",
@@ -4758,7 +4756,7 @@ dependencies = [
[[package]]
name = "ide-run"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"dunce",
"encoding_rs",
@@ -4782,7 +4780,7 @@ dependencies = [
[[package]]
name = "ide-scaffold"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"ide-core",
"ide-tools",
@@ -4798,7 +4796,7 @@ dependencies = [
[[package]]
name = "ide-sdk"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"dunce",
"flate2",
@@ -4821,7 +4819,7 @@ dependencies = [
[[package]]
name = "ide-search"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"criterion",
"encoding_rs",
@@ -4842,7 +4840,7 @@ dependencies = [
[[package]]
name = "ide-spell"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"ide-core",
"parking_lot",
@@ -4855,7 +4853,7 @@ dependencies = [
[[package]]
name = "ide-ssh"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"dirs 6.0.0",
"flate2",
@@ -4878,22 +4876,9 @@ dependencies = [
"uuid",
]
[[package]]
name = "ide-streams"
version = "0.1.47"
dependencies = [
"ide-core",
"ide-language",
"ide-syntax",
"serde",
"serde_json",
"specta",
"tree-sitter",
]
[[package]]
name = "ide-syntax"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"ide-core",
"ide-language",
@@ -4908,7 +4893,7 @@ dependencies = [
[[package]]
name = "ide-terminal"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"ide-core",
"libc",
@@ -4921,7 +4906,7 @@ dependencies = [
[[package]]
name = "ide-text"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"criterion",
"ide-core",
@@ -4934,7 +4919,7 @@ dependencies = [
[[package]]
name = "ide-tools"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"flate2",
"hex",
@@ -4955,7 +4940,7 @@ dependencies = [
[[package]]
name = "ide-vcs"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"blake3",
"dunce",
@@ -4976,7 +4961,7 @@ dependencies = [
[[package]]
name = "ide-vfs"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"chardetng",
"dunce",
@@ -5002,7 +4987,7 @@ dependencies = [
[[package]]
name = "ide-web"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"dirs 6.0.0",
"ide-core",
@@ -5018,7 +5003,7 @@ dependencies = [
[[package]]
name = "ide-workspace"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"blake3",
"dunce",
@@ -6647,7 +6632,7 @@ dependencies = [
[[package]]
name = "openidea"
version = "0.1.47"
version = "0.1.45"
dependencies = [
"base64 0.22.1",
"blake3",
+1 -2
Переглянути файл
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
exclude = ["sdk", "plugins"]
[workspace.package]
version = "0.1.47"
version = "0.1.45"
edition = "2024"
rust-version = "1.96"
license = "Apache-2.0"
@@ -52,7 +52,6 @@ ide-jvm-attach = { path = "crates/ide-jvm-attach" }
ide-jvm-inspect = { path = "crates/ide-jvm-inspect" }
ide-jdwp = { path = "crates/ide-jdwp" }
ide-heap = { path = "crates/ide-heap" }
ide-streams = { path = "crates/ide-streams" }
# serialization & IPC typing
serde = { version = "1", features = ["derive"] }
+1 -1
Переглянути файл
@@ -4,7 +4,7 @@
`src/ui/brands/*.svg` use the unmodified logo paths from
[Simple Icons](https://github.com/simple-icons/simple-icons), retrieved through
Iconify (`simple-icons:angular`, `simple-icons:astro`, `simple-icons:cplusplus`, `simple-icons:dart`, `simple-icons:deepseek`, `simple-icons:django`, `simple-icons:dotnet`, `simple-icons:elixir`, `simple-icons:express`, `simple-icons:fastapi`, `simple-icons:flask`, `simple-icons:flutter`, `simple-icons:go`, `simple-icons:haskell`, `simple-icons:html5`, `simple-icons:kotlin`, `simple-icons:ktor`, `simple-icons:laravel`, `simple-icons:nestjs`, `simple-icons:nextdotjs`, `simple-icons:nodedotjs`, `simple-icons:nuxt`, `simple-icons:openjdk`, `simple-icons:phoenixframework`, `simple-icons:php`, `simple-icons:python`, `simple-icons:quarkus`, `simple-icons:ruby`, `simple-icons:rubyonrails`, `simple-icons:rust`, `simple-icons:scala`, `simple-icons:springboot`, `simple-icons:svelte`, `simple-icons:swift`, `simple-icons:symfony`, `simple-icons:vite`, `simple-icons:zig`) and filled with the brand colors (the standard icon grey for black logos). Licensed under [CC0 1.0 Universal](https://github.com/simple-icons/simple-icons/blob/develop/LICENSE.md).
Iconify (`simple-icons:angular`, `simple-icons:astro`, `simple-icons:cplusplus`, `simple-icons:dart`, `simple-icons:django`, `simple-icons:dotnet`, `simple-icons:elixir`, `simple-icons:express`, `simple-icons:fastapi`, `simple-icons:flask`, `simple-icons:flutter`, `simple-icons:go`, `simple-icons:haskell`, `simple-icons:html5`, `simple-icons:kotlin`, `simple-icons:ktor`, `simple-icons:laravel`, `simple-icons:nestjs`, `simple-icons:nextdotjs`, `simple-icons:nodedotjs`, `simple-icons:nuxt`, `simple-icons:openjdk`, `simple-icons:phoenixframework`, `simple-icons:php`, `simple-icons:python`, `simple-icons:quarkus`, `simple-icons:ruby`, `simple-icons:rubyonrails`, `simple-icons:rust`, `simple-icons:scala`, `simple-icons:springboot`, `simple-icons:svelte`, `simple-icons:swift`, `simple-icons:symfony`, `simple-icons:vite`, `simple-icons:zig`) and filled with the brand colors (the standard icon grey for black logos). Licensed under [CC0 1.0 Universal](https://github.com/simple-icons/simple-icons/blob/develop/LICENSE.md).
## Project Lombok
+23 -106
Переглянути файл
@@ -14,21 +14,20 @@ use std::collections::BTreeMap;
use std::sync::Arc;
use std::time::Duration;
const CONFIG_UPDATE_TIMEOUT: Duration = if cfg!(test) { Duration::from_millis(100) } else { Duration::from_secs(5) };
const DISCOVER_TIMEOUT: Duration = if cfg!(test) { Duration::from_secs(3) } else { Duration::from_secs(120) };
/// Opens `session/new`, reads `configOptions`, and records the `thought_level` choices of the
/// session's model: they describe that model only, and other models may offer different ones.
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec, model: Option<&str>) -> Result<Discovered, String> {
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec) -> Result<Discovered, String> {
let prefer_stored = crate::provider::prefer_stored_copilot_auth();
match run_once(shared, spec, prefer_stored, model).await {
match run_once(shared, spec, prefer_stored).await {
Err(err)
if !prefer_stored
&& crate::provider::is_copilot_provider(&spec.id)
&& crate::provider::has_unconfigured_copilot_ambient_token(&spec.env)
&& super::auth_required(0, &err) =>
{
let retry = run_once(shared, spec, true, model).await;
let retry = run_once(shared, spec, true).await;
if retry.is_ok() {
crate::provider::mark_prefer_stored_copilot_auth();
}
@@ -38,12 +37,7 @@ pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec, model: Option
}
}
async fn run_once(
shared: &Arc<Shared>,
spec: &ProviderSpec,
strip_ambient: bool,
selected_model: Option<&str>,
) -> Result<Discovered, String> {
async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool) -> Result<Discovered, String> {
let root = shared.paths.project_root.clone();
let launch = spec.clone();
let launch = tokio::task::spawn_blocking({
@@ -53,68 +47,28 @@ async fn run_once(
.await
.map_err(|e| e.to_string())?;
let cwd = dunce::canonicalize(&root).unwrap_or(root);
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), ..Default::default() });
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), commands: Mutex::new(None) });
let client = Dialect::wrap(updates.clone());
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(|_| {});
let peer = (shared.connector)(&launch, &cwd, client.clone(), on_stderr)
.map_err(|e| format!("Couldn't start {} for model discovery: {e}", launch.name))?;
.map_err(|e| format!("Couldn't start {} (`{}`): {e}", launch.name, launch.command))?;
let _stop = crate::catalogs::KillPeer(peer.clone());
let conn = Conn::new(peer.clone(), client);
let work = async {
conn.initialize(&client_info()).await.map_err(discovery_error)?;
conn.initialize(&client_info()).await.map_err(|e| e.to_string())?;
let cwd_s = cwd.to_string_lossy().into_owned();
// No project MCP during discovery: Cursor can spend a long time spawning servers.
let new: Value = conn
.request("session/new", json!({ "cwd": cwd_s, "mcpServers": [] }), None)
.await
.map_err(discovery_error)?;
.map_err(|e| e.to_string())?;
let mut options = config::options_of(&new);
config::add_client_options(&launch.id, &mut options);
let model_option = options.iter().find(|o| o.category.as_deref() == Some("model"));
let mut levels = BTreeMap::new();
let has_config = new.get("configOptions").is_some_and(Value::is_array);
if has_config && let Some(model) = model_option.and_then(|o| o.current.as_ref()) {
levels.insert(model.clone(), levels_for_model_from_slice(&options));
}
if let Some(selected) = selected_model
&& let Some(option) = model_option.filter(|o| o.values.iter().any(|v| v.value == selected))
&& !levels.contains_key(selected)
{
let session =
new.get("sessionId").and_then(Value::as_str).ok_or("The agent did not return a session ID")?;
let (method, mut params) = config::set_request(option, selected);
params["sessionId"] = json!(session);
updates.config.lock().session = Some(session.to_owned());
let response: Value = conn.request(method, params, None).await.map_err(discovery_error)?;
let settings = if let Some(settings) = selected_settings(&response, selected) {
Some(settings)
} else {
tokio::time::timeout(CONFIG_UPDATE_TIMEOUT, async {
loop {
let notified = updates.changed.notified();
if let Some(settings) = updates
.config
.lock()
.options
.as_ref()
.and_then(|options| selected_settings(options, selected))
{
return settings;
}
notified.await;
}
})
.await
.ok()
};
match settings {
Some(settings) => levels.insert(selected.to_owned(), levels_for_model_from_slice(&settings)),
// An agent on the legacy `models` field that says nothing more: the model has
// no settings of its own, and switching to it must not fail.
None if !has_config => levels.insert(selected.to_owned(), Vec::new()),
None => return Err("The agent did not report settings for the selected model".to_owned()),
};
}
let model = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.clone());
let levels = match (model, levels_for_model_from_slice(&options)) {
(Some(model), Some(effort)) => BTreeMap::from([(model, effort)]),
_ => BTreeMap::new(),
};
let commands = updates
.commands
.lock()
@@ -134,38 +88,16 @@ async fn run_once(
struct DiscoveryUpdates {
provider: String,
commands: Mutex<Option<Vec<crate::AgentCommand>>>,
config: Mutex<DiscoveryConfig>,
changed: tokio::sync::Notify,
}
#[derive(Default)]
struct DiscoveryConfig {
session: Option<String>,
options: Option<Value>,
}
impl ide_jsonrpc::Handler for DiscoveryUpdates {
fn on_notification(&self, method: &str, params: Value) {
if method != "session/update" {
return;
}
let Some(update) = params.get("update") else { return };
match update["sessionUpdate"].as_str() {
Some("available_commands_update") => {
// Commands are protocol data, not stderr (which may contain credentials).
*self.commands.lock() = Some(config::commands_of(update, &self.provider));
}
Some("config_option_update") => {
let mut config = self.config.lock();
if config.session.as_deref() == params.get("sessionId").and_then(Value::as_str)
&& config.session.is_some()
&& update.get("configOptions").is_some_and(Value::is_array)
{
config.options = Some(update.clone());
self.changed.notify_one();
}
}
_ => {}
if method == "session/update"
&& let Some(update) = params.get("update")
&& update["sessionUpdate"] == "available_commands_update"
{
// Commands are protocol data, not stderr (which may contain credentials).
*self.commands.lock() = Some(config::commands_of(update, &self.provider));
}
}
@@ -174,24 +106,8 @@ impl ide_jsonrpc::Handler for DiscoveryUpdates {
}
}
fn discovery_error(error: ide_jsonrpc::RpcError) -> String {
match error {
ide_jsonrpc::RpcError::Server { code, message, .. } if super::auth_required(code, &message) => {
"Sign in required: the agent could not authenticate model discovery".into()
}
other => format!("The agent could not complete model discovery: {other}"),
}
}
fn selected_settings(response: &Value, model: &str) -> Option<Vec<AgentConfigOption>> {
response.get("configOptions")?.as_array()?;
let options = config::options_of(response);
let current = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.as_deref());
current.is_none_or(|current| current == model).then_some(options)
}
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Vec<AgentConfigOption> {
options
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option<Vec<AgentConfigOption>> {
let levels: Vec<_> = options
.iter()
.filter(|o| config::is_per_model_option(o))
.cloned()
@@ -205,5 +121,6 @@ fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Vec<AgentConfig
}
o
})
.collect()
.collect();
(!levels.is_empty()).then_some(levels)
}
-1
Переглянути файл
@@ -155,7 +155,6 @@ async fn a_task_runs_on_a_v2_agent_and_resumes_its_session() {
config: vec![AgentConfigChoice { id: "model".into(), value: "haiku".into() }],
isolation: Isolation::Local,
base: None,
..Default::default()
})
.await
.unwrap();
+3 -23
Переглянути файл
@@ -17,8 +17,6 @@
pub(crate) mod discover;
mod normalize;
pub(crate) use normalize::base64 as normalize_base64;
use ide_jsonrpc::{Handler, Peer, RpcError, codes};
use normalize::Normalizer;
use parking_lot::Mutex;
@@ -27,7 +25,7 @@ use serde::de::DeserializeOwned;
use serde_json::{Value, json};
use std::collections::HashMap;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
use std::sync::atomic::{AtomicU8, Ordering};
use tokio::sync::oneshot;
/// ACP's error code for a request that needs the user to sign in.
@@ -162,16 +160,9 @@ impl Negotiated {
Self { generation: 2, capabilities, agent_info: response.get("info").cloned(), auth_methods, meta }
}
/// Whether a saved session can be reopened: `loadSession`, or a v1 agent's
/// `sessionCapabilities.resume` (DeepSeek Harness), which stands in for it.
/// Whether a saved session can be reopened (`session/load` on v1, `session/resume` on v2).
pub fn load_session(&self) -> bool {
self.capabilities.get("loadSession").and_then(Value::as_bool) == Some(true) || self.session("resume")
}
/// Whether `session/load` must be sent as `session/resume`: a v1 agent that advertises
/// `sessionCapabilities.resume` instead of `loadSession` (DeepSeek Harness).
pub fn resume_instead_of_load(&self) -> bool {
self.capabilities.get("loadSession").and_then(Value::as_bool) != Some(true) && self.session("resume")
self.capabilities.get("loadSession").and_then(Value::as_bool) == Some(true)
}
/// `promptCapabilities.<name>` (`image`, `audio`, `embeddedContext`).
@@ -212,8 +203,6 @@ pub(crate) struct Dialect {
inner: Arc<dyn Handler>,
/// 0 until `initialize` answers; then 1 or 2.
generation: AtomicU8,
/// Set by `initialize`: a v1 agent's `session/load` is sent as `session/resume`.
resume_load: AtomicBool,
normalizer: Mutex<Normalizer>,
/// Running v2 prompts, by session id.
turns: Mutex<HashMap<String, Turn>>,
@@ -231,7 +220,6 @@ impl Dialect {
Arc::new(Self {
inner,
generation: AtomicU8::new(0),
resume_load: AtomicBool::new(false),
normalizer: Mutex::new(Normalizer::default()),
turns: Mutex::new(HashMap::new()),
})
@@ -241,10 +229,6 @@ impl Dialect {
self.generation.load(Ordering::Acquire)
}
fn resume_load(&self) -> bool {
self.resume_load.load(Ordering::Acquire)
}
fn v2(&self) -> bool {
self.generation() == 2
}
@@ -394,7 +378,6 @@ impl Conn {
let response: Value = self.peer.request("initialize", initialize_params(client_info), None).await?;
let negotiated = Negotiated::from_initialize(&response);
self.dialect.generation.store(negotiated.generation, Ordering::Release);
self.dialect.resume_load.store(negotiated.resume_instead_of_load(), Ordering::Release);
Ok(negotiated)
}
@@ -408,9 +391,6 @@ impl Conn {
let params = serde_json::to_value(params).map_err(|e| RpcError::Protocol(e.to_string()))?;
let value = if self.dialect.v2() {
self.request_v2(method, params, cancel).await?
} else if method == "session/load" && self.dialect.resume_load() {
// Same request shape, without a replay and without v2's setup translation.
self.peer.request("session/resume", params, cancel).await?
} else {
self.peer.request(method, params, cancel).await?
};
-85
Переглянути файл
@@ -180,7 +180,6 @@ async fn discovery_reads_effort_and_fast_from_session_new_then_stops_the_agent()
fn a_v2_initialize_response_reads_as_v1_capabilities() {
let n = Negotiated::from_initialize(&result(TURN, 1));
assert_eq!(n.generation, 2);
assert!(!n.resume_instead_of_load(), "v2 maps `session/load` itself");
assert!(n.load_session());
assert!(n.prompt("image") && n.prompt("embeddedContext") && !n.prompt("audio"));
assert!(n.session("fork") && n.session("resume") && n.session("close") && n.session("delete"));
@@ -682,87 +681,3 @@ fn stdio_mcp_is_v1_baseline_and_negotiated_in_v2() {
.mcp_stdio()
);
}
/// A v1 agent that answers `initialize` with `init` and records every request it gets.
/// Keeps its own `Peer` so the duplex stays open while the client sends.
struct V1Agent {
init: Value,
peer: std::sync::OnceLock<Peer>,
requests: parking_lot::Mutex<Vec<(String, Value)>>,
}
impl Handler for V1Agent {
fn on_notification(&self, _: &str, _: Value) {}
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
self.requests.lock().push((method.to_owned(), params));
Ok(if method == "initialize" { self.init.clone() } else { json!({}) })
}
}
async fn connect_v1(agent: Arc<V1Agent>) -> (Conn, Negotiated) {
let (a, b) = tokio::io::duplex(1 << 20);
let (ar, aw) = tokio::io::split(a);
let (br, bw) = tokio::io::split(b);
let _ = agent.peer.set(Peer::connect_framed(br, bw, agent.clone(), Framing::Lines));
let dialect = Dialect::wrap(Arc::new(Recorder::default()));
let conn = Conn::new(Peer::connect_framed(ar, aw, dialect.clone(), Framing::Lines), dialect);
let n = conn.initialize(&json!({ "name": "OpenIDEA", "version": "0" })).await.unwrap();
assert_eq!((n.generation, conn.generation()), (1, 1));
(conn, n)
}
fn v1_agent(init: Value) -> Arc<V1Agent> {
Arc::new(V1Agent { init, peer: Default::default(), requests: Default::default() })
}
/// A v1 agent that advertises `sessionCapabilities.resume` instead of `loadSession`
/// (DeepSeek Harness) can reopen a saved session, but only through `session/resume`.
#[tokio::test(flavor = "multi_thread")]
async fn a_v1_agent_with_resume_instead_of_load_reopens_through_session_resume() {
let agent = v1_agent(json!({
"protocolVersion": 1,
"agentInfo": { "name": "deepseek-harness-acp", "version": "0.0.1" },
"agentCapabilities": { "sessionCapabilities": { "close": {}, "list": {}, "resume": {} } },
}));
let (conn, n) = connect_v1(agent.clone()).await;
assert!(n.load_session(), "a resume-only agent is reloadable");
assert!(n.resume_instead_of_load());
assert!(n.session("resume"));
let params = json!({ "sessionId": "s1", "cwd": "/p", "mcpServers": [] });
let _: Value = conn.request("session/load", params.clone(), None).await.unwrap();
let requests = agent.requests.lock().clone();
assert_eq!(requests.iter().map(|(m, _)| m.as_str()).collect::<Vec<_>>(), ["initialize", "session/resume"]);
assert_eq!(requests[1].1, params, "same request shape as `session/load`");
}
/// Every other v1 agent is untouched: `loadSession` still sends `session/load`, and an
/// agent advertising neither capability is not treated as loadable.
#[tokio::test(flavor = "multi_thread")]
async fn v1_agents_that_do_not_advertise_resume_keep_session_load() {
for (init, loadable) in [
(json!({ "protocolVersion": 1, "agentCapabilities": { "loadSession": true } }), true),
(json!({ "protocolVersion": 1, "agentCapabilities": { "loadSession": false } }), false),
(json!({ "protocolVersion": 1, "agentCapabilities": { "sessionCapabilities": { "resume": null } } }), false),
(json!({ "protocolVersion": 1 }), false),
] {
let agent = v1_agent(init);
let (conn, n) = connect_v1(agent.clone()).await;
assert_eq!(n.load_session(), loadable);
assert!(!n.resume_instead_of_load());
let _: Value = conn.request("session/load", json!({ "sessionId": "s1" }), None).await.unwrap();
let methods: Vec<String> = agent.requests.lock().iter().map(|(m, _)| m.clone()).collect();
assert_eq!(methods, ["initialize", "session/load"]);
}
// `loadSession: true` wins over a resume-only advertisement.
let agent = v1_agent(json!({
"protocolVersion": 1,
"agentCapabilities": { "loadSession": true, "sessionCapabilities": { "resume": {} } },
}));
let (conn, n) = connect_v1(agent.clone()).await;
assert!(n.load_session() && !n.resume_instead_of_load());
let _: Value = conn.request("session/load", json!({ "sessionId": "s1" }), None).await.unwrap();
let methods: Vec<String> = agent.requests.lock().iter().map(|(m, _)| m.clone()).collect();
assert_eq!(methods, ["initialize", "session/load"]);
}
+19 -182
Переглянути файл
@@ -45,18 +45,9 @@ struct Entry {
error: Option<String>,
flight: Option<watch::Receiver<bool>>,
abort: Option<tokio::task::AbortHandle>,
flight_model: Option<String>,
requested_model: Option<String>,
model_failures: HashMap<String, ModelFailure>,
catalog: Option<CatalogData>,
}
struct ModelFailure {
completed: Instant,
retry_at_ms: f64,
error: String,
}
#[derive(Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct CatalogData {
@@ -118,7 +109,6 @@ impl LaunchContext {
provider::Driver::Acp => b"acp",
provider::Driver::Codex => b"codex",
provider::Driver::Claude => b"claude",
provider::Driver::Copilot => b"copilot",
},
);
field(&mut hash, self.spec.command.as_bytes());
@@ -213,55 +203,18 @@ impl AgentCatalogs {
.unwrap_or_else(|| Self::fallback(shared, provider))
}
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
let state = self.state.lock();
if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref())
{
return catalog.thought_levels.get(model).cloned();
}
drop(state);
let cache = shared.known.lock();
let known = cache.get(provider)?;
known
.catalogs
.get(&shared.root_key())
.map(|saved| &saved.catalog.thought_levels)
.unwrap_or(&known.thought_levels)
.get(model)
.cloned()
}
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
let key = Self::key(shared, provider);
let mut state = self.state.lock();
if state.entries.get(&key).is_some_and(|e| e.flight.is_none()) {
state.entries.remove(&key);
}
}
fn snapshot(&self, shared: &Shared, provider: &str, entry: &Entry) -> AgentModelCatalog {
let catalog = entry.catalog.clone().unwrap_or_else(|| Self::fallback(shared, provider));
let model_failure = entry.requested_model.as_ref().and_then(|model| entry.model_failures.get(model));
let unknown_model = entry
.requested_model
.as_deref()
.is_some_and(|model| catalog.lists(model) && !catalog.thought_levels.contains_key(model));
AgentModelCatalog {
provider: provider.to_owned(),
config: shared.config_for_new_task(catalog.config, provider),
thought_levels: catalog.thought_levels,
refreshing: entry.flight.is_some(),
refreshed_at_ms: catalog.refreshed_at_ms,
retry_at_ms: model_failure
.filter(|failure| self.now().duration_since(failure.completed) < COOLDOWN)
.map(|failure| failure.retry_at_ms)
.or_else(|| {
(!unknown_model)
.then_some(entry.retry_at_ms)
.flatten()
.filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN))
}),
error: model_failure.map(|failure| failure.error.clone()).or_else(|| entry.error.clone()),
retry_at_ms: entry
.retry_at_ms
.filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN)),
error: entry.error.clone(),
}
}
@@ -271,7 +224,6 @@ impl AgentCatalogs {
shared: &Arc<Shared>,
spec: provider::ProviderSpec,
force: bool,
model: Option<&str>,
) -> (AgentModelCatalog, Option<watch::Receiver<bool>>) {
let key = Self::key(shared, &spec.id);
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
@@ -303,7 +255,6 @@ impl AgentCatalogs {
let mut catalog = saved.catalog;
if !matching {
catalog.refreshed_at_ms = None;
catalog.thought_levels.clear();
}
catalog
});
@@ -319,73 +270,31 @@ impl AgentCatalogs {
error: None,
flight: None,
abort: None,
flight_model: None,
requested_model: None,
model_failures: HashMap::new(),
},
);
}
let fallback =
state.entries.get(&key).filter(|entry| entry.catalog.is_none()).map(|_| Self::fallback(shared, &spec.id));
state.generation += 1;
let generation = state.generation;
let entry = state.entries.get_mut(&key).expect("catalog entry");
let catalog = entry.catalog.as_ref().or(fallback.as_ref()).expect("cached catalog");
let cooling = entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN);
let fresh = entry.successful.is_some_and(|at| now.duration_since(at) < FRESH_FOR);
let target = model
.filter(|model| {
(catalog.lists(model) && !catalog.thought_levels.contains_key(*model))
|| (!fresh && catalog.model_option().is_none())
})
.map(str::to_owned);
if model.is_some() && entry.requested_model.as_deref() != model {
entry.requested_model = model.map(str::to_owned);
}
let superseded = model.is_some()
&& entry.flight.is_some()
&& (entry.flight_model.is_some() || target.is_some())
&& entry.flight_model.as_deref() != target.as_deref();
if superseded {
if let Some(abort) = entry.abort.take() {
abort.abort();
}
entry.flight = None;
entry.generation = generation;
entry.flight_model = None;
}
let cooling = match target.as_ref() {
Some(model) => entry.model_failures.get(model).is_some_and(|f| now.duration_since(f.completed) < COOLDOWN),
None => entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN),
};
let eligible = !cooling && (target.is_some() || force || !fresh);
let mut start = None;
if entry.flight.is_none() && eligible {
if entry.flight.is_none() && !cooling && (force || !fresh) {
let (done, ready) = watch::channel(false);
entry.flight = Some(ready);
entry.flight_model = target.clone();
entry.error = None;
if let Some(model) = target.as_ref() {
entry.model_failures.remove(model);
}
entry.retry_at_ms = None;
// Every flight has its own generation, including superseded model selections.
entry.generation = generation;
start = Some((entry.generation, target, done));
start = Some((entry.generation, done));
}
let snapshot = self.snapshot(shared, &spec.id, entry);
let flight = entry.flight.clone();
drop(state);
if superseded && start.is_none() {
self.broadcast(shared, &snapshot);
}
if let Some((generation, model, done)) = start {
if let Some((generation, done)) = start {
self.broadcast(shared, &snapshot);
let coordinator = self.clone();
let shared = shared.clone();
let flight_key = key.clone();
let task = shared.runtime.clone().spawn(async move {
let result = discover(&shared, spec, model.as_deref()).await;
coordinator.complete(&shared, flight_key, generation, model, result);
let result = discover(&shared, spec).await;
coordinator.complete(&shared, flight_key, generation, result);
let _ = done.send(true);
});
// A subscriber can re-enter and change configuration during the start event.
@@ -401,14 +310,7 @@ impl AgentCatalogs {
(snapshot, flight)
}
fn complete(
&self,
shared: &Shared,
key: Key,
generation: u64,
model: Option<String>,
result: Result<Discovered, String>,
) {
fn complete(&self, shared: &Shared, key: Key, generation: u64, result: Result<Discovered, String>) {
let current = provider::load(shared.paths.custom_agents_dir.as_deref(), shared.env_secrets())
.into_iter()
.find(|spec| spec.id == key.2)
@@ -419,7 +321,6 @@ impl AgentCatalogs {
if current.as_ref() != Some(&entry.context) {
entry.flight = None;
entry.abort = None;
entry.flight_model = None;
entry.completed = None;
entry.retry_at_ms = None;
entry.error = None;
@@ -430,16 +331,12 @@ impl AgentCatalogs {
return;
}
let now = self.now();
if model.is_none() {
entry.completed = Some(now);
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
}
entry.completed = Some(now);
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
entry.flight = None;
entry.abort = None;
entry.flight_model = None;
let success = match result {
Ok(found) => {
let previous = entry.catalog.take().unwrap_or_else(|| Self::fallback(shared, &key.2));
let mut cache = shared.known.lock();
let known = cache.entry(key.2.clone()).or_default();
let mut catalog = CatalogData {
@@ -448,7 +345,7 @@ impl AgentCatalogs {
refreshed_at_ms: Some(self.epoch_ms()),
};
// Efforts sessions reported for models discovery doesn't read stay while listed.
for (model, levels) in previous.thought_levels {
for (model, levels) in entry.catalog.take().map(|old| old.thought_levels).unwrap_or_default() {
if catalog.lists(&model) && !catalog.thought_levels.contains_key(&model) {
catalog.thought_levels.insert(model, levels);
}
@@ -467,30 +364,11 @@ impl AgentCatalogs {
entry.catalog = Some(catalog);
shared.persist_known(&cache);
entry.successful = Some(now);
entry.completed = Some(now);
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
entry.model_failures.retain(|model, _| {
entry
.catalog
.as_ref()
.is_some_and(|catalog| catalog.lists(model) && !catalog.thought_levels.contains_key(model))
});
entry.error = None;
true
}
Err(error) => {
if let Some(model) = model {
entry.model_failures.insert(
model,
ModelFailure {
completed: now,
retry_at_ms: self.epoch_ms() + COOLDOWN.as_millis() as f64,
error,
},
);
} else {
entry.error = Some(error);
}
entry.error = Some(error);
false
}
};
@@ -561,22 +439,18 @@ impl AgentCatalogs {
impl crate::AgentManager {
/// Return cached choices immediately and schedule discovery when eligible.
pub fn refresh_models(&self, provider: &str, force: bool, model: Option<&str>) -> IdeResult<AgentModelCatalog> {
pub fn refresh_models(&self, provider: &str, force: bool) -> IdeResult<AgentModelCatalog> {
// Settings and environment secrets can change while this window is open.
*self.shared.providers.write() =
provider::load(self.shared.paths.custom_agents_dir.as_deref(), self.shared.env_secrets());
let spec = self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?;
Ok(self.shared.paths.catalogs.request(&self.shared, spec, force, model).0)
Ok(self.shared.paths.catalogs.request(&self.shared, spec, force).0)
}
}
async fn discover(
shared: &Arc<Shared>,
spec: provider::ProviderSpec,
model: Option<&str>,
) -> Result<Discovered, String> {
async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<Discovered, String> {
match spec.driver {
provider::Driver::Acp => acp::discover::run(shared, &spec, model).await,
provider::Driver::Acp => acp::discover::run(shared, &spec).await,
provider::Driver::Codex => native::codex::discover(spec, shared.paths.project_root.clone()).await,
provider::Driver::Claude => {
let found = native::claude::discover(spec.clone(), shared.paths.project_root.clone()).await?;
@@ -598,43 +472,6 @@ async fn discover(
.collect(),
})
}
provider::Driver::Copilot => {
if shared.uses_copilot_acp_fallback(&spec) {
let acp_spec = native::copilot::acp_fallback_spec(&spec);
return acp::discover::run(shared, &acp_spec, model).await;
}
match native::copilot::discover(spec.clone(), shared.paths.project_root.clone()).await {
Ok(found) => Ok(Discovered {
commands: Some(config::commands_of(
&serde_json::json!({ "availableCommands": found.commands }),
&spec.id,
)),
config: config::options_of(&serde_json::json!({ "configOptions": found.options })),
levels: found
.per_model
.into_iter()
.map(|(model, opts)| {
let parsed = if opts.is_empty() {
Vec::new()
} else {
config::options_of(&serde_json::json!({ "configOptions": opts }))
};
(model, parsed)
})
.collect(),
}),
Err(err) if err.allow_acp_fallback => {
tracing::warn!(
"Copilot headless catalog discovery failed ({}); falling back to `copilot --acp`",
err.message
);
shared.mark_copilot_acp_fallback(&spec);
let acp_spec = native::copilot::acp_fallback_spec(&spec);
acp::discover::run(shared, &acp_spec, model).await
}
Err(err) => Err(err.message),
}
}
}
}
+56 -372
Переглянути файл
@@ -11,10 +11,8 @@ const PROVIDER: &str = "catalog-test";
#[derive(Debug)]
struct Pending {
method: String,
params: Value,
reply: oneshot::Sender<Result<Value, String>>,
notifications: mpsc::UnboundedSender<Value>,
}
struct Harness {
@@ -33,10 +31,6 @@ impl Drop for Live {
impl Harness {
fn new() -> Self {
Self::with_initialize(json!({ "protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] }))
}
fn with_initialize(initialize: Value) -> Self {
let (pending_tx, pending) = mpsc::unbounded_channel();
let launches = Arc::new(AtomicUsize::new(0));
let live = Arc::new(AtomicUsize::new(0));
@@ -48,53 +42,26 @@ impl Harness {
live.fetch_add(1, Ordering::SeqCst);
let guard = Live(live.clone());
let pending = pending_tx.clone();
let initialize = initialize.clone();
let (notifications_tx, mut notifications) = mpsc::unbounded_channel::<Value>();
let (client_io, server_io) = tokio::io::duplex(1 << 16);
let (read, mut write) = tokio::io::split(server_io);
tokio::spawn(async move {
let _guard = guard;
let mut lines = BufReader::new(read).lines();
loop {
let line = tokio::select! {
line = lines.next_line() => match line.unwrap() {
Some(line) => line,
None => break,
},
Some(notification) = notifications.recv() => {
if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() {
break;
}
continue;
}
};
while let Some(line) = lines.next_line().await.unwrap() {
let request: Value = serde_json::from_str(&line).unwrap();
let id = &request["id"];
if id.is_null() {
continue;
}
let response = match request["method"].as_str().unwrap() {
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }),
"session/new" | "session/set_config_option" | "session/set_model" => {
let (reply, mut result) = oneshot::channel();
pending
.send(Pending {
method: request["method"].as_str().unwrap().to_owned(),
params: request["params"].clone(),
reply,
notifications: notifications_tx.clone(),
})
.unwrap();
let result = loop {
tokio::select! {
result = &mut result => break result.unwrap(),
_ = lines.next_line() => return,
Some(notification) = notifications.recv() => {
if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() {
return;
}
}
}
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": {
"protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] } }),
"session/new" => {
let (reply, result) = oneshot::channel();
pending.send(Pending { params: request["params"].clone(), reply }).unwrap();
let result = tokio::select! {
result = result => result.unwrap(),
_ = lines.next_line() => break,
};
match result {
Ok(result) => json!({ "id": id, "jsonrpc": "2.0", "result": result }),
@@ -223,7 +190,7 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
let mut events = events(&manager);
let old = config::options_of(&response(&["old", "retained"], &["low", "high"]));
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
let cached = manager.refresh_models(PROVIDER, false).unwrap();
assert!(cached.refreshing);
assert_eq!(model_values(&cached), ["old", "retained"]);
assert!(cached.refreshed_at_ms.is_none(), "session reports are not fresh discovery");
@@ -237,13 +204,13 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
assert_eq!(fresh.thought_levels["retained"][0].values[0].value, "medium");
assert!(fresh.refreshed_at_ms.is_some() && fresh.retry_at_ms.is_some());
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config);
assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config);
let provider = manager.providers().into_iter().find(|p| p.id == PROVIDER).unwrap();
assert_eq!(provider.config, fresh.config);
let persisted = std::fs::read_to_string(tmp.path().join("models.json")).unwrap();
assert!(!persisted.contains("secret-one") && !persisted.contains("TOKEN"));
let restored = make_manager(tmp.path(), Arc::default(), &harness);
let restored_snapshot = restored.refresh_models(PROVIDER, false, None).unwrap();
let restored_snapshot = restored.refresh_models(PROVIDER, false).unwrap();
assert!(!restored_snapshot.refreshing, "matching persisted launch context remains fresh");
assert_eq!(restored_snapshot.refreshed_at_ms, fresh.refreshed_at_ms);
let provider = restored.providers().into_iter().find(|p| p.id == PROVIDER).unwrap();
@@ -262,7 +229,7 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
let catalogs = Arc::new(AgentCatalogs::default());
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Ok(response(&["first", "second"], &["low", "high"]))).unwrap();
completed(&mut events).await;
// A session on "second" reports its own efforts; one on a model the catalog lacks, or on
@@ -274,16 +241,16 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
let efforts = |catalog: &AgentModelCatalog, model: &str| -> Vec<String> {
catalog.thought_levels[model][0].values.iter().map(|v| v.value.clone()).collect()
};
let catalog = manager.refresh_models(PROVIDER, false, None).unwrap();
let catalog = manager.refresh_models(PROVIDER, false).unwrap();
assert_eq!(catalog.thought_levels.keys().map(String::as_str).collect::<Vec<_>>(), ["first", "second"]);
assert_eq!(efforts(&catalog, "first"), ["low", "high"]);
assert_eq!(efforts(&catalog, "second"), ["off", "auto"]);
let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false, None).unwrap();
let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false).unwrap();
assert_eq!(efforts(&restored, "second"), ["off", "auto"], "persisted with the project's catalog");
// Discovery again reads "first" only; "second" keeps what its session reported.
advance(&catalogs, 60);
while events.try_recv().is_ok() {}
manager.refresh_models(PROVIDER, true, None).unwrap();
manager.refresh_models(PROVIDER, true).unwrap();
harness.next().await.reply.send(Ok(response(&["first", "second"], &["medium"]))).unwrap();
let fresh = completed(&mut events).await;
assert_eq!(efforts(&fresh, "first"), ["medium"]);
@@ -306,7 +273,7 @@ async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
let cached = manager.refresh_models(PROVIDER, false).unwrap();
assert_eq!(model_values(&cached), ["legacy"]);
assert!(cached.refreshing && cached.refreshed_at_ms.is_none());
harness.next().await.reply.send(Err("Sign in required".into())).unwrap();
@@ -325,11 +292,11 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut first_events = events(&first);
let mut second_events = events(&second);
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing);
let pending = harness.next().await;
for _ in 0..10 {
assert!(second.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(second.refresh_models(PROVIDER, true).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
}
let commands = tokio::spawn({
let first = first.clone();
@@ -342,21 +309,21 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co
assert_eq!(completed(&mut second_events).await, done);
commands.await.unwrap().unwrap();
for force in [false, true, false, true] {
assert!(!second.refresh_models(PROVIDER, force, None).unwrap().refreshing);
assert!(!second.refresh_models(PROVIDER, force).unwrap().refreshing);
}
advance(&catalogs, 29);
assert!(!first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!first.refresh_models(PROVIDER, true).unwrap().refreshing);
advance(&catalogs, 1);
assert!(!first.refresh_models(PROVIDER, false, None).unwrap().refreshing, "automatic refresh remains fresh");
assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!first.refresh_models(PROVIDER, false).unwrap().refreshing, "automatic refresh remains fresh");
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["two"], &["high"]))).unwrap();
let newer = completed(&mut first_events).await;
assert_eq!(model_values(&newer), ["two"]);
assert_eq!(completed(&mut second_events).await, newer);
advance(&catalogs, 15 * 60 - 1);
assert!(!second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(!second.refresh_models(PROVIDER, false).unwrap().refreshing);
advance(&catalogs, 1);
assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["three"], &["low"]))).unwrap();
completed(&mut first_events).await;
assert_eq!(harness.launches.load(Ordering::SeqCst), 3);
@@ -370,25 +337,25 @@ async fn failure_keeps_successful_choices_and_throttles_manual_and_auto_retries(
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, true, None).unwrap();
manager.refresh_models(PROVIDER, true).unwrap();
harness.next().await.reply.send(Ok(response(&["cached"], &["low"]))).unwrap();
let success = completed(&mut events).await;
let disk = std::fs::read(tmp.path().join("models.json")).unwrap();
advance(&catalogs, 15 * 60);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Err("Authentication expired".into())).unwrap();
let failed = completed(&mut events).await;
assert_eq!(failed.config, success.config);
assert_eq!(failed.thought_levels, success.thought_levels);
assert_eq!(failed.refreshed_at_ms, success.refreshed_at_ms);
assert!(failed.error.as_deref().unwrap().contains("Sign in required"));
assert!(failed.error.as_deref().unwrap().contains("Authentication expired"));
assert_eq!(std::fs::read(tmp.path().join("models.json")).unwrap(), disk);
assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
advance(&catalogs, 29);
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
advance(&catalogs, 1);
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["recovered"], &["high"]))).unwrap();
let recovered = completed(&mut events).await;
assert_eq!(model_values(&recovered), ["recovered"]);
@@ -403,21 +370,21 @@ async fn timeout_cleans_up_and_enters_the_same_failure_cooldown() {
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
let pending = harness.next().await;
tokio::time::pause();
tokio::time::advance(Duration::from_secs(4)).await;
let failed = completed(&mut events).await;
assert!(failed.error.as_deref().unwrap().contains("time"));
assert!(failed.retry_at_ms.is_some());
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
tokio::time::resume();
stopped(&harness).await;
assert_eq!(harness.live.load(Ordering::SeqCst), 0, "timed-out connection must close");
assert!(pending.reply.is_closed());
advance(&catalogs, 30);
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["retry"], &["low"]))).unwrap();
completed(&mut events).await;
}
@@ -431,16 +398,16 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() {
let first = make_manager(tmp.path(), catalogs.clone(), &harness);
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&second);
first.refresh_models(PROVIDER, false, None).unwrap();
first.refresh_models(PROVIDER, false).unwrap();
let obsolete = harness.next().await;
configure(tmp.path(), "two");
assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
let latest = harness.next().await;
latest.reply.send(Ok(response(&["latest"], &["high"]))).unwrap();
let fresh = completed(&mut events).await;
let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"])));
stopped(&harness).await;
let shown = first.refresh_models(PROVIDER, false, None).unwrap();
let shown = first.refresh_models(PROVIDER, false).unwrap();
assert_eq!(shown.config, fresh.config);
assert_eq!(shown.refreshed_at_ms, fresh.refreshed_at_ms);
assert!(!shown.refreshing);
@@ -448,7 +415,7 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() {
assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete"));
// A changed configuration also invalidates successful freshness/cooldown.
configure(tmp.path(), "three");
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["new-config"], &["medium"]))).unwrap();
completed(&mut events).await;
}
@@ -458,7 +425,7 @@ async fn invalid_provider_is_a_request_error_and_does_not_launch() {
let tmp = tempfile::tempdir().unwrap();
let harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
assert!(manager.refresh_models("missing-provider", true, None).is_err());
assert!(manager.refresh_models("missing-provider", true).is_err());
assert_eq!(harness.launches.load(Ordering::SeqCst), 0);
}
@@ -470,18 +437,18 @@ async fn replacing_the_executable_at_the_same_path_invalidates_freshness_and_obs
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs, &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
let obsolete = harness.next().await;
std::fs::write(tmp.path().join("catalog-test-bin"), "replacement executable with different size").unwrap();
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
let latest = harness.next().await;
latest.reply.send(Ok(response(&["updated"], &["high"]))).unwrap();
let fresh = completed(&mut events).await;
let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"])));
stopped(&harness).await;
assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config);
assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config);
std::fs::write(tmp.path().join("catalog-test-bin"), "another executable").unwrap();
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["new-install"], &["medium"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["new-install"]);
assert_eq!(harness.launches.load(Ordering::SeqCst), 3);
@@ -501,18 +468,18 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts()
let second = make_manager_at(&b, &models_file, catalogs, &harness);
let mut first_events = events(&first);
let mut second_events = events(&second);
first.refresh_models(PROVIDER, false, None).unwrap();
first.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Ok(response(&["account-a-model"], &["low"]))).unwrap();
let a_catalog = completed(&mut first_events).await;
second.refresh_models(PROVIDER, false, None).unwrap();
second.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Ok(response(&["account-b-model"], &["high"]))).unwrap();
let b_catalog = completed(&mut second_events).await;
assert_eq!(first.refresh_models(PROVIDER, false, None).unwrap().config, a_catalog.config);
assert_eq!(second.refresh_models(PROVIDER, false, None).unwrap().config, b_catalog.config);
assert_eq!(first.refresh_models(PROVIDER, false).unwrap().config, a_catalog.config);
assert_eq!(second.refresh_models(PROVIDER, false).unwrap().config, b_catalog.config);
assert_eq!(first.providers().into_iter().find(|p| p.id == PROVIDER).unwrap().config, a_catalog.config);
for (root, expected) in [(&a, &a_catalog), (&b, &b_catalog)] {
let restored = make_manager_at(root, &models_file, Arc::default(), &harness);
let cached = restored.refresh_models(PROVIDER, false, None).unwrap();
let cached = restored.refresh_models(PROVIDER, false).unwrap();
assert!(!cached.refreshing, "matching persisted context should retain freshness");
assert_eq!(cached.config, expected.config);
assert_eq!(cached.refreshed_at_ms, expected.refreshed_at_ms);
@@ -521,7 +488,7 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts()
configure(&a, "new-account");
let changed = make_manager_at(&a, &models_file, Arc::default(), &harness);
let mut events = events(&changed);
let stale = changed.refresh_models(PROVIDER, false, None).unwrap();
let stale = changed.refresh_models(PROVIDER, false).unwrap();
assert!(stale.refreshing, "a different launch environment cannot reuse persisted freshness");
assert!(stale.refreshed_at_ms.is_none());
assert_eq!(stale.config, a_catalog.config, "stale cached choices remain selectable");
@@ -538,7 +505,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
let obsolete = harness.next().await;
configure(tmp.path(), "after");
obsolete.reply.send(Ok(response(&["obsolete"], &["low"]))).unwrap();
@@ -546,7 +513,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove
assert!(model_values(&discarded).is_empty());
assert!(discarded.refreshed_at_ms.is_none());
assert!(!tmp.path().join("models.json").exists());
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Ok(response(&["current"], &["high"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["current"]);
}
@@ -559,296 +526,13 @@ async fn successful_empty_catalog_removes_all_previous_models_and_efforts() {
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, true, None).unwrap();
manager.refresh_models(PROVIDER, true).unwrap();
harness.next().await.reply.send(Ok(response(&["removed"], &["low"]))).unwrap();
completed(&mut events).await;
advance(&catalogs, 30);
manager.refresh_models(PROVIDER, true, None).unwrap();
manager.refresh_models(PROVIDER, true).unwrap();
harness.next().await.reply.send(Ok(response(&[], &[]))).unwrap();
let empty = completed(&mut events).await;
assert!(model_values(&empty).is_empty() && empty.thought_levels.is_empty());
assert!(empty.refreshed_at_ms.is_some() && empty.error.is_none());
}
fn selected_response(model: &str, effort: &[&str]) -> Value {
let mut result = response(&[model], effort);
if effort.is_empty() {
result["configOptions"].as_array_mut().unwrap().retain(|option| option["id"] != "effort");
}
result
}
fn config_notification(session: &str, result: &Value) -> Value {
json!({ "jsonrpc": "2.0", "method": "session/update", "params": {
"sessionId": session,
"update": { "sessionUpdate": "config_option_update", "configOptions": result["configOptions"] }
} })
}
fn efforts<'a>(catalog: &'a AgentModelCatalog, model: &str) -> Vec<&'a str> {
catalog.thought_levels[model]
.iter()
.filter(|option| option.category.as_deref() == Some("thought_level"))
.flat_map(|option| option.values.iter().map(|value| value.value.as_str()))
.collect()
}
#[tokio::test]
async fn selected_models_report_their_own_controls_before_any_task_or_prompt() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let catalogs = Arc::new(AgentCatalogs::default());
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
let models = ["default", "second", "plain", "unknown"];
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
let original = completed(&mut events).await;
assert!(!original.thought_levels.contains_key("second"));
// A fresh catalog and its global cooldown must not delay an unknown selection.
assert!(manager.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
let pending = harness.next().await;
assert_eq!(pending.method, "session/set_config_option");
assert_eq!(pending.params, json!({ "sessionId": "discovery-only", "configId": "model", "value": "second" }));
let mut second = selected_response("second", &["off", "auto", "max"]);
second["configOptions"].as_array_mut().unwrap().push(json!({
"id": "context_tier", "type": "select", "currentValue": "large",
"options": [{ "value": "normal" }, { "value": "large" }]
}));
pending.reply.send(Ok(second)).unwrap();
let learned = completed(&mut events).await;
assert_eq!(learned.config, original.config, "selection discovery never changes the default model");
assert_eq!(efforts(&learned, "default"), ["low", "high"]);
assert_eq!(efforts(&learned, "second"), ["off", "auto", "max"]);
assert!(learned.thought_levels["second"].iter().any(|option| option.id == "context_tier"));
assert!(!learned.thought_levels.contains_key("unknown"));
manager.refresh_models(PROVIDER, false, Some("plain")).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
harness.next().await.reply.send(Ok(selected_response("plain", &[]))).unwrap();
let plain = completed(&mut events).await;
assert!(plain.thought_levels["plain"].is_empty(), "an authoritative no-control result is cached");
for model in ["default", "second", "plain"] {
assert!(!manager.refresh_models(PROVIDER, false, Some(model)).unwrap().refreshing);
}
let restored = make_manager(tmp.path(), Arc::default(), &harness);
let cached = restored.refresh_models(PROVIDER, false, Some("plain")).unwrap();
assert!(!cached.refreshing);
assert!(cached.thought_levels["plain"].is_empty());
assert_eq!(efforts(&cached, "second"), ["off", "auto", "max"]);
assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "never iterate unselected models");
assert!(!tmp.path().join("store").exists(), "no task or prompt is needed");
}
#[tokio::test]
async fn missing_or_failed_selected_settings_remain_unknown_and_have_model_scoped_retry_cooldowns() {
for reply in [Ok(json!({})), Ok(selected_response("default", &["wrong"])), Err("token=secret-one".into())] {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let catalogs = Arc::new(AgentCatalogs::default());
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
let models = ["default", "unsupported", "other"];
manager.refresh_models(PROVIDER, false, None).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
let original = completed(&mut events).await;
manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
harness.next().await.reply.send(reply).unwrap();
let failed = completed(&mut events).await;
assert_eq!(failed.config, original.config);
assert!(!failed.thought_levels.contains_key("unsupported"));
assert!(failed.error.is_some() && failed.retry_at_ms.is_some());
assert!(!failed.error.as_deref().unwrap().contains("secret-one"));
assert!(!manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing);
// The failed model cannot block another model, and its cooldown survives that success.
assert!(manager.refresh_models(PROVIDER, false, Some("other")).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
harness.next().await.reply.send(Ok(selected_response("other", &[]))).unwrap();
assert!(completed(&mut events).await.error.is_none());
assert!(!manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap().refreshing);
advance(&catalogs, 30);
assert!(manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
harness.next().await.reply.send(Ok(selected_response("unsupported", &["high"]))).unwrap();
let retried = completed(&mut events).await;
assert_eq!(efforts(&retried, "unsupported"), ["high"]);
assert!(retried.error.is_none());
}
}
#[tokio::test]
async fn rapid_model_selections_share_the_current_flight_and_discard_superseded_results() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let catalogs = Arc::new(AgentCatalogs::default());
let mut harness = Harness::new();
let first = make_manager(tmp.path(), catalogs.clone(), &harness);
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&first);
let models = ["default", "second", "third"];
first.refresh_models(PROVIDER, false, None).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
completed(&mut events).await;
first.refresh_models(PROVIDER, false, Some("second")).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
let obsolete = harness.next().await;
for _ in 0..5 {
assert!(second.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing);
}
assert_eq!(harness.launches.load(Ordering::SeqCst), 2);
second.refresh_models(PROVIDER, false, Some("third")).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
let current = harness.next().await;
assert_eq!(current.params["value"], "third");
current.reply.send(Ok(selected_response("third", &["max"]))).unwrap();
let fresh = completed(&mut events).await;
let _ = obsolete.reply.send(Ok(selected_response("second", &["obsolete"])));
stopped(&harness).await;
let cached = first.refresh_models(PROVIDER, false, Some("third")).unwrap();
assert_eq!(cached, fresh);
assert_eq!(efforts(&cached, "third"), ["max"]);
assert!(!cached.thought_levels.contains_key("second"));
assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "no stale requests are queued");
assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete"));
}
#[tokio::test]
async fn switching_back_to_a_known_model_cancels_the_unknown_model_flight() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap();
completed(&mut events).await;
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
let obsolete = harness.next().await;
let known = manager.refresh_models(PROVIDER, false, Some("default")).unwrap();
assert!(!known.refreshing);
assert_eq!(completed(&mut events).await, known, "other subscribers also leave loading state");
let _ = obsolete.reply.send(Err("late failure".into()));
stopped(&harness).await;
let cached = manager.refresh_models(PROVIDER, false, Some("default")).unwrap();
assert!(cached.error.is_none() && !cached.thought_levels.contains_key("second"));
assert_eq!(harness.launches.load(Ordering::SeqCst), 2);
}
#[tokio::test]
async fn selected_model_uses_legacy_set_model_and_authoritative_notifications() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
// No cache is needed: the selected model is resolved in the same short-lived session.
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
harness
.next()
.await
.reply
.send(Ok(json!({
"sessionId": "discovery-only",
"models": { "currentModelId": "default", "availableModels": [
{ "modelId": "default", "name": "Default" }, { "modelId": "second", "name": "Second" }
] }
})))
.unwrap();
let selected = harness.next().await;
assert_eq!(selected.method, "session/set_model");
assert_eq!(selected.params, json!({ "sessionId": "discovery-only", "modelId": "second" }));
let notifications = selected.notifications;
selected.reply.send(Ok(json!({}))).unwrap();
notifications.send(config_notification("different-session", &selected_response("second", &["wrong"]))).unwrap();
notifications
.send(config_notification("discovery-only", &selected_response("second", &["medium", "high"])))
.unwrap();
let catalog = completed(&mut events).await;
assert_eq!(efforts(&catalog, "second"), ["medium", "high"]);
assert_eq!(catalog.config.iter().find(|option| option.id == "model").unwrap().current.as_deref(), Some("default"));
assert!(!catalog.thought_levels.contains_key("default"), "legacy model lists alone do not assert no controls");
}
#[tokio::test]
async fn selected_legacy_model_without_settings_has_no_levels_instead_of_failing() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
harness
.next()
.await
.reply
.send(Ok(json!({
"sessionId": "discovery-only",
"models": { "currentModelId": "default", "availableModels": [
{ "modelId": "default", "name": "Default" }, { "modelId": "second", "name": "Second" }
] }
})))
.unwrap();
let selected = harness.next().await;
assert_eq!(selected.method, "session/set_model");
selected.reply.send(Ok(json!({}))).unwrap();
let catalog = completed(&mut events).await;
assert!(catalog.error.is_none(), "{:?}", catalog.error);
assert_eq!(catalog.thought_levels.get("second"), Some(&Vec::new()));
}
#[tokio::test]
async fn catalog_replacement_removes_selected_metadata_for_models_no_longer_listed() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let catalogs = Arc::new(AgentCatalogs::default());
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap();
harness.next().await.reply.send(Ok(selected_response("second", &["max"]))).unwrap();
completed(&mut events).await;
advance(&catalogs, 30);
manager.refresh_models(PROVIDER, true, None).unwrap();
harness.next().await.reply.send(Ok(response(&["default", "new"], &["medium"]))).unwrap();
let replaced = completed(&mut events).await;
assert_eq!(model_values(&replaced), ["default", "new"]);
assert_eq!(efforts(&replaced, "default"), ["medium"]);
assert!(!replaced.thought_levels.contains_key("second") && !replaced.thought_levels.contains_key("new"));
}
#[tokio::test]
async fn selected_model_discovery_uses_the_negotiated_v2_wire_format_and_config_updates() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::with_initialize(json!({
"protocolVersion": 2, "info": { "name": "V2 Catalog Test" }, "capabilities": { "session": {} }
}));
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
let mut initial = response(&["default", "second"], &["low"]);
for option in initial["configOptions"].as_array_mut().unwrap() {
option["configId"] = option.as_object_mut().unwrap().remove("id").unwrap();
}
harness.next().await.reply.send(Ok(initial)).unwrap();
let selected = harness.next().await;
assert_eq!(selected.method, "session/set_config_option");
assert_eq!(
selected.params,
json!({
"sessionId": "discovery-only", "configId": "model", "value": "second", "type": "id"
})
);
// Notifications may arrive before the request response as well as after it.
selected.notifications.send(config_notification("discovery-only", &selected_response("second", &[]))).unwrap();
selected.reply.send(Ok(json!({}))).unwrap();
let catalog = completed(&mut events).await;
assert!(catalog.thought_levels["second"].is_empty());
assert_eq!(efforts(&catalog, "default"), ["low"]);
}
+1 -12
Переглянути файл
@@ -3,7 +3,7 @@
use crate::model::{
AgentCommand, AgentCommandSource, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit,
AgentModelPricing, AgentUsage,
AgentUsage,
};
use serde_json::{Value, json};
@@ -29,7 +29,6 @@ pub(crate) fn add_client_options(provider: &str, config: &mut Vec<AgentConfigOpt
description: Some("Show permission requests from Cursor".into()),
cost_category: None,
usage_multiplier: None,
pricing: None,
},
AgentConfigValue {
value: "bypass".into(),
@@ -37,7 +36,6 @@ pub(crate) fn add_client_options(provider: &str, config: &mut Vec<AgentConfigOpt
description: Some("Automatically approve tool requests in this conversation".into()),
cost_category: None,
usage_multiplier: None,
pricing: None,
},
],
});
@@ -290,7 +288,6 @@ fn legacy(
description: str_of(m, "description"),
cost_category: None,
usage_multiplier: None,
pricing: pricing_of(m),
value,
})
})
@@ -327,18 +324,10 @@ fn value_of(v: &Value) -> Option<AgentConfigValue> {
description: str_of(v, "description"),
cost_category,
usage_multiplier,
pricing: pricing_of(v),
value,
})
}
fn pricing_of(v: &Value) -> Option<Box<AgentModelPricing>> {
v.pointer("/_meta/pricing")
.or_else(|| v.get("pricing"))
.and_then(|p| serde_json::from_value(p.clone()).ok())
.map(Box::new)
}
fn str_of(v: &Value, key: &str) -> Option<String> {
v.get(key).and_then(Value::as_str).map(str::to_owned)
}
+5 -20
Переглянути файл
@@ -134,10 +134,7 @@ fn codex_meta(line: &serde_json::Value) -> Option<(String, Option<String>)> {
let payload =
line.get("payload").filter(|p| p.get("type").and_then(serde_json::Value::as_str) == Some("session_meta"));
let inner = payload.and_then(|p| p.get("payload")).or_else(|| {
line.get("type")
.and_then(serde_json::Value::as_str)
.filter(|t| *t == "session_meta")
.map(|_| line.get("payload").unwrap_or(line))
line.get("type").and_then(serde_json::Value::as_str).filter(|t| *t == "session_meta").and(Some(line))
})?;
let id = inner.get("id").and_then(serde_json::Value::as_str)?.to_owned();
let cwd = inner.get("cwd").and_then(serde_json::Value::as_str).map(str::to_owned);
@@ -296,28 +293,16 @@ mod tests {
assert_eq!(sessions[0].title, "hello there");
}
#[test]
fn codex_meta_accepts_current_and_legacy_shapes() {
let meta = json!({"id": "thread-1", "cwd": "/work/app"});
for line in [
json!({"type": "session_meta", "payload": meta}),
json!({"payload": {"type": "session_meta", "payload": meta}}),
json!({"type": "session_meta", "id": "thread-1", "cwd": "/work/app"}),
] {
assert_eq!(codex_meta(&line), Some(("thread-1".to_owned(), Some("/work/app".to_owned()))));
}
}
#[test]
fn lists_codex_rollouts_with_meta() {
let tmp = tempfile::tempdir().unwrap();
write(
&tmp.path().join("sessions/2026/01/02/rollout-01.jsonl"),
&[
json!({"timestamp": "t", "type": "session_meta",
"payload": {"id": "thread-1", "cwd": "/work/app"}}),
json!({"timestamp": "t", "type": "event_msg",
"payload": {"type": "user_message", "message": "add tests"}}),
json!({"timestamp": "t", "payload": {"type": "session_meta",
"payload": {"id": "thread-1", "cwd": "/work/app"}}}),
json!({"timestamp": "t", "payload": {"type": "user_message",
"payload": {"message": "add tests"}}}),
],
);
write(&tmp.path().join("sessions/notes.jsonl"), &[json!({"nope": true})]);
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+6 -114
Переглянути файл
@@ -45,15 +45,17 @@ pub struct AgentCapabilities {
pub steer: bool,
/// It reports its background tasks and stops them one by one.
pub background_tasks: bool,
/// The task runs read-only: it asks before anything, and requests that would change
/// the project are denied (a temporary side conversation).
pub read_only: bool,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum Isolation {
/// A new git worktree on its own branch.
Worktree,
/// The project's own checkout.
#[default]
Local,
}
@@ -105,9 +107,6 @@ pub struct AgentTask {
// Boxed so that `AgentEvent::Task` stays within clippy's `large_enum_variant` bound on Windows.
#[serde(default)]
pub background: Box<Vec<AgentBackgroundTask>>,
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`), including `"openidea"`.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub mcp_overrides: BTreeMap<String, bool>,
}
/// A task the agent runs in the background while the conversation goes on.
@@ -133,40 +132,6 @@ pub struct AgentRetry {
pub error: Option<String>,
}
/// Token pricing (Credits per 1M tokens) and context window capacity for one tier.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentTokenPricing {
pub input: f64,
pub output: f64,
#[serde(default)]
#[specta(optional)]
pub cache_read: Option<f64>,
#[serde(default)]
#[specta(optional)]
pub cache_write: Option<f64>,
#[serde(default)]
#[specta(optional)]
pub context_tokens: Option<u32>,
}
/// Pricing and context-tier metadata attached to a model [`AgentConfigValue`].
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentModelPricing {
/// `"low"`, `"medium"`, `"high"`, or `"very_high"`.
#[serde(default)]
#[specta(optional)]
pub cost_tier: Option<String>,
/// Request-based billing multiplier (e.g. `1.0`, `0.33`, `3.0`), when applicable.
#[serde(default)]
#[specta(optional)]
pub multiplier: Option<f64>,
/// Token pricing keyed by context tier (`"default"`, `"long_context"`).
#[serde(default)]
pub tiers: BTreeMap<String, AgentTokenPricing>,
}
/// One value of a select-type session setting.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -182,10 +147,6 @@ pub struct AgentConfigValue {
#[serde(default)]
#[specta(optional)]
pub usage_multiplier: Option<String>,
/// Detailed per-tier token pricing from `_meta.pricing` when available.
#[serde(default)]
#[specta(optional)]
pub pricing: Option<Box<AgentModelPricing>>,
}
/// How a setting is changed.
@@ -593,7 +554,7 @@ pub struct AgentProbe {
pub error: Option<String>,
}
#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct NewAgentTask {
/// Validated by the host; defaults to the window project root.
@@ -606,9 +567,6 @@ pub struct NewAgentTask {
pub isolation: Isolation,
/// Branch to start the worktree from; the current branch when `None`.
pub base: Option<String>,
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
#[serde(default)]
pub mcp_overrides: BTreeMap<String, bool>,
}
/// A file the task changed: against [`AgentTask::base_commit`], or against `HEAD` in the
@@ -680,7 +638,7 @@ pub struct AgentModelCatalog {
pub enum AgentEvent {
/// A task was created or its metadata changed.
Task {
task: Box<AgentTask>,
task: AgentTask,
},
Removed {
id: String,
@@ -760,9 +718,6 @@ pub struct McpServer {
/// Agent provider ids this server is enabled for; empty means enabled for all agents.
#[serde(default)]
pub agents: Vec<String>,
/// True when this Workspace server was added outside OpenIDEA and has not been approved yet.
#[serde(default)]
pub unapproved: bool,
}
/// Payload for creating or updating a user or workspace MCP server.
@@ -795,69 +750,6 @@ fn default_true() -> bool {
true
}
/// An external MCP configuration file discovered on disk (user CLI config or workspace file).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpExternalSource {
/// Stable source identifier (e.g. `"copilot-cli"`, `"jetbrains-air"`, `"claude-code"`, `"cursor"`, `"workspace-mcp"`, `"vscode-mcp"`).
pub id: String,
/// Human-readable source label (e.g. `"GitHub Copilot CLI"`).
pub label: String,
/// Absolute path of the discovered configuration file.
pub path: IpcPath,
/// Suggested target scope when importing this source into OpenIDEA settings.
pub suggested_scope: McpScope,
/// Agent provider ID this external CLI reads natively (`Some("copilot")`, `Some("claude")`, `Some("cursor")`, or `None`).
pub native_provider: Option<String>,
/// Servers found inside this external configuration file (values omitted for safety; imported directly on the host).
pub servers: Vec<McpDiscoveredServer>,
}
/// Summary of one server discovered inside an external MCP configuration file.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpDiscoveredServer {
pub name: String,
pub transport: McpTransport,
pub enabled: bool,
pub command: Option<String>,
pub args: Vec<String>,
pub url: Option<String>,
/// Environment variable names declared on this server (values stay on the host).
pub env_keys: Vec<String>,
/// HTTP header names declared on this server (values stay on the host).
pub header_keys: Vec<String>,
}
/// Selection of one server from an external MCP configuration source to import.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpImportSelection {
pub source_id: String,
pub name: String,
}
/// One tool advertised by an MCP server during `tools/list`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpToolSummary {
pub name: String,
pub description: Option<String>,
}
/// Result of testing/probing an MCP server (`initialize` + `tools/list`).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpProbeResult {
pub ok: bool,
pub server_name: Option<String>,
pub server_version: Option<String>,
pub protocol_version: Option<String>,
pub tools: Vec<McpToolSummary>,
pub duration_ms: u32,
pub error: Option<String>,
}
/// Payload for creating a custom ACP agent (always the ACP driver); the id
/// becomes the `<config>/agents/<id>.toml` file name.
#[derive(Clone, Debug, Deserialize, Type)]
+11 -31
Переглянути файл
@@ -170,8 +170,6 @@ struct Session {
id: String,
cwd: PathBuf,
mcp_config: Option<tempfile::TempPath>,
/// MCP servers switched off for this session (`--disallowedTools`), its own config's too.
mcp_off: Vec<String>,
shim: Weak<Shim>,
st: Mutex<State>,
/// Serializes (re)starting the process.
@@ -346,10 +344,9 @@ impl Shim {
cwd: PathBuf,
start: Start,
pending: bool,
params: &Value,
mcp_config: Option<String>,
) -> Arc<Session> {
let mcp_off = mcp_off(params);
let mcp_config = mcp_config(params).and_then(|json| match write_mcp_config(&json) {
let mcp_config = mcp_config.and_then(|json| match write_mcp_config(&json) {
Ok(path) => Some(path),
Err(e) => {
tracing::warn!("Claude Code session {id}: cannot write its MCP configuration: {e}");
@@ -359,7 +356,6 @@ impl Shim {
let session = Arc::new(Session {
id: id.to_owned(),
mcp_config,
mcp_off,
shim: Arc::downgrade(self),
st: Mutex::new(State {
proc: None,
@@ -415,8 +411,13 @@ impl Shim {
}
"session/new" => {
let id = new_uuid(false);
let session =
self.add_session(&id, self.cwd_of(&params), Start::New { id: id.clone() }, false, &params);
let session = self.add_session(
&id,
self.cwd_of(&params),
Start::New { id: id.clone() },
false,
mcp_config(&params),
);
rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
session.announce_commands();
Ok(json!({ "sessionId": id, "configOptions": session.st.lock().settings.options() }))
@@ -432,7 +433,7 @@ impl Shim {
None => return Err(invalid(format!("no Claude Code session {id} in {}", cwd.display()))),
};
let chain = self.base_chain(&cwd, &start).map_err(internal)?;
let session = self.add_session(id, cwd, start, pending, &params);
let session = self.add_session(id, cwd, start, pending, mcp_config(&params));
rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
if method == "session/load" {
session.replay(&chain);
@@ -458,7 +459,7 @@ impl Shim {
(start, st.settings.clone())
};
self.save_pending(&id, Some(&start));
let session = self.add_session(&id, source.cwd.clone(), start, true, &params);
let session = self.add_session(&id, source.cwd.clone(), start, true, mcp_config(&params));
session.st.lock().settings = settings;
let options = session.st.lock().settings.options();
Ok(json!({ "sessionId": id, "configOptions": options }))
@@ -665,9 +666,6 @@ impl Session {
if let Some(config) = &self.mcp_config {
args.extend(["--mcp-config".to_owned(), config.to_string_lossy().into_owned()]);
}
if !self.mcp_off.is_empty() {
args.extend(["--disallowedTools".to_owned(), self.mcp_off.join(",")]);
}
args.extend(start.args());
let launch =
Launch { program: shim.config.program.clone(), args, cwd: self.cwd.clone(), env: shim.config.env.clone() };
@@ -1499,24 +1497,6 @@ fn write_mcp_config(json: &str) -> std::io::Result<tempfile::TempPath> {
Ok(file.into_temp_path())
}
/// The servers switched off for the session (`_meta.openidea.mcpServersOff`) as Claude Code
/// permission rules that deny all of a server's tools (`mcp__<server>`), so a server of
/// Claude Code's own configuration stays off too.
fn mcp_off(params: &Value) -> Vec<String> {
params
.pointer("/_meta/openidea/mcpServersOff")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(Value::as_str)
.map(|name| {
let name: String =
name.chars().map(|c| if c.is_ascii_alphanumeric() || c == '_' || c == '-' { c } else { '_' }).collect();
format!("mcp__{name}")
})
.collect()
}
/// ACP `mcpServers` as Claude Code's `--mcp-config` JSON (`None` when there are none).
fn mcp_config(params: &Value) -> Option<String> {
let servers = params.get("mcpServers")?.as_array()?;
+2 -22
Переглянути файл
@@ -48,17 +48,10 @@ impl Settings {
.filter_map(|m| {
let s = |k: &str| m.get(k).and_then(Value::as_str).map(str::to_owned);
let value = s("value")?;
let resolved = s("resolvedModel");
// The default entry follows the account's default model, so "Default
// (recommended)" hides what actually runs: name the model it resolves to.
let name = match (value.as_str(), resolved.as_deref()) {
("default", Some(r)) if !r.is_empty() => format!("Default ({r})"),
_ => s("displayName").unwrap_or_else(|| value.clone()),
};
Some(Model {
name,
name: s("displayName").unwrap_or_else(|| value.clone()),
description: s("description"),
resolved,
resolved: s("resolvedModel"),
efforts: if m.get("supportsEffort").and_then(Value::as_bool) == Some(true) {
m.get("supportedEffortLevels")
.and_then(Value::as_array)
@@ -237,19 +230,6 @@ mod tests {
assert_eq!(s.model, "claude-x-1");
}
#[test]
fn the_default_entry_is_named_by_the_model_it_runs() {
let s = Settings::from_cli(&init(), &json!({"applied": {"model": "claude-sonnet-5-5"}}));
let names: Vec<_> = s.models.iter().map(|m| m.name.as_str()).collect();
assert_eq!(names, ["Default (claude-sonnet-5-5)", "Opus", "Haiku 4.5"]);
// Without a resolved model, the agent's own name stands.
let s = Settings::from_cli(
&json!({"models": [{"value": "default", "displayName": "Default (recommended)"}]}),
&json!({}),
);
assert_eq!(s.models[0].name, "Default (recommended)");
}
#[test]
fn options_follow_the_model() {
let mut s = Settings::from_cli(&init(), &json!({"applied": {"model": "claude-sonnet-5-5", "effort": "high"}}));
-7
Переглянути файл
@@ -1243,13 +1243,6 @@ async fn skipped_questions_have_no_answers() {
assert_eq!(cancelled, None);
}
#[test]
fn servers_switched_off_become_disallowed_tools() {
assert!(mcp_off(&json!({})).is_empty());
let off = mcp_off(&json!({ "_meta": { "openidea": { "mcpServersOff": ["github", "my server.v2"] } } }));
assert_eq!(off, ["mcp__github", "mcp__my_server_v2"]);
}
#[test]
fn mcp_servers_become_an_mcp_config() {
assert_eq!(mcp_config(&json!({ "mcpServers": [] })), None);
-155
Переглянути файл
@@ -1,155 +0,0 @@
//! Codex's built-in slash commands. `codex app-server` has no command-list API, so the
//! native adapter owns this stable compatibility table; skills stay dynamic via `skills/list`.
use serde_json::Value;
/// Menu metadata shared by agent_commands and the prompt dispatcher.
pub(crate) struct BuiltinCommandSpec {
pub name: &'static str,
pub description: &'static str,
pub hint: Option<&'static str>,
}
pub(crate) const BUILTIN_COMMANDS: &[BuiltinCommandSpec] = &[
BuiltinCommandSpec { name: "plan", description: "Turn plan mode on or off.", hint: None },
BuiltinCommandSpec {
name: "mcp",
description: "Show the status of the MCP servers, or reconnect them.",
hint: Some("[reconnect]"),
},
BuiltinCommandSpec { name: "skills", description: "List available skills.", hint: None },
BuiltinCommandSpec { name: "status", description: "Display session configuration and token usage.", hint: None },
BuiltinCommandSpec {
name: "review",
description: "Review uncommitted changes, or review with custom instructions.",
hint: Some("optional review instructions"),
},
BuiltinCommandSpec {
name: "review-branch",
description: "Review changes relative to a base branch.",
hint: Some("branch name"),
},
BuiltinCommandSpec { name: "review-commit", description: "Review a specific commit.", hint: Some("commit sha") },
BuiltinCommandSpec {
name: "compact",
description: "Summarize conversation to avoid hitting the context limit.",
hint: None,
},
BuiltinCommandSpec {
name: "goal",
description: "Set a goal to keep pursuing.",
hint: Some("[<objective>|clear|pause|resume]"),
},
BuiltinCommandSpec { name: "rename", description: "Rename the current session.", hint: Some("new name") },
BuiltinCommandSpec {
name: "logout",
description: "Sign out of Codex. This option is available when you are logged in via ChatGPT.",
hint: None,
},
];
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum BuiltinCommand {
Plan,
Mcp,
Skills,
Status,
Review,
ReviewBranch,
ReviewCommit,
Compact,
Goal,
Rename,
Logout,
}
impl BuiltinCommand {
fn from_name(name: &str) -> Option<Self> {
Some(match name {
"plan" => Self::Plan,
"mcp" => Self::Mcp,
"skills" => Self::Skills,
"status" => Self::Status,
"review" => Self::Review,
"review-branch" => Self::ReviewBranch,
"review-commit" => Self::ReviewCommit,
"compact" => Self::Compact,
"goal" => Self::Goal,
"rename" => Self::Rename,
"logout" => Self::Logout,
_ => return None,
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(super) struct ParsedCommand {
pub command: BuiltinCommand,
/// Everything after the command name, trimmed but otherwise unchanged.
pub rest: String,
}
impl ParsedCommand {
/// Commands that Codex completes as a turn. Missing review arguments stay local so the
/// adapter can print the command's usage without starting an unnecessary model request.
pub fn starts_turn(&self) -> bool {
matches!(self.command, BuiltinCommand::Compact | BuiltinCommand::Review)
|| (matches!(self.command, BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit)
&& !self.rest.is_empty())
}
}
/// A recognized Codex builtin at the start of the prompt. Unknown slash commands and
/// `$skill` invocations return `None`, so they continue through Codex as ordinary prompts.
pub(super) fn parse(prompt: &Value) -> Option<ParsedCommand> {
let text = prompt.as_array()?.first()?.get("text")?.as_str()?.trim();
let command_text = text.strip_prefix('/')?.trim();
let (name, rest) = command_text.split_once(char::is_whitespace).unwrap_or((command_text, ""));
let command = BuiltinCommand::from_name(&name.to_ascii_lowercase())?;
Some(ParsedCommand { command, rest: rest.trim().to_owned() })
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
fn text(value: &str) -> Value {
json!([{ "type": "text", "text": value }])
}
#[test]
fn every_builtin_is_registered_and_parsed() {
let expected = [
"plan",
"mcp",
"skills",
"status",
"review",
"review-branch",
"review-commit",
"compact",
"goal",
"rename",
"logout",
];
assert_eq!(BUILTIN_COMMANDS.iter().map(|c| c.name).collect::<Vec<_>>(), expected);
for name in expected {
assert!(parse(&text(&format!("/{name}"))).is_some(), "{name}");
}
}
#[test]
fn parsing_keeps_arguments_and_leaves_non_builtins_alone() {
let parsed = parse(&text(" /review-branch origin/main ")).unwrap();
assert_eq!(parsed.command, BuiltinCommand::ReviewBranch);
assert_eq!(parsed.rest, "origin/main");
assert!(parsed.starts_turn());
assert!(!parse(&text("/review-branch")).unwrap().starts_turn());
assert!(parse(&text("/$review check this")).is_none());
assert!(parse(&text("review")).is_none());
let prompt = json!([{ "type": "text", "text": "/compact" }, { "type": "image", "data": "AA==" }]);
assert_eq!(parse(&prompt).unwrap().command, BuiltinCommand::Compact);
}
}
+21 -375
Переглянути файл
@@ -2,11 +2,7 @@
//! translated to and from ACP. A codex thread is an ACP session; a subagent's thread is
//! a subagent session of the thread that spawned it.
mod commands;
mod translate;
mod trust;
pub(crate) use commands::BUILTIN_COMMANDS;
#[cfg(test)]
mod tests;
@@ -14,8 +10,6 @@ mod tests;
use super::Shim;
use crate::acp::AUTH_REQUIRED;
use crate::provider::ProviderSpec;
use crate::{AgentCommand, AgentCommandSource};
use commands::{BuiltinCommand, ParsedCommand};
use ide_jsonrpc::{Framing, Handler, Peer, RpcError, codes};
use parking_lot::Mutex;
use serde_json::{Value, json};
@@ -38,19 +32,6 @@ const EXIT_GRACE: Duration = Duration::from_millis(100);
const NAME_PROMPT: &str = "Name this conversation for a list of tasks: a short title of at most six words, in the \
language the user writes in. Reply with the title only, without quotes or a closing period.";
/// Slash-command metadata for provider discovery and sessions without an advertised list.
pub(crate) fn builtin_commands() -> Vec<AgentCommand> {
BUILTIN_COMMANDS
.iter()
.map(|command| AgentCommand {
name: command.name.to_owned(),
description: command.description.to_owned(),
hint: command.hint.map(str::to_owned),
source: AgentCommandSource::Command,
})
.collect()
}
pub(crate) fn connect(
spec: &ProviderSpec,
cwd: &Path,
@@ -202,8 +183,6 @@ struct State {
threads: HashMap<String, Thread>,
/// The last `account/rateLimits/updated` snapshot.
rate_limits: Option<Value>,
/// Project trust has been checked (and, when needed, asked about) on this connection.
trust_checked: HashSet<String>,
/// Codex exited.
gone: bool,
}
@@ -236,8 +215,6 @@ struct Thread {
early_cancel: Option<Instant>,
/// The latest agent message (a subagent's answer).
answer: String,
/// The latest `thread/tokenUsage/updated` payload, for the `/status` command.
token_usage: Option<Value>,
/// The thread has a name.
named: bool,
/// A name is being asked for.
@@ -343,12 +320,6 @@ impl CodexShim {
self.codex().request(method, params, None).await.map_err(from_codex)
}
fn warning(&self, message: impl Into<String>) {
if let Some(client) = self.client.get() {
let _ = client.notify(crate::WARNING_NOTIFICATION, json!({ "message": message.into() }));
}
}
async fn handle(&self, method: &str, params: Value) -> Result<Value, ResponseError> {
match method {
"initialize" => self.initialize().await,
@@ -432,7 +403,6 @@ impl CodexShim {
async fn new_session(&self, params: &Value) -> Result<Value, ResponseError> {
let models = self.models().await?;
self.prepare_project_trust(params).await;
let mut request = json!({ "cwd": params.get("cwd") });
if let Some(config) = translate::mcp_config(params) {
request["config"] = config;
@@ -450,7 +420,6 @@ impl CodexShim {
async fn load_session(&self, params: &Value) -> Result<Value, ResponseError> {
let id = str_param(params, "sessionId")?;
let models = self.models().await?;
self.prepare_project_trust(params).await;
let mut request = json!({ "threadId": id, "cwd": params.get("cwd") });
if let Some(config) = translate::mcp_config(params) {
request["config"] = config;
@@ -469,7 +438,6 @@ impl CodexShim {
async fn fork_session(&self, params: &Value) -> Result<Value, ResponseError> {
let source = str_param(params, "sessionId")?;
let models = self.models().await?;
self.prepare_project_trust(params).await;
let settings = self.state.lock().threads.get(source).and_then(|t| t.settings.clone());
let mut request = json!({ "threadId": source, "cwd": params.get("cwd") });
if let Some(config) = translate::mcp_config(params) {
@@ -503,18 +471,11 @@ impl CodexShim {
async fn prompt(&self, params: &Value) -> Result<Value, ResponseError> {
let session = str_param(params, "sessionId")?.to_owned();
let prompt = params.get("prompt").unwrap_or(&Value::Null);
let command = commands::parse(prompt);
if let Some(command) = command.as_ref()
&& !command.starts_turn()
{
return self.local_command(&session, command).await;
}
let input = translate::user_input(prompt);
let input = translate::user_input(params.get("prompt").unwrap_or(&Value::Null));
if input.is_empty() {
return Err(invalid("empty prompt"));
}
let models = if command.is_none() { Some(self.models().await?) } else { None };
let models = self.models().await?;
let (done, ended) = oneshot::channel();
let settings = {
let mut state = self.state.lock();
@@ -530,213 +491,33 @@ impl CodexShim {
t.error = None;
t.settings.clone()
};
let started = match command.as_ref() {
Some(command) => match command.command {
BuiltinCommand::Compact => {
// Codex reports compaction as its own turn, using the same started/completed
// notifications that finish the pending session/prompt above.
self.call("thread/compact/start", json!({ "threadId": session })).await
}
BuiltinCommand::Review | BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit => {
self.call("review/start", json!({ "threadId": session, "target": review_target(command) })).await
}
_ => unreachable!("local commands return before a pending turn is created"),
},
None => {
let models = models.expect("ordinary prompts load the model catalog");
let mut request = json!({ "threadId": session, "input": input, "summary": "auto" });
if let Some(s) = &settings {
request["model"] = json!(s.model_slug(&models));
request["approvalPolicy"] = json!(s.mode.approval_policy());
request["sandboxPolicy"] = s.mode.sandbox_policy();
// Omit the default so older app-server versions keep accepting normal
// turns; selecting Plan opts into this newer request field.
if s.collaboration_mode == translate::PLAN_COLLABORATION_MODE
|| s.collaboration_mode_override.is_some()
{
request["collaborationMode"] = translate::collaboration_mode(s, &models);
}
if let Some(effort) = &s.effort {
request["effort"] = json!(effort);
}
}
self.call("turn/start", request).await
let mut request = json!({ "threadId": session, "input": input, "summary": "auto" });
if let Some(s) = settings {
request["model"] = json!(s.model_slug(&models));
request["approvalPolicy"] = json!(s.mode.approval_policy());
request["sandboxPolicy"] = s.mode.sandbox_policy();
if let Some(effort) = &s.effort {
request["effort"] = json!(effort);
}
};
if let Ok(started) = &started
&& let Some(turn) = started.pointer("/turn/id").and_then(Value::as_str)
{
self.turn_known(&session, turn, false);
}
if started.is_ok()
&& command.is_none()
&& let Some(thread) = self.state.lock().threads.get_mut(&session)
&& let Some(settings) = thread.settings.as_mut()
{
// A Default override is needed only for the first turn that resets a resumed
// Plan thread; omitting it afterwards preserves compatibility with older Codex.
settings.collaboration_mode_override = None;
}
if let Err(e) = started {
if let Some(t) = self.state.lock().threads.get_mut(&session) {
t.prompt = None;
match self.call("turn/start", request).await {
Ok(started) => {
if let Some(turn) = started.pointer("/turn/id").and_then(Value::as_str) {
self.turn_known(&session, turn, false);
}
}
Err(e) => {
if let Some(t) = self.state.lock().threads.get_mut(&session) {
t.prompt = None;
}
return Err(e);
}
return Err(e);
}
let (turn, last_error) = ended.await.map_err(|_| error(codes::INTERNAL_ERROR, "Codex exited"))?;
let rate_limits = self.state.lock().rate_limits.clone();
stop_reason(&turn, last_error, rate_limits.as_ref())
}
/// Runs commands that codex-acp historically handled locally: configuration, status,
/// inventory, naming and account actions. They complete without starting a model turn.
async fn local_command(&self, session: &str, command: &ParsedCommand) -> Result<Value, ResponseError> {
let (settings, cwd, token_usage, rate_limits) = {
let state = self.state.lock();
if state.gone {
return Err(error(codes::INTERNAL_ERROR, "Codex exited"));
}
let thread = state.threads.get(session).ok_or_else(|| invalid(format!("no session {session}")))?;
if thread.prompt.is_some() || thread.turn.is_some() {
return Err(invalid("a turn is already running"));
}
(thread.settings.clone(), thread.cwd.clone(), thread.token_usage.clone(), state.rate_limits.clone())
};
match command.command {
BuiltinCommand::Plan => {
if !command.rest.is_empty() {
self.say(session, command_usage(BuiltinCommand::Plan));
return Ok(json!({ "stopReason": "end_turn" }));
}
let models = self.models().await?;
let options = {
let mut state = self.state.lock();
let thread =
state.threads.get_mut(session).ok_or_else(|| invalid(format!("no session {session}")))?;
let settings = thread.settings.as_mut().ok_or_else(|| invalid(format!("no session {session}")))?;
settings.collaboration_mode = if settings.collaboration_mode == translate::PLAN_COLLABORATION_MODE {
translate::DEFAULT_COLLABORATION_MODE.to_owned()
} else {
translate::PLAN_COLLABORATION_MODE.to_owned()
};
settings.collaboration_mode_override = Some(settings.collaboration_mode.clone());
translate::config_options(&models, settings)
};
self.emit(session, json!({ "sessionUpdate": "config_option_update", "configOptions": options }));
}
BuiltinCommand::Status => {
let text =
status_text(session, settings.as_ref(), cwd.as_deref(), token_usage.as_ref(), rate_limits.as_ref());
self.say(session, text);
}
BuiltinCommand::Skills => {
let cwd = cwd.ok_or_else(|| invalid(format!("no session {session}")))?;
let found = self.call("skills/list", json!({ "cwds": [cwd] })).await?;
self.say(session, skills_text(&found));
}
BuiltinCommand::Mcp => match command.rest.as_str() {
"" => self.say(session, self.mcp_text(session).await?),
rest if rest.eq_ignore_ascii_case("reconnect") => {
self.call("config/mcpServer/reload", json!({})).await?;
self.say(session, self.mcp_text(session).await?);
}
_ => self.say(session, command_usage(BuiltinCommand::Mcp)),
},
BuiltinCommand::Rename => {
if command.rest.is_empty() {
self.say(session, command_usage(BuiltinCommand::Rename));
} else {
self.call("thread/name/set", json!({ "threadId": session, "name": command.rest })).await?;
// User commands are authoritative over the automatic title, so the manager
// must retain this title through later generated-name updates.
self.emit(
session,
json!({ "sessionUpdate": "session_info_update", "title": command.rest, "userNamed": true }),
);
}
}
BuiltinCommand::Logout => {
self.call("account/logout", Value::Null).await?;
self.say(session, "Logged out from Codex account.");
}
BuiltinCommand::Goal => self.goal_command(session, &command.rest).await?,
BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit if command.rest.is_empty() => {
self.say(session, command_usage(command.command));
}
BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit => {
return Err(invalid("review command did not start a turn"));
}
BuiltinCommand::Review | BuiltinCommand::Compact => {
return Err(invalid("turn command reached the local command path"));
}
}
Ok(json!({ "stopReason": "end_turn" }))
}
async fn goal_command(&self, session: &str, rest: &str) -> Result<(), ResponseError> {
let argument = rest.trim();
if argument.is_empty() {
self.say(session, command_usage(BuiltinCommand::Goal));
return Ok(());
}
match argument.to_ascii_lowercase().as_str() {
"clear" => {
self.call("thread/goal/clear", json!({ "threadId": session })).await?;
self.say(session, "Goal cleared.");
}
"pause" => {
let response = self
.call("thread/goal/set", json!({ "threadId": session, "status": "paused", "origin": "user" }))
.await?;
self.say(
session,
format!(
"Goal is now {}.",
response.pointer("/goal/status").and_then(Value::as_str).unwrap_or("paused")
),
);
}
"resume" => {
let response = self
.call("thread/goal/set", json!({ "threadId": session, "status": "active", "origin": "user" }))
.await?;
self.say(
session,
format!(
"Goal is now {}.",
response.pointer("/goal/status").and_then(Value::as_str).unwrap_or("active")
),
);
}
_ if argument.chars().count() > 4000 => {
self.say(session, "Command \"/goal\" requires goal text of at most 4000 characters.");
}
_ => {
let response = self
.call(
"thread/goal/set",
json!({ "threadId": session, "objective": argument, "status": "active", "origin": "user" }),
)
.await?;
let status = response.pointer("/goal/status").and_then(Value::as_str).unwrap_or("active");
self.say(session, format!("Goal set and {status}."));
}
}
Ok(())
}
async fn mcp_text(&self, session: &str) -> Result<String, ResponseError> {
let response = self
.call("mcpServerStatus/list", json!({ "threadId": session, "detail": "toolsAndAuthOnly", "limit": 100 }))
.await?;
Ok(mcp_text(&response))
}
fn say(&self, session: &str, text: impl AsRef<str>) {
self.emit(session, translate::chunk("agent_message_chunk", text.as_ref()));
}
async fn steer(&self, params: &Value) -> Result<Value, ResponseError> {
let session = str_param(params, "sessionId")?;
let turn = self.state.lock().threads.get(session).and_then(|t| t.turn.clone());
@@ -862,25 +643,6 @@ impl CodexShim {
fn on_codex_notification(self: &Arc<Self>, method: &str, params: &Value) {
let thread = params.get("threadId").and_then(Value::as_str).unwrap_or_default();
match method {
"configWarning" => {
let Some(summary) = params.get("summary").and_then(Value::as_str).filter(|s| !s.trim().is_empty())
else {
return;
};
let mut message = summary.trim().to_owned();
for key in ["details", "path"] {
if let Some(value) = params.get(key).and_then(Value::as_str).filter(|s| !s.trim().is_empty()) {
message.push_str("\n\n");
message.push_str(value.trim());
}
}
self.warning(message);
}
"warning" => {
if let Some(message) = params.get("message").and_then(Value::as_str).filter(|s| !s.trim().is_empty()) {
self.warning(message);
}
}
"skills/changed" => {
let shim = self.clone();
let sessions: Vec<String> = self
@@ -931,12 +693,7 @@ impl CodexShim {
t.last_chunk = None;
Some(translate::plan(params))
}),
"thread/tokenUsage/updated" => self.with_thread(thread, |t, _| {
if let Some(usage) = params.get("tokenUsage") {
t.token_usage = Some(usage.clone());
}
translate::usage(params)
}),
"thread/tokenUsage/updated" => self.with_thread(thread, |_, _| translate::usage(params)),
"thread/name/updated" => self.with_thread(thread, |t, _| {
let title = params.get("threadName").and_then(Value::as_str)?;
t.named = true;
@@ -1425,114 +1182,3 @@ fn stop_reason(turn: &Value, last_error: Option<Value>, rate_limits: Option<&Val
};
Ok(json!({ "stopReason": stop }))
}
/// The `review/start` target of a parsed review command.
fn review_target(command: &ParsedCommand) -> Value {
match command.command {
BuiltinCommand::Review if command.rest.is_empty() => json!({ "type": "uncommittedChanges" }),
BuiltinCommand::Review => json!({ "type": "custom", "instructions": command.rest }),
BuiltinCommand::ReviewBranch => json!({ "type": "baseBranch", "branch": command.rest }),
BuiltinCommand::ReviewCommit => json!({ "type": "commit", "sha": command.rest, "title": null }),
_ => unreachable!("only review commands have review targets"),
}
}
fn command_usage(command: BuiltinCommand) -> String {
match command {
BuiltinCommand::Plan => "Command \"/plan\" accepts no arguments.".to_owned(),
BuiltinCommand::Mcp => "Command \"/mcp\" accepts no arguments, or `reconnect`.".to_owned(),
BuiltinCommand::ReviewBranch => "Command \"/review-branch\" requires branch name.".to_owned(),
BuiltinCommand::ReviewCommit => "Command \"/review-commit\" requires commit sha.".to_owned(),
BuiltinCommand::Goal => "Command \"/goal\" requires [<objective>|clear|pause|resume].".to_owned(),
BuiltinCommand::Rename => "Command \"/rename\" requires new name.".to_owned(),
_ => "This command does not accept arguments.".to_owned(),
}
}
fn status_text(
session: &str,
settings: Option<&Settings>,
cwd: Option<&str>,
token_usage: Option<&Value>,
rate_limits: Option<&Value>,
) -> String {
let mut lines = Vec::new();
if let Some(settings) = settings {
lines.push(format!("**Model:** {}", settings.model));
lines.push(format!("**Collaboration:** {}", settings.collaboration_mode));
lines.push(format!("**Approval:** {}", settings.mode.approval_policy()));
lines.push(format!("**Sandbox:** {}", settings.mode.sandbox_mode()));
}
if let Some(cwd) = cwd {
lines.push(format!("**Directory:** {cwd}"));
}
lines.push(format!("**Session:** `{session}`"));
if let Some(usage) = token_usage {
let total = usage.pointer("/total/totalTokens").and_then(Value::as_u64);
let used = usage.pointer("/last/totalTokens").and_then(Value::as_u64);
let window = usage.get("modelContextWindow").and_then(Value::as_u64).filter(|window| *window > 0);
if let (Some(total), Some(used), Some(window)) = (total, used, window) {
let percent = (used.saturating_mul(100) + window / 2) / window;
lines.push(format!("**Token usage:** {total} total"));
lines.push(format!("**Context window:** {used} / {window} ({percent}%)"));
}
}
if let Some(primary) = rate_limits.and_then(|r| r.get("primary"))
&& let Some(used) = primary.get("usedPercent").and_then(Value::as_f64)
{
lines.push(format!("**Rate limit:** {used:.0}% used"));
}
lines.join(" \n")
}
fn skills_text(response: &Value) -> String {
let mut seen = HashSet::new();
let names: Vec<String> = response
.get("data")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|entry| entry.get("skills").and_then(Value::as_array))
.flatten()
.filter(|skill| skill.get("enabled") != Some(&Value::Bool(false)))
.filter_map(|skill| {
let name = skill.get("name").and_then(Value::as_str)?.trim();
if name.is_empty() || !seen.insert(name.to_owned()) {
return None;
}
let description = skill
.pointer("/interface/shortDescription")
.or_else(|| skill.get("shortDescription"))
.or_else(|| skill.get("description"))
.and_then(Value::as_str)
.unwrap_or_default();
Some(if description.is_empty() { name.to_owned() } else { format!("{name}: {description}") })
})
.collect();
if names.is_empty() {
"No skills configured.".to_owned()
} else {
format!("Available skills:\n{}", names.iter().map(|name| format!("- {name}")).collect::<Vec<_>>().join("\n"))
}
}
fn mcp_text(response: &Value) -> String {
let servers = response.get("data").and_then(Value::as_array).map(Vec::as_slice).unwrap_or_default();
if servers.is_empty() {
return "No MCP servers configured.".to_owned();
}
let lines = servers
.iter()
.filter_map(|server| {
let name = server.get("name").and_then(Value::as_str)?;
let status = server
.get("runtimeStatus")
.and_then(Value::as_str)
.or_else(|| server.get("authStatus").and_then(Value::as_str))
.unwrap_or("unknown");
let tools = server.get("tools").and_then(Value::as_object).map_or(0, serde_json::Map::len);
Some(format!("- {name}: {status}, {tools} tools"))
})
.collect::<Vec<_>>();
format!("MCP servers:\n{}", lines.join("\n"))
}
+6 -419
Переглянути файл
@@ -180,38 +180,24 @@ fn settings_follow_the_thread_and_the_models() {
let result = json!({"model": "big", "reasoningEffort": null, "approvalPolicy": "untrusted",
"sandbox": {"type": "workspaceWrite"}});
let mut s = Settings::of(&result, &models);
assert_eq!(
s,
Settings {
model: "big".into(),
effort: Some("low".into()),
mode: Mode::Ask,
collaboration_mode: DEFAULT_COLLABORATION_MODE.into(),
collaboration_mode_override: None,
}
);
assert_eq!(s, Settings { model: "big".into(), effort: Some("low".into()), mode: Mode::Ask });
let options = config_options(&models, &s);
let ids: Vec<&str> = options.as_array().unwrap().iter().map(|o| o["id"].as_str().unwrap()).collect();
assert_eq!(ids, [MODEL, EFFORT, MODE, COLLABORATION_MODE]);
assert_eq!(ids, [MODEL, EFFORT, MODE]);
assert_eq!(options[0]["options"].as_array().unwrap().len(), 2, "hidden models are left out");
assert_eq!(options[1]["category"], "thought_level");
assert_eq!(options[1]["options"][1]["name"], "Extra high");
assert_eq!(options[2]["currentValue"], "ask");
assert_eq!(options[3]["currentValue"], "default");
// A model without efforts drops the option; its slug is what codex gets.
s.set(&models, MODEL, "plain").unwrap();
assert_eq!((s.effort.as_deref(), s.model_slug(&models).as_str()), (None, "plain-slug"));
assert_eq!(config_options(&models, &s).as_array().unwrap().len(), 3);
assert_eq!(config_options(&models, &s).as_array().unwrap().len(), 2);
assert!(s.set(&models, EFFORT, "low").is_err());
assert!(s.set(&models, MODEL, "nope").is_err());
s.set(&models, MODE, "full-access").unwrap();
assert_eq!((s.mode.approval_policy(), s.mode.sandbox_policy()), ("never", json!({"type": "dangerFullAccess"})));
s.set(&models, COLLABORATION_MODE, PLAN_COLLABORATION_MODE).unwrap();
assert_eq!(collaboration_mode(&s, &models)["mode"], PLAN_COLLABORATION_MODE);
s.set(&models, COLLABORATION_MODE, DEFAULT_COLLABORATION_MODE).unwrap();
assert_eq!(collaboration_mode(&s, &models)["mode"], DEFAULT_COLLABORATION_MODE);
// A model codex runs that it doesn't list is still offered.
let s = Settings::of(&json!({"model": "custom", "sandbox": {"type": "readOnly"}}), &models);
@@ -240,18 +226,6 @@ fn prompts_become_user_input() {
);
}
#[test]
fn compact_is_recognized_with_completion_whitespace_and_attachments() {
// Completion leaves trailing whitespace and images can remain in the prompt. The first
// text block still names the command; unknown slash-shaped text continues normally.
assert_eq!(commands::parse(&text("/compact")).unwrap().command, BuiltinCommand::Compact);
assert_eq!(commands::parse(&text(" /compact \n")).unwrap().command, BuiltinCommand::Compact);
assert_eq!(commands::parse(&text("/compact now")).unwrap().rest, "now");
let prompt = json!([{"type": "text", "text": "/compact"}, {"type": "image", "data": "AA=="}]);
assert_eq!(commands::parse(&prompt).unwrap().command, BuiltinCommand::Compact);
assert!(commands::parse(&text("x/compact")).is_none());
}
#[test]
fn commands_are_titled_by_what_they_do() {
let cmd = |actions: Value| {
@@ -479,7 +453,6 @@ fn history_replays_turns() {
#[derive(Default)]
struct Client {
updates: Mutex<Vec<Value>>,
warnings: Mutex<Vec<Value>>,
asked: Mutex<Vec<Value>>,
/// Option ids to choose; `None` (or none left) cancels.
answers: Mutex<VecDeque<Option<&'static str>>>,
@@ -489,8 +462,6 @@ impl Handler for Client {
fn on_notification(&self, method: &str, params: Value) {
if method == "session/update" {
self.updates.lock().push(params);
} else if method == "_openidea/warning" {
self.warnings.lock().push(params);
}
}
@@ -556,10 +527,6 @@ async fn questions_share_one_card_and_keep_their_ids() {
#[derive(Clone, Copy, Debug, PartialEq)]
enum Scenario {
AuthFailure,
Command(&'static str),
Compact,
PlanThenPrompt,
PlanToggleThenPrompt,
Interrupt,
Resume,
Steer,
@@ -574,10 +541,6 @@ impl Scenario {
fn file(self) -> &'static str {
match self {
Scenario::AuthFailure => "auth_failure",
Scenario::Command(_) => "simple",
Scenario::Compact => "simple",
Scenario::PlanThenPrompt => "simple",
Scenario::PlanToggleThenPrompt => "simple",
Scenario::Interrupt => "interrupt",
Scenario::Resume => "resume",
Scenario::Steer => "steer",
@@ -635,21 +598,6 @@ async fn drive(scenario: Scenario, acp: &Peer, client: &Client, cwd: &str, threa
Scenario::AuthFailure | Scenario::Simple | Scenario::UsageLimit | Scenario::Subagent => {
out.push(("prompt", request(acp, "session/prompt", prompt("Reply with the single word: hi")).await));
}
Scenario::Compact => {
out.push(("prompt", request(acp, "session/prompt", prompt("/compact")).await));
}
Scenario::Command(command) => {
out.push(("prompt", request(acp, "session/prompt", prompt(command)).await));
}
Scenario::PlanThenPrompt => {
out.push(("plan", request(acp, "session/prompt", prompt("/plan")).await));
out.push(("prompt", request(acp, "session/prompt", prompt("Reply with the single word: hi")).await));
}
Scenario::PlanToggleThenPrompt => {
out.push(("plan", request(acp, "session/prompt", prompt("/plan")).await));
out.push(("default", request(acp, "session/prompt", prompt("/plan")).await));
out.push(("prompt", request(acp, "session/prompt", prompt("Reply with the single word: hi")).await));
}
Scenario::Interrupt => {
out.push(("mode", request(acp, "session/set_config_option", set(MODE, "read-only")).await));
let running = {
@@ -717,37 +665,6 @@ fn load(name: &str) -> Transcript {
Transcript { meta, frames }
}
/// The simple fixture through session setup. Local commands add only the app-server calls
/// they need after it; turn commands keep the fixture's turn notifications.
fn command_transcript(calls: &[(&'static str, Value)]) -> Transcript {
let mut transcript = load(Scenario::Simple.file());
let prompt = transcript
.frames
.iter()
.position(|(out, frame)| *out && frame["method"] == "turn/start")
.expect("the scenario starts a turn");
transcript.frames.truncate(prompt);
transcript.frames.push((true, json!({ "id": 4, "method": "skills/list" })));
transcript.frames.push((false, json!({ "id": 4, "result": { "data": [] } })));
for (index, (method, result)) in calls.iter().enumerate() {
let id = 10 + index;
transcript.frames.push((true, json!({ "id": id, "method": method })));
transcript.frames.push((false, json!({ "id": id, "result": result })));
}
transcript
}
fn turn_command_transcript(method: &str) -> Transcript {
let mut transcript = load(Scenario::Simple.file());
let start = transcript
.frames
.iter_mut()
.find(|(out, frame)| *out && frame["method"] == "turn/start")
.expect("the scenario starts a turn");
start.1["method"] = json!(method);
transcript
}
/// Plays codex: waits for each frame the shim should send, sends what codex sent.
/// Returns the frames the shim sent.
async fn play<R: AsyncRead + Unpin, W: AsyncWrite + Unpin>(
@@ -767,10 +684,10 @@ async fn play<R: AsyncRead + Unpin, W: AsyncWrite + Unpin>(
.unwrap()
.unwrap_or_else(|| panic!("the shim closed before {frame}"));
let actual: Value = serde_json::from_str(&line).unwrap();
// Older recordings predate config inspection, skill discovery and thread naming; play an
// Older recordings predate skill discovery and thread naming; play an
// unsupported server.
let method = actual["method"].as_str().unwrap_or_default();
if matches!(method, "config/read" | "skills/list" | "thread/sample") && frame["method"] != method {
if matches!(method, "skills/list" | "thread/sample") && frame["method"] != method {
let reply = json!({ "id": actual["id"], "error": { "code": -32601, "message": "unsupported" } });
write.write_all(format!("{reply}\n").as_bytes()).await.unwrap();
continue;
@@ -843,149 +760,6 @@ fn session_of(results: &Results, label: &str) -> String {
result(results, label).as_ref().unwrap()["sessionId"].as_str().unwrap().to_owned()
}
#[tokio::test(flavor = "multi_thread")]
async fn configuration_warnings_before_a_session_and_runtime_warnings_reach_the_client() {
let mut transcript = load(Scenario::Simple.file());
transcript.frames.insert(
0,
(
false,
json!({"method": "configWarning", "params": {
"summary": "Project-local config is disabled until the project is trusted.",
"details": "Update the project's trust setting.", "path": "/work/.codex/config.toml"
}}),
),
);
let at = transcript.frames.iter().position(|(out, f)| *out && f["method"] == "turn/start").unwrap();
transcript
.frames
.insert(at, (false, json!({"method": "warning", "params": {"message": "MCP server unavailable"}})));
let (results, client, frames, _, _codex) = replay_transcript(Scenario::Simple, transcript).await;
assert!(result(&results, "new").is_ok());
assert_eq!(
*client.warnings.lock(),
[
json!({"message": "Project-local config is disabled until the project is trusted.\n\nUpdate the project's trust setting.\n\n/work/.codex/config.toml"}),
json!({"message": "MCP server unavailable"}),
]
);
assert!(sent(&frames, "config/value/write").is_empty());
assert!(sent(&frames, "config/batchWrite").is_empty());
}
struct TrustServer {
cwd: String,
disabled: bool,
other_project: bool,
write_error: bool,
overridden: bool,
calls: Mutex<Vec<(String, Value)>>,
}
impl Handler for TrustServer {
fn on_notification(&self, _: &str, _: Value) {}
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
self.calls.lock().push((method.to_owned(), params));
match method {
"initialize" => Ok(json!({})),
"model/list" => Ok(json!({"data": []})),
"config/read" => {
let cwd =
if self.other_project { Path::new(&self.cwd).join("other") } else { PathBuf::from(&self.cwd) };
Ok(json!({"layers": [
{"name": {"type": "user", "profile": null}, "version": "original"},
{"name": {"type": "project", "dotCodexFolder": cwd.join(".codex")},
"disabledReason": self.disabled.then_some("Project config is disabled until trusted.")}
]}))
}
"config/value/write" if self.write_error => Err((-32001, "Config changed concurrently".into())),
"config/value/write" => Ok(json!({"status": if self.overridden {"okOverridden"} else {"ok"}})),
"thread/start" | "thread/resume" | "thread/fork" => {
Ok(json!({"thread": {"id": "s", "turns": []}, "cwd": self.cwd}))
}
"skills/list" => Ok(json!({"data": []})),
_ => Err((codes::METHOD_NOT_FOUND, method.to_owned())),
}
}
}
#[tokio::test(flavor = "multi_thread")]
async fn project_trust_is_confirmed_before_new_resumed_and_forked_sessions() {
for method in ["session/new", "session/load", "session/fork"] {
for (answer, disabled, other_project, write_error, overridden) in [
(Some("codex-trust-project"), true, false, false, false),
(Some("codex-keep-untrusted"), true, false, false, false),
(None, true, false, false, false),
(Some("codex-trust-project"), false, false, false, false),
(Some("codex-trust-project"), true, true, false, false),
(Some("codex-trust-project"), true, false, true, false),
(Some("codex-trust-project"), true, false, false, true),
] {
let tmp = tempfile::tempdir().unwrap();
let cwd = tmp.path().join("project.with.dots-项目").to_string_lossy().into_owned();
let server = Arc::new(TrustServer {
cwd: cwd.clone(),
disabled,
other_project,
write_error,
overridden,
calls: Mutex::default(),
});
let client = Arc::new(Client::default());
client.answers.lock().push_back(answer);
let (ours, theirs) = tokio::io::duplex(1 << 16);
let (read, write) = tokio::io::split(theirs);
let native = Peer::connect_framed(read, write, server.clone(), Framing::Lines);
let acp = attach(client.clone(), |events| {
let (read, write) = tokio::io::split(ours);
Ok(Peer::connect_framed(read, write, events, Framing::Lines))
})
.unwrap();
request(&acp, "initialize", json!({})).await.unwrap();
let params = json!({"cwd": cwd, "sessionId": "source", "mcpServers": []});
request(&acp, method, params.clone()).await.unwrap();
// The same connection must not ask repeatedly after a decline.
request(&acp, method, params).await.unwrap();
let approved = answer == Some("codex-trust-project") && disabled && !other_project;
{
let asked = client.asked.lock();
assert_eq!(asked.len(), usize::from(disabled && !other_project));
if let Some(permission) = asked.first() {
assert!(permission["toolCall"]["title"].as_str().unwrap().contains(&cwd));
assert_eq!(
permission["toolCall"]["kind"], "edit",
"side conversations must deny persistent trust changes"
);
assert_eq!(
permission["options"][0]["kind"], "allow_always",
"task bypass must not grant permanent trust"
);
}
let calls = server.calls.lock();
let writes: Vec<_> = calls.iter().filter(|(m, _)| m == "config/value/write").collect();
assert_eq!(writes.len(), usize::from(approved));
if let Some((_, write)) = writes.first() {
assert_eq!(
*write,
json!({"keyPath": format!("projects.{}.trust_level", json!(cwd)), "value": "trusted", "mergeStrategy": "replace", "expectedVersion": "original"})
);
let written = calls.iter().position(|(m, _)| m == "config/value/write").unwrap();
let started = calls.iter().position(|(m, _)| m.starts_with("thread/")).unwrap();
assert!(written < started, "the session must load config after the write");
}
}
// Drain notifications sent before the last response.
tokio::time::sleep(Duration::from_millis(20)).await;
if approved && (write_error || overridden) {
assert!(!client.warnings.lock().is_empty());
}
acp.kill();
native.kill();
}
}
}
#[tokio::test(flavor = "multi_thread")]
async fn auth_failure_names_auth() {
let (results, _client, frames, _) = replay(Scenario::AuthFailure).await;
@@ -997,7 +771,7 @@ async fn auth_failure_names_auth() {
let categories: Vec<&str> =
new["configOptions"].as_array().unwrap().iter().map(|o| o["category"].as_str().unwrap()).collect();
// The model the user's codex config names; codex doesn't list it, so its efforts are unknown.
assert_eq!(categories, ["model", "mode", "collaboration_mode"]);
assert_eq!(categories, ["model", "mode"]);
let model = new["configOptions"][0]["currentValue"].as_str().unwrap();
assert_eq!(model, "gpt-6-luna");
assert!(new["configOptions"][0]["options"].as_array().unwrap().iter().any(|o| o["value"] == model));
@@ -1237,7 +1011,6 @@ async fn settings_apply_to_the_next_turn() {
(starts[0]["params"]["model"].as_str(), starts[0]["params"]["effort"].as_str()),
(Some("gpt-5.6-luna"), Some("medium"))
);
assert!(starts[0]["params"].get("collaborationMode").is_none());
assert_eq!(
(starts[1]["params"]["model"].as_str(), starts[1]["params"]["effort"].as_str()),
(Some("gpt-5.5"), Some("high"))
@@ -1246,192 +1019,6 @@ async fn settings_apply_to_the_next_turn() {
assert_eq!(client.text(&session, "agent_message_chunk"), "oneOn it.\n\ntwo");
}
#[tokio::test(flavor = "multi_thread")]
async fn compact_is_started_through_its_app_server_method() {
// Play the ordinary-turn fixture with the request swapped: the notifications are the
// same, while this pins the user-visible command to `thread/compact/start`, not a prompt.
let mut transcript = load(Scenario::Simple.file());
let start = transcript
.frames
.iter_mut()
.find(|(out, frame)| *out && frame["method"] == "turn/start")
.expect("the scenario starts a turn");
start.1["method"] = json!("thread/compact/start");
let (results, _client, frames, _meta, _codex) = replay_transcript(Scenario::Compact, transcript).await;
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({"stopReason": "end_turn"}));
assert!(sent(&frames, "turn/start").is_empty());
assert_eq!(sent(&frames, "thread/compact/start").len(), 1);
}
#[tokio::test(flavor = "multi_thread")]
async fn review_commands_start_the_matching_review_target() {
for (prompt, target) in [
("/review", json!({ "type": "uncommittedChanges" })),
("/review focus on errors", json!({ "type": "custom", "instructions": "focus on errors" })),
("/review-branch origin/main", json!({ "type": "baseBranch", "branch": "origin/main" })),
("/review-commit abc123", json!({ "type": "commit", "sha": "abc123", "title": null })),
] {
let (results, _client, frames, _meta, _codex) =
replay_transcript(Scenario::Command(prompt), turn_command_transcript("review/start")).await;
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }), "{prompt}");
assert!(sent(&frames, "turn/start").is_empty(), "{prompt}");
assert_eq!(sent(&frames, "review/start")[0]["params"]["target"], target, "{prompt}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn plan_toggles_collaboration_mode_and_updates_the_composer() {
let (results, client, _frames, _meta, _codex) =
replay_transcript(Scenario::Command("/plan"), command_transcript(&[])).await;
let session = session_of(&results, "new");
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
let update = client.of(&session).into_iter().find(|u| u["sessionUpdate"] == "config_option_update").unwrap();
let plan =
update["configOptions"].as_array().unwrap().iter().find(|o| o["category"] == "collaboration_mode").unwrap();
assert_eq!(plan["currentValue"], "plan");
}
#[tokio::test(flavor = "multi_thread")]
async fn plan_applies_to_the_next_normal_turn() {
let (results, _client, frames, _meta, _codex) =
replay_transcript(Scenario::PlanThenPrompt, load(Scenario::Simple.file())).await;
assert_eq!(result(&results, "plan").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
let start = sent(&frames, "turn/start")[0];
assert_eq!(start["params"]["collaborationMode"]["mode"], "plan");
assert_eq!(start["params"]["collaborationMode"]["settings"]["model"], "gpt-5.6-luna");
}
#[tokio::test(flavor = "multi_thread")]
async fn toggling_plan_off_sends_an_explicit_default_once() {
let (results, _client, frames, _meta, _codex) =
replay_transcript(Scenario::PlanToggleThenPrompt, load(Scenario::Simple.file())).await;
assert_eq!(result(&results, "default").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
let start = sent(&frames, "turn/start")[0];
assert_eq!(start["params"]["collaborationMode"]["mode"], "default");
}
#[tokio::test(flavor = "multi_thread")]
async fn informational_commands_report_skills_mcp_and_status() {
let skills = json!({ "data": [{ "skills": [
{ "name": "review", "enabled": true, "description": "Review changes" },
{ "name": "hidden", "enabled": false, "description": "Hidden" }
] }] });
let servers = json!({ "data": [
{ "name": "github", "runtimeStatus": "connected", "authStatus": "oAuth", "tools": { "search": {} } },
{ "name": "docs", "runtimeStatus": "failed", "authStatus": "unknown", "tools": {} }
] });
for (prompt, method, response, expected) in [
("/skills", "skills/list", skills, "Available skills:\n- review: Review changes"),
(
"/mcp",
"mcpServerStatus/list",
servers,
"MCP servers:\n- github: connected, 1 tools\n- docs: failed, 0 tools",
),
("/status", "", Value::Null, "**Session:**"),
] {
let calls: &[(&str, Value)] = if method.is_empty() { &[] } else { &[(method, response)] };
let calls: Vec<(&'static str, Value)> = calls
.iter()
.map(|(method, response)| {
let method = match *method {
"skills/list" => "skills/list",
"mcpServerStatus/list" => "mcpServerStatus/list",
other => panic!("unexpected method {other}"),
};
(method, response.clone())
})
.collect();
let (results, client, _frames, _meta, _codex) =
replay_transcript(Scenario::Command(prompt), command_transcript(&calls)).await;
let session = session_of(&results, "new");
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
assert!(client.text(&session, "agent_message_chunk").contains(expected), "{prompt}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn rename_and_logout_use_their_app_server_actions() {
let (results, client, frames, _meta, _codex) = replay_transcript(
Scenario::Command("/rename Better name"),
command_transcript(&[("thread/name/set", json!({}))]),
)
.await;
let session = session_of(&results, "new");
assert_eq!(sent(&frames, "thread/name/set")[0]["params"], json!({ "threadId": session, "name": "Better name" }));
let info = client.of(&session).into_iter().find(|u| u["sessionUpdate"] == "session_info_update").unwrap();
assert_eq!((info["title"].as_str(), info["userNamed"].as_bool()), (Some("Better name"), Some(true)));
let (results, client, frames, _meta, _codex) =
replay_transcript(Scenario::Command("/logout"), command_transcript(&[("account/logout", json!({}))])).await;
let session = session_of(&results, "new");
assert_eq!(sent(&frames, "account/logout").len(), 1);
assert_eq!(client.text(&session, "agent_message_chunk"), "Logged out from Codex account.");
}
#[tokio::test(flavor = "multi_thread")]
async fn goal_commands_set_pause_resume_and_clear_through_app_server() {
for (prompt, method, params, result) in [
(
"/goal fix the failing tests",
"thread/goal/set",
json!({ "threadId": "s", "objective": "fix the failing tests", "status": "active", "origin": "user" }),
json!({ "goal": { "status": "active" } }),
),
(
"/goal pause",
"thread/goal/set",
json!({ "threadId": "s", "status": "paused", "origin": "user" }),
json!({ "goal": { "status": "paused" } }),
),
(
"/goal resume",
"thread/goal/set",
json!({ "threadId": "s", "status": "active", "origin": "user" }),
json!({ "goal": { "status": "active" } }),
),
("/goal clear", "thread/goal/clear", json!({ "threadId": "s" }), json!({ "cleared": true })),
] {
let (results, _client, frames, _meta, _codex) =
replay_transcript(Scenario::Command(prompt), command_transcript(&[(method, result)])).await;
let session = session_of(&results, "new");
let sent = sent(&frames, method);
assert_eq!(sent.len(), 1, "{prompt}");
let mut expected = params;
expected["threadId"] = json!(session);
assert_eq!(sent[0]["params"], expected, "{prompt}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn missing_review_arguments_print_usage_without_starting_a_turn() {
for prompt in ["/review-branch", "/review-commit", "/rename", "/goal"] {
let (results, client, frames, _meta, _codex) =
replay_transcript(Scenario::Command(prompt), command_transcript(&[])).await;
let session = session_of(&results, "new");
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
assert!(sent(&frames, "turn/start").is_empty());
assert!(client.text(&session, "agent_message_chunk").starts_with("Command \""), "{prompt}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn mcp_reconnect_reloads_before_reporting_status() {
let servers =
json!({ "data": [{ "name": "github", "runtimeStatus": "connected", "authStatus": "oAuth", "tools": {} }] });
let (results, client, frames, _meta, _codex) = replay_transcript(
Scenario::Command("/mcp reconnect"),
command_transcript(&[("config/mcpServer/reload", json!({})), ("mcpServerStatus/list", servers)]),
)
.await;
let session = session_of(&results, "new");
assert_eq!(sent(&frames, "config/mcpServer/reload").len(), 1);
assert_eq!(sent(&frames, "mcpServerStatus/list").len(), 1);
assert!(client.text(&session, "agent_message_chunk").contains("github: connected"));
}
#[tokio::test(flavor = "multi_thread")]
async fn approvals_are_asked_and_answered() {
let (results, client, frames, _) = replay(Scenario::Approvals).await;
-45
Переглянути файл
@@ -138,12 +138,6 @@ pub(super) struct Settings {
pub model: String,
pub effort: Option<String>,
pub mode: Mode,
/// Codex's Default/Plan collaboration mode. It is sent with each turn because it is
/// part of the turn contract rather than the sandbox permission mode above.
pub collaboration_mode: String,
/// A mode just chosen by the user, sent once even when it is Default so a resumed Plan
/// thread is explicitly reset. Subsequent default turns can omit the field again.
pub collaboration_mode_override: Option<String>,
}
impl Settings {
@@ -162,12 +156,6 @@ impl Settings {
result.get("approvalPolicy").unwrap_or(&Value::Null),
result.get("sandbox").unwrap_or(&Value::Null),
),
collaboration_mode: result
.pointer("/collaborationMode/mode")
.and_then(Value::as_str)
.unwrap_or(DEFAULT_COLLABORATION_MODE)
.to_owned(),
collaboration_mode_override: None,
};
s.fit_effort(models);
s
@@ -206,13 +194,6 @@ impl Settings {
self.effort = Some(value.to_owned());
}
MODE => self.mode = Mode::parse(value).ok_or_else(|| format!("unknown mode {value}"))?,
COLLABORATION_MODE => {
if !matches!(value, DEFAULT_COLLABORATION_MODE | PLAN_COLLABORATION_MODE) {
return Err(format!("unknown collaboration mode {value}"));
}
self.collaboration_mode = value.to_owned();
self.collaboration_mode_override = Some(value.to_owned());
}
_ => return Err(format!("unknown setting {option}")),
}
Ok(())
@@ -222,9 +203,6 @@ impl Settings {
pub(super) const MODEL: &str = "model";
pub(super) const EFFORT: &str = "reasoning_effort";
pub(super) const MODE: &str = "mode";
pub(super) const COLLABORATION_MODE: &str = "collaboration_mode";
pub(super) const DEFAULT_COLLABORATION_MODE: &str = "default";
pub(super) const PLAN_COLLABORATION_MODE: &str = "plan";
/// ACP `configOptions`: model, reasoning effort (for models that have it) and mode.
pub(super) fn config_options(models: &[ModelInfo], s: &Settings) -> Value {
@@ -257,32 +235,9 @@ pub(super) fn config_options(models: &[ModelInfo], s: &Settings) -> Value {
"id": MODE, "name": "Mode", "category": "mode", "type": "select", "currentValue": s.mode.id(),
"options": Mode::ALL.iter().map(|m| select_value(m.id(), m.name(), Some(m.description()))).collect::<Vec<_>>(),
}));
out.push(json!({
"id": COLLABORATION_MODE,
"name": "Collaboration mode",
"category": "collaboration_mode",
"type": "select",
"currentValue": s.collaboration_mode,
"options": [
select_value(DEFAULT_COLLABORATION_MODE, "Default", Some("Execute changes directly")),
select_value(PLAN_COLLABORATION_MODE, "Plan", Some("Plan before making changes")),
],
}));
Value::Array(out)
}
/// `turn/start.collaborationMode`: the preset plus the selected model settings.
pub(super) fn collaboration_mode(settings: &Settings, models: &[ModelInfo]) -> Value {
json!({
"mode": settings.collaboration_mode_override.as_deref().unwrap_or(&settings.collaboration_mode),
"settings": {
"model": settings.model_slug(models),
"reasoning_effort": settings.effort,
"developer_instructions": null,
},
})
}
fn select_value(value: &str, name: &str, description: Option<&str>) -> Value {
let mut v = json!({ "value": value, "name": name });
if let Some(d) = description {
-93
Переглянути файл
@@ -1,93 +0,0 @@
//! A project trusted by the IDE may still be untrusted by Codex. Ask before changing
//! Codex's own decision; only its config API writes the current project's trust entry.
use super::*;
fn disabled_project<'a>(config: &'a Value, cwd: &str) -> Option<&'a Value> {
let folder = Path::new(cwd).join(".codex");
config.get("layers")?.as_array()?.iter().find(|layer| {
layer.pointer("/name/type").and_then(Value::as_str) == Some("project")
&& layer
.pointer("/name/dotCodexFolder")
.and_then(Value::as_str)
.is_some_and(|path| Path::new(path) == folder)
&& layer.get("disabledReason").and_then(Value::as_str).is_some_and(|reason| !reason.trim().is_empty())
})
}
impl CodexShim {
pub(super) async fn prepare_project_trust(&self, params: &Value) {
let Some(cwd) = params.get("cwd").and_then(Value::as_str) else { return };
if !self.state.lock().trust_checked.insert(cwd.to_owned()) {
return;
}
// Old app-servers may not expose config layers. Their warnings still reach the UI.
let Ok(Ok(config)) = tokio::time::timeout(
Duration::from_secs(5),
self.call("config/read", json!({ "cwd": cwd, "includeLayers": true })),
)
.await
else {
return;
};
let Some(layer) = disabled_project(&config, cwd) else { return };
let Some(client) = self.client.get() else { return };
let title = format!(
"Trust project in Codex: {cwd}? This saves trust in your Codex user configuration and allows \
this project's MCP servers, hooks and exec policies to load."
);
let permission = json!({
"sessionId": params.get("sessionId").and_then(Value::as_str).unwrap_or_default(),
"toolCall": {
"toolCallId": format!("codex-project-trust:{cwd}"),
"title": title, "kind": "edit",
"rawInput": { "project": cwd },
},
"options": [
// Permanent trust must never be auto-approved by the task's allow-once bypass.
{ "optionId": "codex-trust-project", "name": "Trust Project in Codex", "kind": "allow_always" },
{ "optionId": "codex-keep-untrusted", "name": "Keep Untrusted", "kind": "reject_once" },
],
});
let answer: Result<Value, RpcError> = client.request("session/request_permission", permission, None).await;
let approved = answer.as_ref().is_ok_and(|answer| {
answer.pointer("/outcome/outcome").and_then(Value::as_str) == Some("selected")
&& answer.pointer("/outcome/optionId").and_then(Value::as_str) == Some("codex-trust-project")
});
if !approved {
if let Some(reason) = layer.get("disabledReason").and_then(Value::as_str) {
self.warning(reason);
}
return;
}
// Quote the path as one key segment: dots and Windows backslashes are literal.
let mut write = json!({
"keyPath": format!("projects.{}.trust_level", json!(cwd)),
"value": "trusted", "mergeStrategy": "replace",
});
if let Some(version) = config["layers"]
.as_array()
.and_then(|layers| {
layers.iter().find(|layer| {
layer.pointer("/name/type").and_then(Value::as_str) == Some("user")
&& layer.pointer("/name/profile").is_none_or(Value::is_null)
})
})
.and_then(|layer| layer.get("version"))
.filter(|version| version.is_string())
{
write["expectedVersion"] = version.clone();
}
match self.call("config/value/write", write).await {
Err(error) => self.warning(format!("Codex could not save trust for {cwd}: {}", error.message)),
Ok(reply) if reply["status"] == "okOverridden" => {
self.warning(format!(
"Codex saved trust for {cwd}, but a higher-priority configuration overrides it. \
Project configuration may remain disabled; check the Codex configuration or contact your administrator."
));
}
_ => {}
}
// start/resume/fork now load the updated config before creating the thread.
}
}
File diff suppressed because it is too large. Load diff
-841
Переглянути файл
@@ -1,841 +0,0 @@
//! Model catalog, effort levels, context-window tiers, and token pricing from
//! `copilot --headless --stdio` (`models.list` + `models.listTokenPriceUnits`).
use crate::model::{AgentModelPricing, AgentTokenPricing};
use serde_json::{Value, json};
use std::collections::{BTreeMap, HashMap};
pub(super) const MODEL: &str = "model";
pub(super) const EFFORT: &str = "reasoning_effort";
pub(super) const CONTEXT_TIER: &str = "context_tier";
pub(super) const MODE: &str = "mode";
pub(super) const ALLOW_ALL: &str = "allow_all";
const BATCH_TOKENS: f64 = 1_000_000.0;
const NANO_AIU_PER_CREDIT: f64 = 1_000_000_000.0;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Mode {
Agent,
Plan,
Autopilot,
}
impl Mode {
pub const ALL: [Mode; 3] = [Mode::Agent, Mode::Plan, Mode::Autopilot];
pub fn id(self) -> &'static str {
match self {
Mode::Agent => "agent",
Mode::Plan => "plan",
Mode::Autopilot => "autopilot",
}
}
pub fn wire(self) -> &'static str {
match self {
Mode::Agent => "interactive",
Mode::Plan => "plan",
Mode::Autopilot => "autopilot",
}
}
pub fn name(self) -> &'static str {
match self {
Mode::Agent => "Agent",
Mode::Plan => "Plan",
Mode::Autopilot => "Autopilot",
}
}
pub fn description(self) -> &'static str {
match self {
Mode::Agent => "Default agent mode for conversational interactions",
Mode::Plan => "Plan mode for creating and executing multi-step plans",
Mode::Autopilot => "Autonomous mode that enables allow-all and runs until task completion",
}
}
pub fn parse(value: &str) -> Option<Mode> {
let short = value.rsplit(['#', '/']).next().unwrap_or(value);
match short {
"agent" | "interactive" => Some(Mode::Agent),
"plan" => Some(Mode::Plan),
"autopilot" => Some(Mode::Autopilot),
_ => None,
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub(super) struct ContextTierChoice {
pub id: &'static str,
pub label: String,
pub tokens: u32,
pub description: &'static str,
}
#[derive(Clone, Debug, PartialEq)]
pub(super) struct ModelEntry {
pub id: String,
pub name: String,
pub description: Option<String>,
pub is_default: bool,
pub default_effort: Option<String>,
pub efforts: Vec<String>,
pub context_tiers: Vec<ContextTierChoice>,
pub default_context_tokens: Option<u32>,
pub max_context_tokens: Option<u32>,
pub pricing: Option<AgentModelPricing>,
}
impl ModelEntry {
/// Copilot's default reasoning effort for this model: user setting (`effortLevel`) when
/// supported, otherwise the model's `defaultReasoningEffort`, `"medium"`, or first listed.
pub fn default_effort<'a>(&'a self, user_default: Option<&str>) -> Option<&'a str> {
if let Some(wanted) = user_default
&& let Some(found) = self.efforts.iter().find(|e| e.as_str() == wanted)
{
return Some(found.as_str());
}
if let Some(model_def) = self.default_effort.as_deref()
&& let Some(found) = self.efforts.iter().find(|e| e.as_str() == model_def)
{
return Some(found.as_str());
}
self.efforts.iter().find(|e| e.as_str() == "medium").or_else(|| self.efforts.first()).map(String::as_str)
}
/// Copilot's default context-window tier for this model: user setting (`contextTier`) when
/// supported, otherwise `"default"` (`200K`), or first listed.
pub fn default_context_tier(&self, user_default: Option<&str>) -> Option<&'static str> {
if let Some(wanted) = user_default
&& let Some(found) = self.context_tiers.iter().find(|t| t.id == wanted)
{
return Some(found.id);
}
self.context_tiers.iter().find(|t| t.id == "default").or_else(|| self.context_tiers.first()).map(|t| t.id)
}
/// Active context window capacity in tokens for `tier`.
pub fn context_tokens(&self, tier: Option<&str>) -> Option<u32> {
if let Some(tier) = tier
&& let Some(found) = self.context_tiers.iter().find(|t| t.id == tier)
{
return Some(found.tokens);
}
self.context_tiers
.iter()
.find(|t| t.id == "default")
.or_else(|| self.context_tiers.first())
.map(|t| t.tokens)
.or(self.default_context_tokens)
.or(self.max_context_tokens)
}
}
/// Copilot's own configured defaults from `user.settings.get` (`~/.copilot/config.json`)
/// and optional CLI launch flags (`--model`, `--effort`, `--context`, `--allow-all`).
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub(super) struct UserDefaults {
pub model: Option<String>,
pub effort: Option<String>,
pub context_tier: Option<String>,
pub mode: Option<Mode>,
pub allow_all: Option<bool>,
}
impl UserDefaults {
pub fn from_rpc_and_args(settings_rpc: Option<&Value>, args: &[String]) -> Self {
let mut out = Self::default();
if let Some(res) = settings_rpc {
out.model = setting_str(res, "model");
out.effort = setting_str(res, "effortLevel").or_else(|| setting_str(res, "reasoningEffort"));
out.context_tier = setting_str(res, "contextTier");
out.mode = setting_str(res, "defaultMode").and_then(|m| Mode::parse(&m));
out.allow_all = setting_str(res, "defaultPermissionMode").and_then(|p| match p.as_str() {
"allow-all" | "allow_all" | "bypass" | "autopilot" => Some(true),
"manual" => Some(false),
_ => None,
});
}
let mut iter = args.iter().peekable();
while let Some(arg) = iter.next() {
let s = arg.as_str();
if s == "--allow-all" || s == "--yolo" {
out.allow_all = Some(true);
} else if let Some(v) = flag_val(s, "--model", &mut iter) {
out.model = Some(v);
} else if let Some(v) =
flag_val(s, "--effort", &mut iter).or_else(|| flag_val(s, "--reasoning-effort", &mut iter))
{
out.effort = Some(v);
} else if let Some(v) = flag_val(s, "--context", &mut iter) {
out.context_tier = Some(v);
}
}
out
}
}
fn setting_str(res: &Value, key: &str) -> Option<String> {
let settings = res.get("settings");
let raw = settings
.and_then(|s| s.get(key))
.and_then(|entry| entry.get("value").or(Some(entry)))
.or_else(|| res.get(key))?;
raw.as_str().map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned)
}
fn flag_val<'a>(
arg: &'a str,
flag: &str,
iter: &mut std::iter::Peekable<std::slice::Iter<'a, String>>,
) -> Option<String> {
if arg == flag {
return iter.next().map(|v| v.trim()).filter(|v| !v.is_empty()).map(str::to_owned);
}
let prefix = format!("{flag}=");
arg.strip_prefix(&prefix).map(str::trim).filter(|v| !v.is_empty()).map(str::to_owned)
}
#[derive(Clone, Debug, PartialEq)]
pub(super) struct Settings {
pub model: String,
pub effort: Option<String>,
pub context_tier: Option<String>,
pub mode: Mode,
pub allow_all: bool,
defaults: UserDefaults,
/// Explicit per-session user overrides; `None` means track Copilot's default for each model.
explicit_effort: Option<String>,
explicit_context_tier: Option<String>,
}
impl Settings {
pub fn new(models: &[ModelEntry], defaults: &UserDefaults) -> Self {
let model = defaults
.model
.as_deref()
.filter(|id| models.iter().any(|m| m.id == *id))
.or_else(|| models.iter().find(|m| m.is_default && m.id != "auto").map(|m| m.id.as_str()))
.or_else(|| models.iter().find(|m| m.id != "auto").map(|m| m.id.as_str()))
.or_else(|| models.first().map(|m| m.id.as_str()))
.unwrap_or("auto")
.to_owned();
let mode = defaults.mode.unwrap_or(Mode::Agent);
let allow_all = defaults.allow_all.unwrap_or(false) || mode == Mode::Autopilot;
let mut s = Self {
model,
effort: None,
context_tier: None,
mode,
allow_all,
defaults: defaults.clone(),
explicit_effort: None,
explicit_context_tier: None,
};
s.fit_to_model(models);
s
}
pub fn fit_to_model(&mut self, models: &[ModelEntry]) {
let Some(m) = models.iter().find(|m| m.id == self.model) else {
self.effort = None;
self.context_tier = None;
return;
};
self.effort = if m.efforts.is_empty() {
None
} else if let Some(wanted) = self.explicit_effort.as_deref().filter(|w| m.efforts.iter().any(|e| e == *w)) {
Some(wanted.to_owned())
} else {
m.default_effort(self.defaults.effort.as_deref()).map(str::to_owned)
};
self.context_tier = if m.context_tiers.is_empty() {
None
} else if let Some(wanted) =
self.explicit_context_tier.as_deref().filter(|w| m.context_tiers.iter().any(|t| t.id == *w))
{
Some(wanted.to_owned())
} else {
m.default_context_tier(self.defaults.context_tier.as_deref()).map(str::to_owned)
};
}
pub fn set(&mut self, models: &[ModelEntry], option: &str, value: &str) -> Result<(), String> {
match option {
MODEL => {
if !models.is_empty() && !models.iter().any(|m| m.id == value) && value != self.model {
return Err(format!("unknown model {value}"));
}
self.model = value.to_owned();
self.fit_to_model(models);
}
EFFORT => {
let m = models.iter().find(|m| m.id == self.model);
if !m.is_some_and(|m| m.efforts.iter().any(|e| e == value)) {
return Err(format!("{} has no reasoning effort {value}", self.model));
}
self.effort = Some(value.to_owned());
self.explicit_effort = Some(value.to_owned());
}
CONTEXT_TIER => {
let m = models.iter().find(|m| m.id == self.model);
if !m.is_some_and(|m| m.context_tiers.iter().any(|t| t.id == value)) {
return Err(format!("{} has no context tier {value}", self.model));
}
self.context_tier = Some(value.to_owned());
self.explicit_context_tier = Some(value.to_owned());
}
MODE => {
let mode = Mode::parse(value).ok_or_else(|| format!("unknown mode {value}"))?;
self.mode = mode;
if mode == Mode::Autopilot {
self.allow_all = true;
}
}
ALLOW_ALL => match value {
"on" | "true" => self.allow_all = true,
"off" | "false" => self.allow_all = false,
_ => return Err(format!("unknown allow_all value {value}")),
},
_ => return Err(format!("unknown setting {option}")),
}
Ok(())
}
pub fn active_context_tokens(&self, models: &[ModelEntry]) -> Option<u32> {
models.iter().find(|m| m.id == self.model).and_then(|m| m.context_tokens(self.context_tier.as_deref()))
}
}
/// Parses `models.list` + optional `models.listTokenPriceUnits` into catalog entries,
/// prepending `"auto"` when not already in the list.
pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<ModelEntry> {
let units = parse_price_units(price_units);
let raw = list
.get("models")
.or_else(|| list.get("data"))
.and_then(Value::as_array)
.map(Vec::as_slice)
.unwrap_or_default();
let mut out = Vec::new();
if !raw.iter().any(|m| str_of(m, "id") == Some("auto")) && !raw.is_empty() {
out.push(ModelEntry {
id: "auto".into(),
name: "Auto".into(),
description: Some("Let Copilot pick the best model".into()),
is_default: false,
default_effort: None,
efforts: Vec::new(),
context_tiers: Vec::new(),
default_context_tokens: None,
max_context_tokens: None,
pricing: None,
});
}
for m in raw {
if let Some(entry) = parse_model(m, &units) {
out.push(entry);
}
}
out
}
fn parse_model(m: &Value, units: &HashMap<String, PriceUnit>) -> Option<ModelEntry> {
let id = str_of(m, "id")?.to_owned();
if m.get("model_picker_enabled").and_then(Value::as_bool) == Some(false)
|| m.get("modelPickerEnabled").and_then(Value::as_bool) == Some(false)
{
return None;
}
let name = str_of(m, "name")
.or_else(|| str_of(m, "label"))
.or_else(|| str_of(m, "displayName"))
.filter(|s| !s.is_empty())
.unwrap_or(&id)
.to_owned();
let mut efforts = parse_efforts(m);
efforts.sort_by_key(|e| effort_rank(e));
efforts.dedup();
let limits = m.pointer("/capabilities/limits");
let max_prompt =
limits.and_then(|l| u32_of(l, "max_prompt_tokens").or_else(|| u32_of(l, "maxPromptTokens"))).filter(|&n| n > 0);
let max_window = limits
.and_then(|l| u32_of(l, "max_context_window_tokens").or_else(|| u32_of(l, "maxContextWindowTokens")))
.filter(|&n| n > 0);
let billing = m.get("billing");
let multiplier = billing.and_then(|b| f64_of(b, "multiplier"));
let raw_category = str_of(m, "modelPickerPriceCategory")
.or_else(|| str_of(m, "model_picker_price_category"))
.or_else(|| str_of(m, "priceCategory"))
.or_else(|| str_of(m, "price_category"))
.or_else(|| billing.and_then(|b| str_of(b, "priceCategory").or_else(|| str_of(b, "price_category"))));
let mut cost_tier = raw_category.and_then(normalize_cost_tier).map(str::to_owned);
let token_prices = billing.and_then(|b| b.get("token_prices").or_else(|| b.get("tokenPrices")));
let unit = units.get(&id).copied().unwrap_or(PriceUnit::Credits);
let (mut tiers, default_max, long_max) = parse_token_prices(token_prices, max_prompt, max_window, unit);
let mut context_tiers = Vec::new();
if let (Some(def_tokens), Some(long_tokens)) = (default_max, long_max)
&& def_tokens < long_tokens
{
context_tiers.push(ContextTierChoice {
id: "default",
label: format_tokens(def_tokens),
tokens: def_tokens,
description: "Default recommended context size",
});
context_tiers.push(ContextTierChoice {
id: "long_context",
label: format_tokens(long_tokens),
tokens: long_tokens,
description: "Maximum context window for longer sessions",
});
}
if cost_tier.is_none()
&& let Some(def) = tiers.get("default")
{
cost_tier = Some(infer_cost_tier(def.output).to_owned());
}
if let Some(def_tokens) = default_max.or(max_window).or(max_prompt)
&& let Some(def) = tiers.get_mut("default")
&& def.context_tokens.is_none()
{
def.context_tokens = Some(def_tokens);
}
if let Some(long_tokens) = long_max
&& let Some(long) = tiers.get_mut("long_context")
{
long.context_tokens = Some(long_tokens);
}
let pricing = (!tiers.is_empty() || cost_tier.is_some() || multiplier.is_some()).then_some(AgentModelPricing {
cost_tier,
multiplier,
tiers,
});
let description = multiplier
.map(|mul| {
let clean = round6(mul);
if (clean - clean.round()).abs() < 1e-6 {
format!("{}x", clean.round() as i64)
} else {
format!("{clean}x")
}
})
.or_else(|| str_of(m, "description").filter(|d| !d.is_empty() && *d != name).map(str::to_owned))
.or_else(|| (id == "auto").then(|| "Let Copilot pick the best model".to_owned()));
let is_default = m
.get("is_chat_default")
.or_else(|| m.get("isChatDefault"))
.or_else(|| m.get("isDefault"))
.and_then(Value::as_bool)
.unwrap_or(false);
let default_effort = str_of(m, "defaultReasoningEffort")
.or_else(|| str_of(m, "default_reasoning_effort"))
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned);
Some(ModelEntry {
id,
name,
description,
is_default,
default_effort,
efforts,
context_tiers,
default_context_tokens: default_max.or(max_window).or(max_prompt),
max_context_tokens: long_max.or(default_max).or(max_window).or(max_prompt),
pricing,
})
}
fn parse_efforts(m: &Value) -> Vec<String> {
let arr = m
.get("supportedReasoningEfforts")
.or_else(|| m.get("supported_reasoning_efforts"))
.or_else(|| m.pointer("/capabilities/supports/reasoning_effort"))
.or_else(|| m.pointer("/capabilities/supports/reasoningEffort"));
arr.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|v| v.as_str().filter(|s| !s.is_empty()).map(str::to_owned))
.collect()
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum PriceUnit {
Credits,
NanoAiu,
}
fn parse_price_units(raw: Option<&Value>) -> HashMap<String, PriceUnit> {
let mut out = HashMap::new();
let Some(raw) = raw else { return out };
let unit_of = |s: &str| {
if s.eq_ignore_ascii_case("nano_aiu") || s.eq_ignore_ascii_case("nanoaiu") || s.contains("nano") {
Some(PriceUnit::NanoAiu)
} else if s.to_ascii_lowercase().contains("credit") || s.eq_ignore_ascii_case("aic") {
Some(PriceUnit::Credits)
} else {
None
}
};
if let Some(map) =
raw.get("units").or_else(|| raw.get("priceUnits")).or_else(|| raw.get("models")).and_then(Value::as_object)
{
for (k, v) in map {
let u = v
.as_str()
.and_then(unit_of)
.or_else(|| v.get("unit").or_else(|| v.get("priceUnit")).and_then(Value::as_str).and_then(unit_of));
if let Some(u) = u {
out.insert(k.clone(), u);
}
}
}
for key in ["units", "priceUnits", "models"] {
if let Some(arr) = raw.get(key).and_then(Value::as_array) {
for item in arr {
let id = str_of(item, "modelId").or_else(|| str_of(item, "id"));
let u = str_of(item, "unit").or_else(|| str_of(item, "priceUnit")).and_then(unit_of);
if let (Some(id), Some(u)) = (id, u) {
out.insert(id.to_owned(), u);
}
}
}
}
out
}
fn parse_token_prices(
tp: Option<&Value>,
max_prompt: Option<u32>,
max_window: Option<u32>,
unit: PriceUnit,
) -> (BTreeMap<String, AgentTokenPricing>, Option<u32>, Option<u32>) {
let mut tiers = BTreeMap::new();
let Some(tp) = tp else {
return (tiers, None, max_window.or(max_prompt));
};
let batch =
f64_of(tp, "batch_size").or_else(|| f64_of(tp, "batchSize")).filter(|&b| b > 0.0).unwrap_or(BATCH_TOKENS);
let batch_scale = BATCH_TOKENS / batch;
let unit_scale = match unit {
PriceUnit::Credits => 1.0,
PriceUnit::NanoAiu => 1.0 / NANO_AIU_PER_CREDIT,
};
let scale = batch_scale * unit_scale;
let parse_tier = |node: &Value| -> Option<(AgentTokenPricing, Option<u32>)> {
let input = f64_of(node, "input_price").or_else(|| f64_of(node, "inputPrice"))?;
let output = f64_of(node, "output_price").or_else(|| f64_of(node, "outputPrice"))?;
// Guard against raw nano-AIU numbers even if `listTokenPriceUnits` was unavailable.
let effective = if unit == PriceUnit::Credits && (input >= 10_000_000.0 || output >= 10_000_000.0) {
scale / NANO_AIU_PER_CREDIT
} else {
scale
};
let cache_read = f64_of(node, "cache_read_price")
.or_else(|| f64_of(node, "cacheReadPrice"))
.or_else(|| f64_of(node, "cache_price"))
.or_else(|| f64_of(node, "cachePrice"))
.map(|v| round6(v * effective));
let cache_write = f64_of(node, "cache_write_price")
.or_else(|| f64_of(node, "cacheWritePrice"))
.map(|v| round6(v * effective));
let ctx = u32_of(node, "max_prompt_tokens")
.or_else(|| u32_of(node, "maxPromptTokens"))
.or_else(|| u32_of(node, "context_max"))
.or_else(|| u32_of(node, "contextMax"))
.filter(|&n| n > 0);
Some((
AgentTokenPricing {
input: round6(input * effective),
output: round6(output * effective),
cache_read,
cache_write,
context_tokens: ctx,
},
ctx,
))
};
// Both CAPI `/models` (`token_prices.default` + `token_prices.long_context`) and
// `copilot --headless` `models.list` (top-level `tokenPrices` + `tokenPrices.longContext`)
// share the same per-tier fields.
let def_node = tp.get("default").unwrap_or(tp);
let mut def_max = None;
if let Some((def_pricing, ctx)) = parse_tier(def_node) {
def_max = ctx;
tiers.insert("default".into(), def_pricing);
}
let long_node = tp.get("longContext").or_else(|| tp.get("long_context"));
let mut long_max = None;
if let Some(long_node) = long_node
&& let Some((mut long_pricing, ctx)) = parse_tier(long_node)
{
// Use the full context window capacity (`1_000_000`) when available so models whose
// `max_prompt_tokens` deduct `max_output_tokens` (e.g. `872_000` = `1M - 128K` on
// GPT-6 Sol, `936_000` = `1M - 64K` on Gemini 4 Carbon) display cleanly as `1M`.
let cap = match (ctx, max_window) {
(Some(c), Some(w)) if w >= c => Some(w),
(Some(c), _) => Some(c),
(None, w) => w.or(max_prompt),
};
long_max = cap;
long_pricing.context_tokens = cap;
tiers.insert("long_context".into(), long_pricing);
} else if let (Some(d), Some(p)) = (def_max, max_prompt)
&& d < p
&& let Some(def) = tiers.get("default").cloned()
{
let cap = max_window.filter(|&w| w >= p).unwrap_or(p);
long_max = Some(cap);
tiers.insert("long_context".into(), AgentTokenPricing { context_tokens: Some(cap), ..def });
}
(tiers, def_max, long_max)
}
fn normalize_cost_tier(raw: &str) -> Option<&'static str> {
match raw.trim().to_ascii_lowercase().as_str() {
"lightweight" | "low" => Some("low"),
"versatile" | "medium" | "standard" => Some("medium"),
"powerful" | "high" | "premium" => Some("high"),
"very_high" | "veryhigh" => Some("very_high"),
_ => None,
}
}
fn infer_cost_tier(output_credits_per_1m: f64) -> &'static str {
if output_credits_per_1m < 300.0 {
"low"
} else if output_credits_per_1m <= 1500.0 {
"medium"
} else {
"high"
}
}
/// Formats token capacity matching VS Code (`200000` → `"200K"`, `1000000` → `"1M"`).
pub(super) fn format_tokens(tokens: u32) -> String {
if tokens >= 1_000_000 {
let m = (f64::from(tokens) / 1_000_000.0 * 10.0).floor() / 10.0;
if (m - m.round()).abs() < 1e-6 { format!("{}M", m.round() as u32) } else { format!("{m:.1}M") }
} else if tokens > 900_000 {
"1M".into()
} else if tokens >= 1_000 {
format!("{}K", (f64::from(tokens) / 1_000.0).round() as u32)
} else {
tokens.to_string()
}
}
pub(super) fn effort_rank(effort: &str) -> u8 {
match effort {
"none" => 0,
"minimal" => 1,
"low" => 2,
"medium" => 3,
"high" => 4,
"xhigh" | "extra_high" => 5,
"max" => 6,
_ => 3,
}
}
pub(super) fn effort_label(effort: &str) -> (&'static str, &'static str) {
match effort {
"none" => ("None", "No additional reasoning; fastest responses."),
"minimal" => ("Minimal", "Least reasoning; fastest responses."),
"low" => ("Low", "Minimal reasoning before responding."),
"medium" => ("Medium", "Balanced reasoning and speed."),
"high" => ("High", "More thorough reasoning; slower responses."),
"xhigh" => ("Extra High", "Extensive reasoning for the hardest problems."),
"max" => ("Max", "Maximum reasoning; slowest but most thorough."),
_ => ("Default", ""),
}
}
/// ACP `configOptions` for the active session settings.
pub(super) fn config_options(models: &[ModelEntry], s: &Settings) -> Value {
let mut model_values: Vec<Value> = models.iter().map(model_option_value).collect();
if !s.model.is_empty() && !models.iter().any(|m| m.id == s.model) {
model_values.push(json!({ "value": s.model, "name": s.model }));
}
let mut out = Vec::new();
if !model_values.is_empty() {
out.push(json!({
"id": MODEL,
"name": "Model",
"category": "model",
"type": "select",
"currentValue": s.model,
"options": model_values,
}));
}
if let Some(m) = models.iter().find(|m| m.id == s.model) {
if let (Some(opt), Some(current)) = (effort_option_for(m, s.effort.as_deref()), s.effort.as_deref()) {
let mut o = opt;
o["currentValue"] = json!(current);
out.push(o);
}
if let (Some(opt), Some(current)) =
(context_tier_option_for(m, s.context_tier.as_deref()), s.context_tier.as_deref())
{
let mut o = opt;
o["currentValue"] = json!(current);
out.push(o);
}
}
out.push(json!({
"id": MODE,
"name": "Mode",
"category": "mode",
"type": "select",
"currentValue": s.mode.id(),
"options": Mode::ALL.iter().map(|m| json!({
"value": m.id(),
"name": m.name(),
"description": m.description(),
})).collect::<Vec<_>>(),
}));
out.push(json!({
"id": ALLOW_ALL,
"name": "Allow All",
"category": "permissions",
"type": "select",
"currentValue": if s.allow_all { "on" } else { "off" },
"options": [
{ "value": "on", "name": "On", "description": "Automatically approve all tool, path, and URL requests" },
{ "value": "off", "name": "Off", "description": "Require approval for tool, path, and URL requests" },
],
}));
Value::Array(out)
}
/// Per-model options (`[reasoning_effort?, context_tier?]`) for every model in `models`,
/// each defaulted to Copilot's own defaults (respecting `user.settings.get` / CLI flags).
pub(super) fn per_model_options(models: &[ModelEntry], defaults: &UserDefaults) -> Vec<(String, Vec<Value>)> {
models
.iter()
.map(|m| {
let mut opts = Vec::new();
if let Some(effort) = effort_option_for(m, m.default_effort(defaults.effort.as_deref())) {
opts.push(effort);
}
if let Some(ctx) = context_tier_option_for(m, m.default_context_tier(defaults.context_tier.as_deref())) {
opts.push(ctx);
}
(m.id.clone(), opts)
})
.collect()
}
fn model_option_value(m: &ModelEntry) -> Value {
let mut v = json!({ "value": m.id, "name": m.name });
if let Some(d) = &m.description {
v["description"] = json!(d);
}
if let Some(pricing) = &m.pricing {
let mut meta = serde_json::Map::new();
meta.insert("pricing".into(), json!(pricing));
if let Some(cat) = &pricing.cost_tier {
meta.insert("copilotPriceCategory".into(), json!(cat));
}
v["_meta"] = Value::Object(meta);
}
v
}
fn effort_option_for(m: &ModelEntry, current: Option<&str>) -> Option<Value> {
if m.efforts.len() <= 1 && m.efforts.is_empty() {
return None;
}
let default = current.filter(|c| m.efforts.iter().any(|e| e == *c)).or_else(|| m.default_effort(None))?;
let options: Vec<Value> = m
.efforts
.iter()
.map(|e| {
let (label, desc) = effort_label(e);
let name = if label == "Default" { capitalize(e) } else { label.to_owned() };
let mut item = json!({ "value": e, "name": name });
if !desc.is_empty() {
item["description"] = json!(desc);
}
item
})
.collect();
Some(json!({
"id": EFFORT,
"name": "Effort Level",
"description": "How much reasoning the model performs before responding. Higher effort can improve quality at the cost of speed.",
"category": "thought_level",
"type": "select",
"currentValue": default,
"options": options,
}))
}
fn context_tier_option_for(m: &ModelEntry, current: Option<&str>) -> Option<Value> {
if m.context_tiers.len() < 2 {
return None;
}
let default =
current.filter(|c| m.context_tiers.iter().any(|t| t.id == *c)).or_else(|| m.default_context_tier(None))?;
let options: Vec<Value> = m
.context_tiers
.iter()
.map(|t| {
json!({
"value": t.id,
"name": t.label,
"description": t.description,
})
})
.collect();
Some(json!({
"id": CONTEXT_TIER,
"name": "Context Size",
"description": "Context window size for this model.",
"category": "model_config",
"type": "select",
"currentValue": default,
"options": options,
}))
}
fn capitalize(s: &str) -> String {
let mut chars = s.chars();
chars.next().map(|c| c.to_uppercase().chain(chars).collect()).unwrap_or_default()
}
fn round6(n: f64) -> f64 {
let r = (n * 1_000_000.0).round() / 1_000_000.0;
if r == 0.0 { 0.0 } else { r }
}
fn str_of<'a>(v: &'a Value, key: &str) -> Option<&'a str> {
v.get(key).and_then(Value::as_str)
}
fn f64_of(v: &Value, key: &str) -> Option<f64> {
v.get(key).and_then(Value::as_f64).filter(|n| n.is_finite())
}
fn u32_of(v: &Value, key: &str) -> Option<u32> {
v.get(key).and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok())
}
-540
Переглянути файл
@@ -1,540 +0,0 @@
use super::models::{self, CONTEXT_TIER, EFFORT, MODEL, Mode, Settings, UserDefaults};
use super::{acp_args, acp_fallback_spec, attach, headless_args};
use crate::config;
use crate::provider::Driver;
use ide_jsonrpc::{Framing, Handler, Peer, codes};
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::sync::{Arc, OnceLock};
fn sample_models_list() -> Value {
json!({
"models": [
{
"id": "gemini-4-carbon",
"name": "Gemini 4 Carbon",
"priceCategory": "versatile",
"supportedReasoningEfforts": ["low", "medium", "high"],
"defaultReasoningEffort": "medium",
"capabilities": {
"supports": { "vision": true, "reasoningEffort": true },
"limits": {
"max_context_window_tokens": 1_000_000,
"max_prompt_tokens": 1_000_000,
"max_output_tokens": 64_000
}
},
"billing": {
"is_premium": true,
"multiplier": 1.0,
"token_prices": {
"batch_size": 1_000_000,
"preferred_tier": "default",
"default": {
"input_price": 100.0,
"output_price": 500.0,
"cache_read_price": 10.0,
"cache_write_price": 0.0,
"max_prompt_tokens": 200_000
},
"long_context": {
"input_price": 200.0,
"output_price": 1000.0,
"cache_read_price": 10.0,
"cache_write_price": 0.0,
"max_prompt_tokens": 1_000_000
}
}
}
},
{
"id": "gpt-5.6-sol",
"name": "GPT-5.6 Sol",
"priceCategory": "powerful",
"supportedReasoningEfforts": ["none", "low", "medium", "high", "xhigh", "max"],
"defaultReasoningEffort": "medium",
"capabilities": {
"supports": { "vision": true },
"limits": {
"max_context_window_tokens": 1_000_000,
"max_prompt_tokens": 1_000_000
}
},
"billing": {
"multiplier": 2.0,
"token_prices": {
"batch_size": 1_000_000,
"default": {
"input_price": 250_000_000_000.0,
"output_price": 1_500_000_000_000.0,
"cache_read_price": 25_000_000_000.0,
"cache_write_price": 0.0,
"max_prompt_tokens": 200_000
},
"long_context": {
"input_price": 500_000_000_000.0,
"output_price": 3_000_000_000_000.0,
"cache_read_price": 50_000_000_000.0,
"cache_write_price": 0.0,
"max_prompt_tokens": 1_000_000
}
}
}
},
{
"id": "mai-experimental-internal",
"name": "MAI Experimental",
"priceCategory": "lightweight",
"supportedReasoningEfforts": ["low", "medium"],
"capabilities": {
"limits": {
"max_context_window_tokens": 131_072,
"max_prompt_tokens": 131_072
}
},
"billing": {
"multiplier": 0.33
}
}
]
})
}
fn sample_price_units() -> Value {
json!({
"units": {
"gemini-4-carbon": "ai_credits",
"gpt-5.6-sol": "nano_aiu"
}
})
}
#[test]
fn parses_tiered_context_windows_pricing_and_uses_copilots_own_defaults() {
let catalog = models::parse_catalog(&sample_models_list(), Some(&sample_price_units()));
assert_eq!(
catalog.iter().map(|m| m.id.as_str()).collect::<Vec<_>>(),
["auto", "gemini-4-carbon", "gpt-5.6-sol", "mai-experimental-internal"]
);
let gemini = catalog.iter().find(|m| m.id == "gemini-4-carbon").unwrap();
assert_eq!(gemini.default_effort(None), Some("medium"));
assert_eq!(gemini.default_context_tier(None), Some("default"));
assert_eq!(
gemini.context_tiers.iter().map(|t| (t.id, t.label.as_str(), t.tokens)).collect::<Vec<_>>(),
[("default", "200K", 200_000), ("long_context", "1M", 1_000_000)]
);
let pricing = gemini.pricing.as_ref().unwrap();
assert_eq!(pricing.cost_tier.as_deref(), Some("medium"));
let long_p = &pricing.tiers["long_context"];
assert_eq!(
(long_p.input, long_p.output, long_p.cache_read, long_p.cache_write),
(200.0, 1000.0, Some(10.0), Some(0.0))
);
let def_p = &pricing.tiers["default"];
assert_eq!((def_p.input, def_p.output), (100.0, 500.0));
// Nano-AIU conversion (10^9 nano-AIU = 1 AI Credit).
let sol = catalog.iter().find(|m| m.id == "gpt-5.6-sol").unwrap();
assert_eq!(sol.default_effort(None), Some("medium"));
assert_eq!(sol.default_context_tier(None), Some("default"));
let sol_long = &sol.pricing.as_ref().unwrap().tiers["long_context"];
assert_eq!((sol_long.input, sol_long.output, sol_long.cache_read), (500.0, 3000.0, Some(50.0)));
// Single-window model has no multi-tier `context_tier` toggle.
let mai = catalog.iter().find(|m| m.id == "mai-experimental-internal").unwrap();
assert!(mai.context_tiers.is_empty());
assert_eq!(mai.default_effort(None), Some("medium"));
// Initial settings pick Copilot's own defaults (`medium` effort + `default` 200K context).
let mut s = Settings::new(&catalog, &UserDefaults::default());
assert_eq!(s.model, "gemini-4-carbon");
assert_eq!(s.effort.as_deref(), Some("medium"));
assert_eq!(s.context_tier.as_deref(), Some("default"));
assert_eq!(s.active_context_tokens(&catalog), Some(200_000));
// Switching to GPT-5.6 Sol without an explicit override stays on Copilot's defaults (`medium` + `default`).
s.set(&catalog, MODEL, "gpt-5.6-sol").unwrap();
assert_eq!(s.effort.as_deref(), Some("medium"));
assert_eq!(s.context_tier.as_deref(), Some("default"));
// Explicit session overrides (`xhigh` + `long_context`) stick across models that support them,
// and fall back to Copilot's default when switching to a model that does not.
s.set(&catalog, EFFORT, "xhigh").unwrap();
s.set(&catalog, CONTEXT_TIER, "long_context").unwrap();
assert_eq!(s.active_context_tokens(&catalog), Some(1_000_000));
s.set(&catalog, MODEL, "mai-experimental-internal").unwrap();
assert_eq!(s.effort.as_deref(), Some("medium"));
assert_eq!(s.context_tier, None);
// User settings from `user.settings.get` (1.0.112+ `{ value, default, isDefault }` shape) and CLI flags are honored.
let rpc_settings = json!({
"settings": {
"model": { "value": "gpt-5.6-sol", "default": null, "isDefault": false },
"effortLevel": { "value": "high", "default": null, "isDefault": false },
"contextTier": { "value": "long_context", "default": null, "isDefault": false },
"defaultMode": { "value": "plan", "default": "interactive", "isDefault": false },
}
});
let user_defs = UserDefaults::from_rpc_and_args(Some(&rpc_settings), &[]);
let configured = Settings::new(&catalog, &user_defs);
assert_eq!(configured.model, "gpt-5.6-sol");
assert_eq!(configured.effort.as_deref(), Some("high"));
assert_eq!(configured.context_tier.as_deref(), Some("long_context"));
assert_eq!(configured.mode, Mode::Plan);
// Per-model discovery options preserve pricing on `model` values and emit Copilot's defaults.
let raw = models::config_options(&catalog, &Settings::new(&catalog, &UserDefaults::default()));
let parsed = config::parse_options(&raw);
let model_opt = parsed.iter().find(|o| o.id == MODEL).unwrap();
let gem_val = model_opt.values.iter().find(|v| v.value == "gemini-4-carbon").unwrap();
assert_eq!(gem_val.pricing.as_ref().unwrap().cost_tier.as_deref(), Some("medium"));
assert_eq!(parsed.iter().find(|o| o.id == EFFORT).unwrap().current.as_deref(), Some("medium"));
assert_eq!(parsed.iter().find(|o| o.id == CONTEXT_TIER).unwrap().current.as_deref(), Some("default"));
}
#[test]
fn parses_headless_sdk_models_list_flat_token_prices_and_single_tier_models() {
let sdk_list = json!({
"models": [
{ "id": "auto", "name": "Auto" },
{
"id": "gemini-4-carbon",
"name": "Gemini 4 Carbon",
"modelPickerCategory": "powerful",
"modelPickerPriceCategory": "medium",
"supportedReasoningEfforts": ["low", "medium", "high"],
"capabilities": {
"limits": {
"max_context_window_tokens": 1_000_000,
"max_output_tokens": 64_000,
"max_prompt_tokens": 936_000
}
},
"billing": {
"tokenPrices": {
"inputPrice": 200,
"outputPrice": 1000,
"cachePrice": 10,
"cacheReadPrice": 10,
"cacheWritePrice": 0,
"contextMax": 200_000,
"maxPromptTokens": 200_000,
"batchSize": 1_000_000,
"longContext": {
"inputPrice": 200,
"outputPrice": 1000,
"cachePrice": 10,
"cacheReadPrice": 10,
"cacheWritePrice": 0,
"contextMax": 936_000,
"maxPromptTokens": 936_000
}
}
}
},
{
"id": "gpt-6-sol",
"name": "GPT-6 Sol",
"modelPickerPriceCategory": "medium",
"supportedReasoningEfforts": ["none", "low", "medium", "high", "xhigh", "max"],
"capabilities": {
"limits": {
"max_context_window_tokens": 1_000_000,
"max_output_tokens": 128_000,
"max_prompt_tokens": 872_000
}
},
"billing": {
"tokenPrices": {
"inputPrice": 250,
"outputPrice": 1250,
"contextMax": 272_000,
"maxPromptTokens": 272_000,
"batchSize": 1_000_000,
"longContext": {
"inputPrice": 500,
"outputPrice": 2500,
"contextMax": 872_000,
"maxPromptTokens": 872_000
}
}
}
},
{
"id": "gpt-5.3-codex",
"name": "GPT-5.3-Codex",
"modelPickerPriceCategory": "medium",
"supportedReasoningEfforts": ["low", "medium", "high", "xhigh"],
"capabilities": {
"limits": {
"max_context_window_tokens": 400_000,
"max_output_tokens": 128_000,
"max_prompt_tokens": 272_000
}
},
"billing": {
"tokenPrices": {
"inputPrice": 150,
"outputPrice": 600,
"contextMax": 272_000,
"maxPromptTokens": 272_000,
"batchSize": 1_000_000
}
}
}
]
});
let units = json!({
"units": [
{ "modelId": "gemini-4-carbon", "unit": "ai_credits" },
{ "modelId": "gpt-6-sol", "unit": "ai_credits" },
{ "modelId": "gpt-5.3-codex", "unit": "ai_credits" }
]
});
let catalog = models::parse_catalog(&sdk_list, Some(&units));
let carbon = catalog.iter().find(|m| m.id == "gemini-4-carbon").unwrap();
assert_eq!(
carbon.context_tiers.iter().map(|t| (t.id, t.label.as_str())).collect::<Vec<_>>(),
[("default", "200K"), ("long_context", "1M")]
);
let cp = carbon.pricing.as_ref().unwrap();
assert_eq!(cp.cost_tier.as_deref(), Some("medium"));
assert_eq!((cp.tiers["long_context"].input, cp.tiers["long_context"].output), (200.0, 1000.0));
let sol = catalog.iter().find(|m| m.id == "gpt-6-sol").unwrap();
assert_eq!(
sol.context_tiers.iter().map(|t| (t.id, t.label.as_str())).collect::<Vec<_>>(),
[("default", "272K"), ("long_context", "1M")]
);
let codex = catalog.iter().find(|m| m.id == "gpt-5.3-codex").unwrap();
assert!(codex.context_tiers.is_empty(), "single-tier model must not get a synthetic long_context tier");
}
#[test]
fn headless_and_acp_args_roundtrip_while_preserving_user_flags() {
assert_eq!(headless_args(&["--acp".into()]), vec!["--headless", "--no-auto-update", "--stdio"]);
assert_eq!(
headless_args(&["--log-level".into(), "debug".into(), "--headless".into(), "--stdio".into()]),
vec!["--log-level", "debug", "--headless", "--stdio", "--no-auto-update"]
);
assert_eq!(
acp_args(&[
"--headless".into(),
"--no-auto-update".into(),
"--stdio".into(),
"--context".into(),
"long_context".into()
]),
vec!["--acp", "--context", "long_context"]
);
let spec = crate::provider::builtin_spec("copilot").unwrap();
assert_eq!(spec.driver, Driver::Copilot);
let fallback = acp_fallback_spec(&spec);
assert_eq!(fallback.driver, Driver::Acp);
assert_eq!(fallback.args, vec!["--acp"]);
}
struct FakeCopilotServer {
peer: OnceLock<Peer>,
calls: Mutex<Vec<(String, Value)>>,
}
impl Handler for FakeCopilotServer {
fn on_notification(&self, _method: &str, _params: Value) {}
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
self.calls.lock().push((method.to_owned(), params.clone()));
match method {
"connect" => Ok(json!({ "ok": true, "protocolVersion": 3, "version": "1.0.112" })),
"models.list" => Ok(sample_models_list()),
"models.listTokenPriceUnits" => Ok(sample_price_units()),
"user.settings.get" => Ok(json!({ "settings": { "model": "gemini-4-carbon" } })),
"commands.list" => Ok(json!({ "commands": [{ "name": "compact", "description": "Compact context" }] })),
"skills.discover" => Ok(json!({ "skills": [] })),
"session.create" => Ok(json!({ "sessionId": "cop-sess-1" })),
"session.model.switchTo" => Ok(json!({ "modelId": params["modelId"] })),
"session.mode.set" => Ok(json!({})),
"session.permissions.setApproveAll" => {
assert!(params.get("enabled").and_then(Value::as_bool).is_some());
Ok(json!({ "success": true }))
}
"session.send" => {
if let Some(peer) = self.peer.get().cloned() {
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
std::thread::spawn(move || {
let _ = peer.notify(
"session.event",
json!({
"sessionId": sid,
"event": {
"id": "e1",
"type": "session.usage_info",
"data": { "currentTokens": 42_000, "tokenLimit": 1_000_000 }
}
}),
);
let _ = peer.notify(
"session.event",
json!({
"sessionId": sid,
"event": {
"id": "e2",
"type": "assistant.message_delta",
"data": { "messageId": "m1", "deltaContent": "Hello from 1M context!" }
}
}),
);
let _ = peer.notify(
"session.event",
json!({
"sessionId": sid,
"event": {
"id": "e3",
"type": "session.idle",
"data": { "aborted": false, "mode": "interactive" }
}
}),
);
});
}
Ok(json!({ "messageId": "msg-1" }))
}
_ => Err((codes::METHOD_NOT_FOUND, format!("unexpected {method}"))),
}
}
}
struct CollectUpdates(Mutex<Vec<Value>>);
impl Handler for CollectUpdates {
fn on_notification(&self, method: &str, params: Value) {
if method == "session/update" {
self.0.lock().push(params["update"].clone());
}
}
fn on_request(&self, method: &str, _params: Value) -> Result<Value, (i64, String)> {
Err((codes::METHOD_NOT_FOUND, format!("unexpected {method}")))
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_turns() {
let server = Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()) });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates.clone(), move |events| {
let (a, b) = tokio::io::duplex(1 << 16);
let (ar, aw) = tokio::io::split(a);
let (br, bw) = tokio::io::split(b);
let srv_peer = Peer::connect_framed(br, bw, server_clone.clone(), Framing::ContentLength);
let _ = server_clone.peer.set(srv_peer);
Ok(Peer::connect_framed(ar, aw, events, Framing::ContentLength))
})
.unwrap();
let init: Value = client.request("initialize", json!({}), None).await.unwrap();
assert_eq!(init["agentInfo"]["version"], "1.0.112");
assert_eq!(init["agentCapabilities"]["_meta"]["openidea"]["steer"], true);
let created: Value = client.request("session/new", json!({ "cwd": "/tmp", "mcpServers": [] }), None).await.unwrap();
assert_eq!(created["sessionId"], "cop-sess-1");
// Verify `session.create` sent `"trustWorkingDirectory": "session"`, `gemini-4-carbon`,
// and Copilot's own defaults (`reasoningEffort: "medium"` and `contextTier: "default"`).
{
let calls = server.calls.lock();
let (_, create_params) = calls.iter().find(|(m, _)| m == "session.create").unwrap();
assert_eq!(create_params["trustWorkingDirectory"], "session");
assert_eq!(create_params["model"], "gemini-4-carbon");
assert_eq!(create_params["reasoningEffort"], "medium");
assert_eq!(create_params["contextTier"], "default");
}
// Switch Context Size up to 1M (`long_context`) and Effort to `high` live via `session/set_config_option`.
let _: Value = client
.request(
"session/set_config_option",
json!({
"sessionId": "cop-sess-1",
"configId": "reasoning_effort",
"value": "high"
}),
None,
)
.await
.unwrap();
let switched_1m: Value = client
.request(
"session/set_config_option",
json!({
"sessionId": "cop-sess-1",
"configId": "context_tier",
"value": "long_context"
}),
None,
)
.await
.unwrap();
let opts_1m = config::options_of(&switched_1m);
assert_eq!(opts_1m.iter().find(|o| o.id == "context_tier").unwrap().current.as_deref(), Some("long_context"));
// Run a turn and verify 1M usage_update + streamed message chunk.
let prompt_res: Value = client
.request(
"session/prompt",
json!({
"sessionId": "cop-sess-1",
"prompt": [{ "type": "text", "text": "Explain architecture" }]
}),
None,
)
.await
.unwrap();
assert_eq!(prompt_res["stopReason"], "end_turn");
{
let seen = updates.0.lock();
assert!(
seen.iter().any(|u| u["sessionUpdate"] == "usage_update" && u["size"] == 1_000_000 && u["used"] == 42_000)
);
assert!(
seen.iter().any(
|u| u["sessionUpdate"] == "agent_message_chunk" && u["content"]["text"] == "Hello from 1M context!"
)
);
}
// Switch Context Size back down to 200K (`default`) live via `session/set_config_option`.
let switched: Value = client
.request(
"session/set_config_option",
json!({
"sessionId": "cop-sess-1",
"configId": "context_tier",
"value": "default"
}),
None,
)
.await
.unwrap();
let opts = config::options_of(&switched);
assert_eq!(opts.iter().find(|o| o.id == "context_tier").unwrap().current.as_deref(), Some("default"));
{
let calls = server.calls.lock();
let (_, sw_params) = calls.iter().rfind(|(m, _)| m == "session.model.switchTo").unwrap();
assert_eq!(sw_params["modelId"], "gemini-4-carbon");
assert_eq!(sw_params["reasoningEffort"], "high");
assert_eq!(sw_params["contextTier"], "default");
}
// Switching context_tier immediately emits an updated `usage_update` with `size: 200_000`.
assert!(
updates
.0
.lock()
.iter()
.any(|u| u["sessionUpdate"] == "usage_update" && u["size"] == 200_000 && u["used"] == 42_000)
);
}
-583
Переглянути файл
@@ -1,583 +0,0 @@
//! Pure translations between Copilot headless JSON-RPC payloads (`session.event`,
//! permissions, slash commands, MCP servers) and ACP v1.
use crate::LIMITS_UPDATE;
use serde_json::{Map, Value, json};
use std::collections::{HashMap, HashSet};
use std::path::Path;
const MAX_OUTPUT: usize = 64 * 1024;
#[derive(Default)]
pub(super) struct EventTranslator {
/// Assistant message IDs that already streamed deltas, so final `assistant.message` won't duplicate them.
streamed_messages: HashSet<String>,
/// Tool call metadata captured on `tool.execution_start`, keyed by `toolCallId`.
tools: HashMap<String, ToolInfo>,
/// Subagents started in this session (`toolCallId` → subagent session id).
subagents: HashMap<String, String>,
/// Last reported prompt token count, used when updating context size.
pub last_used_tokens: Option<u32>,
}
#[derive(Clone, Debug)]
struct ToolInfo {
kind: &'static str,
title: String,
locations: Vec<Value>,
output: String,
diffs: Vec<Value>,
}
/// An ACP notification `(session_id, update)` produced from a Copilot `session.event`.
pub(super) struct Translated {
pub updates: Vec<(String, Value)>,
pub terminal: Option<TurnTerminal>,
}
#[derive(Debug, Clone, PartialEq)]
pub(super) enum TurnTerminal {
Idle { aborted: bool },
Error { message: String, data: Option<Value> },
}
impl EventTranslator {
pub fn reset_turn(&mut self) {
self.streamed_messages.clear();
}
pub fn translate(&mut self, main_session: &str, event: &Value, fallback_limit: Option<u32>) -> Translated {
let mut out = Translated { updates: Vec::new(), terminal: None };
let event_type = str_of(event, "type").unwrap_or_default();
let data = event.get("data").unwrap_or(&Value::Null);
let agent_id = str_of(event, "agentId").filter(|s| !s.is_empty());
let target_session =
agent_id.map(|id| format!("{main_session}:sub:{id}")).unwrap_or_else(|| main_session.to_owned());
match event_type {
"assistant.reasoning_delta" => {
let delta = str_of(data, "deltaContent").or_else(|| str_of(data, "content")).unwrap_or_default();
if !delta.is_empty() {
out.updates.push((
target_session,
json!({ "sessionUpdate": "agent_thought_chunk", "content": { "type": "text", "text": delta } }),
));
}
}
"assistant.message_delta" => {
if data.get("parentToolCallId").and_then(Value::as_str).is_some() && agent_id.is_none() {
return out;
}
if let Some(mid) = str_of(data, "messageId") {
self.streamed_messages.insert(mid.to_owned());
}
let delta = str_of(data, "deltaContent").unwrap_or_default();
if !delta.is_empty() {
out.updates.push((
target_session,
json!({ "sessionUpdate": "agent_message_chunk", "content": { "type": "text", "text": delta } }),
));
}
}
"assistant.message" => {
if data.get("parentToolCallId").and_then(Value::as_str).is_some() && agent_id.is_none() {
return out;
}
let already = str_of(data, "messageId").is_some_and(|mid| self.streamed_messages.contains(mid));
if !already && let Some(content) = str_of(data, "content").filter(|c| !c.is_empty()) {
out.updates.push((
target_session,
json!({ "sessionUpdate": "agent_message_chunk", "content": { "type": "text", "text": content } }),
));
}
}
"tool.execution_start" => {
let tool_name = str_of(data, "toolName").unwrap_or_default();
if matches!(tool_name, "report_intent" | "tool_search_tool" | "tool_search_tool_regex") {
return out;
}
let Some(call_id) = str_of(data, "toolCallId").filter(|s| !s.is_empty()) else { return out };
let args = data.get("arguments").unwrap_or(&Value::Null);
if tool_name == "task" && agent_id.is_none() {
let sub_id = format!("{main_session}:task:{call_id}");
self.subagents.insert(call_id.to_owned(), sub_id.clone());
let title = str_of(args, "name").or_else(|| str_of(args, "agent_type")).unwrap_or("Subagent");
let desc = str_of(args, "description");
let prompt = str_of(args, "prompt");
out.updates.push((
main_session.to_owned(),
json!({
"sessionUpdate": "subagent_update",
"subagentId": sub_id,
"title": title,
"description": desc,
"prompt": prompt,
"status": "running",
"cancellable": false,
}),
));
return out;
}
let info = describe_tool(tool_name, args);
let mut update = json!({
"sessionUpdate": "tool_call",
"toolCallId": call_id,
"title": info.title,
"kind": info.kind,
"status": "in_progress",
});
if !info.locations.is_empty() {
update["locations"] = Value::Array(info.locations.clone());
}
if !info.diffs.is_empty() {
update["content"] = Value::Array(info.diffs.clone());
}
self.tools.insert(call_id.to_owned(), info);
out.updates.push((target_session, update));
}
"tool.execution_partial_result" | "tool.shell_output" => {
let Some(call_id) = str_of(data, "toolCallId") else { return out };
let chunk = str_of(data, "partialOutput")
.or_else(|| str_of(data, "output"))
.or_else(|| str_of(data, "chunk"))
.unwrap_or_default();
if chunk.is_empty() {
return out;
}
if let Some(info) = self.tools.get_mut(call_id) {
info.output.push_str(chunk);
trim_tail(&mut info.output);
let content = tool_content(&info.output, &info.diffs);
out.updates.push((
target_session,
json!({
"sessionUpdate": "tool_call_update",
"toolCallId": call_id,
"content": content,
}),
));
}
}
"tool.execution_complete" => {
let Some(call_id) = str_of(data, "toolCallId") else { return out };
let success = data.get("success").and_then(Value::as_bool).unwrap_or(true);
let result_text = extract_tool_result_text(data);
if let Some(sub_id) = self.subagents.remove(call_id) {
out.updates.push((
main_session.to_owned(),
json!({
"sessionUpdate": "subagent_update",
"subagentId": sub_id,
"status": if success { "done" } else { "failed" },
"reply": result_text,
"error": (!success).then(|| result_text.clone()).flatten(),
}),
));
return out;
}
let Some(mut info) = self.tools.remove(call_id) else { return out };
if info.output.is_empty()
&& let Some(t) = result_text
&& info.kind != "edit"
{
info.output = t;
trim_tail(&mut info.output);
}
let mut update = json!({
"sessionUpdate": "tool_call_update",
"toolCallId": call_id,
"status": if success { "completed" } else { "failed" },
});
let content = tool_content(&info.output, &info.diffs);
if !content.is_empty() {
update["content"] = Value::Array(content);
}
out.updates.push((target_session, update));
}
"subagent.started" => {
if let Some(call_id) = str_of(data, "toolCallId") {
let sub_id = self
.subagents
.entry(call_id.to_owned())
.or_insert_with(|| format!("{main_session}:task:{call_id}"))
.clone();
let title = str_of(data, "agentDisplayName").or_else(|| str_of(data, "agentName"));
let desc = str_of(data, "agentDescription");
out.updates.push((
main_session.to_owned(),
json!({
"sessionUpdate": "subagent_update",
"subagentId": sub_id,
"title": title,
"description": desc,
"status": "running",
}),
));
}
}
"subagent.failed" => {
if let Some(call_id) = str_of(data, "toolCallId")
&& let Some(sub_id) = self.subagents.get(call_id).cloned()
{
out.updates.push((
main_session.to_owned(),
json!({
"sessionUpdate": "subagent_update",
"subagentId": sub_id,
"status": "failed",
"error": str_of(data, "error").or_else(|| str_of(data, "message")),
}),
));
}
}
"session.title_changed" => {
if let Some(title) = str_of(data, "title").map(str::trim).filter(|t| !t.is_empty()) {
out.updates.push((
main_session.to_owned(),
json!({ "sessionUpdate": "session_info_update", "title": title }),
));
}
}
"session.usage_info" => {
let used = data.get("currentTokens").and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok());
let limit = data
.get("tokenLimit")
.and_then(Value::as_u64)
.and_then(|n| u32::try_from(n).ok())
.filter(|&n| n > 0)
.or(fallback_limit);
if let (Some(used), Some(size)) = (used, limit) {
self.last_used_tokens = Some(used);
out.updates.push((
main_session.to_owned(),
json!({ "sessionUpdate": "usage_update", "used": used, "size": size }),
));
}
}
"assistant.usage" => {
if agent_id.is_none() {
let used = data.get("inputTokens").and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok());
if let (Some(used), Some(size)) = (used, fallback_limit.filter(|&s| s > 0)) {
self.last_used_tokens = Some(used);
out.updates.push((
main_session.to_owned(),
json!({ "sessionUpdate": "usage_update", "used": used, "size": size }),
));
}
}
if let Some(limits) = quota_limits(data.get("quotaSnapshots")) {
out.updates.push((main_session.to_owned(), limits));
}
}
"session.idle" if agent_id.is_none() => {
let mode = str_of(data, "mode").unwrap_or_default();
if mode != "autopilot" {
let aborted = data.get("aborted").and_then(Value::as_bool).unwrap_or(false);
out.terminal = Some(TurnTerminal::Idle { aborted });
}
}
"session.autopilot_stopped" if agent_id.is_none() => {
let reason = str_of(data, "reason").unwrap_or_default();
if reason == "error" {
out.terminal = Some(TurnTerminal::Error { message: "Autopilot request failed".into(), data: None });
} else {
out.terminal = Some(TurnTerminal::Idle { aborted: reason == "aborted" });
}
}
"session.error" if agent_id.is_none() => {
let message = str_of(data, "message").unwrap_or("Copilot reported an error.").to_owned();
out.terminal = Some(TurnTerminal::Error { message, data: Some(data.clone()) });
}
_ => {}
}
out
}
}
fn describe_tool(name: &str, args: &Value) -> ToolInfo {
let mut locations = Vec::new();
let mut diffs = Vec::new();
if let Some(p) = str_of(args, "path").or_else(|| str_of(args, "filePath")).filter(|p| !p.is_empty()) {
locations.push(json!({ "path": p }));
}
let (kind, title) = match name {
"bash" | "powershell" | "shell" => {
let cmd = str_of(args, "command").or_else(|| str_of(args, "description")).unwrap_or("Run command");
("execute", cmd.to_owned())
}
"view" | "read_file" => {
let label = str_of(args, "path")
.and_then(|p| Path::new(p).file_name().and_then(|n| n.to_str()))
.unwrap_or("Read file");
("read", format!("Read {label}"))
}
"grep" | "glob" | "semantic_search" => {
let pat = str_of(args, "pattern").or_else(|| str_of(args, "query")).unwrap_or(name);
("search", format!("Search {pat}"))
}
"edit" => {
let path = str_of(args, "path").unwrap_or_default();
let old = str_of(args, "old_str").unwrap_or_default();
let new = str_of(args, "new_str").unwrap_or_default();
if !path.is_empty() {
diffs.push(json!({ "type": "diff", "path": path, "oldText": old, "newText": new }));
}
let label = Path::new(path).file_name().and_then(|n| n.to_str()).unwrap_or("file");
("edit", format!("Edit {label}"))
}
"create" => {
let path = str_of(args, "path").unwrap_or_default();
let new = str_of(args, "file_text").unwrap_or_default();
if !path.is_empty() {
diffs.push(json!({ "type": "diff", "path": path, "oldText": "", "newText": new }));
}
let label = Path::new(path).file_name().and_then(|n| n.to_str()).unwrap_or("file");
("edit", format!("Create {label}"))
}
"web_fetch" => {
let url = str_of(args, "url").unwrap_or("URL");
("fetch", format!("Fetch {url}"))
}
_ => ("other", str_of(args, "description").unwrap_or(name).to_owned()),
};
ToolInfo { kind, title, locations, output: String::new(), diffs }
}
fn extract_tool_result_text(data: &Value) -> Option<String> {
if let Some(err) = data.pointer("/error/message").and_then(Value::as_str).filter(|s| !s.is_empty()) {
return Some(err.to_owned());
}
let result = data.get("result")?;
if let Some(s) = result.as_str() {
return (!s.is_empty()).then(|| s.to_owned());
}
str_of(result, "content")
.or_else(|| str_of(result, "detailedContent"))
.or_else(|| str_of(result, "textResultForLlm"))
.filter(|s| !s.is_empty())
.map(str::to_owned)
}
fn tool_content(output: &str, diffs: &[Value]) -> Vec<Value> {
let mut out = diffs.to_vec();
if !output.is_empty() {
out.push(json!({ "type": "content", "content": { "type": "text", "text": output } }));
}
out
}
fn quota_limits(snapshots: Option<&Value>) -> Option<Value> {
let map = snapshots?.as_object()?;
let mut limits = Vec::new();
for (window, snap) in map {
let used_pct = snap
.get("percentageUsed")
.and_then(Value::as_f64)
.or_else(|| snap.get("remainingPercentage").and_then(Value::as_f64).map(|rem| 100.0 - rem));
let Some(used_pct) = used_pct.filter(|p| p.is_finite()) else { continue };
let resets_ms = snap.get("resetsAt").and_then(Value::as_f64);
let mut entry = json!({
"window": window,
"usedPercent": used_pct.clamp(0.0, 100.0),
});
if let Some(ms) = resets_ms {
entry["resetsMs"] = json!(ms);
}
limits.push(entry);
}
(!limits.is_empty()).then(|| json!({ "sessionUpdate": LIMITS_UPDATE, "limits": limits }))
}
/// Builds an ACP `session/request_permission` payload from Copilot's `permission.requested` data.
pub(super) fn permission_request(session_id: &str, perm: &Value) -> Value {
let kind = str_of(perm, "kind").unwrap_or("other");
let tool_call_id = str_of(perm, "toolCallId").unwrap_or("permission");
let (acp_kind, title, raw_input) = match kind {
"shell" => {
let cmd = str_of(perm, "fullCommandText").or_else(|| str_of(perm, "command")).unwrap_or_default();
let title = str_of(perm, "intention")
.filter(|s| !s.is_empty())
.map(str::to_owned)
.unwrap_or_else(|| if cmd.is_empty() { "Run shell command".into() } else { format!("Run {cmd}") });
("execute", title, json!({ "command": cmd }))
}
"write" => {
let path = str_of(perm, "fileName").or_else(|| str_of(perm, "path")).unwrap_or("file");
("edit", format!("Edit {path}"), json!({ "path": path }))
}
"read" => {
let path = str_of(perm, "path").unwrap_or("file");
("read", format!("Read {path}"), json!({ "path": path }))
}
"url" => {
let url = str_of(perm, "url").unwrap_or("URL");
("fetch", format!("Allow network access to {url}"), json!({ "url": url }))
}
"mcp" => {
let server = str_of(perm, "serverName").unwrap_or("MCP");
let tool = str_of(perm, "toolName").unwrap_or("tool");
("other", format!("Run {server}: {tool}"), perm.clone())
}
_ => {
let t = str_of(perm, "intention").or_else(|| str_of(perm, "message")).unwrap_or("Allow action");
("other", t.to_owned(), perm.clone())
}
};
json!({
"sessionId": session_id,
"toolCall": {
"toolCallId": tool_call_id,
"kind": acp_kind,
"title": title,
"rawInput": raw_input,
},
"options": [
{ "optionId": "approve-once", "name": "Allow once", "kind": "allow_once" },
{ "optionId": "approved", "name": "Always allow", "kind": "allow_always" },
{ "optionId": "denied", "name": "Reject", "kind": "reject_once" },
],
})
}
/// Builds an ACP `session/request_permission` question card for Copilot's `userInput.request`.
pub(super) fn user_input_permission_request(session_id: &str, req: &Value) -> Value {
let question = str_of(req, "question").unwrap_or("Provide input");
let choices: Vec<Value> = req
.get("choices")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|c| c.as_str().map(|label| json!({ "label": label, "description": "" })))
.collect();
json!({
"sessionId": session_id,
"toolCall": {
"toolCallId": str_of(req, "toolCallId").unwrap_or("ask_user"),
"kind": "other",
"title": question,
"_meta": {
"questions": [{
"header": "Question",
"question": question,
"multiSelect": false,
"options": choices,
}]
}
},
"options": [
{ "optionId": "submit", "name": "Submit", "kind": "allow_once" },
{ "optionId": "cancel", "name": "Cancel", "kind": "reject_once" },
],
})
}
/// Converts ACP `mcpServers` array into Copilot's `mcpServers` object map.
pub(super) fn wire_mcp_servers(acp_servers: Option<&Value>) -> Option<Value> {
let list = acp_servers?.as_array()?;
let mut out = Map::new();
for item in list {
let Some(name) = str_of(item, "name").filter(|n| !n.is_empty()) else { continue };
let transport = str_of(item, "type").unwrap_or("stdio");
match transport {
"http" | "sse" => {
let Some(url) = str_of(item, "url").filter(|u| !u.is_empty()) else { continue };
let mut headers = Map::new();
for kv in item.get("headers").and_then(Value::as_array).into_iter().flatten() {
if let (Some(k), Some(v)) = (str_of(kv, "name"), str_of(kv, "value")) {
headers.insert(k.to_owned(), json!(v));
}
}
out.insert(
name.to_owned(),
json!({
"type": transport,
"url": url,
"headers": headers,
"tools": ["*"],
}),
);
}
_ => {
let Some(cmd) = str_of(item, "command").filter(|c| !c.is_empty()) else { continue };
let args: Vec<Value> = item.get("args").and_then(Value::as_array).cloned().unwrap_or_default();
let mut env = Map::new();
for kv in item.get("env").and_then(Value::as_array).into_iter().flatten() {
if let (Some(k), Some(v)) = (str_of(kv, "name"), str_of(kv, "value")) {
env.insert(k.to_owned(), json!(v));
}
}
out.insert(
name.to_owned(),
json!({
"type": "local",
"command": cmd,
"args": args,
"env": env,
"tools": ["*"],
}),
);
}
}
}
(!out.is_empty()).then_some(Value::Object(out))
}
/// Converts `commands.list` + `skills.discover` results into ACP `availableCommands`.
pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Option<&Value>) -> Vec<Value> {
let mut seen = HashSet::new();
let mut out = Vec::new();
for cmd in commands_res.and_then(|v| v.get("commands")).and_then(Value::as_array).into_iter().flatten() {
let Some(name) = str_of(cmd, "name").map(|n| n.trim_start_matches('/')).filter(|n| !n.is_empty()) else {
continue;
};
if !seen.insert(name.to_owned()) {
continue;
}
let hint = cmd.pointer("/input/hint").and_then(Value::as_str).filter(|h| !h.is_empty());
out.push(json!({
"name": name,
"description": str_of(cmd, "description").unwrap_or_default(),
"source": "command",
"input": hint.map(|h| json!({ "hint": h })),
}));
}
for skill in skills_res.and_then(|v| v.get("skills")).and_then(Value::as_array).into_iter().flatten() {
if skill.get("enabled").and_then(Value::as_bool) == Some(false)
|| skill.get("userInvocable").and_then(Value::as_bool) == Some(false)
{
continue;
}
let Some(name) = str_of(skill, "commandName")
.or_else(|| str_of(skill, "name"))
.map(|n| n.trim_start_matches('/'))
.filter(|n| !n.is_empty())
else {
continue;
};
if !seen.insert(name.to_owned()) {
continue;
}
let hint = str_of(skill, "argumentHint").filter(|h| !h.is_empty());
out.push(json!({
"name": name,
"description": str_of(skill, "description").unwrap_or_default(),
"source": "skill",
"input": hint.map(|h| json!({ "hint": h })),
}));
}
out
}
fn trim_tail(text: &mut String) {
if text.len() > MAX_OUTPUT {
let mut cut = text.len() - MAX_OUTPUT;
while !text.is_char_boundary(cut) {
cut += 1;
}
text.replace_range(..cut, "");
}
}
fn str_of<'a>(v: &'a Value, key: &str) -> Option<&'a str> {
v.get(key).and_then(Value::as_str)
}
-1
Переглянути файл
@@ -13,7 +13,6 @@
pub(crate) mod claude;
pub(crate) mod codex;
pub(crate) mod copilot;
use ide_jsonrpc::{Framing, Handler, Peer};
use std::path::{Path, PathBuf};
+4 -34
Переглянути файл
@@ -20,8 +20,6 @@ pub(crate) enum Driver {
Codex,
/// `claude` in stream-json mode.
Claude,
/// `copilot --headless --no-auto-update --stdio`.
Copilot,
}
#[derive(Clone, Debug, PartialEq)]
@@ -56,21 +54,8 @@ const BUILTIN: &[(&str, &str, Driver, &[&str], &str)] = &[
&["npx", "-y", "@agentclientprotocol/[email protected]"],
"Run `codex login` in a terminal.",
),
(
"deepseek-harness",
"DeepSeek Harness",
Driver::Acp,
&["dsh", "--profile", "acp"],
"Run `dsh` in a terminal and sign in.",
),
("gemini", "Gemini CLI", Driver::Acp, &["gemini", "--experimental-acp"], "Run `gemini` in a terminal and sign in."),
(
"copilot",
"GitHub Copilot",
Driver::Copilot,
&["copilot", "--headless", "--no-auto-update", "--stdio"],
"Run `copilot` in a terminal and sign in.",
),
("copilot", "GitHub Copilot", Driver::Acp, &["copilot", "--acp"], "Run `copilot` in a terminal and sign in."),
("cursor", "Cursor", Driver::Acp, &["cursor-agent", "acp"], "Run `cursor-agent login` in a terminal."),
("opencode", "OpenCode", Driver::Acp, &["opencode", "acp"], "Run `opencode auth login` in a terminal."),
("qwen", "Qwen Code", Driver::Acp, &["qwen", "--experimental-acp"], "Run `qwen` in a terminal and sign in."),
@@ -257,13 +242,10 @@ fn render_login_command<'a>(program: &Path, args: impl IntoIterator<Item = &'a s
}
/// Whether `id` names a built-in agent that needs no registry install (native drivers
/// other than `copilot`, and `npx -y` adapters). CLI built-ins (`copilot`, `gemini`, …)
/// can be installed and updated from the ACP Registry into `<config>/agents/<id>.toml`.
/// and `npx -y` adapters). CLI built-ins (`copilot`, `gemini`, …) can be installed and
/// updated from the ACP Registry into `<config>/agents/<id>.toml`.
pub(crate) fn is_builtin(id: &str) -> bool {
id != "copilot"
&& BUILTIN
.iter()
.any(|&(bid, _, driver, cmd, _)| bid == id && (driver != Driver::Acp || cmd.first() == Some(&"npx")))
BUILTIN.iter().any(|&(bid, _, driver, cmd, _)| bid == id && (driver != Driver::Acp || cmd.first() == Some(&"npx")))
}
/// Display name of a built-in agent, when `id` is one.
@@ -636,10 +618,6 @@ pub(crate) fn load(custom_dir: Option<&Path>, secrets: Option<&dyn EnvSecrets>)
files.sort();
for path in files {
let Some(id) = path.file_stem().and_then(|s| s.to_str()).map(str::to_owned) else { continue };
let explicit_driver = std::fs::read_to_string(&path)
.ok()
.and_then(|t| toml::from_str::<toml::Table>(&t).ok())
.is_some_and(|t| t.contains_key("driver"));
let agent = match CustomAgent::read_with(&path, &id, secrets) {
Ok(a) => a,
Err(e) => {
@@ -665,14 +643,6 @@ pub(crate) fn load(custom_dir: Option<&Path>, secrets: Option<&dyn EnvSecrets>)
match specs.iter_mut().find(|s| s.id == spec.id) {
Some(existing) => {
spec.login_hint = existing.login_hint.clone();
if !explicit_driver && existing.driver == Driver::Copilot && spec.driver == Driver::Acp {
// Registry installs (`github-copilot-cli`) record `args = ["--acp"]` with no
// `driver`; upgrade them in place to the native headless driver (which
// automatically falls back to `--acp`) while keeping the installed executable
// path and registry version tracking. Explicit `driver = "acp"` stays ACP.
spec.driver = Driver::Copilot;
spec.args = crate::native::copilot::headless_args(&spec.args);
}
if spec.source == AgentSource::Custom {
spec.source = AgentSource::Builtin;
}
-1
Переглянути файл
@@ -64,7 +64,6 @@ async fn create(mgr: &AgentManager, provider: &str, prompt: &str) -> String {
config: config(provider),
isolation: Isolation::Local,
base: None,
..Default::default()
};
mgr.create(req).await.unwrap().id
}
File diff suppressed because it is too large. Load diff
+6 -22
Переглянути файл
@@ -47,20 +47,13 @@ pub fn plan(root: &Path, model: &BuildModel, module: &Path, cache: &Path) -> Ide
fs::write(
&script,
format!(
r#"import org.gradle.util.GradleVersion
gradle.projectsEvaluated {{
r#"gradle.projectsEvaluated {{
def p = gradle.rootProject.project({})
def update = {{ t ->
t.dependsOn 'processResources'
// Resolved here so the action holds no task or project (configuration cache).
def dir = p.tasks.getByName('processResources').destinationDir
def manifest = new File({})
t.doLast {{ manifest.setText(dir.absolutePath, 'UTF-8') }}
def resources = p.tasks.named('processResources')
p.tasks.register('openideaUpdateResources') {{
dependsOn resources
doLast {{ new File({}).setText(resources.get().destinationDir.absolutePath, 'UTF-8') }}
}}
// `register` is Gradle 4.9+.
if (GradleVersion.current() >= GradleVersion.version('4.9')) p.tasks.register('openideaUpdateResources', update)
else p.tasks.create('openideaUpdateResources', update)
}}
"#,
literal(&p.path),
@@ -179,16 +172,7 @@ mod tests {
assert_eq!(gradle.command, "/tools/gradlew");
assert_eq!(gradle.args.last().unwrap(), ":app:openideaUpdateResources");
let script = fs::read_to_string(cache.join("resources.init.gradle")).unwrap();
assert!(
script.contains("processResources")
&& script.contains(".destinationDir\n")
&& script.contains("setText(dir.absolutePath")
);
// `register` is Gradle 4.9+ (#3864).
assert!(script.contains("else p.tasks.create('openideaUpdateResources', update)"), "{script}");
// The configuration cache can't serialize a task or project the action refers to.
let action = &script[script.find("doLast").unwrap()..script.find("// `register`").unwrap()];
assert!(!action.contains("p.") && !action.contains("tasks"), "{action}");
assert!(script.contains("processResources") && script.contains("destinationDir.absolutePath"));
assert!(!script.contains("build/resources/main")); // The task owns custom output locations.
}
+1 -1
Переглянути файл
@@ -548,7 +548,7 @@ impl PathMap {
}
/// Removes `.` and resolvable `..` components without touching the file system.
pub(crate) fn normalize(p: &Path) -> PathBuf {
fn normalize(p: &Path) -> PathBuf {
use std::path::Component;
let mut out = PathBuf::new();
for c in p.components() {
+24 -218
Переглянути файл
@@ -40,18 +40,6 @@ pub fn structure_outputs(root: &Path, ps: &ProjectStructureSettings) -> (PathBuf
(main, test)
}
/// Whether Rebuild may delete the output folder `dir`: never the project folder or one above
/// it, nor a folder that holds or lies inside a source, test or resource root.
fn deletable_output(dir: &Path, root: &Path, roots: &StructureRoots) -> bool {
let dir = normalize(dir);
let overlaps = |r: &PathBuf| {
let r = normalize(r);
r.starts_with(&dir) || dir.starts_with(&r)
};
!normalize(root).starts_with(&dir)
&& !roots.sources.iter().chain(&roots.tests).chain(&roots.resources).chain(&roots.test_resources).any(overlaps)
}
fn module_name(root: &Path) -> String {
root.file_name().map_or_else(|| "project".to_owned(), |n| n.to_string_lossy().into_owned())
}
@@ -219,11 +207,7 @@ pub fn structure_plan(
let mut steps = Vec::new();
if kind == BuildKind::Rebuild {
let dirs: Vec<PathBuf> =
[&main_out, &test_out].into_iter().filter(|d| deletable_output(d, root, roots)).cloned().collect();
if !dirs.is_empty() {
steps.push(BuildStep::action(Action::Clean(dirs), root));
}
steps.push(BuildStep::action(Action::Clean(vec![main_out.clone(), test_out.clone()]), root));
}
let main_cp = library_entries(root, ps, false);
let compile = |name: &str, sources: &[PathBuf], out: &Path, cp: &[String]| -> IdeResult<BuildStep> {
@@ -326,8 +310,6 @@ fn artifact_steps(
.find(|f| f.module == artifact.module || f.module.is_empty() && artifact.module == ".")
.or_else(|| ps.facets.iter().find(|f| f.kind == "web"));
let staging = cache.join("artifacts").join(file_name(&artifact.name));
// What the last build laid out in a folder the user chose, so the next one replaces only that.
let record = cache.join("artifacts").join(format!("{}.files", file_name(&artifact.name)));
let mut steps = Vec::new();
match (artifact.kind, war) {
(ArtifactKind::Jar, None) => {
@@ -342,11 +324,7 @@ fn artifact_steps(
manifest.push_str(&format!("Class-Path: {}\r\n", names.join(" ")));
}
steps.push(BuildStep::action(
Action::Layout {
into: staging.clone(),
entries: vec![(classes.to_path_buf(), PathBuf::new())],
record: None,
},
Action::Layout { into: staging.clone(), entries: vec![(classes.to_path_buf(), PathBuf::new())] },
root,
));
// The jar's Class-Path names the libraries next to it.
@@ -354,7 +332,6 @@ fn artifact_steps(
Action::Layout {
into: out.clone(),
entries: libraries.iter().map(|l| (l.clone(), file_of(l))).collect(),
record: Some(record),
},
root,
));
@@ -376,9 +353,7 @@ fn artifact_steps(
for lib in &libraries {
entries.push((lib.clone(), Path::new("WEB-INF/lib").join(file_of(lib))));
}
// The exploded output may be a folder the user chose; the staging folder is the IDE's own.
let record = (exploded != staging).then_some(record);
steps.push(BuildStep::action(Action::Layout { into: exploded.clone(), entries, record }, root));
steps.push(BuildStep::action(Action::Layout { into: exploded.clone(), entries }, root));
let archive = war
.map(Path::to_path_buf)
.or_else(|| (kind != ArtifactKind::WarExploded).then(|| artifact_file(root, artifact)));
@@ -432,17 +407,15 @@ pub(crate) enum Action {
/// relative paths; files that are already up to date are left alone.
CopyResources { from: Vec<PathBuf>, to: PathBuf },
/// Lays out an artifact in `into`: each folder's content or file goes to its relative
/// place (`""` = the top). What is no longer laid out is removed: without `record`, `into`
/// is the IDE's own folder and is laid out afresh; with it, `into` is a folder the user chose
/// and only the files the previous layout recorded there are removed, never anything else.
Layout { into: PathBuf, entries: Vec<(PathBuf, PathBuf)>, record: Option<PathBuf> },
/// place (`""` = the top). What is no longer laid out is removed.
Layout { into: PathBuf, entries: Vec<(PathBuf, PathBuf)> },
/// Zips the folder `from` into the archive `to`, with this manifest first.
Archive { from: PathBuf, to: PathBuf, manifest: Option<String> },
}
impl Action {
pub(crate) fn display(&self, root: &Path) -> String {
let rel = |p: &Path| p.strip_prefix(root).unwrap_or(p).to_string_lossy().replace('\\', "/");
let rel = |p: &Path| p.strip_prefix(root).unwrap_or(p).to_string_lossy().into_owned();
match self {
Action::Clean(dirs) => format!("Clean {}", dirs.iter().map(|d| rel(d)).collect::<Vec<_>>().join(", ")),
Action::CopyResources { to, .. } => format!("Copy resources to {}", rel(to)),
@@ -468,39 +441,29 @@ impl Action {
}
Ok(format!("{copied} resource file(s) copied"))
}
Action::Layout { into, entries, record } => {
Action::Layout { into, entries } => {
// A fresh layout: files dropped from the sources must not linger in the artifact.
if entries.iter().any(|(from, _)| from.starts_with(into)) {
return Err(IdeError::invalid(format!(
"The artifact output folder {} holds files the artifact is made of",
into.display()
)));
}
if record.is_none() && into.exists() {
if into.exists() {
fs::remove_dir_all(into)
.map_err(|e| IdeError::internal(format!("cannot delete {} ({e})", into.display())))?;
}
let mut written = Vec::new();
let mut copied = 0;
for (from, to) in entries {
let target = into.join(to);
// The folders of the output it goes into (and a folder entry's own) are
// never links; a file in a link's place replaces the link.
let mut at = into.to_path_buf();
let folders = to.components().count().saturating_sub(usize::from(!from.is_dir()));
for c in to.components().take(folders) {
at.push(c);
refuse_link(&at)?;
}
if from.is_dir() {
copy_tree(from, &target, &mut written, cancel)?;
copied += copy_tree(from, &target, cancel)?;
} else if from.is_file() {
copy_file(from, &target)?;
written.push(target);
copied += 1;
}
}
if let Some(record) = record {
replace_recorded(into, record, &written)?;
}
Ok(format!("{} file(s) laid out", written.len()))
Ok(format!("{copied} file(s) laid out"))
}
Action::Archive { from, to, manifest } => {
archive(from, to, manifest.as_deref(), cancel)?;
@@ -511,10 +474,6 @@ impl Action {
}
fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
// A link in the artifact's place is replaced, not written through.
if fs::symlink_metadata(to).is_ok_and(|m| m.file_type().is_symlink()) {
fs::remove_file(to).map_err(|e| IdeError::internal(format!("cannot replace {} ({e})", to.display())))?;
}
if let Some(parent) = to.parent() {
fs::create_dir_all(parent)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
@@ -523,80 +482,23 @@ fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
Ok(())
}
fn refuse_link(folder: &Path) -> IdeResult<()> {
if fs::symlink_metadata(folder).is_ok_and(|m| m.file_type().is_symlink()) {
return Err(IdeError::invalid(format!(
"{} links to another folder; the artifact is not laid out through it",
folder.display()
)));
}
Ok(())
}
fn copy_tree(from: &Path, to: &Path, written: &mut Vec<PathBuf>, cancel: &CancellationToken) -> IdeResult<()> {
fn copy_tree(from: &Path, to: &Path, cancel: &CancellationToken) -> IdeResult<usize> {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Ok(entries) = fs::read_dir(from) else { return Ok(()) };
let Ok(entries) = fs::read_dir(from) else { return Ok(0) };
let mut copied = 0;
for e in entries.flatten() {
let Ok(t) = e.file_type() else { continue };
let target = to.join(e.file_name());
if t.is_dir() {
refuse_link(&target)?;
copy_tree(&e.path(), &target, written, cancel)?;
copied += copy_tree(&e.path(), &target, cancel)?;
} else if t.is_file() {
copy_file(&e.path(), &target)?;
written.push(target);
copied += 1;
}
}
Ok(())
}
/// Removes the files the previous layout recorded in `into` that this one didn't write
/// (and the folders that leaves empty), then records `written` for the next layout.
fn replace_recorded(into: &Path, record: &Path, written: &[PathBuf]) -> IdeResult<()> {
let now: std::collections::HashSet<PathBuf> =
written.iter().filter_map(|p| p.strip_prefix(into).ok().map(Path::to_path_buf)).collect();
let before = fs::read_to_string(record).unwrap_or_default();
let mut lines = before.lines();
// The record names its folder first: one made for another output folder removes nothing.
let same = lines.next().is_some_and(|dir| Path::new(dir) == into);
for rel in lines.filter(|_| same).map(PathBuf::from) {
// Only plain relative paths inside `into`: a damaged record must not reach elsewhere.
if rel.as_os_str().is_empty()
|| now.contains(&rel)
|| rel.components().any(|c| !matches!(c, std::path::Component::Normal(_)))
{
continue;
}
let file = into.join(&rel);
// Never through a link: a folder of the output that now links elsewhere (or a file that
// is a link) leads out of what the layout wrote.
let mut at = into.to_path_buf();
let linked = rel.components().any(|c| {
at.push(c);
fs::symlink_metadata(&at).is_ok_and(|m| m.file_type().is_symlink())
});
if !linked && file.is_file() {
let _ = fs::remove_file(&file);
let mut dir = file.parent();
while let Some(d) = dir.filter(|d| *d != into && d.starts_with(into)) {
if fs::remove_dir(d).is_err() {
break;
}
dir = d.parent();
}
}
}
let mut list: Vec<String> = now.iter().map(|p| p.to_string_lossy().into_owned()).collect();
list.sort();
list.insert(0, into.to_string_lossy().into_owned());
if let Some(parent) = record.parent() {
fs::create_dir_all(parent)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
}
fs::write(record, list.join("\n"))
.map_err(|e| IdeError::internal(format!("cannot write {} ({e})", record.display())))
Ok(copied)
}
fn archive(from: &Path, to: &Path, manifest: Option<&str>, cancel: &CancellationToken) -> IdeResult<()> {
@@ -744,15 +646,15 @@ mod tests {
let main_cp = cp(javac);
let entries: Vec<&str> = main_cp.split(sep).collect();
assert_eq!(entries.len(), 2, "{main_cp}");
assert!(Path::new(entries[0]).ends_with("lib/*"));
assert!(Path::new(entries[1]).ends_with("WEB-INF/lib/*"));
assert!(entries[0].ends_with("lib/*"));
assert!(entries[1].ends_with("WEB-INF/lib/*"));
assert!(javac.args.windows(2).any(|w| w == ["--release", "17"]));
let args = fs::read_to_string(tmp.path().join("cache/javac/production.args")).unwrap();
assert!(args.contains("A.java") && !args.contains("ATest.java"));
assert_eq!(shown[2], "Copy resources to out/production/shop");
let test = &plan.steps[3];
let test_cp = cp(test);
assert_eq!(Path::new(test_cp.split(sep).next().unwrap()), root.join("out/production/shop"));
assert!(test_cp.starts_with(&root.join("out/production/shop").to_string_lossy().into_owned()));
assert!(test_cp.contains("junit.jar"));
}
@@ -791,40 +693,7 @@ mod tests {
let javac = &plan.steps[0];
assert!(!javac.args.iter().any(|a| a == "-cp"), "{:?}", javac.args);
assert!(javac.args.windows(4).any(|w| w == ["-source", "1.8", "-target", "1.8"]));
assert!(
javac.args.windows(2).any(|w| w[0] == "-d" && Path::new(&w[1]).ends_with("build/classes/production/p"))
);
}
#[test]
fn rebuild_never_cleans_an_output_folder_over_the_project_or_its_sources() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("p");
write(&root.join("src/A.java"), "class A {}");
let roots = StructureRoots { sources: vec![root.join("src")], ..Default::default() };
for (main, test) in [(".", "bin"), ("src", "src/../test-out"), ("src/classes", ".."), ("", "")] {
let mut ps = ProjectStructureSettings::default();
ps.modules.insert(
".".into(),
ModuleStructureSettings {
compiler_output: main.into(),
test_compiler_output: test.into(),
..Default::default()
},
);
let plan = structure_plan(&root, &ps, &roots, None, "17", BuildKind::Rebuild, &tmp.path().join("c"))
.unwrap()
.unwrap();
let clean: Vec<String> =
plan.steps.iter().map(BuildStep::display).filter(|s| s.starts_with("Clean")).collect();
let expected: &[&str] = match main {
"." => &["Clean bin"],
"src" => &["Clean src/../test-out"],
"src/classes" => &[],
_ => &["Clean out/production/p, out/test/p"],
};
assert_eq!(clean, expected, "{main} / {test}");
}
assert!(javac.args.windows(2).any(|w| w[0] == "-d" && w[1].ends_with("build/classes/production/p")));
}
#[test]
@@ -941,71 +810,8 @@ mod tests {
let tmp = tempfile::tempdir().unwrap();
let web = tmp.path().join("WebRoot");
write(&web.join("a.jsp"), "");
let action = Action::Layout {
into: tmp.path().to_path_buf(),
entries: vec![(web.clone(), PathBuf::new())],
record: None,
};
let action = Action::Layout { into: tmp.path().to_path_buf(), entries: vec![(web.clone(), PathBuf::new())] };
assert!(action.run(&CancellationToken::new()).is_err());
assert!(web.join("a.jsp").is_file());
}
#[test]
fn a_chosen_output_folder_keeps_what_the_artifact_did_not_put_there() {
let tmp = tempfile::tempdir().unwrap();
let project = tmp.path().join("project");
write(&project.join("src/A.java"), "class A {}");
write(&project.join(".git/HEAD"), "ref: refs/heads/main");
let libs = tmp.path().join("libs");
write(&libs.join("a.jar"), "a");
write(&libs.join("b.jar"), "b");
let record = tmp.path().join("cache/artifacts/app.files");
let layout = |names: &[&str]| Action::Layout {
into: project.clone(),
entries: names.iter().map(|n| (libs.join(n), PathBuf::from(n))).collect(),
record: Some(record.clone()),
};
layout(&["a.jar", "b.jar"]).run(&CancellationToken::new()).unwrap();
assert!(project.join("a.jar").is_file() && project.join("b.jar").is_file());
// A library dropped from the artifact goes; the project's own files stay.
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
assert!(project.join("a.jar").is_file() && !project.join("b.jar").exists());
assert!(project.join("src/A.java").is_file() && project.join(".git/HEAD").is_file());
// A damaged record never reaches outside the folder.
write(&record, &format!("{}\n../outside.txt", project.display()));
write(&tmp.path().join("outside.txt"), "x");
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
assert!(tmp.path().join("outside.txt").is_file());
// Nor through a folder of the output that now links elsewhere.
#[cfg(unix)]
{
write(&project.join("assets/x.txt"), "laid out");
write(&record, &format!("{}\nassets/x.txt", project.display()));
fs::remove_dir_all(project.join("assets")).unwrap();
std::os::unix::fs::symlink(project.join("src"), project.join("assets")).unwrap();
write(&project.join("src/x.txt"), "source");
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
assert!(project.join("src/x.txt").is_file());
}
// An entry's own folder that links elsewhere stops the layout instead of copying through it.
#[cfg(unix)]
{
fs::remove_file(project.join("assets")).unwrap();
std::os::unix::fs::symlink(project.join("src"), project.join("classes")).unwrap();
write(&tmp.path().join("out/A.class"), "compiled");
let into_link = Action::Layout {
into: project.clone(),
entries: vec![(tmp.path().join("out"), PathBuf::from("classes"))],
record: Some(record.clone()),
};
assert!(into_link.run(&CancellationToken::new()).is_err());
assert!(!project.join("src/A.class").exists());
fs::remove_file(project.join("classes")).unwrap();
}
// Nor does one made for another output folder.
write(&project.join("c.jar"), "mine");
write(&record, "/elsewhere\nc.jar");
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
assert!(project.join("c.jar").is_file());
}
}
+3 -7
Переглянути файл
@@ -30,8 +30,7 @@ def processedResources = { Project p, s ->
def describe = { Project p ->
def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
if (p.gradle.parent != null) m.build = identity(p.rootProject)
// Gradle 4.x has it as a convention property, not an extension.
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
def sets = p.extensions.findByName('sourceSets')
if (sets != null) {
// Test source sets as IDEA classifies them: `test`, test fixtures, JVM test suites,
// and sets whose folders the `idea` plugin lists as test sources.
@@ -52,12 +51,9 @@ def describe = { Project p ->
}
}
try {
// `java` is Gradle 4.10+ (a convention before), its toolchain 6.7+.
def java = p.extensions.findByName('java')
def lv = null
try { lv = java?.toolchain?.languageVersion?.getOrNull() } catch (ignored) {}
def target = java != null ? java.targetCompatibility : p.findProperty('targetCompatibility')
m.java = lv != null ? lv.asInt() : (target?.majorVersion as Integer)
def lv = java?.toolchain?.languageVersion?.getOrNull()
m.java = lv != null ? lv.asInt() : (java?.targetCompatibility?.majorVersion as Integer)
} catch (ignored) {}
println '@openidea-model\t' + JsonOutput.toJson(m)
}
+1 -1
Переглянути файл
@@ -1463,7 +1463,7 @@ dependencies {
model.projects.push(project);
}
assert!(build_files(root, &model).contains(&root.join("included/deps.gradle")));
let model = crate::BuildModel { maven: None, gradle: vec![model], sbt: Vec::new() };
let model = crate::BuildModel { maven: None, gradle: vec![model] };
assert_eq!(crate::dependency_coordinates(root, &model)[0].artifact_id, "included");
}
+1 -83
Переглянути файл
@@ -1,16 +1,13 @@
//! A Gradle project's resolved dependencies for the Dependency Analyzer:
//! `gradle <project>:dependencies --configuration <name>`, parsed from its tree report.
//! The reports it read are kept per build ([`save_gradle_report`]) until a build file
//! changes, for readers that must not run Gradle themselves (plugins).
use crate::gradle;
use crate::process;
use crate::sync::{self, SyncOptions, error_summary};
use crate::sync::{SyncOptions, error_summary};
use ide_core::{CancellationToken, IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
use std::sync::Mutex;
/// One line of the report: an occurrence of a dependency where it is requested.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
@@ -161,54 +158,6 @@ pub fn gradle_dependencies(
Ok(parse_report(&out.text))
}
/// A `dependencies` report of one project of a build for one configuration.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct GradleReport {
/// Gradle path of the project (`:`, `:app`).
pub project: String,
pub configuration: String,
pub dependencies: Vec<GradleDependency>,
}
#[derive(Default, Serialize, Deserialize)]
struct ReportCache {
/// The build files the reports were read with ([`sync::hash_gradle_files`]).
hash: String,
reports: Vec<GradleReport>,
}
const REPORT_CACHE: &str = "gradle-dependencies.json";
/// Keeps `report` with the build's other reports (`cache_dir` is the build's cache
/// directory), replacing an earlier one of the same project and configuration. Reports
/// read before a build file changed are dropped.
pub fn save_gradle_report(
root: &Path,
cache_dir: &Path,
model: &gradle::GradleModel,
report: &GradleReport,
) -> IdeResult<()> {
// Reports of several configurations may finish together: one read-modify-write at a time.
static SAVING: Mutex<()> = Mutex::new(());
let _saving = SAVING.lock().unwrap_or_else(|e| e.into_inner());
let hash = sync::hash_gradle_files(&gradle::build_files(root, model));
let mut cache = sync::read_cache::<ReportCache>(cache_dir, REPORT_CACHE)
.filter(|c| c.hash == hash)
.unwrap_or_else(|| ReportCache { hash, reports: Vec::new() });
cache.reports.retain(|r| (&r.project, &r.configuration) != (&report.project, &report.configuration));
cache.reports.push(report.clone());
sync::write_cache(cache_dir, REPORT_CACHE, &cache)
}
/// The reports kept for the build, unless a build file changed since they were read.
pub fn gradle_reports(root: &Path, cache_dir: &Path, model: &gradle::GradleModel) -> Vec<GradleReport> {
let Some(cache) = sync::read_cache::<ReportCache>(cache_dir, REPORT_CACHE) else { return Vec::new() };
if cache.hash != sync::hash_gradle_files(&gradle::build_files(root, model)) {
return Vec::new();
}
cache.reports
}
#[cfg(test)]
mod tests {
use super::*;
@@ -285,37 +234,6 @@ runtimeClasspath - Runtime classpath of source set 'main'.
);
}
#[test]
fn reports_are_kept_per_project_and_configuration_until_a_build_file_changes() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
let cache = root.join("cache");
std::fs::write(root.join("settings.gradle"), "include 'app'").unwrap();
std::fs::write(root.join("build.gradle"), "").unwrap();
let model = gradle::load(root).unwrap();
assert!(gradle_reports(root, &cache, &model).is_empty());
let report = |project: &str, configuration: &str, version: &str| GradleReport {
project: project.into(),
configuration: configuration.into(),
dependencies: vec![dep("org.a", "b", Some(version))],
};
save_gradle_report(root, &cache, &model, &report(":app", "runtimeClasspath", "1.0")).unwrap();
save_gradle_report(root, &cache, &model, &report(":app", "compileClasspath", "1.0")).unwrap();
// Reading a report again replaces what was read before.
save_gradle_report(root, &cache, &model, &report(":app", "runtimeClasspath", "2.0")).unwrap();
assert_eq!(
gradle_reports(root, &cache, &model),
[report(":app", "compileClasspath", "1.0"), report(":app", "runtimeClasspath", "2.0")]
);
// A comment changes nothing Gradle reads; a dependency does.
std::fs::write(root.join("build.gradle"), "// notes").unwrap();
assert_eq!(gradle_reports(root, &cache, &model).len(), 2);
std::fs::write(root.join("build.gradle"), "dependencies { implementation 'org.a:b:3.0' }").unwrap();
assert!(gradle_reports(root, &cache, &model).is_empty());
save_gradle_report(root, &cache, &model, &report(":", "compileClasspath", "3.0")).unwrap();
assert_eq!(gradle_reports(root, &cache, &model), [report(":", "compileClasspath", "3.0")]);
}
#[cfg(unix)]
#[test]
fn runs_the_report_of_the_project_and_configuration() {
+10 -80
Переглянути файл
@@ -1,4 +1,4 @@
//! Build tool models for the Maven, Gradle and sbt tool windows, and Build › Build
//! Build tool models for the Maven and Gradle tool windows, and Build › Build
//! Project ([`compile`]) for Maven, Gradle, Cargo, Go and TypeScript projects.
//!
//! [`load`] reads the project's build files (instant, no build tool involved)
@@ -13,15 +13,13 @@ pub mod kotlin_bridge;
pub mod maven;
pub mod pom_edit;
mod process;
pub mod sbt;
mod sync;
pub mod web;
mod xml;
pub use gradle::{GradleModel, GradleProject, GradleTask};
pub use gradle_deps::{GradleDependency, GradleReport, gradle_dependencies, gradle_reports, save_gradle_report};
pub use gradle_deps::{GradleDependency, gradle_dependencies};
pub use maven::{MavenDependency, MavenModel, MavenPlugin, MavenProfile, MavenProject, Omission};
pub use sbt::{SbtBuild, SbtProject};
pub use sync::{
SyncOptions, SyncProgress, maven_profiles, save_maven_profiles, sync_gradle, sync_gradle_model, sync_maven,
};
@@ -44,9 +42,6 @@ pub struct BuildModel {
pub maven: Option<MavenModel>,
#[serde(default)]
pub gradle: Vec<GradleModel>,
/// sbt builds, read from their `build.sbt` (sbt is not started).
#[serde(default)]
pub sbt: Vec<SbtBuild>,
}
impl BuildModel {
@@ -101,7 +96,7 @@ pub fn load_linked(
g
})
.collect();
BuildModel { maven, gradle, sbt: sbt::load(root) }
BuildModel { maven, gradle }
}
/// Gradle project folders outside `root` as of the last sync (`includeFlat` siblings):
@@ -127,22 +122,10 @@ pub fn gradle_external_roots(
gradle::external_roots(root, dirs.iter().map(String::as_str))
}
/// Directories outside `root`, outermost only, of Maven POMs linked from there and, in a
/// trusted project, of the modules its reactor lists there (`<module>../service-a</module>`):
/// extra content roots, as IDEA imports such modules with content roots of their own.
/// Linked POMs are read as explicit paths; the reactor's POMs are parsed, but not their
/// parents, and nothing walks directories. `cache_dir` holds the profiles chosen at the last sync.
pub fn maven_external_roots(
root: &Path,
cache_dir: &Path,
settings: &ide_core::settings::MavenSettings,
trusted: bool,
) -> Vec<PathBuf> {
let mut dirs = maven::external_pom_dirs(root, &settings.linked_projects);
if trusted {
let profiles = settings.profiles(&sync::maven_profiles(cache_dir));
dirs.extend(maven::reactor_external_dirs(root, &profiles, &settings.unlinked_projects));
}
/// Directories of Maven POMs linked from outside `root`, outermost only.
/// Reads just those explicit paths (no POM parse and no directory walk).
pub fn maven_external_roots(root: &Path, linked: &[String]) -> Vec<PathBuf> {
let dirs = maven::external_pom_dirs(root, linked);
let owned: Vec<String> = dirs.iter().map(|dir| dir.to_string_lossy().into_owned()).collect();
gradle::external_roots(root, owned.iter().map(String::as_str))
}
@@ -263,59 +246,6 @@ mod tests {
assert!(gradle_external_roots(&root, &temp.path().join("cache"), &settings).is_empty());
}
#[test]
fn reactor_modules_outside_the_root_are_content_roots_of_a_trusted_project() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("workspace");
let cache = base.join("cache");
let write = |rel: &str, text: &str| {
let path = base.join(rel).join("pom.xml");
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
std::fs::write(path, format!("<project><artifactId>{rel}</artifactId>{text}</project>")).unwrap();
};
let reactor = |modules: &str| {
format!(
"<packaging>pom</packaging><modules>{modules}</modules>\
<profiles><profile><id>extra</id><modules><module>../service-c</module></modules></profile></profiles>"
)
};
let all = "<module>core</module><module>../service-a</module><module>..</module>";
write("workspace", &reactor(all));
write("workspace/core", "<modules><module>../../service-d</module></modules>");
write("service-a", "<modules><module>impl</module><module>../service-e</module></modules>");
for module in ["service-a/impl", "service-c", "service-d", "service-e", "unrelated"] {
write(module, "");
}
// The folder holding the project is not a module beside it, nor are its other modules.
write("", "<modules><module>workspace</module><module>unrelated</module></modules>");
let mut settings = ide_core::settings::MavenSettings::default();
let roots = |settings: &ide_core::settings::MavenSettings, trusted| {
maven_external_roots(&root, &cache, settings, trusted)
};
let (a, c, d, e) =
(base.join("service-a"), base.join("service-c"), base.join("service-d"), base.join("service-e"));
assert_eq!(roots(&settings, true), [a.clone(), d.clone(), e.clone()]);
assert!(roots(&settings, false).is_empty(), "Restricted Mode does not widen the index");
settings.active_profiles = "extra".into();
assert_eq!(roots(&settings, true), [a.clone(), c.clone(), d.clone(), e.clone()]);
save_maven_profiles(&cache, &["!extra".into()]).unwrap();
assert_eq!(roots(&settings, true), [a.clone(), d.clone(), e.clone()]);
settings.unlinked_projects = vec![a.join("pom.xml").to_string_lossy().replace('\\', "/")];
assert_eq!(roots(&settings, true), std::slice::from_ref(&d));
settings.unlinked_projects.clear();
write("workspace", &reactor("<module>core</module>"));
assert_eq!(roots(&settings, true), std::slice::from_ref(&d));
write("workspace/core", "");
assert!(roots(&settings, true).is_empty());
write("workspace", &reactor(all));
assert_eq!(roots(&settings, true), [a, e]);
}
#[test]
fn settings_profiles_and_checkbox_choices_control_modules_before_sync() {
let tmp = tempfile::tempdir().unwrap();
@@ -399,7 +329,7 @@ mod tests {
..Default::default()
};
let gradle = gradle::load(root).into_iter().collect();
let model = BuildModel { maven: Some(maven), gradle, sbt: Vec::new() };
let model = BuildModel { maven: Some(maven), gradle };
let names: Vec<String> = dependency_coordinates(root, &model)
.into_iter()
.map(|c| format!("{}{}:{}:{}", if c.gradle { "G " } else { "M " }, c.group_id, c.artifact_id, c.version))
@@ -418,7 +348,7 @@ mod tests {
"ext { gson = '2.8.9' }\ndependencies { implementation \"com.google.code.gson:gson:${gson}\" }\n",
)
.unwrap();
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect(), sbt: Vec::new() };
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect() };
let names: Vec<String> = dependency_coordinates(root, &model)
.into_iter()
.map(|c| format!("{}:{}:{}", c.group_id, c.artifact_id, c.version))
@@ -437,7 +367,7 @@ mod tests {
)
.unwrap();
std::fs::write(root.join("gradle.properties"), "# versions\nv = 1.2\nonlyInProperties: 2.3\n").unwrap();
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect(), sbt: Vec::new() };
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect() };
let versions: Vec<_> = dependency_coordinates(root, &model).into_iter().map(|c| c.version).collect();
assert_eq!(versions, ["1.2", "2.3"]);
}
+2 -86
Переглянути файл
@@ -1235,86 +1235,6 @@ pub fn external_pom_dirs(root: &Path, linked: &[String]) -> Vec<PathBuf> {
out
}
type FileStamp = Option<(Option<std::time::SystemTime>, u64)>;
fn file_stamp(path: &Path) -> FileStamp {
std::fs::metadata(path).ok().map(|m| (m.modified().ok(), m.len()))
}
/// The POM files a reactor walk read or looked for, and the module folders it found outside the root.
struct ReactorScan {
stamps: Vec<(PathBuf, FileStamp)>,
dirs: Vec<PathBuf>,
}
/// Folders of the modules that the reactor of `root/pom.xml` lists outside `root`
/// (`<module>../service-a</module>`), with their own modules in turn, including those of
/// the active `profiles`. An `unlinked` POM leaves out its modules too. A folder that
/// holds `root` (`<module>..</module>`) is not a module beside the project and is skipped.
/// Callers keep the outermost directory only. Memoized on the POMs' modification times and
/// sizes: content roots are read on hot paths (every references search, Find in Files).
pub fn reactor_external_dirs(root: &Path, profiles: &[String], unlinked: &[String]) -> Vec<PathBuf> {
type Memo = HashMap<(PathBuf, Vec<String>, Vec<String>), ReactorScan>;
static MEMO: std::sync::LazyLock<Mutex<Memo>> = std::sync::LazyLock::new(Default::default);
let key = (root.to_path_buf(), profiles.to_vec(), unlinked.to_vec());
if let Some(scan) = MEMO.lock().unwrap_or_else(|e| e.into_inner()).get(&key)
&& scan.stamps.iter().all(|(path, stamp)| file_stamp(path) == *stamp)
{
return scan.dirs.clone();
}
let scan = scan_reactor(root, profiles, unlinked);
let dirs = scan.dirs.clone();
MEMO.lock().unwrap_or_else(|e| e.into_inner()).insert(key, scan);
dirs
}
/// Reads only the POMs the reactor lists (no parent resolution and no directory walk).
fn scan_reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> ReactorScan {
let canonical_root = dunce::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
let chosen = Resolver::new(None, profiles);
let unlinked: HashSet<String> = unlinked.iter().map(|p| normalized_pom(p.trim())).collect();
let first = root.join("pom.xml");
let mut scan = ReactorScan { stamps: vec![(first.clone(), file_stamp(&first))], dirs: Vec::new() };
let mut seen: HashSet<PathBuf> = HashSet::new();
let mut pending = vec![first];
while let Some(path) = pending.pop() {
if seen.len() >= MAX_PROJECTS {
break;
}
let canonical = dunce::canonicalize(&path).unwrap_or_else(|_| path.clone());
if !seen.insert(canonical.clone()) || unlinked.contains(&project_rel(&canonical_root, &canonical)) {
continue;
}
let Some(pom) = xml::read_text(&path).as_deref().and_then(parse_pom) else { continue };
let dir = path.parent().unwrap_or(root).to_path_buf();
let dir_canon = dunce::canonicalize(&dir).unwrap_or_else(|_| dir.clone());
if !dir_canon.starts_with(&canonical_root) {
if canonical_root.starts_with(&dir_canon) {
continue;
}
scan.dirs.push(dir_canon);
}
let active: Vec<&RawProfile> = chosen.active(&pom.profiles).collect();
let props: HashMap<String, String> =
pom.properties.iter().chain(active.iter().flat_map(|p| &p.properties)).cloned().collect();
for module in pom.modules.iter().chain(active.iter().flat_map(|p| &p.modules)) {
let module = interpolate(module, &props);
if module.contains("${") {
continue;
}
let mut mp = crate::gradle::normalize(&dir.join(module));
if mp.is_dir() || mp.extension().is_none_or(|e| e != "xml") {
mp.push("pom.xml");
}
scan.stamps.push((mp.clone(), file_stamp(&mp)));
if mp.is_file() {
pending.push(mp);
}
}
}
scan
}
/// Whether `root` holds a Maven build or the settings link one inside it.
pub fn has_projects(root: &Path, settings: &ide_core::settings::MavenSettings) -> bool {
is_maven_project(root) || !linked_poms(root, &settings.linked_projects).is_empty()
@@ -2559,12 +2479,8 @@ mod tests {
assert_eq!(normalized[0], dunce::canonicalize(b.join("pom.xml")).unwrap().to_string_lossy().replace('\\', "/"));
assert_eq!(normalized[1], "pom.xml");
assert_eq!(normalized[2], "stub/pom.xml");
let external_roots = |linked: &[String]| {
let settings = ide_core::settings::MavenSettings { linked_projects: linked.to_vec(), ..Default::default() };
crate::maven_external_roots(&a, &base.join("cache"), &settings, true)
};
assert_eq!(external_roots(&normalized), vec![b.clone()]);
assert_eq!(external_roots(&stored), vec![b.clone()]);
assert_eq!(crate::maven_external_roots(&a, &normalized), vec![b.clone()]);
assert_eq!(crate::maven_external_roots(&a, &stored), vec![b.clone()]);
let removed = load_with_linked(&a, None, &[], &[]);
assert!(removed.projects.iter().all(|p| p.artifact_id != "b"));
-301
Переглянути файл
@@ -1,301 +0,0 @@
//! sbt builds for the sbt tool window: each `build.sbt` build under the project root
//! with the projects its definition declares (`lazy val core = project`,
//! `(project in file("core"))`, `Project("core", file("core"))`), read statically —
//! sbt itself is not started.
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct SbtBuild {
/// Folder of `build.sbt`, relative to the project root (`""` for the root itself).
pub dir: String,
/// The launcher: a `sbt` / `sbtx` script in the build folder, else `sbt` on `PATH`.
pub command: String,
/// `sbt.version` of `project/build.properties`.
pub version: Option<String>,
/// The root project first, then the declared projects in source order.
pub projects: Vec<SbtProject>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct SbtProject {
/// The project id tasks are scoped with (`core/compile`).
pub id: String,
/// Base folder relative to the build folder (`""` for the build's own).
pub dir: String,
/// The build's root project: its tasks run unscoped (and aggregate when sbt does).
pub root: bool,
}
/// The sbt builds under `root` (outermost `build.sbt` folders).
pub fn load(root: &Path) -> Vec<SbtBuild> {
ide_core::project_roots::discover(root, &["build.sbt"])
.into_iter()
.filter_map(|dir| {
let text = std::fs::read_to_string(dir.join("build.sbt")).ok()?;
let rel = dir.strip_prefix(root).unwrap_or(&dir).to_string_lossy().replace('\\', "/");
let name = dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| "root".to_owned());
Some(SbtBuild {
dir: rel,
command: launcher(&dir),
version: build_version(&dir),
projects: projects(&text, &name),
})
})
.collect()
}
fn launcher(dir: &Path) -> String {
for script in ["sbt", "sbtx"] {
if !cfg!(windows) && dir.join(script).is_file() {
return format!("./{script}");
}
}
if cfg!(windows) && dir.join("sbt.bat").is_file() {
return "sbt.bat".to_owned();
}
"sbt".to_owned()
}
fn build_version(dir: &Path) -> Option<String> {
let text = std::fs::read_to_string(dir.join("project/build.properties")).ok()?;
text.lines().find_map(|line| {
let (key, value) = line.split_once('=')?;
(key.trim() == "sbt.version").then(|| value.trim().to_owned())
})
}
/// `text` with comments and the contents of string literals blanked (quotes kept),
/// byte for byte, so offsets into it are offsets into `text`.
fn mask(text: &str) -> String {
let mut out = String::with_capacity(text.len());
let blank = |out: &mut String, c: char| {
if c == '\n' {
out.push('\n');
} else {
out.extend(std::iter::repeat_n(' ', c.len_utf8()));
}
};
let mut chars = text.chars().peekable();
while let Some(c) = chars.next() {
match c {
'"' => {
out.push('"');
let mut ahead = chars.clone();
if ahead.next() == Some('"') && ahead.next() == Some('"') {
// `"""…"""`: no escapes inside.
chars.next();
chars.next();
out.push_str("\"\"");
let mut quotes = 0;
for c in chars.by_ref() {
quotes = if c == '"' { quotes + 1 } else { 0 };
if quotes > 0 {
out.push('"')
} else {
blank(&mut out, c)
}
if quotes == 3 {
break;
}
}
continue;
}
while let Some(c) = chars.next() {
if c == '"' || c == '\n' {
out.push(c);
break;
}
blank(&mut out, c);
if c == '\\'
&& let Some(n) = chars.next()
{
blank(&mut out, n);
}
}
}
'/' if chars.peek() == Some(&'/') => {
blank(&mut out, c);
for c in chars.by_ref() {
blank(&mut out, c);
if c == '\n' {
break;
}
}
}
'/' if chars.peek() == Some(&'*') => {
blank(&mut out, c);
let mut prev = ' ';
for c in chars.by_ref() {
blank(&mut out, c);
if prev == '*' && c == '/' {
break;
}
prev = c;
}
}
_ => out.push(c),
}
}
out
}
fn identifier(s: &str) -> Option<(&str, &str)> {
let s = s.trim_start();
if let Some(rest) = s.strip_prefix('`') {
let end = rest.find('`')?;
return Some((&rest[..end], &rest[end + 1..]));
}
let end = s.find(|c: char| !(c.is_alphanumeric() || c == '_')).unwrap_or(s.len());
(end > 0).then(|| (&s[..end], &s[end..]))
}
/// The string literal at the start of `s` (after spaces), and the rest.
fn string_literal(s: &str) -> Option<(&str, &str)> {
let rest = s.trim_start().strip_prefix('"')?;
let end = rest.find('"')?;
Some((&rest[..end], &rest[end + 1..]))
}
/// The folder of a `file("x")` / `new File("x")` at the start of `s`.
fn file_arg(s: &str) -> Option<&str> {
let s = s.trim_start();
let s = s.strip_prefix("file").or_else(|| s.strip_prefix("new File"))?;
let s = s.trim_start().strip_prefix('(')?;
string_literal(s).map(|(dir, _)| dir)
}
fn normalize_dir(dir: &str) -> String {
let dir = dir.trim_start_matches("./").trim_end_matches('/');
if dir == "." { String::new() } else { dir.to_owned() }
}
/// What a `lazy val <id> = <rhs>` declares: a project and its base folder. `rhs` is
/// masked (see [`mask`]); `original` is the same text unmasked, for the folder names.
fn project_of(id: &str, rhs: &str, original: &str) -> Option<String> {
let at = |s: &str| original.get(rhs.len() - s.len()..).unwrap_or_default();
let rhs = rhs.trim_start().trim_start_matches('(').trim_start();
if let Some(rest) = rhs.strip_prefix("Project") {
// `Project("id", file("dir"))` / `Project(id = "x", base = file("dir"))`.
let args = rest.trim_start().strip_prefix('(')?;
let base = args.find("file(").or_else(|| args.find("new File("))?;
return file_arg(at(&args[base..])).map(normalize_dir);
}
let rest = rhs.strip_prefix("project")?;
if rest.starts_with(|c: char| c.is_alphanumeric() || c == '_') {
return None;
}
let rest = rest.trim_start();
let located = rest
.strip_prefix(".in")
.and_then(|r| r.trim_start().strip_prefix('('))
.or_else(|| rest.strip_prefix("in ").or_else(|| rest.strip_prefix("in\t")));
Some(match located.and_then(|l| file_arg(at(l))) {
Some(dir) => normalize_dir(dir),
None => id.to_owned(),
})
}
/// The projects a build definition declares; `name` is the build folder's name, the id
/// sbt gives an implicit root project.
pub fn projects(text: &str, name: &str) -> Vec<SbtProject> {
let masked = mask(text);
let mut out: Vec<SbtProject> = Vec::new();
let mut from = 0;
while let Some(found) = masked[from..].find("val ") {
let at = from + found;
from = at + 4;
if masked[..at].chars().last().is_some_and(|c| c.is_alphanumeric() || c == '_') {
continue;
}
let Some((id, tail)) = identifier(&masked[from..]) else { continue };
let Some(rhs) = tail.trim_start().strip_prefix('=') else { continue };
if rhs.starts_with('=') || rhs.starts_with('>') {
continue;
}
let Some(dir) = project_of(id, rhs, &text[masked.len() - rhs.len()..]) else { continue };
if !out.iter().any(|p| p.id == id) {
out.push(SbtProject { id: id.to_owned(), root: dir.is_empty(), dir });
}
}
match out.iter().position(|p| p.root) {
Some(i) => {
let root = out.remove(i);
out.insert(0, root);
}
None => out.insert(0, SbtProject { id: name.to_owned(), dir: String::new(), root: true }),
}
out
}
#[cfg(test)]
mod tests {
use super::*;
fn ids(text: &str) -> Vec<(String, String, bool)> {
projects(text, "shop").into_iter().map(|p| (p.id, p.dir, p.root)).collect()
}
#[test]
fn single_project_builds_have_an_implicit_root() {
assert_eq!(
ids("ThisBuild / scalaVersion := \"3.3.4\"\nname := \"shop\"\n"),
[("shop".into(), "".into(), true)]
);
}
#[test]
fn declared_projects_and_their_folders() {
let text = r#"
// lazy val commented = project
lazy val root = (project in file("."))
.aggregate(core, `web-app`, util)
.settings(name := "shop")
lazy val core = project
lazy val `web-app` = (project in file("modules/web")).dependsOn(core)
lazy val util = project.in(file("libs/util/"))
lazy val legacy = Project("legacy", file("old"))
/* lazy val hidden = project */
val description = "lazy val fake = project"
lazy val projectSettings = Seq(scalacOptions += "-deprecation")
"#;
assert_eq!(
ids(text),
[
("root".into(), "".into(), true),
("core".into(), "core".into(), false),
("web-app".into(), "modules/web".into(), false),
("util".into(), "libs/util".into(), false),
("legacy".into(), "old".into(), false),
]
);
}
#[test]
fn a_root_declared_last_is_listed_first() {
let text = "lazy val api = project\nlazy val all = (project in file(\".\")).aggregate(api)\n";
assert_eq!(ids(text), [("all".into(), "".into(), true), ("api".into(), "api".into(), false)]);
}
#[test]
fn builds_are_found_with_their_launcher_and_version() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
std::fs::create_dir_all(root.join("svc/project")).unwrap();
std::fs::create_dir_all(root.join("svc/core")).unwrap();
std::fs::write(root.join("svc/build.sbt"), "lazy val core = project\n").unwrap();
// A project's own build.sbt is part of the outer build.
std::fs::write(root.join("svc/core/build.sbt"), "libraryDependencies += \"a\" % \"b\" % \"1\"\n").unwrap();
std::fs::write(root.join("svc/project/build.properties"), "sbt.version = 1.10.7\n").unwrap();
let builds = load(root);
assert_eq!(builds.len(), 1);
let b = &builds[0];
assert_eq!((b.dir.as_str(), b.command.as_str(), b.version.as_deref()), ("svc", "sbt", Some("1.10.7")));
assert_eq!(b.projects.iter().map(|p| p.id.as_str()).collect::<Vec<_>>(), ["svc", "core"]);
}
}
+3 -3
Переглянути файл
@@ -136,11 +136,11 @@ pub fn save_maven_profiles(cache_dir: &Path, profiles: &[String]) -> IdeResult<b
Ok(true)
}
pub(crate) fn read_cache<T: DeserializeOwned>(dir: &Path, name: &str) -> Option<T> {
fn read_cache<T: DeserializeOwned>(dir: &Path, name: &str) -> Option<T> {
serde_json::from_slice(&std::fs::read(dir.join(name)).ok()?).ok()
}
pub(crate) fn write_cache<T: Serialize>(dir: &Path, name: &str, value: &T) -> IdeResult<()> {
fn write_cache<T: Serialize>(dir: &Path, name: &str, value: &T) -> IdeResult<()> {
std::fs::create_dir_all(dir)?;
let json = serde_json::to_vec(value).map_err(|e| IdeError::internal(e.to_string()))?;
let tmp = dir.join(format!("{name}.tmp"));
@@ -156,7 +156,7 @@ fn hash_files(files: &[PathBuf]) -> String {
/// Like IDEA's auto-import CRC: editing a comment or reformatting a build script
/// does not make the last sync stale.
pub(crate) fn hash_gradle_files(files: &[PathBuf]) -> String {
fn hash_gradle_files(files: &[PathBuf]) -> String {
hash_contents(files, |f| {
let text = std::fs::read_to_string(f).unwrap_or_default();
let script = f.extension().is_some_and(|e| e == "gradle" || e == "kts");
+7 -26
Переглянути файл
@@ -172,25 +172,13 @@ pub fn build(root: &Path, model: &BuildModel, id: &str, cache: &Path) -> IdeResu
fs::write(
&script,
format!(
r#"import org.gradle.util.GradleVersion
gradle.projectsEvaluated {{
r#"gradle.projectsEvaluated {{
def p = gradle.rootProject.project({})
def artifact = {{ t ->
t.dependsOn 'war'
// Resolved here so the action holds no task or project (configuration cache).
def war = p.tasks.getByName('war')
// `archiveFile` is Gradle 5.1+, `archivePath` is gone in 8.0.
def archive = war.hasProperty('archiveFile') ? war.archiveFile : war.archivePath
def manifest = new File({})
t.doLast {{
def file = archive instanceof File ? archive : archive.get().asFile
manifest.setText(file.absolutePath, 'UTF-8')
}}
def warTask = p.tasks.named('war')
p.tasks.register('openideaTomcatArtifact') {{
dependsOn warTask
doLast {{ new File({}).setText(warTask.get().archiveFile.get().asFile.absolutePath, 'UTF-8') }}
}}
// `register` is Gradle 4.9+.
if (GradleVersion.current() >= GradleVersion.version('4.9')) p.tasks.register('openideaTomcatArtifact', artifact)
else p.tasks.create('openideaTomcatArtifact', artifact)
}}
"#,
groovy_literal(path),
@@ -282,7 +270,7 @@ mod tests {
assert_eq!(a.len(), 1);
let plan = build(tmp.path(), &model, &a[0].id, &tmp.path().join("base")).unwrap();
assert!(plan.args.contains(&":openideaTomcatArtifact".into()));
assert!(fs::read_to_string(tmp.path().join("base/war.init.gradle")).unwrap().contains("? war.archiveFile :"));
assert!(fs::read_to_string(tmp.path().join("base/war.init.gradle")).unwrap().contains("archiveFile.get()"));
assert!(!crate::gradle::has_war_plugin("// plugins { war }"));
}
@@ -309,14 +297,7 @@ mod tests {
assert!(plan.args.contains(&format!("{}:openideaTomcatArtifact", module.trim_end_matches(':'))));
let script = fs::read_to_string(cache.join("war.init.gradle")).unwrap();
assert!(script.contains(&format!("rootProject.project('{}')", module)));
assert!(script.contains("manifest.setText(file.absolutePath, 'UTF-8')"));
// `archiveFile` is Gradle 5.1+, `register` 4.9+ (#3864).
assert!(
script.contains(": war.archivePath") && script.contains("else p.tasks.create('openideaTomcatArtifact'")
);
// The configuration cache can't serialize a task or project the action refers to.
let action = &script[script.find("doLast").unwrap()..script.find("// `register`").unwrap()];
assert!(!action.contains("p.") && !action.contains("war."), "{action}");
assert!(script.contains("archiveFile.get().asFile.absolutePath, 'UTF-8'"));
}
}
}
-3
Переглянути файл
@@ -343,8 +343,6 @@ pub struct InlayHintsSettings {
/// Hints of other kinds (chaining, closing labels…).
pub other: bool,
pub disabled_languages: Vec<String>,
/// Code vision as a whole (usages, author and language-server lenses); the switches below apply while it is on.
pub code_vision: bool,
/// Code vision: usages above declarations.
pub code_vision_usages: bool,
/// Code vision: last author of a declaration (VCS blame) beside its usages.
@@ -375,7 +373,6 @@ impl Default for InlayHintsSettings {
parameters: true,
other: true,
disabled_languages: Vec::new(),
code_vision: true,
code_vision_usages: true,
code_vision_author: true,
code_vision_no_usages: true,
-5
Переглянути файл
@@ -38,11 +38,6 @@ pub enum IdeEvent {
WindowGroupsChanged,
/// A window entered or left full screen, itself or as a member of a full-screen window group.
WindowFullscreenChanged,
/// This remote window's connection to its host ended on its own (network loss, the host or
/// its server went away); the window's project is unreachable until it reconnects.
RemoteConnectionLost {
host: String,
},
ProjectTrustChanged {
root: crate::IpcPath,
trusted: bool,
+1 -3
Переглянути файл
@@ -14,8 +14,7 @@ pub fn inside_git_repo(dir: &Path) -> bool {
dir.ancestors().any(|d| d.join(".git").exists() || d.join(".jj").exists())
}
/// IDEA's default list, plus `.jj`, rope's `.ropeproject` (pylsp-rope creates it in the
/// project root) and the Windows shell files.
/// IDEA's default list, plus `.jj` and the Windows shell files.
pub const DEFAULT_IGNORED_NAMES: &[&str] = &[
"*.pyc",
"*.pyo",
@@ -26,7 +25,6 @@ pub const DEFAULT_IGNORED_NAMES: &[&str] = &[
".git",
".hg",
".jj",
".ropeproject",
".svn",
"CVS",
"__pycache__",
+5 -8
Переглянути файл
@@ -167,11 +167,10 @@ const GRADLE: &[&str] = &["gradle", "gradlew"];
/// Gradle's own JVM and the compiler's source encoding are untouched.
pub const GRADLE_FILE_ENCODING_SCRIPT: &str = "\
// Written by OpenIDEA: a UTF-8 default charset for applications run by Gradle, as the Run console decodes UTF-8.
import org.gradle.util.GradleVersion
// `configureEach` (lazy) is Gradle 4.9+; older ones configure each task as it is added.
def each = { tasks, Closure action -> GradleVersion.current() >= GradleVersion.version('4.9') ? tasks.configureEach(action) : tasks.all(action) }
allprojects {
each(tasks.withType(JavaExec)) { t -> t.defaultCharacterEncoding = 'UTF-8' }
tasks.withType(JavaExec).configureEach {
defaultCharacterEncoding = 'UTF-8'
}
}
";
@@ -622,12 +621,10 @@ mod tests {
#[test]
fn gradle_script_respects_the_builds_own_file_encoding() {
let s = GRADLE_FILE_ENCODING_SCRIPT;
assert!(s.contains("each(tasks.withType(JavaExec))"), "{s}");
assert!(s.contains("t.defaultCharacterEncoding = 'UTF-8'"), "{s}");
assert!(s.contains("tasks.withType(JavaExec).configureEach"), "{s}");
assert!(s.contains("defaultCharacterEncoding = 'UTF-8'"), "{s}");
assert!(!s.contains("doFirst"), "the build must be able to override the default: {s}");
assert!(!s.contains("withType(Test)") && !s.contains("JavaCompile"), "{s}");
// Gradle before 4.9 has no `configureEach` (#3864).
assert!(s.contains("? tasks.configureEach(action) : tasks.all(action)"), "{s}");
}
#[test]
-96
Переглянути файл
@@ -1,6 +1,3 @@
use serde::{Deserialize, Serialize};
use specta::Type;
/// The Windows OS build used by ConPTY; unavailable on other platforms or on query failure.
#[cfg(windows)]
pub fn windows_build_number() -> Option<u32> {
@@ -19,61 +16,6 @@ pub fn windows_build_number() -> Option<u32> {
None
}
/// A caption button of a frameless window's title bar.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum WindowButton {
Minimize,
Maximize,
Close,
}
/// Which caption buttons the title bar shows on each side, in order from left to right.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct WindowButtonLayout {
pub left: Vec<WindowButton>,
pub right: Vec<WindowButton>,
}
impl Default for WindowButtonLayout {
/// Minimise, maximise, close on the right (Windows, and Linux when the desktop says nothing).
fn default() -> Self {
Self { left: Vec::new(), right: vec![WindowButton::Minimize, WindowButton::Maximize, WindowButton::Close] }
}
}
impl WindowButtonLayout {
/// Reads GTK's `gtk-decoration-layout` (also GNOME's `button-layout`): button names separated
/// by commas, the left side before the colon, e.g. `close,maximize,minimize:icon`. Names other
/// than the three caption buttons (`icon`, `menu`, `appmenu`, `spacer`) are skipped, as are
/// repeats. A value without any caption button is unusable for a frameless window: `None`.
pub fn from_gtk_decoration_layout(layout: &str) -> Option<Self> {
let mut seen = Vec::new();
let mut side = |part: Option<&str>| {
let mut buttons = Vec::new();
for name in part.unwrap_or_default().split(',') {
let button = match name.trim() {
"minimize" => WindowButton::Minimize,
"maximize" => WindowButton::Maximize,
"close" => WindowButton::Close,
_ => continue,
};
if !seen.contains(&button) {
seen.push(button);
buttons.push(button);
}
}
buttons
};
// GTK splits at the first colon only; without one, every button is on the left.
let mut parts = layout.splitn(2, ':');
let left = side(parts.next());
let right = side(parts.next());
(!left.is_empty() || !right.is_empty()).then_some(Self { left, right })
}
}
#[cfg(test)]
mod tests {
#[test]
@@ -84,42 +26,4 @@ mod tests {
#[cfg(not(windows))]
assert_eq!(build, None);
}
use super::{WindowButton::*, WindowButtonLayout};
fn layout(left: &[super::WindowButton], right: &[super::WindowButton]) -> Option<WindowButtonLayout> {
Some(WindowButtonLayout { left: left.to_vec(), right: right.to_vec() })
}
#[test]
fn reads_gtk_decoration_layouts() {
let cases = [
// KDE Plasma with `ButtonsOnLeft=XAIS` (#3794).
("close,maximize,minimize:icon", layout(&[Close, Maximize, Minimize], &[])),
("close,minimize,maximize:", layout(&[Close, Minimize, Maximize], &[])),
(":minimize,maximize,close", layout(&[], &[Minimize, Maximize, Close])),
// GNOME's default.
("appmenu:close", layout(&[], &[Close])),
("menu:minimize,close", layout(&[], &[Minimize, Close])),
("icon,close:minimize,maximize", layout(&[Close], &[Minimize, Maximize])),
(" close , spacer : minimize ", layout(&[Close], &[Minimize])),
// No colon: GTK puts everything on the left.
("close,minimize", layout(&[Close, Minimize], &[])),
// Only the first colon separates the sides; a button appears once.
("close:minimize:maximize", layout(&[Close], &[])),
("close,close:close,minimize", layout(&[Close], &[Minimize])),
("", None),
(":", None),
("appmenu:", None),
("garbage", None),
];
for (value, expected) in cases {
assert_eq!(WindowButtonLayout::from_gtk_decoration_layout(value), expected, "{value:?}");
}
}
#[test]
fn default_layout_is_on_the_right() {
assert_eq!(WindowButtonLayout::default(), layout(&[], &[Minimize, Maximize, Close]).unwrap());
}
}
+1 -97
Переглянути файл
@@ -653,10 +653,6 @@ pub struct NotificationSettings {
/// Mirror balloon notifications to the OS when no OpenIDEA window is focused.
#[serde(default = "default_true")]
pub system_notifications: bool,
/// Terminal command completions (#3712): `off` | `longRunning` | `all`.
pub terminal_completion: String,
/// `longRunning`: the run time a finished command must reach, in seconds.
pub terminal_threshold_seconds: u32,
/// Group id → display; groups not listed use their default.
pub groups: BTreeMap<String, NotificationGroupSettings>,
}
@@ -665,24 +661,9 @@ fn default_true() -> bool {
true
}
fn default_terminal_completion() -> String {
"longRunning".to_owned()
}
fn default_terminal_threshold_seconds() -> u32 {
10
}
impl Default for NotificationSettings {
fn default() -> Self {
Self {
balloons: true,
sound: false,
system_notifications: true,
terminal_completion: default_terminal_completion(),
terminal_threshold_seconds: default_terminal_threshold_seconds(),
groups: BTreeMap::new(),
}
Self { balloons: true, sound: false, system_notifications: true, groups: BTreeMap::new() }
}
}
@@ -760,9 +741,6 @@ pub struct AppearanceSettings {
pub main_menu_style: String,
/// A lone Alt press focuses or opens the main menu (IDEA `ide.windows.main.menu.focus.on.alt`).
pub main_menu_alt: bool,
/// Settings open in a native window of their own (IDEA parity); off opens them
/// as a dialog inside the project window, which needs no new webview.
pub settings_in_separate_window: bool,
/// `subpixel` | `greyscale` | `none`
pub ide_antialiasing: String,
pub editor_antialiasing: String,
@@ -862,7 +840,6 @@ impl Default for AppearanceSettings {
menu_icons: true,
main_menu_style: "hamburger".into(),
main_menu_alt: true,
settings_in_separate_window: true,
ide_antialiasing: "greyscale".into(),
editor_antialiasing: "greyscale".into(),
show_tool_window_bars: true,
@@ -915,13 +892,7 @@ pub struct EditorSettings {
pub docstring_format: String,
/// Color Scheme › Language Defaults › Rainbow brackets: `()`, `[]`, `{}` coloured by depth.
pub rainbow_brackets: bool,
/// The bracket kinds rainbow brackets colour.
pub rainbow_bracket_kinds: RainbowBracketKinds,
/// Colours the rainbow bracket depth cycles through (2–5).
pub rainbow_bracket_colors: u32,
pub ligatures: bool,
/// Editor › Font and Tools › Terminal › Font: the font pickers list only monospaced fonts.
pub only_monospaced_fonts: bool,
/// Fallback font for glyphs the main font lacks; empty = none.
pub fallback_font: String,
/// Typography Settings › Main font weight (CSS 100–900), as IDEA.
@@ -965,10 +936,7 @@ impl Default for EditorSettings {
semantic_highlighting: false,
docstring_format: "rest".into(),
rainbow_brackets: false,
rainbow_bracket_kinds: RainbowBracketKinds::default(),
rainbow_bracket_colors: 3,
ligatures: false,
only_monospaced_fonts: true,
fallback_font: String::new(),
font_weight: 400,
bold_font_weight: 700,
@@ -991,23 +959,6 @@ impl Default for EditorSettings {
}
}
/// Color Scheme › Language Defaults › Rainbow brackets: which delimiters are coloured.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct RainbowBracketKinds {
pub round: bool,
pub square: bool,
pub curly: bool,
/// Type argument / parameter delimiters and markup tags, where the syntax tree marks them.
pub angle: bool,
}
impl Default for RainbowBracketKinds {
fn default() -> Self {
Self { round: true, square: true, curly: true, angle: false }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct FileSettings {
@@ -1396,9 +1347,6 @@ pub struct JavaSettings {
pub jdtls_vm_args: String,
/// Share one JDT LS across builds in an ordinary project window; other windows remain separate.
pub jdtls_shared: bool,
/// JDK homes added by hand (Platform Settings › SDKs › Add JDK from Disk…), listed with the
/// detected ones.
pub added_jdks: Vec<String>,
/// Build Tools › Maven.
pub maven: MavenSettings,
/// Build Tools › Gradle.
@@ -1800,41 +1748,6 @@ mod tests {
}
}
#[test]
fn rainbow_bracket_options_default_and_round_trip() {
let old: Settings = serde_json::from_str(r#"{"editor":{"rainbowBrackets":true}}"#).unwrap();
assert!(old.editor.rainbow_brackets);
assert_eq!(old.editor.rainbow_bracket_kinds, RainbowBracketKinds::default());
assert_eq!(old.editor.rainbow_bracket_colors, 3);
let defaults = Settings::default().editor;
assert!(!defaults.rainbow_brackets);
let kinds = defaults.rainbow_bracket_kinds;
assert!(kinds.round && kinds.square && kinds.curly && !kinds.angle);
let mut settings = Settings::default();
settings.editor.rainbow_bracket_kinds =
RainbowBracketKinds { round: false, square: true, curly: true, angle: true };
settings.editor.rainbow_bracket_colors = 5;
let json = serde_json::to_value(&settings).unwrap();
assert_eq!(json["editor"]["rainbowBracketKinds"]["angle"], true);
assert_eq!(json["editor"]["rainbowBracketColors"], 5);
let restored: Settings = serde_json::from_value(json).unwrap();
assert_eq!(restored.editor.rainbow_bracket_kinds, settings.editor.rainbow_bracket_kinds);
assert_eq!(restored.editor.rainbow_bracket_colors, 5);
}
#[test]
fn only_monospaced_fonts_defaults_on_and_round_trips() {
let old: Settings = serde_json::from_str(r#"{"editor":{"ligatures":true}}"#).unwrap();
assert!(old.editor.only_monospaced_fonts);
let mut settings = Settings::default();
settings.editor.only_monospaced_fonts = false;
let json = serde_json::to_value(&settings).unwrap();
assert_eq!(json["editor"]["onlyMonospacedFonts"], false);
let restored: Settings = serde_json::from_value(json).unwrap();
assert!(!restored.editor.only_monospaced_fonts);
}
#[test]
fn docstring_format_defaults_and_round_trips() {
let old: Settings = serde_json::from_str(r#"{"editor":{"semanticHighlighting":true}}"#).unwrap();
@@ -1933,15 +1846,6 @@ mod tests {
assert_eq!(serde_json::to_value(off).unwrap()["appearance"]["mainMenuAlt"], false);
}
#[test]
fn settings_open_in_a_separate_window_unless_turned_off() {
let old: Settings = serde_json::from_str(r#"{"appearance":{"compactMode":true}}"#).unwrap();
assert!(old.appearance.settings_in_separate_window);
let off: Settings = serde_json::from_str(r#"{"appearance":{"settingsInSeparateWindow":false}}"#).unwrap();
assert!(!off.appearance.settings_in_separate_window);
assert_eq!(serde_json::to_value(off).unwrap()["appearance"]["settingsInSeparateWindow"], false);
}
#[test]
fn editor_font_weights_default_to_regular_and_bold() {
let json = serde_json::to_value(Settings::default()).unwrap();
-7
Переглянути файл
@@ -43,9 +43,6 @@ impl Default for VcsSettings {
pub struct GitSettings {
/// Show blame after the current editor line.
pub inline_blame: bool,
/// A click (or Enter / Space) on the inline blame label opens its commit; off, the
/// label is plain text and a click on it places the caret as past the line end.
pub inline_blame_clickable: bool,
pub show_branch_in_project_view: bool,
/// Path to the git executable; empty = auto-detect.
pub executable: String,
@@ -57,8 +54,6 @@ pub struct GitSettings {
pub warn_detached_head: bool,
/// Background check for incoming commits: `auto` | `always` | `never`.
pub incoming_check: String,
/// Minutes between background checks for incoming commits.
pub incoming_check_interval: u32,
/// Branch name globs, `;`/`,`-separated; force push to them is prohibited.
pub protected_branches: String,
/// Initial state of Commit Options › Sign-off Commit.
@@ -83,7 +78,6 @@ impl Default for GitSettings {
fn default() -> Self {
Self {
inline_blame: false,
inline_blame_clickable: true,
show_branch_in_project_view: false,
executable: String::new(),
update_method: "merge".into(),
@@ -91,7 +85,6 @@ impl Default for GitSettings {
warn_crlf: true,
warn_detached_head: true,
incoming_check: "auto".into(),
incoming_check_interval: 15,
protected_branches: "master; main".into(),
sign_off: false,
warn_large_files: true,
+6 -14
Переглянути файл
@@ -6,16 +6,11 @@ use ide_run::wrap::{self, program_name};
use std::path::Path;
const GRADLE_INIT: &str = r#"// Written by OpenIDEA for Run with Coverage.
import org.gradle.util.GradleVersion
// `configureEach` (lazy) is Gradle 4.9+; older ones configure each task as it is added.
def each = { tasks, Closure action -> GradleVersion.current() >= GradleVersion.version('4.9') ? tasks.configureEach(action) : tasks.all(action) }
allprojects { p ->
p.plugins.withId('java') {
p.apply plugin: 'jacoco'
each(p.tasks.withType(Test)) { t -> t.finalizedBy('jacocoTestReport') }
def xml = p.tasks.getByName('jacocoTestReport').reports.xml
// `Report.required` is Gradle 6.1+, `enabled` is gone in 8.0.
if (xml.hasProperty('required')) xml.required.set(true) else xml.enabled = true
allprojects {
plugins.withId('java') {
apply plugin: 'jacoco'
tasks.withType(Test).configureEach { t -> t.finalizedBy(tasks.named('jacocoTestReport')) }
tasks.named('jacocoTestReport') { r -> r.reports { xml.required.set(true) } }
}
}
"#;
@@ -396,10 +391,7 @@ mod tests {
let p = prepare(dir.path(), &cfg("gradle", "./gradlew", &[":app:test", "--tests", "*Calc"]), dir.path());
let (l, report) = launch(&p);
assert_eq!(l.args[0], "--init-script");
let script = std::fs::read_to_string(&l.args[1]).unwrap();
assert!(script.contains("p.apply plugin: 'jacoco'"), "{script}");
// `Report.required` is Gradle 6.1+, `configureEach` 4.9+ (#3864).
assert!(script.contains("else xml.enabled = true") && script.contains(": tasks.all(action)"), "{script}");
assert!(std::fs::read_to_string(&l.args[1]).unwrap().contains("jacoco"));
assert!(matches!(report, CoverageReportSpec::Jacoco { .. }));
}
-5
Переглянути файл
@@ -216,11 +216,6 @@ fn settle<T>(result: Result<T, InspectError>) -> IdeResult<Result<T, JvmInspectU
InspectError::TimedOut => U::TimedOut,
InspectError::Closed => U::BackendClosed,
InspectError::Failed(message) => return Err(IdeError::internal(format!("JVM inspector: {message}"))),
// Only the stream trace commands answer these, never the memory view's.
other @ (InspectError::NoSession
| InspectError::NotAtChainStart(_)
| InspectError::Busy
| InspectError::NoTrace) => return Err(IdeError::internal(format!("JVM inspector: {other}"))),
}))
}
+1 -1
Переглянути файл
@@ -23,7 +23,7 @@ use std::time::Duration;
pub use heap::*;
pub use inspect::{JvmFieldsResult, JvmInspectUnavailable, JvmInstancesResult, JvmObjectRef, JvmReferrersResult};
pub(crate) use inspect::{fields, instances, referrers, set_inspector, vm_target, watch_link};
pub(crate) use inspect::{fields, instances, referrers, set_inspector, watch_link};
#[cfg(all(test, unix))]
pub(crate) use scan::watch_for_attached_jvm;
pub(crate) use scan::{JvmFinder, attach_target, find_attached_jvm, find_local_jvm, local_jdwp_port};
-46
Переглянути файл
@@ -19,7 +19,6 @@ mod jvm_memory;
pub mod kotlin;
pub mod kotlin_lsp;
mod session;
mod stream_trace;
pub mod unity;
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
@@ -40,7 +39,6 @@ use std::path::{Path, PathBuf};
use std::sync::atomic::Ordering;
use std::sync::{Arc, Weak};
use std::time::Duration;
pub use stream_trace::{TracePhase, TraceProgress, TraceRun, TraceUnavailable};
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -148,9 +146,6 @@ pub struct DebugCapabilities {
pub js_page: bool,
/// The adapter evaluates expressions while the program runs, without a stack frame.
pub live_evaluate: bool,
/// A stream chain can be traced while the program runs it ([`DebugManager::stream_trace`]).
/// Can change during the session, like `jvm_instances`.
pub stream_trace: bool,
}
/// Result of [`DebugManager::redefine_classes`].
@@ -607,7 +602,6 @@ pub(crate) fn capabilities_from(caps: &Value) -> DebugCapabilities {
jvm_heap: false,
js_page: false,
live_evaluate: false,
stream_trace: false,
}
}
@@ -619,7 +613,6 @@ pub(crate) fn session_capabilities(session: &Session) -> DebugCapabilities {
caps.jvm_heap = JVM_MEMORY_ADAPTERS.contains(&session.adapter.as_str());
caps.js_page = js_debug::is_page(session);
caps.live_evaluate = session.adapter == js_debug::ADAPTER;
caps.stream_trace = stream_trace::available(session);
caps
}
@@ -1624,7 +1617,6 @@ impl DebugManager {
// DAP: a response without the flag continued every thread.
let all = body.get("allThreadsContinued").and_then(Value::as_bool).unwrap_or(true);
session.suspended.resumed(ticket, thread_id, all);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: all });
Ok(())
}
@@ -1673,7 +1665,6 @@ impl DebugManager {
step_settled(&session, sent)?;
// A step runs its thread; other threads stopped by their own events stay stopped.
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
Ok(())
}
@@ -1785,7 +1776,6 @@ impl DebugManager {
.await;
step_settled(&session, sent)?;
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
Ok(())
}
@@ -1883,42 +1873,6 @@ impl DebugManager {
jvm_memory::referrers(&*self.session(s)?, object, limit).await
}
/// Gives the session the backend for [`Self::stream_trace`] (used by java-debug sessions
/// only); the UI is told to reload the session's capabilities.
pub fn set_stream_tracer(
&self,
s: DebugSessionId,
tracer: Arc<dyn ide_jvm_inspect::StreamTracer>,
) -> IdeResult<()> {
let session = self.session(s)?;
if session.ended.is_cancelled() {
return Err(no_session(s));
}
stream_trace::set_tracer(&session, tracer);
Ok(())
}
/// Traces the stream chain `plan` (the JSON of `ide_streams::RealRunPlan`) while the program
/// runs it, from `thread_id` stopped where the chain starts. Leaves the thread stopped right
/// after the chain's terminal operation. `cancel` stops keeping records; the program runs on.
pub async fn stream_trace(
&self,
s: DebugSessionId,
thread_id: i64,
plan: Value,
cancel: ide_core::CancellationToken,
progress: impl Fn(TraceProgress) + Send + Sync,
) -> IdeResult<TraceRun> {
let session = self.session(s)?;
Ok(stream_trace::run(self, &session, thread_id, &plan, &cancel, &progress).await)
}
/// Ends the running terminal operation by interrupting its thread, then by throwing into it.
/// `None` when no trace runs.
pub async fn stream_trace_abort(&self, s: DebugSessionId) -> IdeResult<Option<ide_jvm_inspect::AbortState>> {
stream_trace::abort(&*self.session(s)?).await
}
/// HotSwap: reloads the classes compiled since the session started (or since the
/// last reload) into the debuggee (java-debug `redefineClasses`).
pub async fn redefine_classes(&self, s: DebugSessionId) -> IdeResult<HotSwapResult> {
-18
Переглянути файл
@@ -114,10 +114,6 @@ pub(crate) struct Session {
pub jvm_located: watch::Sender<bool>,
pub kotlin_mirror: Mutex<Option<crate::kotlin::SourceMirror>>,
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
pub stream_tracer: parking_lot::Mutex<Option<Arc<dyn ide_jvm_inspect::StreamTracer>>>,
pub(crate) stream_trace: parking_lot::Mutex<Option<crate::stream_trace::ActiveTrace>>,
/// The last trace that finished, until the stop its records were read in ends.
pub(crate) stream_trace_done: parking_lot::Mutex<Option<crate::stream_trace::DoneTrace>>,
/// Used only by a kotlin-lsp session: see [`Session::kotlin_lsp_quirks`].
pub(crate) quirks: kotlin_lsp::Quirks,
pub(crate) unity_startup_activity: Mutex<Instant>,
@@ -199,13 +195,6 @@ impl Suspension {
self.0.lock().ticket
}
/// The ticket of a stop of `thread` (its own or every thread's) taken after ticket `after`.
pub fn stopped_since(&self, thread: i64, after: u64) -> Option<u64> {
let stops = self.0.lock();
let own = stops.threads.iter().find(|&&(id, _)| id == thread).map(|&(_, ticket)| ticket);
own.max(stops.all).filter(|&ticket| ticket > after)
}
/// After a successful resume-like request for `thread`; `all`: every thread ran.
pub fn resumed(&self, ticket: u64, thread: i64, all: bool) {
self.0.lock().release(Some(thread), all, ticket);
@@ -281,9 +270,6 @@ impl Session {
jvm_located: watch::channel(false).0,
kotlin_mirror: Mutex::new(None),
jvm_memory: tokio::sync::Mutex::default(),
stream_tracer: parking_lot::Mutex::new(None),
stream_trace: parking_lot::Mutex::new(None),
stream_trace_done: parking_lot::Mutex::new(None),
quirks: kotlin_lsp::Quirks::default(),
unity_startup_activity: Mutex::new(Instant::now()),
}
@@ -755,9 +741,6 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
}
"stopped" => {
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
if crate::stream_trace::resume_traced_stop(s, int("threadId"), all) {
return;
}
s.suspended.stopped(int("threadId"), all);
let mut reason = str_("reason").unwrap_or_else(|| "pause".into());
if let Some(quirks) = s.kotlin_lsp_quirks() {
@@ -777,7 +760,6 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
// DAP: an event without the flag continues its thread alone. The UI keeps treating
// it as all threads; the suspension, which holds only threads that stopped, need not.
s.suspended.continued(int("threadId"), all.unwrap_or(false));
crate::stream_trace::release_done(s);
s.emit(DebugEvent::Continued {
thread_id: int("threadId").unwrap_or(0),
all_threads_continued: all.unwrap_or(true),
-433
Переглянути файл
@@ -1,433 +0,0 @@
//! A stream chain traced while the program itself runs it. The JDT LS bundle arms the trace with
//! the thread stopped where the chain starts; the program runs on `continue`, and the bundle holds
//! the thread inside the terminal operation once it has run, until a `stepOut` brings java-debug
//! to a stop of its own in which the records are read.
use crate::jvm_memory::vm_target;
use crate::session::Session;
use crate::{DebugManager, StepKind};
use ide_core::event::DebugEvent;
use ide_core::{CancellationToken, IdeError, IdeResult};
use ide_jvm_inspect::{
AbortState, InspectError, InspectFuture, StreamTracer, TraceCollected, TraceId, TraceState, VmTarget,
};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use specta::Type;
use std::future::Future;
use std::sync::Arc;
use std::time::Duration;
/// Records the bundle keeps; later ones are only counted.
const BUDGET: u32 = 50_000;
const WAIT_MS: u32 = 500;
const STOP_POLL: Duration = Duration::from_millis(20);
const STOP_WAIT: Duration = Duration::from_secs(30);
const RESUME_TIMEOUT: Duration = Duration::from_secs(30);
/// The bundle reaches the JVM through java-debug's own session.
const ADAPTER: &str = "java-debug";
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct TraceProgress {
pub phase: TracePhase,
pub records: u64,
pub dropped: u64,
/// Since the program started running the chain, as the bundle measures it.
pub elapsed_ms: u64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum TracePhase {
Arming,
Running,
/// The terminal operation runs on, keeping no more records.
RecordingStopped,
Aborting,
/// The terminal operation finished: stepping out of it and reading the records.
Collecting,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TraceRun {
/// `generation`: the stop the records were read in, the only one their objects are valid in.
Done {
collected: TraceCollected,
generation: u64,
/// Stops of the traced thread while the program ran the chain, resumed unseen.
resumed_stops: u32,
},
Unavailable {
reason: TraceUnavailable,
},
Failed {
detail: String,
},
/// Stop Recording or Abort Operation came before the terminal operation ran.
Cancelled {
detail: String,
},
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum TraceUnavailable {
/// Not a java-debug session, or no JDT LS bundle behind it.
NoBackend,
NotSuspended,
NotAtChainStart {
detail: String,
},
/// A trace already runs in this session or its JVM.
Busy,
/// java-debug has no debug session for the JVM.
NoSession,
Unsupported {
detail: String,
},
}
/// A trace that finished. Its records keep their objects from being collected until the stop they
/// were read in ends; then the UI no longer shows them and [`release_done`] lets them go.
pub(crate) struct DoneTrace {
tracer: Arc<dyn StreamTracer>,
target: VmTarget,
id: TraceId,
}
/// The stop a finished trace was read in ended (a resume, a step, a `continued` event).
pub(crate) fn release_done(s: &Session) {
let Some(done) = s.stream_trace_done.lock().take() else { return };
let ended = s.ended.clone();
let session = s.id.0;
tokio::spawn(async move {
tokio::select! {
biased;
() = ended.cancelled() => {}
result = done.tracer.release(&done.target, done.id) => {
if let Err(e) = result {
tracing::debug!(session, trace = done.id, "releasing a finished stream trace: {e}");
}
}
}
});
}
/// The session's running trace; `id` is `None` until `arm` answers.
pub(crate) struct ActiveTrace {
tracer: Arc<dyn StreamTracer>,
target: VmTarget,
id: Option<TraceId>,
aborting: bool,
thread_id: i64,
/// From the `continue` that runs the chain until the bundle holds the thread after it.
running: bool,
resumed_stops: u32,
}
/// A stop of the traced thread while the program runs the chain is resumed instead of shown, as
/// IntelliJ does (spec G5): the UI keeps Resume locked meanwhile, and a breakpoint java-debug set
/// since the bundle last switched them off, hit inside the terminal's invoke, would hold that
/// invoke forever. java-debug stops a breakpoint's thread alone; a stop of every thread is shown.
/// `true` when the stop was taken.
pub(crate) fn resume_traced_stop(s: &Arc<Session>, thread_id: Option<i64>, all: bool) -> bool {
let Some(thread_id) = thread_id.filter(|_| !all) else { return false };
{
let mut slot = s.stream_trace.lock();
let Some(active) = slot.as_mut().filter(|a| a.running && a.thread_id == thread_id) else { return false };
active.resumed_stops += 1;
}
let s = s.clone();
tokio::spawn(async move {
let sent =
s.conn.request_timeout("continue", serde_json::json!({ "threadId": thread_id }), RESUME_TIMEOUT).await;
if let Err(e) = sent {
tracing::warn!(session = s.id.0, thread_id, "resuming a stop inside a stream trace: {e}");
}
});
true
}
fn set_running(s: &Session, running: bool) {
if let Some(active) = s.stream_trace.lock().as_mut() {
active.running = running;
}
}
/// Frees the session for the next trace however this one ends, a dropped future included.
struct Claim<'s>(&'s Session);
impl Drop for Claim<'_> {
fn drop(&mut self) {
self.0.stream_trace.lock().take();
}
}
pub(crate) fn set_tracer(s: &Session, tracer: Arc<dyn StreamTracer>) {
*s.stream_tracer.lock() = Some(tracer);
s.emit(DebugEvent::Capabilities);
}
fn tracer(s: &Session) -> Option<Arc<dyn StreamTracer>> {
s.stream_tracer.lock().clone().filter(|_| s.adapter == ADAPTER)
}
pub(crate) fn available(s: &Session) -> bool {
tracer(s).is_some()
}
pub(crate) async fn run(
mgr: &DebugManager,
s: &Session,
thread_id: i64,
plan: &Value,
cancel: &CancellationToken,
progress: &(impl Fn(TraceProgress) + Send + Sync),
) -> TraceRun {
let unavailable = |reason| TraceRun::Unavailable { reason };
let Some(tracer) = tracer(s) else { return unavailable(TraceUnavailable::NoBackend) };
let target = vm_target(s);
let _claim = {
let mut slot = s.stream_trace.lock();
if slot.is_some() {
return unavailable(TraceUnavailable::Busy);
}
*slot = Some(ActiveTrace {
tracer: tracer.clone(),
target: target.clone(),
id: None,
aborting: false,
thread_id,
running: false,
resumed_stops: 0,
});
Claim(s)
};
if !s.suspended.get() {
return unavailable(TraceUnavailable::NotSuspended);
}
// The bundle releases the previous trace itself when this one arms.
s.stream_trace_done.lock().take();
static TOKENS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
let token =
format!("{}-{}-{}", std::process::id(), s.id.0, TOKENS.fetch_add(1, std::sync::atomic::Ordering::Relaxed));
let mut trace = Trace {
mgr,
s,
tracer: &*tracer,
target: &target,
thread_id,
progress,
token,
arm_sent: false,
id: None,
last: Counts::default(),
};
match trace.drive(plan, cancel).await {
Ok(run) => {
if let (TraceRun::Done { .. }, Some(id)) = (&run, trace.id) {
*s.stream_trace_done.lock() = Some(DoneTrace { tracer: tracer.clone(), target: target.clone(), id });
}
run
}
Err(run) => {
// A stop from now on is the user's to see.
set_running(s, false);
trace.release().await;
run
}
}
}
/// `None` when no trace runs or it is still arming. The trace itself goes on to report how the
/// abort ended it.
pub(crate) async fn abort(s: &Session) -> IdeResult<Option<AbortState>> {
let (tracer, target, id) = {
let mut slot = s.stream_trace.lock();
let Some(active) = slot.as_mut() else { return Ok(None) };
let Some(id) = active.id else { return Ok(None) };
active.aborting = true;
(active.tracer.clone(), active.target.clone(), id)
};
let result = tokio::select! {
biased;
() = s.ended.cancelled() => return Ok(None),
result = tracer.abort(&target, id) => result,
};
match result {
Ok(state) => Ok(Some(state)),
Err(InspectError::NoTrace) => Ok(None),
Err(e) => Err(IdeError::internal(format!("cannot abort the stream trace: {e}"))),
}
}
#[derive(Default)]
struct Counts {
records: u64,
dropped: u64,
elapsed_ms: u64,
}
struct Trace<'a, P> {
mgr: &'a DebugManager,
s: &'a Session,
tracer: &'a dyn StreamTracer,
/// The stop the trace was armed in.
target: &'a VmTarget,
thread_id: i64,
progress: &'a P,
/// Names the trace to the bundle before `arm` answers (see [`StreamTracer::release_armed`]).
token: String,
arm_sent: bool,
/// Set once `arm` answers.
id: Option<TraceId>,
last: Counts,
}
impl<P: Fn(TraceProgress) + Send + Sync> Trace<'_, P> {
/// `Err` ends the trace early.
async fn drive(&mut self, plan: &Value, cancel: &CancellationToken) -> Result<TraceRun, TraceRun> {
let (s, tracer, target) = (self.s, self.tracer, self.target);
self.report(TracePhase::Arming);
self.arm_sent = true;
let id = self
.until_ended(tracer.arm(target, self.thread_id, plan, BUDGET, &self.token))
.await?
.map_err(|e| if s.ended.is_cancelled() { ended() } else { refused(e) })?;
self.id = Some(id);
if let Some(active) = s.stream_trace.lock().as_mut() {
active.id = Some(id);
}
// Before the request: the thread can stop again before its reply arrives.
set_running(s, true);
self.dap(self.mgr.resume(s.id, self.thread_id)).await?;
let mut stopped = false;
loop {
if cancel.is_cancelled() && !stopped {
stopped = true;
// Refused when the trace parked or failed just before: `wait` reports that.
match self.until_ended(tracer.stop(target, id)).await? {
Ok(records) => {
self.last.records = records;
self.report(TracePhase::RecordingStopped);
}
Err(e) => tracing::debug!(session = s.id.0, trace = id, "stream trace stop: {e}"),
}
}
match self.inspect(tracer.wait(target, id, WAIT_MS)).await? {
TraceState::Running { records, dropped, elapsed_ms } => {
self.last = Counts { records, dropped, elapsed_ms };
let aborting = s.stream_trace.lock().as_ref().is_some_and(|a| a.aborting);
self.report(if aborting {
TracePhase::Aborting
} else if stopped {
TracePhase::RecordingStopped
} else {
TracePhase::Running
});
}
TraceState::Parked { records, dropped } => {
set_running(s, false);
self.last.records = records;
self.last.dropped = dropped;
break;
}
TraceState::Failed { detail } => return Err(TraceRun::Failed { detail }),
TraceState::Cancelled { detail } => return Err(TraceRun::Cancelled { detail }),
}
}
self.report(TracePhase::Collecting);
let before = s.suspended.ticket();
self.dap(self.mgr.step(s.id, self.thread_id, StepKind::Out)).await?;
// Another thread's stop meanwhile is not this one: the traced thread would still be
// inside the terminal operation.
let stop = async {
loop {
if let Some(ticket) = s.suspended.stopped_since(self.thread_id, before) {
return ticket;
}
tokio::time::sleep(STOP_POLL).await;
}
};
let Ok(generation) = self.until_ended(tokio::time::timeout(STOP_WAIT, stop)).await? else {
// Collecting in the old stop would only be refused as stale.
return Err(TraceRun::Failed { detail: step_out_timeout() });
};
let stopped_in = VmTarget { generation, ..vm_target(s) };
let collected = self.inspect(tracer.collect(&stopped_in, id, self.last.records)).await?;
let resumed_stops = s.stream_trace.lock().as_ref().map_or(0, |a| a.resumed_stops);
Ok(TraceRun::Done { collected, generation, resumed_stops })
}
/// After a trace that ended early. Left to the bundle, an armed trace would keep every
/// breakpoint off and a parked one its thread suspended behind java-debug's back; the bundle
/// undoes either, or does so once a terminal still running returns. Not after a finished
/// trace: the records it unpins are the values the result shows ([`release_done`] does, once
/// that stop ends). An `arm` that never answered (it timed out) may still have armed: released
/// by its token.
async fn release(&self) {
if self.s.ended.is_cancelled() {
return;
}
let work = match self.id {
Some(id) => self.tracer.release(self.target, id),
None if self.arm_sent => self.tracer.release_armed(self.target, &self.token),
None => return,
};
if let Ok(Err(e)) = self.until_ended(work).await {
tracing::debug!(session = self.s.id.0, trace = ?self.id, "stream trace release: {e}");
}
}
fn report(&self, phase: TracePhase) {
let Counts { records, dropped, elapsed_ms } = self.last;
(self.progress)(TraceProgress { phase, records, dropped, elapsed_ms });
}
/// A reply may never come once the session ends.
async fn until_ended<T>(&self, work: impl Future<Output = T>) -> Result<T, TraceRun> {
tokio::select! {
biased;
() = self.s.ended.cancelled() => Err(ended()),
value = work => Ok(value),
}
}
async fn inspect<T>(&self, work: InspectFuture<'_, T>) -> Result<T, TraceRun> {
self.until_ended(work).await?.map_err(|e| self.failed(e.to_string()))
}
async fn dap(&self, work: impl Future<Output = IdeResult<()>>) -> Result<(), TraceRun> {
self.until_ended(work).await?.map_err(|e| self.failed(e.message))
}
/// A request that failed because the session was ending says so.
fn failed(&self, detail: String) -> TraceRun {
if self.s.ended.is_cancelled() { ended() } else { TraceRun::Failed { detail } }
}
}
fn step_out_timeout() -> String {
format!(
"java-debug reported no stop within {} s of stepping out of the stream's terminal operation",
STOP_WAIT.as_secs()
)
}
fn ended() -> TraceRun {
TraceRun::Failed { detail: "the debug session ended".into() }
}
fn refused(e: InspectError) -> TraceRun {
use TraceUnavailable as U;
let reason = match e {
InspectError::NotSuspended => U::NotSuspended,
InspectError::Busy => U::Busy,
InspectError::NoSession => U::NoSession,
InspectError::Unsupported(detail) => U::Unsupported { detail },
InspectError::NotAtChainStart(detail) => U::NotAtChainStart { detail },
other => return TraceRun::Failed { detail: other.to_string() },
};
TraceRun::Unavailable { reason }
}
+3 -55
Переглянути файл
@@ -1,7 +1,6 @@
//! Protocol flow against an in-memory fake adapter.
mod jvm_inspect;
mod stream_trace;
use super::*;
use crate::adapter::{AdapterIo, LaunchFuture};
@@ -72,21 +71,10 @@ async fn windows_stop_releases_the_debuggees_port_before_returning() {
.unwrap();
let pid = child.0.id();
child.1 = Some(ide_core::process::ProcessTree::capture(pid));
// A running program: one suspended at a breakpoint is killed at once (#3658), without the
// wait for its tree this test is about.
let h = harness(Script {
debuggee_pid: Some(pid),
supports_terminate,
continued_after_stop: true,
..Default::default()
});
let h = harness(Script { debuggee_pid: Some(pid), supports_terminate, ..Default::default() });
let id = h.start(config()).await.unwrap();
let session = h.manager.session(id).unwrap();
// The pid, then the stop at launch and the `continued` that ends it.
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid)
|| session.suspended.ticket() == 0
|| session.suspended.get()
{
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
let stop = tokio::spawn({
@@ -144,16 +132,6 @@ struct Script {
continue_reply: Option<Value>,
/// Answer `continue` and stop at a breakpoint again, instead of letting the program exit.
stop_after_continue: bool,
/// Answer `stepOut` and stop these threads one after the other, 100 ms apart (java-debug
/// stops the stepping thread right after the call returns).
step_out_stops: &'static [i64],
/// Refuse `stepOut`.
refuse_step_out: bool,
/// Refuse `continue`.
refuse_continue: bool,
/// Stop thread 1 alone at a breakpoint right after each of the first this many `continue`s
/// that `continue_reply` answers.
breakpoints_after_continue: usize,
/// The `reason` of the stop a `next` ends with (`step` when unset; kotlin-lsp says `breakpoint`).
step_reason: Option<&'static str>,
/// Refuse `next`, then stop at a breakpoint (one the program hit meanwhile).
@@ -207,10 +185,6 @@ impl Default for Script {
hang_up_after_stop: false,
continue_reply: None,
stop_after_continue: false,
step_out_stops: &[],
refuse_step_out: false,
refuse_continue: false,
breakpoints_after_continue: 0,
step_reason: None,
refuse_next: false,
invalidated_after_stop: false,
@@ -274,7 +248,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
let mut running = false;
let mut thread_requests = 0;
let mut unity = false;
let mut breakpoints_left = script.breakpoints_after_continue;
macro_rules! send {
($v:expr) => {{
let mut v: Value = $v;
@@ -521,21 +494,7 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
{"label": ""},
]})
),
"continue" if script.refuse_continue => send!(
json!({"type": "response", "request_seq": msg["seq"], "command": "continue", "success": false, "message": "Thread is not suspended"})
),
"continue" if script.continue_reply.is_some() => {
ok!(msg, script.continue_reply.clone().unwrap());
if breakpoints_left > 0 {
breakpoints_left -= 1;
send!(
json!({"type": "event", "event": "stopped", "body": {"reason": "breakpoint", "threadId": 1}})
);
}
}
"stepOut" if script.refuse_step_out => send!(
json!({"type": "response", "request_seq": msg["seq"], "command": "stepOut", "success": false, "message": "Thread is not suspended"})
),
"continue" if script.continue_reply.is_some() => ok!(msg, script.continue_reply.clone().unwrap()),
"continue" if script.stop_after_continue => {
ok!(msg, json!({"allThreadsContinued": true}));
send!(
@@ -548,16 +507,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
send!(json!({"type": "event", "event": "terminated"}));
}
"pause" if script.hang_up_on_pause => break,
"stepOut" if !script.step_out_stops.is_empty() => {
ok!(msg, Value::Null);
for (i, thread) in script.step_out_stops.iter().enumerate() {
if i > 0 {
tokio::time::sleep(Duration::from_millis(100)).await;
}
let reason = if i + 1 == script.step_out_stops.len() { "step" } else { "breakpoint" };
send!(json!({"type": "event", "event": "stopped", "body": {"reason": reason, "threadId": thread}}));
}
}
"stepIn" | "stepOut" | "pause" => ok!(msg, Value::Null),
"redefineClasses" => {
send!(
@@ -1922,7 +1871,6 @@ fn godot_registry(port: u16, command: &str, args: &[&str]) -> Arc<LanguageRegist
framework_files: Vec::new(),
formatter: None,
scratch_template: None,
rainbow_brackets: Default::default(),
tree_sitter: None,
language_servers: vec![],
debugger: Some(ide_language::DebuggerConfig {
-558
Переглянути файл
@@ -1,558 +0,0 @@
//! A stream chain traced while the program runs it, through a session's stream tracer.
use super::*;
use ide_core::CancellationToken;
use ide_jvm_inspect::{
AbortState, CollectedTerminal, InspectError, InspectFuture, JvmValue, StreamTracer, TraceCollected, TraceId,
TraceState, VmTarget,
};
use std::collections::VecDeque;
use tokio::sync::Notify;
const TRACE: TraceId = 7;
#[derive(Default)]
struct FakeTracer {
/// Answers to `wait`, in order. Once they run out, `wait` signals `waiting` and answers only
/// after more are pushed and `more` is notified.
waits: Mutex<VecDeque<Result<TraceState, InspectError>>>,
arm_error: Mutex<Option<InspectError>>,
stop_error: Mutex<Option<InspectError>>,
collect_error: Mutex<Option<InspectError>>,
/// The record count each `collect` was given.
collect_records: Mutex<Vec<u64>>,
calls: Mutex<Vec<(&'static str, VmTarget)>>,
waiting: Notify,
more: Notify,
}
impl FakeTracer {
fn scripted(waits: impl IntoIterator<Item = TraceState>) -> Arc<Self> {
Self::answering(waits.into_iter().map(Ok))
}
fn answering(waits: impl IntoIterator<Item = Result<TraceState, InspectError>>) -> Arc<Self> {
Arc::new(Self { waits: Mutex::new(waits.into_iter().collect()), ..Self::default() })
}
fn record(&self, name: &'static str, target: &VmTarget) {
self.calls.lock().push((name, target.clone()));
}
fn names(&self) -> Vec<&'static str> {
self.calls.lock().iter().map(|(name, _)| *name).collect()
}
fn target_of(&self, name: &str) -> VmTarget {
self.calls.lock().iter().find(|(n, _)| *n == name).map(|(_, t)| t.clone()).unwrap()
}
}
impl StreamTracer for FakeTracer {
fn arm<'a>(
&'a self,
target: &'a VmTarget,
_thread_id: i64,
_plan: &'a Value,
_budget: u32,
_token: &'a str,
) -> InspectFuture<'a, TraceId> {
self.record("arm", target);
let error = self.arm_error.lock().clone();
Box::pin(async move { error.map_or(Ok(TRACE), Err) })
}
fn wait<'a>(&'a self, target: &'a VmTarget, _trace: TraceId, _ms: u32) -> InspectFuture<'a, TraceState> {
self.record("wait", target);
Box::pin(async move {
loop {
if let Some(state) = self.waits.lock().pop_front() {
return state;
}
self.waiting.notify_one();
self.more.notified().await;
}
})
}
fn stop<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, u64> {
self.record("stop", target);
let error = self.stop_error.lock().clone();
Box::pin(async move { error.map_or(Ok(3), Err) })
}
fn abort<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, AbortState> {
self.record("abort", target);
Box::pin(async { Ok(AbortState::Interrupted) })
}
fn collect<'a>(&'a self, target: &'a VmTarget, _trace: TraceId, records: u64) -> InspectFuture<'a, TraceCollected> {
self.record("collect", target);
self.collect_records.lock().push(records);
let error = self.collect_error.lock().clone();
Box::pin(async move { error.map_or_else(|| Ok(collected()), Err) })
}
fn release<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, ()> {
self.record("release", target);
Box::pin(async { Ok(()) })
}
fn release_armed<'a>(&'a self, target: &'a VmTarget, _token: &'a str) -> InspectFuture<'a, ()> {
self.record("releaseArmed", target);
Box::pin(async { Ok(()) })
}
}
fn collected() -> TraceCollected {
TraceCollected {
records: vec![(0, JvmValue::Primitive { type_name: "int".into(), text: "1".into() })],
dropped: 0,
terminal: CollectedTerminal::Void,
skipped_breakpoints: 0,
sequentialized: false,
}
}
fn running(records: u64) -> TraceState {
TraceState::Running { records, dropped: 0, elapsed_ms: 5 }
}
fn parked() -> TraceState {
TraceState::Parked { records: 10, dropped: 0 }
}
/// java-debug keeps the program running after `continue` and stops right after a `stepOut`.
fn java_debug() -> Script {
Script { continue_reply: Some(json!({"allThreadsContinued": true})), step_out_stops: &[1], ..Script::default() }
}
async fn stopped_java(h: &Harness, tracer: &Arc<FakeTracer>) -> DebugSessionId {
let id = h.start(java_config("launch")).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
h.manager.set_stream_tracer(id, tracer.clone()).unwrap();
id
}
async fn trace(h: &Harness, id: DebugSessionId) -> IdeResult<TraceRun> {
let run = h.manager.stream_trace(id, 1, json!({"steps": []}), CancellationToken::new(), |_| {});
tokio::time::timeout(Duration::from_secs(10), run).await.expect("the trace did not end")
}
/// A trace in its own task, returned once it waits for the answers its tracer has not got.
async fn hanging_trace(
h: &Harness,
id: DebugSessionId,
tracer: &FakeTracer,
) -> tokio::task::JoinHandle<IdeResult<TraceRun>> {
hanging_trace_with(h, id, tracer, |_| {}).await
}
async fn hanging_trace_with(
h: &Harness,
id: DebugSessionId,
tracer: &FakeTracer,
progress: impl Fn(TraceProgress) + Send + Sync + 'static,
) -> tokio::task::JoinHandle<IdeResult<TraceRun>> {
let manager = h.manager.clone();
let task = tokio::spawn(async move {
manager.stream_trace(id, 1, json!({"steps": []}), CancellationToken::new(), progress).await
});
tokio::time::timeout(Duration::from_secs(5), tracer.waiting.notified()).await.expect("the trace did not wait");
task
}
fn phases(seen: &Mutex<Vec<TraceProgress>>) -> Vec<TracePhase> {
seen.lock().iter().map(|p| p.phase).collect()
}
fn progress(phase: TracePhase, records: u64, elapsed_ms: u64) -> TraceProgress {
TraceProgress { phase, records, dropped: 0, elapsed_ms }
}
#[tokio::test]
async fn trace_runs_continue_then_step_out() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([running(10), parked()]);
let id = stopped_java(&h, &tracer).await;
let start = h.manager.session(id).unwrap().suspended.ticket();
let run = trace(&h, id).await.unwrap();
let TraceRun::Done { collected: got, generation, resumed_stops } = run else { panic!("not done: {run:?}") };
assert_eq!(got, collected());
assert_eq!(resumed_stops, 0);
assert!(generation > start, "collected in the stop of the trace ({start}), not after it ({generation})");
let commands = h.commands();
let resumed = commands.iter().position(|c| c == "continue").expect("no continue");
let stepped = commands.iter().position(|c| c == "stepOut").expect("no stepOut");
assert!(resumed < stepped, "{commands:?}");
assert_eq!(h.request("continue")["arguments"]["threadId"], 1);
assert_eq!(h.request("stepOut")["arguments"]["threadId"], 1);
assert_eq!(tracer.names(), ["arm", "wait", "wait", "collect"]);
assert_eq!(*tracer.collect_records.lock(), [10], "collect is told how many records the trace parked with");
assert_eq!(tracer.target_of("arm").generation, start);
assert_eq!(tracer.target_of("collect").generation, generation);
assert!(h.manager.session(id).unwrap().suspended.get());
}
#[tokio::test]
async fn trace_reports_progress() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([running(10), parked()]);
let id = stopped_java(&h, &tracer).await;
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
let sink = seen.clone();
let run = h.manager.stream_trace(id, 1, json!({}), CancellationToken::new(), move |p| sink.lock().push(p)).await;
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
assert_eq!(
*seen.lock(),
[
progress(TracePhase::Arming, 0, 0),
progress(TracePhase::Running, 10, 5),
progress(TracePhase::Collecting, 10, 5),
]
);
}
#[tokio::test]
async fn cancel_stops_recording_once() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([running(10), running(12), parked()]);
let id = stopped_java(&h, &tracer).await;
let cancel = CancellationToken::new();
let on_running = cancel.clone();
let seen: Arc<Mutex<Vec<TracePhase>>> = Arc::default();
let sink = seen.clone();
let run = h
.manager
.stream_trace(id, 1, json!({}), cancel, move |p| {
if p.phase == TracePhase::Running {
on_running.cancel();
}
sink.lock().push(p.phase);
})
.await;
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
assert_eq!(tracer.names(), ["arm", "wait", "stop", "wait", "wait", "collect"]);
assert_eq!(
*seen.lock(),
[
TracePhase::Arming,
TracePhase::Running,
TracePhase::RecordingStopped,
TracePhase::RecordingStopped,
TracePhase::Collecting
]
);
}
#[tokio::test]
async fn second_trace_is_busy() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let first = hanging_trace(&h, id, &tracer).await;
let second = trace(&h, id).await.unwrap();
assert_eq!(second, TraceRun::Unavailable { reason: TraceUnavailable::Busy });
assert_eq!(tracer.names().iter().filter(|n| **n == "arm").count(), 1);
first.abort();
}
#[tokio::test]
async fn trace_ends_when_session_ends() {
// The fake adapter lets the program exit on `continue`.
let h = harness(Script::default());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let session = h.manager.session(id).unwrap();
let run = trace(&h, id).await.unwrap();
assert_eq!(run, TraceRun::Failed { detail: "the debug session ended".into() });
assert!(session.stream_trace.lock().is_none());
let next = trace(&h, id).await;
assert!(!matches!(next, Ok(TraceRun::Unavailable { reason: TraceUnavailable::Busy })), "{next:?}");
}
#[tokio::test]
async fn dropping_the_trace_frees_the_session() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let first = hanging_trace(&h, id, &tracer).await;
first.abort();
assert!(first.await.unwrap_err().is_cancelled());
let session = h.manager.session(id).unwrap();
assert!(session.stream_trace.lock().is_none());
// The first trace resumed the thread.
session.suspended.stopped(Some(1), false);
let again = hanging_trace(&h, id, &tracer).await;
assert_eq!(tracer.names().iter().filter(|n| **n == "arm").count(), 2);
again.abort();
}
#[tokio::test]
async fn arm_errors_map_to_unavailable_or_failed() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
*tracer.arm_error.lock() = Some(InspectError::NotAtChainStart("the stop is on line 4".into()));
assert_eq!(
trace(&h, id).await.unwrap(),
TraceRun::Unavailable { reason: TraceUnavailable::NotAtChainStart { detail: "the stop is on line 4".into() } }
);
*tracer.arm_error.lock() = Some(InspectError::TimedOut);
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: InspectError::TimedOut.to_string() });
assert!(!h.commands().iter().any(|c| c == "continue"));
}
#[tokio::test]
async fn abort_reaches_the_running_trace() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
assert_eq!(h.manager.stream_trace_abort(id).await.unwrap(), None);
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
let sink = seen.clone();
let task = hanging_trace_with(&h, id, &tracer, move |p| sink.lock().push(p)).await;
assert_eq!(h.manager.stream_trace_abort(id).await.unwrap(), Some(AbortState::Interrupted));
assert_eq!(tracer.target_of("abort"), tracer.target_of("arm"));
let thrown = "java.lang.RuntimeException: oi-cancel:1";
tracer.waits.lock().extend([Ok(running(4)), Ok(TraceState::Failed { detail: thrown.into() })]);
tracer.more.notify_one();
let run = tokio::time::timeout(Duration::from_secs(5), task).await.unwrap().unwrap().unwrap();
assert_eq!(run, TraceRun::Failed { detail: thrown.into() });
assert_eq!(phases(&seen), [TracePhase::Arming, TracePhase::Aborting]);
assert_eq!(tracer.names().last(), Some(&"release"));
}
#[tokio::test]
async fn failed_wait_passes_its_detail_through() {
let h = harness(java_debug());
let detail = "the program began to exit while the stream ran: stop the debug session";
let tracer = FakeTracer::scripted([running(1), TraceState::Failed { detail: detail.into() }]);
let id = stopped_java(&h, &tracer).await;
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: detail.into() });
assert_eq!(tracer.names(), ["arm", "wait", "wait", "release"]);
assert!(!h.commands().iter().any(|c| c == "stepOut"));
}
#[tokio::test]
async fn a_trace_cancelled_before_its_terminal_says_so() {
let detail = "cancelled before the terminal ran";
let tracer = FakeTracer::scripted([TraceState::Cancelled { detail: detail.into() }]);
let h = harness(java_debug());
let id = stopped_java(&h, &tracer).await;
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Cancelled { detail: detail.into() });
assert!(!h.commands().iter().any(|c| c == "stepOut"));
}
#[tokio::test]
async fn a_wait_that_errs_releases_the_trace() {
let h = harness(java_debug());
let tracer = FakeTracer::answering([Ok(running(1)), Err(InspectError::TimedOut)]);
let id = stopped_java(&h, &tracer).await;
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: InspectError::TimedOut.to_string() });
assert_eq!(tracer.names(), ["arm", "wait", "wait", "release"]);
assert_eq!(tracer.target_of("release"), tracer.target_of("arm"));
}
#[tokio::test]
async fn a_refused_step_out_releases_the_trace() {
let h = harness(Script { refuse_step_out: true, ..java_debug() });
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
let run = trace(&h, id).await.unwrap();
assert!(matches!(&run, TraceRun::Failed { detail } if detail.contains("not suspended")), "{run:?}");
assert_eq!(tracer.names(), ["arm", "wait", "release"]);
}
#[tokio::test]
async fn a_refused_continue_releases_the_trace() {
let h = harness(Script { refuse_continue: true, ..java_debug() });
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let run = trace(&h, id).await.unwrap();
assert!(matches!(&run, TraceRun::Failed { .. }), "{run:?}");
assert_eq!(tracer.names(), ["arm", "release"]);
}
#[tokio::test]
async fn a_failed_collect_releases_the_trace() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([parked()]);
*tracer.collect_error.lock() = Some(InspectError::Stale);
let id = stopped_java(&h, &tracer).await;
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Failed { .. }));
assert_eq!(tracer.names(), ["arm", "wait", "collect", "release"]);
}
fn stops(h: &Harness) -> usize {
h.events.lock().iter().filter(|e| matches!(e, IdeEvent::Debug { event: DebugEvent::Stopped { .. }, .. })).count()
}
#[tokio::test]
async fn a_stop_of_the_traced_thread_while_the_chain_runs_is_resumed_unseen() {
// A breakpoint java-debug set meanwhile, hit inside the terminal's invoke before the bundle
// switched it off: held there, the invoke would never return.
let h = harness(Script { breakpoints_after_continue: 1, ..java_debug() });
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let shown = stops(&h);
let task = hanging_trace(&h, id, &tracer).await;
for _ in 0..200 {
if h.commands().iter().filter(|c| *c == "continue").count() == 2 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
assert_eq!(h.commands().iter().filter(|c| *c == "continue").count(), 2, "{:?}", h.commands());
assert_eq!(h.log.lock().iter().rfind(|m| m["command"] == "continue").unwrap()["arguments"]["threadId"], 1);
tracer.waits.lock().push_back(Ok(parked()));
tracer.more.notify_one();
let run = tokio::time::timeout(Duration::from_secs(5), task).await.unwrap().unwrap().unwrap();
let TraceRun::Done { resumed_stops, .. } = run else { panic!("not done: {run:?}") };
assert_eq!(resumed_stops, 1);
assert_eq!(stops(&h), shown + 1, "only the step-out stop is shown, after the trace parked");
}
#[tokio::test]
async fn a_finished_trace_is_not_released() {
// Releasing unpins the records, which the result's values still show until the program runs on.
let h = harness(java_debug());
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Done { .. }));
assert!(!tracer.names().contains(&"release"), "{:?}", tracer.names());
}
#[tokio::test]
async fn a_finished_trace_is_released_once_the_program_runs_on() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Done { .. }));
h.manager.resume(id, 1).await.unwrap();
tokio::time::timeout(Duration::from_secs(5), async {
while !tracer.names().contains(&"release") {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("the finished trace was not released");
assert_eq!(tracer.names().iter().filter(|n| **n == "release").count(), 1);
}
#[tokio::test]
async fn an_arm_without_a_reply_is_released_by_its_token() {
// The bundle may still finish arming after the reply timed out: its breakpoints would stay off.
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
*tracer.arm_error.lock() = Some(InspectError::TimedOut);
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Failed { .. }));
assert_eq!(tracer.names(), ["arm", "releaseArmed"]);
}
#[tokio::test]
async fn refused_stop_leaves_the_outcome_to_wait() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([running(10), parked()]);
*tracer.stop_error.lock() = Some(InspectError::NoTrace);
let id = stopped_java(&h, &tracer).await;
let cancel = CancellationToken::new();
let on_running = cancel.clone();
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
let sink = seen.clone();
let run = h
.manager
.stream_trace(id, 1, json!({}), cancel, move |p| {
if p.phase == TracePhase::Running {
on_running.cancel();
}
sink.lock().push(p);
})
.await;
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
assert_eq!(tracer.names(), ["arm", "wait", "stop", "wait", "collect"]);
assert_eq!(phases(&seen), [TracePhase::Arming, TracePhase::Running, TracePhase::Collecting]);
}
#[tokio::test]
async fn another_threads_stop_is_not_the_step_out() {
// Thread 2 stops at a breakpoint 100 ms before the traced thread's step out ends.
let h = harness(Script { step_out_stops: &[2, 1], ..java_debug() });
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
let start = h.manager.session(id).unwrap().suspended.ticket();
let run = trace(&h, id).await.unwrap();
let TraceRun::Done { generation, .. } = run else { panic!("not done: {run:?}") };
assert_eq!(
generation,
start + 2,
"collected in thread 2's stop, not in the traced thread's step-out stop after it"
);
assert_eq!(tracer.target_of("collect").generation, generation);
}
#[tokio::test]
async fn step_out_without_a_stop_times_out() {
let h = harness(Script { step_out_stops: &[], ..java_debug() });
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
tokio::time::pause();
let run = h.manager.stream_trace(id, 1, json!({}), CancellationToken::new(), |_| {}).await.unwrap();
assert_eq!(
run,
TraceRun::Failed {
detail: "java-debug reported no stop within 30 s of stepping out of the stream's terminal operation".into()
}
);
assert!(h.commands().iter().any(|c| c == "stepOut"));
assert_eq!(tracer.names(), ["arm", "wait", "release"]);
}
#[tokio::test]
async fn capability_only_for_java_debug() {
let h = harness(Script::default());
let tracer = FakeTracer::scripted([]);
let java = h.start(java_config("launch")).await.unwrap();
assert!(!h.manager.capabilities(java).unwrap().stream_trace);
h.manager.set_stream_tracer(java, tracer.clone()).unwrap();
assert!(h.manager.capabilities(java).unwrap().stream_trace);
let other = h.start(config()).await.unwrap();
h.manager.set_stream_tracer(other, tracer.clone()).unwrap();
assert!(!h.manager.capabilities(other).unwrap().stream_trace);
}
+2 -64
Переглянути файл
@@ -14,7 +14,6 @@ mod snowflake;
pub mod source;
pub mod split;
pub mod sql;
pub mod tools;
mod watch;
pub use watch::SourcesWatch;
@@ -280,18 +279,6 @@ type Session = Arc<tokio::sync::Mutex<Option<Held>>>;
const MAX_META_ROWS: usize = 100_000;
/// Rows of catalog query `q`, run again as [`sql::postgres_legacy`] when a PostgreSQL server's
/// catalog lacks a column it reads (openGauss, PostgreSQL 9).
async fn catalog_rows(pool: &Pool, q: &str) -> IdeResult<Vec<Vec<Option<String>>>> {
match pool.rows(q, MAX_META_ROWS).await {
Err(e) if pool.driver() == DbDriver::Postgres => match sql::postgres_legacy(q) {
Some(legacy) => pool.rows(&legacy, MAX_META_ROWS).await.map_err(|_| e),
None => Err(e),
},
rows => rows,
}
}
fn flag(v: &Option<String>) -> bool {
matches!(v.as_deref(), Some("1" | "t" | "true" | "YES"))
}
@@ -788,56 +775,6 @@ impl DbManager {
Ok(v.unwrap_or_else(|| "Connected".into()))
}
/// Runs `job` with the client tool at `executable` against target `id`, connected like the
/// data source (through its SSH tunnel, with its SSL settings and password), until it exits
/// or `cancel` fires. Connects first, so a missing password fails the way it does for a
/// console. Returns the exit code.
pub async fn run_tool(
&self,
id: &str,
executable: &std::path::Path,
job: &tools::DbToolJob,
cancel: &CancellationToken,
on_output: impl FnMut(Vec<tools::ToolLine>),
) -> IdeResult<Option<i32>> {
let tool = job.tool();
if !tool.is_program(executable) {
return Err(IdeError::invalid(format!("{} is not {}", executable.display(), tool.program())));
}
let source = self.source(id)?;
if source.driver != tool.driver() {
return Err(IdeError::invalid(format!("{} cannot connect to {}", tool.program(), source.name)));
}
self.pool(id).await?;
let password = self.password(&source).await;
// Holding the tunnel keeps it open while the tool runs, even if the tree disconnects.
let (target, _tunnel) = self.endpoint(&source, None, true).await?;
let prepared = tools::prepare(job, &target, password.as_deref());
tools::run(executable, &prepared.args, &prepared.env, cancel, on_output).await
}
/// The command [`DbManager::run_tool`] would run, for the dialogs' preview: the data source's
/// own host and port (not a tunnel's local end), and no password.
pub fn tool_preview(&self, id: &str, executable: &std::path::Path, job: &tools::DbToolJob) -> IdeResult<String> {
let source = self.source(id)?;
let prepared = tools::prepare(job, &source, None);
Ok(tools::command_line(executable, &prepared.args))
}
/// The PostgreSQL server's `server_version_num` (`150013` for 15.13).
pub async fn server_version(&self, id: &str) -> IdeResult<u32> {
let pool = self.pool(id).await?;
if pool.driver() != DbDriver::Postgres {
return Err(IdeError::invalid("not a PostgreSQL data source"));
}
let rows = pool.rows("SHOW server_version_num", 1).await?;
rows.into_iter()
.next()
.and_then(|r| r.into_iter().next().flatten())
.and_then(|v| v.trim().parse().ok())
.ok_or_else(|| IdeError::internal("no server version"))
}
pub fn is_connected(&self, id: &str) -> bool {
self.pools.lock().contains_key(id)
}
@@ -1142,7 +1079,8 @@ impl DbManager {
let driver = pool.driver();
let mut out = SchemaObjects::default();
if let Some(q) = sql::routines(driver, schema) {
out.routines = catalog_rows(&pool, &q)
out.routines = pool
.rows(&q, MAX_META_ROWS)
.await?
.into_iter()
.filter_map(|r| {
+7 -51
Переглянути файл
@@ -219,9 +219,6 @@ pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {
}
/// Rows: `index name, unique (0/1), column` (one row per indexed column, in order).
// Key columns are paired from one series up to `max_index_keys` (the server's INDEX_MAX_KEYS, the
// most columns an index or key has): unlike a series per catalog row, it lets the planner find the
// table's rows through the catalog's index first.
pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
match driver {
@@ -239,8 +236,8 @@ pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
"SELECT i.relname, CASE WHEN ix.indisunique THEN 1 ELSE 0 END, a.attname \
FROM pg_index ix JOIN pg_class t ON t.oid = ix.indrelid JOIN pg_class i ON i.oid = ix.indexrelid \
JOIN pg_namespace n ON n.oid = t.relnamespace \
JOIN generate_series(0, current_setting('max_index_keys')::int - 1) AS k(ord) ON k.ord < ix.indnatts \
JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ix.indkey[k.ord] \
JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord) ON true \
JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum \
WHERE n.nspname = {s} AND t.relname = {t} ORDER BY i.relname, k.ord"
),
DbDriver::Mysql => format!(
@@ -287,15 +284,12 @@ pub fn completion_columns(driver: DbDriver) -> &'static str {
FROM sqlite_master m JOIN pragma_table_info(m.name) p \
WHERE m.type IN ('table', 'view') AND m.name NOT LIKE 'sqlite\\_%' ESCAPE '\\' ORDER BY m.name, p.cid"
}
// Identity columns own their sequence through an internal dependency (`attidentity` is PostgreSQL 10+).
DbDriver::Postgres => {
"SELECT n.nspname, c.relname, CASE c.relkind WHEN 'v' THEN 'view' WHEN 'm' THEN 'materialized view' ELSE 'table' END, a.attname, \
format_type(a.atttypid, a.atttypmod), CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END, \
CASE WHEN EXISTS (SELECT 1 FROM pg_index i WHERE i.indrelid = c.oid AND i.indisprimary \
AND a.attnum = ANY(i.indkey)) THEN 1 ELSE 0 END, \
CASE WHEN a.atthasdef OR EXISTS (SELECT 1 FROM pg_depend d WHERE d.refclassid = 'pg_class'::regclass \
AND d.refobjid = c.oid AND d.refobjsubid = a.attnum AND d.classid = 'pg_class'::regclass \
AND d.deptype = 'i') THEN 1 ELSE 0 END \
CASE WHEN a.atthasdef OR a.attidentity <> '' THEN 1 ELSE 0 END \
FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace JOIN pg_attribute a ON a.attrelid = c.oid \
WHERE c.relkind IN ('r', 'v', 'm', 'p', 'f') AND a.attnum > 0 AND NOT a.attisdropped \
AND n.nspname NOT IN ('pg_catalog', 'information_schema') \
@@ -369,9 +363,9 @@ pub fn foreign_keys(driver: DbDriver) -> &'static str {
FROM pg_constraint con \
JOIN pg_class sc ON sc.oid = con.conrelid JOIN pg_namespace sn ON sn.oid = sc.relnamespace \
JOIN pg_class tc ON tc.oid = con.confrelid JOIN pg_namespace tn ON tn.oid = tc.relnamespace \
JOIN generate_series(1, current_setting('max_index_keys')::int) AS k(ord) ON k.ord <= array_upper(con.conkey, 1) \
JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = con.conkey[k.ord] \
JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = con.confkey[k.ord] \
CROSS JOIN LATERAL unnest(con.conkey, con.confkey) WITH ORDINALITY AS k(s, t, ord) \
JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = k.s \
JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = k.t \
WHERE con.contype = 'f' AND sn.nspname NOT IN ('pg_catalog', 'information_schema') \
ORDER BY 1, 2, 3, k.ord LIMIT 20000"
}
@@ -414,7 +408,7 @@ pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String
"SELECT {s}, {t}, f.id, f.\"from\", {s}, f.\"table\", f.\"to\" FROM pragma_foreign_key_list({t}, {s}) f ORDER BY f.id, f.seq"
),
DbDriver::Postgres => format!(
"SELECT sn.nspname, sc.relname, con.conname, sa.attname, tn.nspname, tc.relname, ta.attname FROM pg_constraint con JOIN pg_class sc ON sc.oid = con.conrelid JOIN pg_namespace sn ON sn.oid = sc.relnamespace JOIN pg_class tc ON tc.oid = con.confrelid JOIN pg_namespace tn ON tn.oid = tc.relnamespace JOIN generate_series(1, current_setting('max_index_keys')::int) AS k(ord) ON k.ord <= array_upper(con.conkey, 1) JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = con.conkey[k.ord] JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = con.confkey[k.ord] WHERE con.contype = 'f' AND sn.nspname = {s} AND sc.relname = {t} ORDER BY 3, k.ord"
"SELECT sn.nspname, sc.relname, con.conname, sa.attname, tn.nspname, tc.relname, ta.attname FROM pg_constraint con JOIN pg_class sc ON sc.oid = con.conrelid JOIN pg_namespace sn ON sn.oid = sc.relnamespace JOIN pg_class tc ON tc.oid = con.confrelid JOIN pg_namespace tn ON tn.oid = tc.relnamespace CROSS JOIN LATERAL unnest(con.conkey, con.confkey) WITH ORDINALITY AS k(s, t, ord) JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = k.s JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = k.t WHERE con.contype = 'f' AND sn.nspname = {s} AND sc.relname = {t} ORDER BY 3, k.ord"
),
DbDriver::Mysql => format!(
"SELECT table_schema, table_name, constraint_name, column_name, referenced_table_schema, referenced_table_name, referenced_column_name FROM information_schema.key_column_usage WHERE referenced_table_name IS NOT NULL AND table_schema = {s} AND table_name = {t} ORDER BY constraint_name, ordinal_position"
@@ -677,16 +671,6 @@ pub fn sqlite_trigger_event(sql: &str) -> (String, String) {
(timing.to_owned(), event.to_ascii_lowercase())
}
/// PostgreSQL catalog query `sql` of this module for servers whose catalog predates a column
/// it reads: PostgreSQL before 11 (`prokind`), and the servers built on an older PostgreSQL
/// (openGauss, GaussDB). `None` when it reads none.
pub fn postgres_legacy(sql: &str) -> Option<String> {
let legacy = sql
.replace("CASE WHEN p.prokind = 'p' THEN 'procedure' ELSE 'function' END", "'function'")
.replace("p.prokind IN ('f', 'p')", "NOT p.proisagg AND NOT p.proiswindow");
(legacy != sql).then_some(legacy)
}
/// Rows: `name, kind (function/procedure), arguments, result` of a schema's routines (none in SQLite).
pub fn routines(driver: DbDriver, schema: &str) -> Option<String> {
let s = quote_literal(driver, schema);
@@ -1188,32 +1172,4 @@ mod tests {
assert_eq!(crate::conn::begin_statement(driver), "BEGIN");
assert_eq!(crate::plan::explain_statement(driver, "select 1;"), "EXPLAIN USING TABULAR select 1");
}
#[test]
fn postgres_catalog_queries_run_on_older_servers() {
let pg = DbDriver::Postgres;
// Neither LATERAL (9.3), WITH ORDINALITY (9.4) nor attidentity (10) in any metadata query:
// openGauss / GaussDB parse 9.2's grammar and catalog. `prokind` (11) has its legacy rerun.
let queries = [
schemas(pg, false).to_owned(),
schemas(pg, true).to_owned(),
tables(pg, "s"),
columns(pg, "s", "t"),
indexes(pg, "s", "t"),
completion_columns(pg).to_owned(),
foreign_keys(pg).to_owned(),
table_foreign_keys(pg, "s", "t"),
triggers(pg, "s", "t"),
routines(pg, "s").unwrap(),
sequences(pg, "s").unwrap(),
];
for q in queries {
let upper = q.to_uppercase();
assert!(!["LATERAL", "ORDINALITY", "ATTIDENTITY"].iter().any(|w| upper.contains(w)), "{q}");
}
assert_eq!(postgres_legacy(completion_columns(pg)), None);
let routines = postgres_legacy(&routines(pg, "s").unwrap()).unwrap();
assert!(!routines.contains("prokind") && routines.contains("NOT p.proisagg"));
assert_eq!(postgres_legacy(&indexes(pg, "s", "t")), None);
}
}
-341
Переглянути файл
@@ -1,341 +0,0 @@
//! What a dump or restore dialog asks for, as typed options, and the arguments that do it.
//! The connection arguments come from [`super::connection`]; these are the rest.
use super::DbTool;
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbDumpFormat {
/// SQL text, restored with `psql`.
Plain,
Custom,
/// A directory of files; the only format `pg_dump` writes in parallel.
Directory,
Tar,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbDumpStatements {
Copy,
Inserts,
ColumnInserts,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbDumpContent {
All,
SchemaOnly,
DataOnly,
}
/// Name lists hold `pg_dump` patterns (`*`, `?`, quoted names).
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbPgDumpOptions {
pub format: DbDumpFormat,
pub statements: DbDumpStatements,
pub content: DbDumpContent,
pub schemas: Vec<String>,
pub tables: Vec<String>,
pub exclude_tables: Vec<String>,
/// Plain format only: archives get DROP / CREATE at restore.
pub clean: bool,
pub if_exists: bool,
pub create: bool,
pub no_owner: bool,
pub no_privileges: bool,
/// Directory format only.
pub jobs: u32,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbPgRestoreOptions {
pub content: DbDumpContent,
pub schemas: Vec<String>,
pub clean: bool,
pub if_exists: bool,
pub no_owner: bool,
pub no_privileges: bool,
pub single_transaction: bool,
pub exit_on_error: bool,
/// Ignored with a single transaction, which `pg_restore` cannot split.
pub jobs: u32,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbPsqlOptions {
pub single_transaction: bool,
pub stop_on_error: bool,
}
/// A run of a client tool: which one, the file it writes or reads, and its options.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "tool", rename_all = "camelCase")]
pub enum DbToolJob {
PgDump {
file: String,
options: DbPgDumpOptions,
},
/// `file`: an archive, or a directory archive.
PgRestore {
file: String,
options: DbPgRestoreOptions,
},
Psql {
file: String,
options: DbPsqlOptions,
},
}
impl DbToolJob {
pub fn tool(&self) -> DbTool {
match self {
DbToolJob::PgDump { .. } => DbTool::PgDump,
DbToolJob::PgRestore { .. } => DbTool::PgRestore,
DbToolJob::Psql { .. } => DbTool::Psql,
}
}
/// The arguments after the connection ones.
pub fn args(&self) -> Vec<String> {
match self {
DbToolJob::PgDump { file, options } => pg_dump(options, file),
DbToolJob::PgRestore { file, options } => pg_restore(options, file),
DbToolJob::Psql { file, options } => psql(options, file),
}
}
}
fn flag(on: bool, flag: &str) -> Option<String> {
on.then(|| flag.to_owned())
}
fn content(c: DbDumpContent) -> Option<String> {
match c {
DbDumpContent::All => None,
DbDumpContent::SchemaOnly => Some("--schema-only".into()),
DbDumpContent::DataOnly => Some("--data-only".into()),
}
}
fn each(names: &[String], option: &str) -> impl Iterator<Item = String> {
names.iter().map(|n| n.trim()).filter(|n| !n.is_empty()).map(move |n| format!("--{option}={n}"))
}
fn pg_dump(o: &DbPgDumpOptions, file: &str) -> Vec<String> {
let plain = o.format == DbDumpFormat::Plain;
let format = match o.format {
DbDumpFormat::Plain => "p",
DbDumpFormat::Custom => "c",
DbDumpFormat::Directory => "d",
DbDumpFormat::Tar => "t",
};
let mut args = vec![format!("--format={format}"), format!("--file={file}")];
args.extend(match o.statements {
DbDumpStatements::Copy => None,
DbDumpStatements::Inserts => Some("--inserts".to_owned()),
DbDumpStatements::ColumnInserts => Some("--column-inserts".to_owned()),
});
args.extend(content(o.content));
args.extend(each(&o.schemas, "schema"));
args.extend(each(&o.tables, "table"));
args.extend(each(&o.exclude_tables, "exclude-table"));
args.extend(flag(plain && o.clean, "--clean"));
args.extend(flag(plain && o.clean && o.if_exists, "--if-exists"));
args.extend(flag(plain && o.create, "--create"));
args.extend(flag(o.no_owner, "--no-owner"));
args.extend(flag(o.no_privileges, "--no-privileges"));
if o.format == DbDumpFormat::Directory && o.jobs > 1 {
args.push(format!("--jobs={}", o.jobs));
}
args.push("--verbose".into());
args
}
fn pg_restore(o: &DbPgRestoreOptions, file: &str) -> Vec<String> {
let mut args: Vec<String> = content(o.content).into_iter().collect();
args.extend(each(&o.schemas, "schema"));
args.extend(flag(o.clean, "--clean"));
args.extend(flag(o.clean && o.if_exists, "--if-exists"));
args.extend(flag(o.no_owner, "--no-owner"));
args.extend(flag(o.no_privileges, "--no-privileges"));
args.extend(flag(o.single_transaction, "--single-transaction"));
args.extend(flag(o.exit_on_error, "--exit-on-error"));
if o.jobs > 1 && !o.single_transaction {
args.push(format!("--jobs={}", o.jobs));
}
args.push("--verbose".into());
if !file.is_empty() {
args.push(file.to_owned());
}
args
}
fn psql(o: &DbPsqlOptions, file: &str) -> Vec<String> {
// `~/.psqlrc` could switch databases or change settings before the dump runs.
let mut args = vec!["--no-psqlrc".to_owned()];
args.extend((!file.is_empty()).then(|| format!("--file={file}")));
args.extend(flag(o.single_transaction, "--single-transaction"));
args.extend(flag(o.stop_on_error, "--set=ON_ERROR_STOP=1"));
args
}
/// The command as a shell would need it typed: the dialogs' preview.
pub fn command_line(program: &Path, args: &[String]) -> String {
let quote = |s: &str| {
if !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || "@%+=:,./-_".contains(c)) {
s.to_owned()
} else {
format!("'{}'", s.replace('\'', "'\\''"))
}
};
std::iter::once(program.to_string_lossy().into_owned())
.chain(args.iter().cloned())
.map(|a| quote(&a))
.collect::<Vec<_>>()
.join(" ")
}
#[cfg(test)]
mod tests {
use super::*;
fn dump() -> DbPgDumpOptions {
DbPgDumpOptions {
format: DbDumpFormat::Plain,
statements: DbDumpStatements::Copy,
content: DbDumpContent::All,
schemas: vec![],
tables: vec![],
exclude_tables: vec![],
clean: false,
if_exists: false,
create: false,
no_owner: false,
no_privileges: false,
jobs: 1,
}
}
fn restore() -> DbPgRestoreOptions {
DbPgRestoreOptions {
content: DbDumpContent::All,
schemas: vec![],
clean: false,
if_exists: false,
no_owner: false,
no_privileges: false,
single_transaction: false,
exit_on_error: true,
jobs: 1,
}
}
fn args(job: DbToolJob) -> Vec<String> {
job.args()
}
#[test]
fn dumps_plain_sql_with_copy_by_default() {
let job = DbToolJob::PgDump { file: "/tmp/shop.sql".into(), options: dump() };
assert_eq!(args(job), ["--format=p", "--file=/tmp/shop.sql", "--verbose"]);
}
#[test]
fn turns_lists_and_switches_into_flags() {
let options = DbPgDumpOptions {
statements: DbDumpStatements::ColumnInserts,
content: DbDumpContent::DataOnly,
schemas: vec!["public".into(), "audit".into()],
tables: vec!["public.orders".into()],
exclude_tables: vec!["public.log_*".into()],
clean: true,
if_exists: true,
create: true,
no_owner: true,
..dump()
};
assert_eq!(
args(DbToolJob::PgDump { file: "/tmp/x.sql".into(), options }),
[
"--format=p",
"--file=/tmp/x.sql",
"--column-inserts",
"--data-only",
"--schema=public",
"--schema=audit",
"--table=public.orders",
"--exclude-table=public.log_*",
"--clean",
"--if-exists",
"--create",
"--no-owner",
"--verbose",
]
);
}
#[test]
fn leaves_drop_and_create_to_the_restore_of_an_archive() {
let options = DbPgDumpOptions { format: DbDumpFormat::Custom, clean: true, create: true, ..dump() };
let a = args(DbToolJob::PgDump { file: "/tmp/x.dump".into(), options });
assert!(!a.iter().any(|a| a == "--clean" || a == "--create"), "{a:?}");
}
#[test]
fn runs_parallel_jobs_only_where_the_tool_can() {
let dir = DbPgDumpOptions { format: DbDumpFormat::Directory, jobs: 4, ..dump() };
assert!(args(DbToolJob::PgDump { file: "/tmp/d".into(), options: dir.clone() }).contains(&"--jobs=4".into()));
let custom = DbPgDumpOptions { format: DbDumpFormat::Custom, ..dir };
assert!(!args(DbToolJob::PgDump { file: "/tmp/d".into(), options: custom }).contains(&"--jobs=4".into()));
let single = DbPgRestoreOptions { jobs: 4, single_transaction: true, ..restore() };
let a = args(DbToolJob::PgRestore { file: "/tmp/x".into(), options: single });
assert!(a.contains(&"--single-transaction".into()) && !a.iter().any(|a| a.starts_with("--jobs")));
}
#[test]
fn restores_the_archive_named_last_and_stops_on_the_first_error() {
assert_eq!(
args(DbToolJob::PgRestore { file: "/tmp/shop.dump".into(), options: restore() }),
["--exit-on-error", "--verbose", "/tmp/shop.dump"]
);
}
#[test]
fn leaves_out_an_archive_not_chosen_yet() {
let a = args(DbToolJob::PgRestore { file: String::new(), options: restore() });
assert_eq!(a, ["--exit-on-error", "--verbose"]);
}
#[test]
fn runs_a_sql_file_in_one_transaction_that_stops_on_error() {
let options = DbPsqlOptions { single_transaction: true, stop_on_error: true };
assert_eq!(
args(DbToolJob::Psql { file: "/tmp/shop.sql".into(), options }),
["--no-psqlrc", "--file=/tmp/shop.sql", "--single-transaction", "--set=ON_ERROR_STOP=1"]
);
}
#[test]
fn quotes_what_a_shell_would_split() {
let line = command_line(
Path::new("/usr/bin/pg_dump"),
&["--port=5432".into(), "--file=/tmp/my dump.sql".into(), "--table=it's".into()],
);
assert_eq!(line, r#"/usr/bin/pg_dump --port=5432 '--file=/tmp/my dump.sql' '--table=it'\''s'"#);
}
#[test]
fn reads_the_job_the_dialog_sends() {
let json = r#"{"tool":"psql","file":"/tmp/a.sql","options":{"singleTransaction":true,"stopOnError":false}}"#;
let job: DbToolJob = serde_json::from_str(json).unwrap();
assert_eq!(job.tool(), DbTool::Psql);
}
}
-558
Переглянути файл
@@ -1,558 +0,0 @@
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`): finding installed copies, the
//! arguments and environment that connect them like the data source, and running them.
mod jobs;
pub use jobs::*;
use crate::source::{DataSource, DbDriver, DbSslMode};
use ide_core::{CancellationToken, IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::ffi::OsStr;
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::time::Duration;
use tokio::io::{AsyncBufReadExt, AsyncRead, BufReader};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbTool {
PgDump,
PgRestore,
Psql,
}
impl DbTool {
pub fn program(self) -> &'static str {
self.programs()[0]
}
/// Executable names.
pub fn programs(self) -> &'static [&'static str] {
match self {
DbTool::PgDump => &["pg_dump"],
DbTool::PgRestore => &["pg_restore"],
DbTool::Psql => &["psql"],
}
}
pub fn driver(self) -> DbDriver {
DbDriver::Postgres
}
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`…).
/// The data source's password is handed only to such a program.
pub fn is_program(self, path: &Path) -> bool {
let Some(stem) = path.file_stem().and_then(OsStr::to_str) else { return false };
self.programs().iter().any(|p| {
stem.strip_prefix(p).is_some_and(|rest| {
let digits = rest.strip_prefix(['-', '.', '_']).unwrap_or(rest);
digits.chars().all(|c| c.is_ascii_digit())
})
})
}
}
/// An installed copy of a tool.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", rename = "DbToolInstall")]
pub struct ToolInstall {
pub path: String,
/// First line of `--version`, e.g. `pg_dump (PostgreSQL) 17.2`.
pub version: String,
}
/// A line the tool wrote.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", rename = "DbToolLine")]
pub struct ToolLine {
pub stderr: bool,
pub text: String,
}
/// Directories holding the tools that are often missing from `PATH`, by platform.
fn known_dirs() -> Vec<PathBuf> {
let mut dirs = Vec::new();
if cfg!(target_os = "macos") {
for prefix in ["/opt/homebrew", "/usr/local"] {
dirs.push(PathBuf::from(format!("{prefix}/bin")));
let opt = PathBuf::from(format!("{prefix}/opt"));
for keg in ["libpq", "postgresql"] {
dirs.extend(children(&opt, keg).into_iter().map(|d| d.join("bin")));
}
}
dirs.extend(
children(Path::new("/Applications/Postgres.app/Contents/Versions"), "").into_iter().map(|d| d.join("bin")),
);
} else if cfg!(windows) {
for var in ["ProgramFiles", "ProgramFiles(x86)"] {
if let Some(base) = std::env::var_os(var) {
let root = PathBuf::from(base).join("PostgreSQL");
dirs.extend(children(&root, "").into_iter().map(|d| d.join("bin")));
}
}
} else {
dirs.extend(children(Path::new("/usr/lib/postgresql"), "").into_iter().map(|d| d.join("bin")));
dirs.extend(children(Path::new("/usr"), "pgsql-").into_iter().map(|d| d.join("bin")));
}
dirs
}
/// Subdirectories of `parent` whose name starts with `prefix`, newest version first.
fn children(parent: &Path, prefix: &str) -> Vec<PathBuf> {
let Ok(entries) = std::fs::read_dir(parent) else { return Vec::new() };
let mut dirs: Vec<PathBuf> = entries
.flatten()
.filter(|e| e.file_name().to_str().is_some_and(|n| n.starts_with(prefix)))
.map(|e| e.path())
.filter(|p| p.is_dir())
.collect();
dirs.sort_by_key(|p| std::cmp::Reverse(version_key(&p.to_string_lossy())));
dirs
}
/// The numbers in `text`, for comparing versions (`17.2` after `9.6`).
fn version_key(text: &str) -> Vec<u32> {
text.split(|c: char| !c.is_ascii_digit()).filter_map(|n| n.parse().ok()).collect()
}
/// The installed copies of `tool` on `PATH` and in the usual install directories, newest first.
/// Blocking: runs each one's `--version`.
pub fn find_installs(tool: DbTool) -> Vec<ToolInstall> {
let path = ide_core::process::host_var_os("PATH").unwrap_or_default();
let mut dirs: Vec<PathBuf> = std::env::split_paths(&path).collect();
dirs.extend(known_dirs());
let mut seen = Vec::new();
let mut out = Vec::new();
for dir in dirs {
for program in tool.programs() {
let Some(found) = ide_core::process::find_executable(program, dir.as_os_str()) else { continue };
let real = dunce::canonicalize(&found).unwrap_or_else(|_| found.clone());
if seen.contains(&real) {
continue;
}
seen.push(real);
if let Ok(version) = version_of(&found) {
out.push(ToolInstall { path: found.to_string_lossy().into_owned(), version });
}
}
}
out.sort_by_key(|i| std::cmp::Reverse(version_key(&i.version)));
out
}
/// The first line `path --version` prints. Blocking.
pub fn version_of(path: &Path) -> IdeResult<String> {
let (ok, text) = capture(path, "--version")?;
match text.lines().next().map(str::trim).filter(|l| !l.is_empty()) {
Some(line) if ok => Ok(line.to_owned()),
_ => Err(IdeError::invalid(format!("{} is not a working executable", path.display()))),
}
}
/// Runs `path arg` for at most five seconds; whether it succeeded, and its standard output.
fn capture(path: &Path, arg: &str) -> IdeResult<(bool, String)> {
if !path.is_file() {
return Err(IdeError::not_found(format!("{} does not exist", path.display())));
}
let mut cmd = std::process::Command::new(path);
cmd.arg(arg).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
ide_core::process::prepare(&mut cmd);
let mut child = cmd.spawn().map_err(|e| IdeError::invalid(format!("cannot run {}: {e}", path.display())))?;
let mut stdout = child.stdout.take().expect("piped");
let reader = std::thread::spawn(move || {
let mut buf = Vec::new();
let _ = std::io::Read::read_to_end(&mut stdout, &mut buf);
buf
});
let deadline = std::time::Instant::now() + Duration::from_secs(5);
let status = loop {
if let Some(status) = child.try_wait()? {
break status;
}
if std::time::Instant::now() > deadline {
let _ = child.kill();
let _ = child.wait();
return Err(IdeError::invalid(format!("{} {arg} did not finish", path.display())));
}
std::thread::sleep(Duration::from_millis(20));
};
let out = reader.join().unwrap_or_default();
Ok((status.success(), String::from_utf8_lossy(&out).into_owned()))
}
/// What made a dump, read from its first bytes (a directory: its `toc.dat`).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbDumpKind {
/// `pg_dump` custom or tar archive, or a directory archive: `pg_restore`.
PostgresArchive,
/// Plain SQL from `pg_dump`: `psql`.
PostgresSql,
/// `mysqldump` / `mariadb-dump`: not for the PostgreSQL tools.
MysqlSql,
Unknown,
}
/// Blocking: reads at most the first 4 KiB.
pub fn dump_kind(path: &Path) -> IdeResult<DbDumpKind> {
use std::io::Read;
if path.is_dir() {
return Ok(if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown });
}
let mut head = Vec::with_capacity(4096);
std::fs::File::open(path)
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?
.take(4096)
.read_to_end(&mut head)?;
Ok(kind_of(&head))
}
fn kind_of(head: &[u8]) -> DbDumpKind {
// A tar archive keeps `toc.dat` first; its name starts the 512-byte header.
if head.starts_with(b"PGDMP") || head.starts_with(b"toc.dat\0") {
return DbDumpKind::PostgresArchive;
}
let text = String::from_utf8_lossy(head);
let comments: Vec<&str> = text.lines().take(20).filter(|l| l.starts_with("--")).collect();
if comments.iter().any(|l| l.contains("PostgreSQL database dump")) {
DbDumpKind::PostgresSql
} else if comments.iter().any(|l| l.starts_with("-- MySQL dump") || l.starts_with("-- MariaDB dump")) {
DbDumpKind::MysqlSql
} else {
DbDumpKind::Unknown
}
}
/// Arguments and environment that connect `tool` to `source` (already resolved, through its
/// tunnel when it has one). The password is left to [`prepare`].
pub fn connection(tool: DbTool, source: &DataSource) -> (Vec<String>, Vec<(String, String)>) {
let mut args = Vec::new();
let host = source.host.trim();
if !host.is_empty() {
args.push(format!("--host={host}"));
}
args.push(format!("--port={}", source.port.or(source.driver.default_port()).unwrap_or(5432)));
if !source.user.trim().is_empty() {
args.push(format!("--username={}", source.user.trim()));
}
if !source.database.is_empty() {
args.push(format!("--dbname={}", dbname_arg(&source.database)));
}
// Without a terminal a password prompt would wait forever: fail instead.
args.push("--no-password".into());
let mut env = vec![
("PGAPPNAME".to_owned(), format!("OpenIDEA {}", tool.program())),
(
"PGSSLMODE".to_owned(),
match source.ssl {
DbSslMode::Disable => "disable",
DbSslMode::Prefer => "prefer",
DbSslMode::Require => "require",
DbSslMode::VerifyCa => "verify-ca",
DbSslMode::VerifyFull => "verify-full",
}
.to_owned(),
),
];
for (var, file) in [
("PGSSLROOTCERT", &source.ssl_ca_file),
("PGSSLCERT", &source.ssl_cert_file),
("PGSSLKEY", &source.ssl_key_file),
] {
if !file.trim().is_empty() {
env.push((var.to_owned(), ide_ssh::expand(file.trim()).to_string_lossy().into_owned()));
}
}
if source.read_only {
env.push(("PGOPTIONS".to_owned(), "-c default_transaction_read_only=on".to_owned()));
}
(args, env)
}
/// `--dbname` reads a connection string or URI as connection parameters: such a database name
/// goes in quoted as the string's `dbname`, so it cannot pick another host or credentials.
fn dbname_arg(name: &str) -> String {
if name.contains('=') || name.starts_with("postgresql://") || name.starts_with("postgres://") {
format!("dbname='{}'", name.replace('\\', "\\\\").replace('\'', "\\'"))
} else {
name.to_owned()
}
}
/// How a tool is started: connection arguments, then the job's, and the environment.
pub struct Prepared {
pub args: Vec<String>,
pub env: Vec<(String, String)>,
}
/// The command for `job` against `source`. The password goes in `PGPASSWORD`, never in the
/// arguments, which other users of the machine can read in the process list.
pub fn prepare(job: &DbToolJob, source: &DataSource, password: Option<&str>) -> Prepared {
let (mut args, mut env) = connection(job.tool(), source);
args.extend(job.args());
if let Some(p) = password.filter(|p| !p.is_empty()) {
env.push(("PGPASSWORD".into(), p.to_owned()));
}
Prepared { args, env }
}
/// Runs `program` until it exits, passing its output in batches. Returns the exit code
/// (`None`: ended by a signal). Cancelling kills it and everything it started.
pub async fn run(
program: &Path,
args: &[String],
env: &[(String, String)],
cancel: &CancellationToken,
mut on_output: impl FnMut(Vec<ToolLine>),
) -> IdeResult<Option<i32>> {
let mut cmd = tokio::process::Command::new(program);
cmd.args(args)
.envs(env.iter().map(|(k, v)| (k, v)))
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
ide_core::process::prepare(cmd.as_std_mut());
ide_core::process::own_group(cmd.as_std_mut());
let mut child = cmd.spawn().map_err(|e| IdeError::invalid(format!("cannot start {}: {e}", program.display())))?;
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
if let Some(out) = child.stdout.take() {
forward(out, false, tx.clone());
}
if let Some(err) = child.stderr.take() {
forward(err, true, tx);
}
let mut batch = Vec::new();
let mut tick = tokio::time::interval(Duration::from_millis(100));
loop {
tokio::select! {
line = rx.recv() => match line {
Some(line) => {
batch.push(line);
if batch.len() >= 500 {
on_output(std::mem::take(&mut batch));
}
}
None => break,
},
_ = tick.tick() => {
if !batch.is_empty() {
on_output(std::mem::take(&mut batch));
}
}
_ = cancel.cancelled() => {
if let Some(pid) = child.id() {
ide_core::process::kill_tree_of(pid);
}
let _ = child.kill().await;
return Err(IdeError::cancelled());
}
}
}
if !batch.is_empty() {
on_output(batch);
}
let status = tokio::select! {
status = child.wait() => status?,
_ = cancel.cancelled() => {
if let Some(pid) = child.id() {
ide_core::process::kill_tree_of(pid);
}
let _ = child.kill().await;
return Err(IdeError::cancelled());
}
};
Ok(status.code())
}
fn forward(
pipe: impl AsyncRead + Unpin + Send + 'static,
stderr: bool,
tx: tokio::sync::mpsc::UnboundedSender<ToolLine>,
) {
tokio::spawn(async move {
let mut reader = BufReader::new(pipe);
let mut buf = Vec::new();
loop {
buf.clear();
match reader.read_until(b'\n', &mut buf).await {
Ok(0) | Err(_) => break,
Ok(_) => {
let text = String::from_utf8_lossy(&buf).trim_end_matches(['\r', '\n']).to_owned();
if tx.send(ToolLine { stderr, text }).is_err() {
break;
}
}
}
}
});
}
#[cfg(test)]
mod tests {
use super::*;
fn pg() -> DataSource {
DataSource {
driver: DbDriver::Postgres,
host: "db.example.test".into(),
port: Some(6543),
user: "app".into(),
database: "shop".into(),
..DataSource::default()
}
}
#[test]
fn connects_like_the_data_source_without_prompting() {
let (args, env) = connection(DbTool::PgDump, &pg());
assert_eq!(args, ["--host=db.example.test", "--port=6543", "--username=app", "--dbname=shop", "--no-password"]);
assert!(env.contains(&("PGSSLMODE".into(), "prefer".into())));
assert!(!env.iter().any(|(k, _)| k == "PGPASSWORD" || k == "PGOPTIONS"));
}
#[test]
fn a_database_named_like_connection_parameters_stays_a_name() {
for (name, arg) in [
("host=evil.example dbname=p", r"--dbname=dbname='host=evil.example dbname=p'"),
(r"it's=\x", r"--dbname=dbname='it\'s=\\x'"),
("postgresql://evil.example/p", "--dbname=dbname='postgresql://evil.example/p'"),
] {
let (args, _) = connection(DbTool::PgDump, &DataSource { database: name.into(), ..pg() });
assert!(args.contains(&arg.to_owned()), "{args:?}");
}
}
#[test]
fn default_port_and_optional_fields() {
let source = DataSource { port: None, user: String::new(), database: String::new(), ..pg() };
let (args, _) = connection(DbTool::Psql, &source);
assert_eq!(args, ["--host=db.example.test", "--port=5432", "--no-password"]);
}
#[test]
fn read_only_sources_refuse_writes() {
let source = DataSource { read_only: true, ssl: DbSslMode::VerifyFull, ..pg() };
let (_, env) = connection(DbTool::PgRestore, &source);
assert!(env.contains(&("PGOPTIONS".into(), "-c default_transaction_read_only=on".into())));
assert!(env.contains(&("PGSSLMODE".into(), "verify-full".into())));
}
#[test]
fn only_the_tool_itself_is_accepted() {
for ok in ["/usr/bin/pg_dump", "/pg/bin/pg_dump.exe", "/usr/bin/pg_dump-17", "/opt/pg_dump17"] {
assert!(DbTool::PgDump.is_program(Path::new(ok)), "{ok}");
}
for bad in ["/usr/bin/pg_dumpall", "/bin/sh", "/usr/bin/pg_restore", "/tmp/evil"] {
assert!(!DbTool::PgDump.is_program(Path::new(bad)), "{bad}");
}
}
#[test]
fn tells_dumps_apart_by_their_header() {
assert_eq!(kind_of(b"PGDMP\x01\x0f"), DbDumpKind::PostgresArchive);
assert_eq!(kind_of(b"toc.dat\0\0\0"), DbDumpKind::PostgresArchive);
assert_eq!(kind_of(b"--\n-- PostgreSQL database dump\n--\n"), DbDumpKind::PostgresSql);
assert_eq!(kind_of(b"-- MySQL dump 10.13 Distrib 8.4.6\n--\n"), DbDumpKind::MysqlSql);
assert_eq!(kind_of(b"-- MariaDB dump 10.19 Distrib 11.4.2\n"), DbDumpKind::MysqlSql);
assert_eq!(kind_of(b"CREATE TABLE t (id int);\n"), DbDumpKind::Unknown);
}
#[test]
fn newer_versions_sort_first() {
assert!(version_key("pg_dump (PostgreSQL) 17.2") > version_key("pg_dump (PostgreSQL) 9.6.24"));
}
#[cfg(unix)]
#[tokio::test]
async fn streams_both_pipes_and_reports_the_exit_code() {
let mut lines = Vec::new();
let code = run(
Path::new("/bin/sh"),
&["-c".into(), "echo out; echo err >&2; exit 3".into()],
&[],
&CancellationToken::new(),
|batch| lines.extend(batch),
)
.await
.unwrap();
assert_eq!(code, Some(3));
assert!(lines.contains(&ToolLine { stderr: false, text: "out".into() }));
assert!(lines.contains(&ToolLine { stderr: true, text: "err".into() }));
}
#[cfg(unix)]
#[tokio::test]
async fn cancelling_stops_the_process() {
let cancel = CancellationToken::new();
let stop = cancel.clone();
tokio::spawn(async move {
tokio::time::sleep(Duration::from_millis(100)).await;
stop.cancel();
});
let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], &cancel, |_| {}).await;
assert!(result.is_err());
}
/// A stand-in for `tool` that prints each argument on a line, then whether `PGPASSWORD`
/// holds the expected password.
#[cfg(unix)]
fn echo_tool(dir: &Path, tool: DbTool) -> PathBuf {
use std::os::unix::fs::PermissionsExt;
let path = dir.join(tool.program());
std::fs::write(
&path,
"#!/bin/sh\nfor a in \"$@\"; do echo \"arg:$a\"; done\necho \"env:${PGPASSWORD:+set}\"\n",
)
.unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
path
}
#[cfg(unix)]
#[tokio::test]
async fn the_password_never_reaches_the_arguments() {
const SECRET: &str = "s3cret-pass-do-not-leak";
let dir = std::env::temp_dir().join(format!("openidea-tools-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&dir).unwrap();
let file = dir.join("out.sql").to_string_lossy().into_owned();
let jobs = [
DbToolJob::PgDump {
file: file.clone(),
options: DbPgDumpOptions {
format: DbDumpFormat::Plain,
statements: DbDumpStatements::Copy,
content: DbDumpContent::All,
schemas: vec!["public".into()],
tables: vec![],
exclude_tables: vec![],
clean: true,
if_exists: true,
create: false,
no_owner: false,
no_privileges: false,
jobs: 1,
},
},
DbToolJob::Psql {
file: file.clone(),
options: DbPsqlOptions { single_transaction: true, stop_on_error: true },
},
];
for job in jobs {
let program = echo_tool(&dir, job.tool());
let prepared = prepare(&job, &pg(), Some(SECRET));
assert!(!prepared.args.iter().any(|a| a.contains(SECRET)), "{:?}", prepared.args);
let mut lines = Vec::new();
run(&program, &prepared.args, &prepared.env, &CancellationToken::new(), |b| lines.extend(b)).await.unwrap();
let text: Vec<&str> = lines.iter().map(|l| l.text.as_str()).collect();
assert!(text.contains(&"arg:--dbname=shop"), "{text:?}");
assert!(!text.iter().any(|l| l.contains(SECRET)), "{text:?}");
assert!(text.contains(&"env:set"), "the tool gets the password from PGPASSWORD: {text:?}");
}
std::fs::remove_dir_all(&dir).unwrap();
}
}
-170
Переглянути файл
@@ -133,173 +133,3 @@ async fn a_reused_physical_connection_restores_the_full_default_path() -> IdeRes
);
Ok(())
}
/// Indexes, foreign keys, routines and completion read the catalog with queries every
/// PostgreSQL-protocol server answers, back to the 9.2 core of openGauss / GaussDB (#3637).
#[tokio::test]
async fn table_details_routines_and_completion_on_older_catalogs() -> IdeResult<()> {
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let c = CancellationToken::new();
for stmt in [
"DROP SCHEMA IF EXISTS oi_meta CASCADE",
"CREATE SCHEMA oi_meta",
"CREATE TABLE oi_meta.orders (region INT, id INT, note TEXT DEFAULT 'x', PRIMARY KEY (region, id))",
"CREATE TABLE oi_meta.lines (n INT PRIMARY KEY, o_region INT, o_id INT, \
FOREIGN KEY (o_region, o_id) REFERENCES oi_meta.orders (region, id))",
"CREATE INDEX lines_order ON oi_meta.lines (o_id, o_region)",
"CREATE FUNCTION oi_meta.twice(v INT) RETURNS INT AS 'SELECT v * 2' LANGUAGE sql",
] {
db.execute("p", stmt, 10, &c).await?;
}
let details = db.table_details("p", "oi_meta", "lines").await?;
let index = details.indexes.iter().find(|i| i.name == "lines_order").expect("lines_order");
assert_eq!(index.columns, ["o_id", "o_region"]);
assert!(!index.unique);
assert_eq!(details.foreign_keys.len(), 1, "{:?}", details.foreign_keys);
assert_eq!(details.foreign_keys[0].columns, ["o_region", "o_id"]);
assert_eq!(details.foreign_keys[0].ref_columns, ["region", "id"]);
let orders = db.table_details("p", "oi_meta", "orders").await?;
let key = orders.indexes.iter().find(|i| i.unique).expect("primary key index");
assert_eq!(key.columns, ["region", "id"]);
let objects = db.schema_objects("p", "oi_meta").await?;
assert!(objects.routines.iter().any(|r| r.name == "twice"), "{:?}", objects.routines);
let completion = db.completion("p").await?;
assert!(completion.tables.iter().any(|t| t.schema == "oi_meta" && t.name == "orders"));
db.execute("p", "DROP SCHEMA oi_meta CASCADE", 10, &c).await?;
Ok(())
}
/// Opening a table pairs the columns of composite keys in order, also when a foreign key lists
/// them in another order than the key it references; its data page and DDL read the same catalog,
/// and completion tells identity columns apart in one query (#3637).
#[tokio::test]
async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let c = CancellationToken::new();
for stmt in [
"DROP SCHEMA IF EXISTS oi_keys CASCADE",
"CREATE SCHEMA oi_keys",
"CREATE TABLE oi_keys.pairs (a INT, b INT, PRIMARY KEY (b, a))",
"CREATE TABLE oi_keys.refs (id INT PRIMARY KEY, x INT, y INT, FOREIGN KEY (y, x) REFERENCES oi_keys.pairs (b, a))",
"CREATE UNIQUE INDEX refs_yx ON oi_keys.refs (y, x)",
"INSERT INTO oi_keys.pairs VALUES (1, 2)",
"INSERT INTO oi_keys.refs VALUES (7, 1, 2)",
] {
db.execute("p", stmt, 10, &c).await?;
}
let details = db.table_details("p", "oi_keys", "refs").await?;
let indexes: Vec<_> = details.indexes.iter().map(|i| (i.name.as_str(), i.unique, i.columns.join(","))).collect();
assert_eq!(indexes, [("refs_pkey", true, "id".into()), ("refs_yx", true, "y,x".into())]);
let key = |k: &ide_db::ForeignKey| (k.columns.join(","), k.ref_table.clone(), k.ref_columns.join(","));
assert_eq!(
details.foreign_keys.iter().map(key).collect::<Vec<_>>(),
[("y,x".into(), "pairs".into(), "b,a".into())]
);
let pairs = db.table_details("p", "oi_keys", "pairs").await?;
assert_eq!(pairs.indexes[0].columns, ["b", "a"]);
let page = db.table_page("p", "oi_keys", "refs", None, &[], 0, 10, &c).await?;
assert_eq!(page.result.rows.len(), 1);
// Identity columns (PostgreSQL 10+; openGauss has none) are optional in INSERT.
let identity =
db.execute("p", "CREATE TABLE oi_keys.ids (n INT GENERATED ALWAYS AS IDENTITY, v INT)", 10, &c).await;
let completion = db.completion("p").await?;
if identity.is_ok() {
let ids = completion.tables.iter().find(|t| t.schema == "oi_keys" && t.name == "ids").expect("ids");
let defaults: Vec<_> = ids.columns.iter().map(|c| (c.name.as_str(), c.has_default)).collect();
assert_eq!(defaults, [("n", true), ("v", false)]);
}
assert!(
completion.foreign_keys.iter().any(|k| k.table == "refs" && key(k).2 == "b,a"),
"{:?}",
completion.foreign_keys
);
// The other catalog reads of the tree and its DDL actions, on the same server.
assert!(db.schemas("p").await?.iter().any(|s| s == "oi_keys"));
assert_eq!(db.tables("p", "oi_keys").await?.len(), if identity.is_ok() { 3 } else { 2 });
db.execute("p", "CREATE SEQUENCE oi_keys.seq", 10, &c).await?;
let objects = db.schema_objects("p", "oi_keys").await?;
assert_eq!(objects.sequences.len(), 1);
assert!(db.ddl("p", "oi_keys", "refs").await?.contains("FOREIGN KEY"));
db.execute("p", "DROP SCHEMA oi_keys CASCADE", 10, &c).await?;
Ok(())
}
/// Runs `job` with the newest installed copy of its tool, the way the dialogs do.
async fn run_tool(db: &DbManager, target: &str, job: ide_db::tools::DbToolJob) -> IdeResult<()> {
let install = ide_db::tools::find_installs(job.tool()).into_iter().next().expect("installed");
let mut lines = Vec::new();
let code = db.run_tool(target, install.path.as_ref(), &job, &CancellationToken::new(), |b| lines.extend(b)).await?;
assert_eq!(code, Some(0), "{} failed: {lines:?}", job.tool().program());
Ok(())
}
#[tokio::test]
async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
use ide_db::tools::{
DbDumpContent, DbDumpFormat, DbDumpStatements, DbPgDumpOptions, DbPgRestoreOptions, DbPsqlOptions, DbTool,
DbToolJob, find_installs,
};
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let server = db.server_version("p").await? / 10000;
let major = |t: DbTool| {
find_installs(t).first().and_then(|i| i.version.split(' ').nth(2)?.split('.').next()?.parse::<u32>().ok())
};
// Other major versions write or refuse what this server needs; the dialogs warn about that instead.
if [DbTool::PgDump, DbTool::PgRestore, DbTool::Psql].into_iter().any(|t| major(t) != Some(server)) {
return Ok(());
}
create_schemas(&db).await;
let c = CancellationToken::new();
db.execute("p", "DROP DATABASE IF EXISTS oi_restore", 1, &c).await?;
db.execute("p", "CREATE DATABASE oi_restore", 1, &c).await?;
let file = |name: &str| tmp.path().join(name).to_string_lossy().into_owned();
let dump = |format, file: String, schema: &str| DbToolJob::PgDump {
file,
options: DbPgDumpOptions {
format,
statements: DbDumpStatements::Copy,
content: DbDumpContent::All,
schemas: vec![schema.into()],
tables: vec![],
exclude_tables: vec![],
clean: false,
if_exists: false,
create: false,
no_owner: false,
no_privileges: false,
jobs: 1,
},
};
let archive = file("a.dump");
run_tool(&db, "p", dump(DbDumpFormat::Custom, archive.clone(), "oi_a")).await?;
let restore = DbPgRestoreOptions {
content: DbDumpContent::All,
schemas: vec![],
clean: false,
if_exists: false,
no_owner: false,
no_privileges: false,
single_transaction: false,
exit_on_error: true,
jobs: 1,
};
run_tool(&db, "p:oi_restore", DbToolJob::PgRestore { file: archive, options: restore }).await?;
let script = file("b.sql");
run_tool(&db, "p", dump(DbDumpFormat::Plain, script.clone(), "oi_b")).await?;
let psql = DbPsqlOptions { single_transaction: true, stop_on_error: true };
run_tool(&db, "p:oi_restore", DbToolJob::Psql { file: script, options: psql }).await?;
let r = db.execute("p:oi_restore", "SELECT a.tag || ', ' || b.tag FROM oi_a.items a, oi_b.items b", 1, &c).await?;
assert_eq!(r.rows[0][0].as_deref(), Some("from a, from b"));
db.disconnect("p:oi_restore").await;
db.execute("p", "DROP DATABASE oi_restore", 1, &c).await?;
Ok(())
}
+2 -21
Переглянути файл
@@ -26,8 +26,6 @@ pub enum Capability {
DatabaseSources,
VcsRead,
VcsWrite,
/// The Maven / Gradle dependency graph the IDE resolved.
BuildRead,
/// The plugin's own key-value store and data directory.
Storage,
/// The plugin's own secrets (kept in the client's OS keychain).
@@ -57,9 +55,6 @@ pub enum Capability {
FsRead(String),
/// Write files outside the project under one path.
FsWrite(String),
/// Load the plugin's Java agent into the JVMs of Java run configurations. Never
/// declared: it comes from `[[contributes.javaAgents]]`.
JavaAgent,
}
/// How a grant is presented (plan 4.2).
@@ -77,9 +72,7 @@ pub enum Risk {
impl Capability {
pub fn risk(&self) -> Risk {
match self {
Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead | Self::BuildRead => {
Risk::Low
}
Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead => Risk::Low,
Self::EditorWrite
| Self::DatabaseSources
| Self::VcsWrite
@@ -97,8 +90,7 @@ impl Capability {
| Self::Process(_)
| Self::Lsp(_)
| Self::FsRead(_)
| Self::FsWrite(_)
| Self::JavaAgent => Risk::High,
| Self::FsWrite(_) => Risk::High,
}
}
@@ -119,7 +111,6 @@ impl Capability {
Self::IdeCommands => "Run any IDE action or other plugins' commands as if you chose them, including running programs, committing and pushing".into(),
Self::VcsRead => "Read version control state".into(),
Self::VcsWrite => "Change version control state (commit, fetch, checkout)".into(),
Self::BuildRead => "Read the project's resolved Maven and Gradle dependencies".into(),
Self::Storage => "Store its own data".into(),
Self::Secrets => "Store secrets in the system keychain".into(),
Self::Events => "Observe editor, filesystem and version control events".into(),
@@ -144,7 +135,6 @@ impl Capability {
}
Self::FsRead(path) => format!("Read files under {path}, outside the project"),
Self::FsWrite(path) => format!("Change files under {path}, outside the project"),
Self::JavaAgent => "Run code inside the Java applications you start".into(),
}
}
@@ -256,7 +246,6 @@ impl fmt::Display for Capability {
Self::DatabaseSources => f.write_str("database.sources"),
Self::VcsRead => f.write_str("vcs.read"),
Self::VcsWrite => f.write_str("vcs.write"),
Self::BuildRead => f.write_str("build.read"),
Self::Storage => f.write_str("storage"),
Self::Secrets => f.write_str("secrets"),
Self::Events => f.write_str("events"),
@@ -270,7 +259,6 @@ impl fmt::Display for Capability {
Self::Lsp(s) => write!(f, "lsp:{s}"),
Self::FsRead(p) => write!(f, "fs.read:{p}"),
Self::FsWrite(p) => write!(f, "fs.write:{p}"),
Self::JavaAgent => f.write_str("java.agent"),
}
}
}
@@ -342,13 +330,11 @@ impl FromStr for Capability {
"database.sources" => Self::DatabaseSources,
"vcs.read" => Self::VcsRead,
"vcs.write" => Self::VcsWrite,
"build.read" => Self::BuildRead,
"storage" => Self::Storage,
"secrets" => Self::Secrets,
"events" => Self::Events,
"events.input" => Self::InputEvents,
"clipboard" => Self::Clipboard,
"java.agent" => Self::JavaAgent,
_ => return Err(format!("unknown capability {s:?}")),
})
}
@@ -397,7 +383,6 @@ mod tests {
"editor.write",
"project.write",
"vcs.write",
"build.read",
"storage",
"secrets",
"events",
@@ -407,7 +392,6 @@ mod tests {
"process:cargo",
"lsp:phoxite",
"lsp:rust-analyzer",
"java.agent",
] {
assert_eq!(s.parse::<Capability>().unwrap().to_string(), s);
}
@@ -441,11 +425,8 @@ mod tests {
assert_eq!(Capability::Clipboard.risk(), Risk::Medium);
assert_eq!(Capability::Process("cargo".into()).risk(), Risk::High);
assert_eq!(Capability::Lsp("phoxite".into()).risk(), Risk::High);
assert_eq!(Capability::BuildRead.risk(), Risk::Low);
assert!(!Capability::Lsp("phoxite".into()).covers(&Capability::Lsp("intelephense".into())));
assert!(Capability::Storage.auto_migrates() && !Capability::EditorWrite.auto_migrates());
assert_eq!(Capability::JavaAgent.risk(), Risk::High);
assert!(!Capability::JavaAgent.auto_migrates());
}
/// A trusted project's files name programs the IDE starts by itself: the git and language
+2 -19
Переглянути файл
@@ -10,8 +10,6 @@
//! - `process:<program>` grants record the program's absolute path and file
//! hash at grant time. Calls use that path, never a `PATH` lookup, and fail
//! when the file changed (re-confirmation needed).
//! - `java.agent` grants record the agent jar's path and hash the same way;
//! a launch adds the agent only while the jar still has that hash.
use crate::capability::{Capability, Risk};
use serde::{Deserialize, Serialize};
@@ -269,7 +267,7 @@ impl Ledger {
if cap == &Capability::NetAsk {
grant.net_hosts.clear();
}
if let Capability::Process(_) | Capability::JavaAgent = cap {
if let Capability::Process(_) = cap {
grant.binaries.remove(&s);
for binaries in grant.project_binaries.values_mut() {
binaries.remove(&s);
@@ -292,7 +290,7 @@ impl Ledger {
self.grants.get_mut(subject).is_some_and(|g| g.net_hosts.remove(host))
}
/// Records the program approved for a `process:` grant (or the jar of a `java.agent` one).
/// Records the program approved for a `process:` grant.
pub fn set_binary(&mut self, subject: &Subject, cap: &Capability, binary: BinaryGrant) {
if let Some(grant) = self.grants.get_mut(subject) {
grant.binaries.insert(cap.to_string(), binary);
@@ -677,21 +675,6 @@ mod tests {
assert!(l.check_binary(&r.subject, &cap).unwrap_err().contains("changed"));
}
#[test]
fn revoking_java_agent_forgets_its_jar() {
let mut l = Ledger::in_memory();
let r = req("1.0.0", "h", &[], &["java.agent"]);
let cap = Capability::JavaAgent;
let jar = BinaryGrant { path: "/plugins/p/agent.jar".into(), hash: "abc".into() };
l.confirm(&r, std::slice::from_ref(&cap), [(cap.to_string(), jar.clone())].into());
assert_eq!(l.pinned_binary(&r.subject, &cap), Some(jar.clone()));
l.set(&r.subject, &cap, false);
assert_eq!(l.pinned_binary(&r.subject, &cap), None);
// Granting again without a new hash does not bring the old one back.
l.set(&r.subject, &cap, true);
assert_eq!(l.pinned_binary(&r.subject, &cap), None);
}
#[test]
fn hashes_and_grouping() {
let tmp = tempfile::tempdir().unwrap();
+1 -25
Переглянути файл
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
pub const MANIFEST_FILE: &str = "plugin.toml";
/// The plugin API (engine) version this host implements.
pub const ENGINE_VERSION: &str = "1.10.0";
pub const ENGINE_VERSION: &str = "1.9.0";
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
pub const LEGACY_API: &str = "0.1";
/// Marketplace categories, in the order they are shown.
@@ -360,14 +360,6 @@ impl Manifest {
if matches!(cap, Capability::Lsp(_)) {
self.needs_api(&format!("capability `{cap}`"), 9)?;
}
if matches!(cap, Capability::BuildRead) {
self.needs_api(&format!("capability `{cap}`"), 10)?;
}
if matches!(cap, Capability::JavaAgent) {
return Err(
"`java.agent` comes from `[[contributes.javaAgents]]`: remove it from [capabilities]".into()
);
}
}
if let Some(dark) = &self.icon_dark {
if self.icon.is_none() {
@@ -738,22 +730,6 @@ required = [\"lsp:phoxite\"]
assert_eq!(m.capabilities.required, [Capability::Lsp("phoxite".into())]);
}
#[test]
fn the_build_capability_needs_api_1_10() {
let caps = "[capabilities]\noptional = [\"build.read\"]\n";
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.9"))).contains("new in plugin API 1.10"));
let m = Manifest::parse(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).unwrap();
assert_eq!(m.capabilities.optional, [Capability::BuildRead]);
}
#[test]
fn java_agent_capability_is_not_declared() {
for list in ["required", "optional"] {
let caps = format!("[capabilities]\n{list} = [\"java.agent\"]\n");
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).contains("contributes.javaAgents"));
}
}
#[test]
fn parses_icons() {
let m = Manifest::parse(&format!("{BASE}icon = \"icon.svg\"\nicon-dark = \"icon_dark.svg\"\n")).unwrap();
-2
Переглянути файл
@@ -30,8 +30,6 @@ ide-vcs.workspace = true
ide-dap.workspace = true
ide-heap.workspace = true
ide-jvm-attach.workspace = true
ide-jvm-inspect.workspace = true
ide-streams.workspace = true
ide-build.workspace = true
ide-analysis.workspace = true
ide-coverage.workspace = true
+1 -3
Переглянути файл
@@ -320,8 +320,7 @@ fn rename_failure(error: &io::Error) -> RenameFailure {
}
/// Only Windows splits these paths. Renames are cheap; cross-volume copies run in
/// the background. Consumers always use Local, even when migration fails. On every
/// system, tool virtual environments moved from elsewhere are dropped (#3581).
/// the background. Consumers always use Local, even when migration fails.
pub fn migrate(data: &Path, local: &Path) {
if cfg!(target_os = "windows") && data != local {
migrate_entries(data, local);
@@ -329,7 +328,6 @@ pub fn migrate(data: &Path, local: &Path) {
if cfg!(target_os = "windows") {
relative_tool_shims(&local.join("tools"));
}
ide_tools::drop_moved_venvs(&local.join("tools"));
}
/// Wrappers written before they named their tool relative to themselves hold its absolute
-9
Переглянути файл
@@ -190,7 +190,6 @@ impl Host {
open_locks: Default::default(),
};
host.apply_proxy();
host.apply_added_jdks();
ops::agent::move_user_mcp_values(&host);
host
}
@@ -532,14 +531,6 @@ impl Host {
}
}
impl Host {
/// Lists the JDKs added by hand (global Settings › SDKs) with the detected ones.
pub fn apply_added_jdks(&self) {
let homes = self.global_settings.effective().languages.java.added_jdks;
ide_sdk::java::set_added_jdks(homes.into_iter().map(PathBuf::from));
}
}
#[cfg(test)]
mod tests {
use super::*;
+1 -1
Переглянути файл
@@ -331,7 +331,7 @@ targetIndex, or narrow the call with a contextSnippet that shows the one you mea
FileEdit::Rename { from, to } => vec![from, to],
};
for p in paths {
if let Err(e) = call.ensure_writable_place(p) {
if let Err(e) = super::super::tool::ensure_inside(call.root(), p) {
let hint = format!(
"{}. Nothing was renamed. A rename that must change a file outside the project cannot run here.",
e.message
+3 -9
Переглянути файл
@@ -1,5 +1,4 @@
use super::page::{OFFSET, Page};
use super::scope::{self, Scope};
use super::tool::{Call, Output, Param, ParamType, Tool};
use ide_core::{Diagnostic, IdeResult, Severity};
use serde_json::{Map, Value, json};
@@ -15,8 +14,7 @@ pub fn tools() -> Vec<Tool> {
Use this tool to explore current open editors.",
open_editors,
)
.param(scope::param()),
),
Tool::new(
"get_current_file",
"Returns the focused editor's file and selection reported by the IDE.
@@ -45,20 +43,18 @@ Lines and UTF-16 columns are 1-based.",
project_problems,
)
.param(Param::optional("errorsOnly", ParamType::Boolean, "Only errors (default) or warnings too"))
.param(scope::param())
.param(Param::optional("limit", ParamType::Integer, "Problems to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET)),
]
}
async fn open_editors(call: Call) -> IdeResult<Output> {
let dir = Scope::of(&call)?;
let windows = call.host.mcp_windows(call.root());
let open = call.host.mcp_reports.editors(&windows);
let active = call.host.mcp_reports.focused(call.window()).filter(|e| dir.contains(&e.path.0));
let active = call.host.mcp_reports.focused(call.window());
Output::json(json!({
"activeFilePath": active.map(|e| call.display(&e.path.0)),
"openFiles": open.iter().filter(|p| dir.contains(p)).map(|p| call.display(p)).collect::<Vec<_>>(),
"openFiles": open.iter().map(|p| call.display(p)).collect::<Vec<_>>(),
}))
}
@@ -103,11 +99,9 @@ async fn file_problems(call: Call) -> IdeResult<Output> {
async fn project_problems(call: Call) -> IdeResult<Output> {
let page = Page::of(&call, PROBLEMS_LIMIT)?;
let errors_only = call.flag("errorsOnly", true)?;
let dir = Scope::of(&call)?;
let files = call.host.mcp_reports.problems(&call.host.mcp_windows(call.root()));
let problems: Vec<(String, Value)> = files
.into_iter()
.filter(|f| dir.contains(&f.path.0))
.flat_map(|f| {
let path = call.display(&f.path.0);
let wanted = f.items.into_iter().filter(|d| !errors_only || d.severity == Severity::Error);
+2 -5
Переглянути файл
@@ -167,10 +167,7 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
}
call.confirm(&subject, Some(detail)).await?;
// Exactly the request the user approved: preparing it again would read the
// environment files again, which may name another destination by now.
let redact_url = prepared.url.clone();
let exchange = ide_http::send(prepared, Some(&path), &call.cancel).await?;
let exchange = ide_http::run(input, &call.cancel).await?;
let history = call.project().http_history.clone();
let saved = exchange.clone();
let _ = call.host().blocking(move || history.add(&saved)).await;
@@ -191,7 +188,7 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
"status": response.map(|r| r.status),
"statusText": response.map(|r| r.status_text.clone()),
"totalMs": response.map(|r| r.total_ms).or(exchange.entry.total_ms),
"error": redact_transport_error(exchange.entry.error.clone(), &redact_url),
"error": redact_transport_error(exchange.entry.error.clone(), &prepared.url),
"body": body,
"bodyTruncated": body_truncated,
}))
+15 -16
Переглянути файл
@@ -10,7 +10,6 @@ mod files;
mod http;
mod page;
mod reports;
mod scope;
mod search;
mod symbols;
mod tool;
@@ -55,17 +54,14 @@ impl Registry {
if self.0.mcp_reports.remote_roots().iter().any(|p| p == root) {
return Err("not supported for remote projects yet".into());
}
let projects = self.0.projects.read();
let open = || projects.iter().filter(|(_, p)| !p.light);
let mut windows: Vec<_> = open().filter(|(_, p)| p.root == root).map(|(w, p)| (w.clone(), p.clone())).collect();
if windows.is_empty() {
// A project attached to an open one: the window it is attached in.
windows = open()
.filter(|(_, p)| tool::attached_projects(&p.root).iter().any(|a| a == root))
.map(|(w, p)| (w.clone(), p.clone()))
.collect();
}
drop(projects);
let mut windows: Vec<_> = self
.0
.projects
.read()
.iter()
.filter(|(_, p)| p.root == root && !p.light)
.map(|(w, p)| (w.clone(), p.clone()))
.collect();
let focused = self.0.mcp_reports.focused_window();
windows.sort_by(|a, b| {
(Some(&b.0) == focused.as_ref()).cmp(&(Some(&a.0) == focused.as_ref())).then(a.0.cmp(&b.0))
@@ -75,10 +71,13 @@ impl Registry {
}
impl ToolRegistry for Registry {
fn projects(&self) -> Vec<PathBuf> {
let open: Vec<_> = self.0.projects().into_iter().filter(|p| !p.light).collect();
// Attached projects are listed too, so a `projectPath` inside one names it.
let attached: Vec<_> = open.iter().flat_map(|p| tool::attached_projects(&p.root)).collect();
open.into_iter().map(|p| p.root.clone()).chain(attached).chain(self.0.mcp_reports.remote_roots()).collect()
self.0
.projects()
.into_iter()
.filter(|p| !p.light)
.map(|p| p.root.clone())
.chain(self.0.mcp_reports.remote_roots())
.collect()
}
fn tools(&self, root: &Path) -> Result<Vec<ide_mcp::Tool>, String> {
let (_, project) = self.target(root)?;
+4 -17
Переглянути файл
@@ -128,11 +128,9 @@ 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, 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, \
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, \
crashed, stoppedByAgent, stoppedByUser or startFailed; `exitCode`; `crash` with the signal or exception of a crashed \
process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
),
@@ -154,7 +152,6 @@ 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()) {
@@ -188,7 +185,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, ready.as_ref(), from, &call.cancel).await?;
let end = run.wait(deadline, None, from, &call.cancel).await?;
let mut extra = output_view(&call, &run, from)?;
extra.insert("waitEnded".into(), end.as_str().into());
result(&run, extra)
@@ -212,12 +209,6 @@ 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))
@@ -305,7 +296,6 @@ pub fn list_runs() -> Tool {
start of the command, exit code and times. `get_run_status` gives a tab's whole status.",
|call| async move {
let page = Page::of(&call, LIST_LIMIT)?;
let dir = crate::mcp::scope::Scope::of(&call)?;
let wanted = call.opt_str("state")?.filter(|s| s != "all");
let states = match wanted.as_deref() {
None => None,
@@ -326,8 +316,6 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
.iter()
.rev()
.map(|r| r.status())
// A tab belongs where its command runs.
.filter(|s| dir.contains_shown(call.root(), s["workingDirectory"].as_str().unwrap_or_default()))
.filter(|s| {
states.as_ref().is_none_or(|states| s["state"].as_str().is_some_and(|v| states.contains(&v)))
})
@@ -344,7 +332,6 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
ParamType::String,
"all (default), running, idle (not running), error (failed, crashed, startFailed), or one state",
))
.param(crate::mcp::scope::param())
.param(Param::optional("limit", ParamType::Integer, "Tabs to return at most (default 10)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
-6
Переглянути файл
@@ -139,13 +139,8 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
}
let page = Page::of(&call, CONFIGURATIONS_LIMIT)?;
let query = call.opt_str("query")?.map(|q| q.to_lowercase());
let dir = crate::mcp::scope::Scope::of(&call)?;
let list: Vec<Value> = configs
.iter()
// A configuration belongs where it runs.
.filter(|c| {
dir.contains(&c.cwd.as_deref().map_or_else(|| call.root().to_path_buf(), |d| call.root().join(d)))
})
.filter(|c| {
query.as_ref().is_none_or(|q| {
[c.name.as_str(), c.kind.as_str(), command_line(c).as_str()]
@@ -169,7 +164,6 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
in the file instead of project-wide run configurations.",
))
.param(Param::optional("query", ParamType::String, "Only configurations whose name, type or command contains it"))
.param(crate::mcp::scope::param())
.param(Param::optional("limit", ParamType::Integer, "Configurations to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
-56
Переглянути файл
@@ -1,56 +0,0 @@
//! The `scope` argument of the query tools: the directory their results are limited to, a
//! folder of the project or a project attached to it.
use crate::mcp::tool::{Call, Param, ParamType};
use ide_core::{IdeError, IdeResult};
use std::path::{Path, PathBuf};
pub fn param() -> Param {
Param::optional(
"scope",
ParamType::String,
"Directory to limit results to: relative to the project root, or absolute",
)
}
/// No `scope`: everything.
pub struct Scope(Option<PathBuf>);
impl Scope {
pub fn of(call: &Call) -> IdeResult<Self> {
let Some(raw) = call.opt_str("scope")?.filter(|s| !s.trim().is_empty()) else { return Ok(Self(None)) };
let given = Path::new(raw.trim());
let path = crate::mcp::tool::normalize(&if given.is_absolute() {
given.to_path_buf()
} else {
call.root().join(given)
});
let roots: Vec<PathBuf> =
std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots()).collect();
// Before touching the file system: on Windows, resolving `\\host\share` signs in to that host.
if !ide_vfs::content_path_allowed(&path, &roots) {
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
}
let path = dunce::canonicalize(&path).unwrap_or(path);
if !path.is_dir() {
return Err(IdeError::not_found(format!("scope {raw} is not a directory")));
}
if !roots.iter().any(|root| path.starts_with(root)) {
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
}
Ok(Self(Some(path)))
}
pub fn dir(&self) -> Option<&Path> {
self.0.as_deref()
}
pub fn contains(&self, path: &Path) -> bool {
self.0.as_ref().is_none_or(|dir| path.starts_with(dir))
}
/// For a path the tools return: project-relative with `/`, or absolute.
pub fn contains_shown(&self, root: &Path, path: &str) -> bool {
self.0.is_none() || self.contains(&root.join(path))
}
}
+17 -57
Переглянути файл
@@ -6,7 +6,6 @@
//! the editor (one per character except emoji and other astral characters).
use crate::mcp::page::{OFFSET, Page};
use crate::mcp::scope::{self, Scope};
use crate::mcp::tool::{Call, Output, Param, ParamType, Tool};
use crate::mcp::util::{INDEXING_PARTIAL_RESULT_REASON, MEDIUM_TIMEOUT};
use crate::ops::search::SearchEvent;
@@ -68,7 +67,6 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|call| async move { text_search(call, false).await },
)
.param(Param::required("q", ParamType::String, "Text to search for"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
@@ -91,7 +89,6 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|call| async move { text_search(call, true).await },
)
.param(Param::required("q", ParamType::String, "Regex pattern to search for"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
@@ -113,7 +110,6 @@ If you don't find a suitable result, try again with include_external=true to sea
|call| async move { symbol_search(call).await },
)
.param(Param::required("q", ParamType::String, "Symbol query text"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(Param::optional(
"include_external",
@@ -140,7 +136,6 @@ Paths are optional additional glob filters relative to the project root.",
|call| async move { file_search(call).await },
)
.param(Param::required("q", ParamType::String, "Glob pattern to search for"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(Param::optional(
"includeExcluded",
@@ -544,7 +539,6 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
let pattern = query(&call, if is_regex { "Regex pattern is empty" } else { "Search text is empty" })?;
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
let around = context(&call)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
// Globs Find in Files cannot take are applied afterwards, so the engine must not
// stop at `limit` matches the filter may drop.
@@ -565,8 +559,7 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
whole_word: false,
include,
exclude,
// Only `scope` is walked.
scope: dir.dir().map_or(SearchScope::Project, |d| SearchScope::Directory { path: d.to_path_buf().into() }),
scope: SearchScope::Project,
max_matches,
context: Default::default(),
};
@@ -575,12 +568,8 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
}
let (files, summary, timed_out) = run_search(&call, query.clone()).await?;
// Content roots outside the project are reported by absolute path.
let mut files: Vec<(String, FileMatches)> = files
.into_iter()
.filter(|f| dir.contains(&f.path.0))
.map(|f| (call.display(&f.path.0), f))
.filter(|(path, _)| scope.matches(path))
.collect();
let mut files: Vec<(String, FileMatches)> =
files.into_iter().map(|f| (call.display(&f.path.0), f)).filter(|(path, _)| scope.matches(path)).collect();
files.sort_by(|a, b| a.0.cmp(&b.0));
// Only these can match a line break.
let may_span = is_regex || pattern.contains('\n');
@@ -750,7 +739,6 @@ async fn run_search(call: &Call, query: SearchQuery) -> IdeResult<(Vec<FileMatch
async fn file_search(call: Call) -> IdeResult<Output> {
let q = query(&call, "Glob pattern is empty")?;
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
let include_excluded = call.flag("includeExcluded", false)?;
let glob = GlobSetBuilder::new()
@@ -760,19 +748,10 @@ async fn file_search(call: Call) -> IdeResult<Output> {
// Ignored names and "Exclude files" patterns, which `read_dir` does not flag.
let excludes = if include_excluded { None } else { Some(FileMask::new(&[], &call.project().search_excludes())?) };
let root = call.root().to_path_buf();
// `scope`, or the project folder and the content roots its walk does not cover: those
// outside it and those inside it that it skips as ignored.
let roots: Vec<PathBuf> = match dir.dir() {
Some(dir) => vec![dir.to_path_buf()],
None => std::iter::once(root.clone())
.chain(
call.project()
.content_roots()
.into_iter()
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r)),
)
.collect(),
};
// The project folder and the content roots outside it.
let roots: Vec<PathBuf> = std::iter::once(root.clone())
.chain(call.project().content_roots().into_iter().filter(|r| relative_to_root(&root, r).is_none()))
.collect();
let host = call.host();
let walk = Walk {
host: host.clone(),
@@ -853,9 +832,9 @@ impl Walk {
}
}
EntryKind::File => {
// Files of content roots outside the project go by absolute path, with `/` as elsewhere.
// Files of content roots outside the project go by absolute path.
let path = relative_to_root(&self.root, &entry.path)
.unwrap_or_else(|| entry.path.to_string_lossy().replace('\\', "/"));
.unwrap_or_else(|| entry.path.to_string_lossy().into_owned());
if self.glob.is_match(&path) && self.scope.matches(&path) {
if found.len() == self.limit {
return true;
@@ -877,7 +856,6 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
let q = query(&call, "Search query is empty")?;
let (page, limit) = page(&call, SYMBOL_SEARCH_DEFAULT_LIMIT)?;
let around = context(&call)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
let external = call.flag("include_external", false)?;
let host = call.host();
@@ -885,30 +863,16 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
let indexing_before = project.index.status().indexing;
let pool = if scope.is_all() { limit + 1 } else { ((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL) };
let found = {
let (project, q, dir) = (project.clone(), q.clone(), dir.dir().map(Path::to_path_buf));
host.blocking(move || {
Ok(match dir {
// Filtered in the index: a pool cut before the filter could miss every match.
Some(dir) => project
.index
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| p.starts_with(&dir), &|| false)
.unwrap_or_default(),
None => project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool),
})
})
.await?
let (project, q) = (project.clone(), q.clone());
host.blocking(move || Ok(project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool))).await?
};
let mut items: Vec<SearchItem> = found
.into_iter()
// By the path the other tools give: the index shows a root outside the project by its
// folder name, which is no path to read.
.filter(|s| dir.contains(&s.path.0))
.map(|s| (call.display(&s.path.0), s))
.filter(|(path, _)| scope.matches(path))
.map(|(path, s)| SearchItem {
.filter(|s| scope.matches(&s.rel_path))
.map(|s| SearchItem {
name: Some(s.name),
container: s.container.filter(|c| !c.is_empty()),
..SearchItem::at(path, s.range)
..SearchItem::at(s.rel_path, s.range)
})
.collect();
let mut timed_out = false;
@@ -916,15 +880,11 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
let budget = MEDIUM_TIMEOUT.saturating_sub(started.elapsed());
let (symbols, out_of_time) = workspace_symbols(&call, &q, budget).await;
timed_out = out_of_time;
let mut roots = project.content_roots();
roots.extend(crate::mcp::tool::attached_projects(call.root()));
for (name, container, location) in symbols {
let path = location.uri.clone().unwrap_or_else(|| call.display(&location.path));
// Project files (attached projects' too) obey `scope` and `paths`; library symbols
// are what was asked for.
let inside = location.uri.is_none()
&& (!Path::new(&path).is_absolute() || roots.iter().any(|r| location.path.starts_with(r)));
if inside && !(dir.contains_shown(call.root(), &path) && scope.matches(&path)) {
// Project files obey `paths`; library symbols are what was asked for.
let inside = location.uri.is_none() && !Path::new(&path).is_absolute();
if inside && !scope.matches(&path) {
continue;
}
let item = SearchItem {
+1 -8
Переглянути файл
@@ -211,7 +211,6 @@ pub fn find_references() -> Tool {
Tool::new("find_references", "Find references using the language service and the IDE's project index. Positions are 1-based UTF-16. Reports incomplete results when analysis is still running.", |call| async move {
let path = call.resolve_readable(&call.str("filePath")?).await?;
let page = super::page::Page::of(&call, REFERENCES_LIMIT)?;
let dir = super::scope::Scope::of(&call)?;
let line = call.opt_i64("line")?.ok_or_else(|| IdeError::invalid("missing line"))?;
let column = call.opt_i64("column")?.ok_or_else(|| IdeError::invalid("missing column"))?;
let project = call.project.clone();
@@ -249,12 +248,7 @@ pub fn find_references() -> Tool {
// `classified`, when there, goes with `locations` one to one.
if let serde_json::Value::Object(map) = &mut value {
let mut list = |key: &str| match map.remove(key) { Some(serde_json::Value::Array(items)) => items, _ => Vec::new() };
let (mut locations, mut classified) = (list("locations"), list("classified"));
if dir.dir().is_some() {
let inside = |l: &serde_json::Value| l["path"].as_str().is_some_and(|p| dir.contains(std::path::Path::new(p)));
locations.retain(inside);
classified.retain(|c| inside(&c["location"]));
}
let (locations, classified) = (list("locations"), list("classified"));
let classified = page.take(classified, &mut serde_json::Map::new());
let locations = page.take(locations, map);
map.insert("locations".into(), locations.into());
@@ -266,7 +260,6 @@ pub fn find_references() -> Tool {
.param(Param::required("line", ParamType::Integer, "1-based line"))
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
.param(Param::optional("includeDeclaration", ParamType::Boolean, "Include declarations (default true)"))
.param(super::scope::param())
.param(Param::optional("limit", ParamType::Integer, "References to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
}
+2 -33
Переглянути файл
@@ -37,12 +37,7 @@ impl Call {
.collect()
}
pub fn resolve_inside(&self, path: &str) -> IdeResult<PathBuf> {
resolve_inside(self.root(), path).or_else(|e| {
// An absolute path may name a trusted attached project, wherever it is.
let absolute = path.starts_with("file://") || Path::new(path).is_absolute();
let attached = if absolute { self.trusted_attachments() } else { Vec::new() };
attached.iter().find_map(|root| resolve_inside(root, path).ok()).ok_or(e)
})
resolve_inside(self.root(), path)
}
pub async fn resolve_writable(&self, path: &str) -> IdeResult<PathBuf> {
let path = self.resolve_inside(path)?;
@@ -51,24 +46,7 @@ impl Call {
}
pub async fn check_writable(&self, path: &Path) -> IdeResult<()> {
self.project.require_trust()?;
self.ensure_writable_place(path)
}
/// `path` is inside the project or a trusted project attached to it.
pub fn ensure_writable_place(&self, path: &Path) -> IdeResult<()> {
ensure_inside(self.root(), path).or_else(|e| {
if self.trusted_attachments().iter().any(|root| ensure_inside(root, path).is_ok()) {
Ok(())
} else {
Err(e)
}
})
}
/// The projects attached to this one that the user trusts (each is trusted on its own).
fn trusted_attachments(&self) -> Vec<PathBuf> {
attached_projects(self.root())
.into_iter()
.filter(|root| self.host.trust.trusted(root).unwrap_or(false))
.collect()
ensure_inside(self.root(), path)
}
pub async fn ask(&self, request: ide_core::event::McpUiRequest) -> IdeResult<()> {
self.host.mcp_requests.ask(self, request).await
@@ -322,12 +300,3 @@ pub fn resolve_inside(root: &Path, raw: &str) -> IdeResult<PathBuf> {
pub fn ensure_inside(root: &Path, path: &Path) -> IdeResult<()> {
resolve_inside(root, &path.to_string_lossy()).map(|_| ())
}
/// The projects attached to the one at `root` (its workspace members), `root` itself left out.
pub(crate) fn attached_projects(root: &Path) -> Vec<PathBuf> {
ide_workspace::workspace::Workspace::load(root)
.ok()
.flatten()
.map(|w| w.projects.into_iter().filter(|p| p != root).collect())
.unwrap_or_default()
}
+6 -14
Переглянути файл
@@ -29,7 +29,7 @@ fn relative_to(root: &Path, path: &Path) -> String {
};
match rel {
Some(rel) => rel.to_string_lossy().replace('\\', "/"),
None => path.to_string_lossy().replace('\\', "/"),
None => path.to_string_lossy().into_owned(),
}
}
@@ -266,16 +266,11 @@ By default all Git repositories are returned.",
.map(|r| (r.root.into_path_buf(), r.head))
.collect();
let wanted = call.opt_str("repositoryPathRelativeToProject")?;
let scope = super::scope::Scope::of(&call)?;
let git = git_executable(&call);
// A repository asked for, or the one holding `scope`.
let target = match &wanted {
Some(wanted) => Some(call.resolve_inside(wanted)?),
None => scope.dir().map(Path::to_path_buf),
};
let mut roots: Vec<(PathBuf, Option<String>)> = match target {
let mut roots: Vec<(PathBuf, Option<String>)> = match &wanted {
None => repos,
Some(path) => {
Some(wanted) => {
let path = call.resolve_inside(wanted)?;
// The innermost repository containing the path.
match innermost_repo(repos, &path) {
Some(repo) => vec![repo],
@@ -287,8 +282,7 @@ By default all Git repositories are returned.",
vec![(root, branch)]
}
None => {
let shown = wanted.unwrap_or_else(|| call.display(&path));
return Err(IdeError::not_found(format!("No git repository found for path: {shown}")));
return Err(IdeError::not_found(format!("No git repository found for path: {wanted}")));
}
},
}
@@ -299,13 +293,12 @@ By default all Git repositories are returned.",
for (root, branch) in roots {
let rel = relative_to_project(&call, &root);
let (git, dir) = (git.clone(), root.clone());
let mut entries = host
let entries = host
.blocking(move || read_status(&git, &dir, include_untracked, include_ignored))
.await
.map_err(|e| {
IdeError::internal(format!("Failed to get git status for repository '{rel}': {}", e.message))
})?;
entries.retain(|e| scope.contains(&root.join(e.path.trim_end_matches('/'))));
let count = |f: fn(&StatusEntry) -> bool| entries.iter().filter(|e| f(e)).count();
let listed: Vec<Value> = entries
.iter()
@@ -352,7 +345,6 @@ By default all Git repositories are returned.",
))
.param(Param::optional("includeUntracked", ParamType::Boolean, "Whether to include untracked files"))
.param(Param::optional("includeIgnored", ParamType::Boolean, "Whether to include ignored files"))
.param(super::scope::param())
.param(Param::optional("limit", ParamType::Integer, "Entries to return per repository at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
+36 -309
Переглянути файл
@@ -8,8 +8,7 @@ use ide_agent::registry::{AgentRegistry, RegistryPaths};
use ide_agent::{
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentEntry,
AgentEvent, AgentModelCatalog, AgentProbe, AgentPrompt, AgentProvider, AgentQueued, AgentTask, CustomAgentInput,
ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput,
McpTransport, NewAgentTask,
ExternalSession, McpScope, McpServer, McpServerInput, NewAgentTask,
};
use ide_core::error::ErrorKind;
use ide_core::{IdeError, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
@@ -30,15 +29,9 @@ pub fn providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
}
/// Refreshes the selected agent's model catalog without sending a prompt.
pub fn refresh_models(
host: &Host,
window: &str,
provider: String,
force: bool,
model: Option<String>,
) -> IdeResult<AgentModelCatalog> {
pub fn refresh_models(host: &Host, window: &str, provider: String, force: bool) -> IdeResult<AgentModelCatalog> {
host.require_trust(window)?;
host.project(window)?.agents.refresh_models(&provider, force, model.as_deref())
host.project(window)?.agents.refresh_models(&provider, force)
}
/// Overrides built-in agent `id`'s command with `command` (its agent file keeps the
@@ -268,6 +261,18 @@ pub async fn fork(host: &Host, window: &str, task: String, turns: Option<u32>) -
host.project(window)?.agents.fork(&task, turns).await
}
/// Creates a temporary side conversation of `source`: lives in memory only, never
/// persisted, not listed.
pub async fn create_ephemeral(
host: &Host,
window: &str,
request: NewAgentTask,
source: String,
) -> IdeResult<AgentTask> {
host.require_trust(window)?;
host.project(window)?.agents.create_ephemeral(request, &source).await
}
/// Drops the task's turns after its first `turns`; returns the message of the first dropped one.
pub async fn rollback(host: &Host, window: &str, task: String, turns: u32) -> IdeResult<Option<AgentPrompt>> {
host.require_trust(window)?;
@@ -472,21 +477,19 @@ fn persist_mcp_map(
Ok(())
}
fn update_mcp_maps<F>(host: &Host, window: &str, approve: &[String], f: F) -> IdeResult<Vec<McpServer>>
fn update_mcp_maps<F>(host: &Host, window: &str, approve: Option<&str>, f: F) -> IdeResult<Vec<McpServer>>
where
F: FnOnce(&mut McpServerMap, &mut McpServerMap, Option<&std::path::Path>) -> Result<Vec<String>, String>,
F: FnOnce(&mut McpServerMap, &mut McpServerMap, Option<&std::path::Path>) -> Result<(), String>,
{
let (mut user, mut workspace, project) = mcp_maps(host, window);
let prev_user = user.clone();
let prev_workspace = workspace.clone();
let project_root = project.as_ref().map(|p| p.root.as_path());
let extra_approved = f(&mut user, &mut workspace, project_root).map_err(IdeError::invalid)?;
if let Some(p) = &project {
for name in approve.iter().chain(extra_approved.iter()) {
if let Some(server) = workspace.get(name.as_str()) {
host.mcp_approvals.approve(&p.root, name, server)?;
}
}
f(&mut user, &mut workspace, project_root).map_err(IdeError::invalid)?;
if let (Some(name), Some(p)) = (approve, &project)
&& let Some(server) = workspace.get(name)
{
host.mcp_approvals.approve(&p.root, name, server)?;
}
if workspace != prev_workspace {
persist_mcp_map(host, project.as_ref(), McpScope::Workspace, &workspace)?;
@@ -504,22 +507,11 @@ fn listed(
user: &McpServerMap,
workspace: McpServerMap,
) -> Vec<McpServer> {
let raw_workspace = workspace.clone();
let workspace = match project {
Some(p) => host.mcp_approvals.apply(&p.root, workspace),
None => workspace,
};
let mut out = ide_agent::mcp::servers_from_settings(user, &workspace);
if let Some(p) = project {
for srv in &mut out {
if srv.scope == McpScope::Workspace
&& let Some(raw) = raw_workspace.get(&srv.name)
{
srv.unapproved = !host.mcp_approvals.approved(&p.root, &srv.name, raw);
}
}
}
out
ide_agent::mcp::servers_from_settings(user, &workspace)
}
/// The MCP servers agent sessions of the project at `root` get: the user's, values filled in, and
@@ -533,8 +525,7 @@ pub(crate) fn session_mcp_servers(
use ide_workspace::settings::SettingsScope;
let mut user = settings.layer(SettingsScope::Global).agents.mcp_servers;
fill_mcp_values(secrets, &mut user);
let mut workspace = settings.layer(SettingsScope::Project).agents.mcp_servers;
workspace.retain(|name, srv| approvals.approved(root, name, srv));
let workspace = approvals.apply(root, settings.layer(SettingsScope::Project).agents.mcp_servers);
ide_agent::mcp::servers_from_settings(&user, &workspace)
}
@@ -547,298 +538,45 @@ pub fn mcp_list(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
/// Creates or updates a User or Workspace MCP server and returns the updated list. A Workspace
/// server saved here is one the user turned on.
pub fn mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<Vec<McpServer>> {
let approve: Vec<String> =
(input.scope == McpScope::Workspace).then(|| input.name.trim().to_owned()).into_iter().collect();
update_mcp_maps(host, window, &approve, |user, workspace, project_root| {
ide_agent::mcp::apply_save(user, workspace, project_root.is_some(), input).map(|()| Vec::new())
})
}
/// Parses and saves one or more MCP servers from a pasted JSON snippet (`{"mcpServers": {...}}` or
/// single server object). Workspace servers explicitly saved here by the user are approved.
pub fn mcp_save_json(
host: &Host,
window: &str,
scope: McpScope,
raw_json: String,
fallback_name: Option<String>,
agents: Vec<String>,
) -> IdeResult<Vec<McpServer>> {
update_mcp_maps(host, window, &[], |user, workspace, project_root| {
let saved = ide_agent::mcp::apply_save_json(
user,
workspace,
project_root.is_some(),
scope,
&raw_json,
fallback_name.as_deref(),
agents,
)?;
Ok(if scope == McpScope::Workspace { saved } else { Vec::new() })
let approve = (input.scope == McpScope::Workspace).then(|| input.name.trim().to_owned());
update_mcp_maps(host, window, approve.as_deref(), |user, workspace, project_root| {
ide_agent::mcp::apply_save(user, workspace, project_root.is_some(), input)
})
}
/// Enables or disables an MCP server and returns the updated list.
pub fn mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) -> IdeResult<Vec<McpServer>> {
let approve: Vec<String> = ide_agent::mcp::parse_server_id(&id)
let approve = ide_agent::mcp::parse_server_id(&id)
.filter(|(scope, _)| enabled && *scope == McpScope::Workspace)
.map(|(_, name)| name.to_owned())
.into_iter()
.collect();
update_mcp_maps(host, window, &approve, |user, workspace, _| {
ide_agent::mcp::apply_set_enabled(user, workspace, &id, enabled).map(|_| Vec::new())
.map(|(_, name)| name.to_owned());
update_mcp_maps(host, window, approve.as_deref(), |user, workspace, _| {
ide_agent::mcp::apply_set_enabled(user, workspace, &id, enabled).map(|_| ())
})
}
/// Removes a User or Workspace MCP server and returns the updated list.
pub fn mcp_remove(host: &Host, window: &str, id: String) -> IdeResult<Vec<McpServer>> {
update_mcp_maps(host, window, &[], |user, workspace, _| {
ide_agent::mcp::apply_remove(user, workspace, &id).map(|_| Vec::new())
update_mcp_maps(host, window, None, |user, workspace, _| {
ide_agent::mcp::apply_remove(user, workspace, &id).map(|_| ())
})
}
/// Copies MCP servers from `.mcp.json` and `.vscode/mcp.json` into the workspace settings once;
/// they stay off until the user turns them on.
pub fn mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
update_mcp_maps(host, window, &[], |_, workspace, project_root| {
update_mcp_maps(host, window, None, |_, workspace, project_root| {
let root = project_root.ok_or_else(|| "Open a project to import workspace MCP servers".to_string())?;
ide_agent::mcp::apply_import(workspace, root);
Ok(Vec::new())
Ok(())
})
}
/// Discovers external MCP configuration files on disk (CLI user configs + workspace `.mcp.json`).
pub async fn mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<McpExternalSource>> {
let project_root = host.project(window).ok().filter(|p| !p.light).map(|p| p.root.clone());
let home = dirs::home_dir();
tokio::task::spawn_blocking(move || {
ide_agent::mcp::discover_external_sources(home.as_deref(), project_root.as_deref())
})
.await
.map_err(|e| IdeError::internal(e.to_string()))
}
/// Imports selected servers from discovered external MCP configuration files into User or Workspace scope.
/// Imported Workspace entries remain unapproved (disabled) until the user explicitly enables them.
pub async fn mcp_import_selected(
host: &Host,
window: &str,
scope: McpScope,
selections: Vec<McpImportSelection>,
overwrite: bool,
) -> IdeResult<Vec<McpServer>> {
let home = dirs::home_dir();
update_mcp_maps(host, window, &[], move |user, workspace, project_root| {
ide_agent::mcp::apply_import_selected(
user,
workspace,
home.as_deref(),
project_root,
scope,
&selections,
overwrite,
)?;
Ok(Vec::new())
})
}
/// Tests an MCP server by connecting (`initialize`) and listing its tools (`tools/list`).
pub async fn mcp_test(host: &Host, window: &str, id: String) -> IdeResult<McpProbeResult> {
host.require_trust(window)?;
let (user, workspace, project) = mcp_maps(host, window);
let (scope, name) = ide_agent::mcp::parse_server_id(&id)
.ok_or_else(|| IdeError::not_found(format!("MCP server `{id}` not found")))?;
let server = match scope {
McpScope::User => user.get(name),
McpScope::Workspace => workspace.get(name),
}
.cloned()
.ok_or_else(|| IdeError::not_found(format!("MCP server `{name}` not found")))?;
if scope == McpScope::Workspace {
let p = project.as_ref().ok_or_else(|| IdeError::invalid("Open a project to test workspace MCP servers"))?;
if !host.mcp_approvals.approved(&p.root, name, &server) {
return Err(IdeError::invalid("Enable this workspace MCP server first before testing it"));
}
}
let cwd = project.as_ref().map(|p| p.root.clone()).or_else(dirs::home_dir).unwrap_or_else(std::env::temp_dir);
match server.transport {
McpTransport::Stdio => Ok(ide_agent::mcp::probe_stdio_server(&server, &cwd).await),
McpTransport::Http | McpTransport::Sse => Ok(probe_http_mcp_server(&server).await),
}
}
async fn probe_http_mcp_server(server: &ide_core::settings::AgentMcpServer) -> McpProbeResult {
let started = std::time::Instant::now();
let elapsed_ms = || u32::try_from(started.elapsed().as_millis()).unwrap_or(u32::MAX);
let Some(url) = server.url.as_deref().map(str::trim).filter(|u| !u.is_empty()) else {
return McpProbeResult {
ok: false,
server_name: None,
server_version: None,
protocol_version: None,
tools: Vec::new(),
duration_ms: elapsed_ms(),
error: Some("URL is empty".into()),
};
};
let mut headers = reqwest::header::HeaderMap::new();
headers.insert(
reqwest::header::ACCEPT,
reqwest::header::HeaderValue::from_static("application/json, text/event-stream"),
);
for (k, v) in &server.headers {
if let (Ok(name), Ok(val)) =
(reqwest::header::HeaderName::from_bytes(k.as_bytes()), reqwest::header::HeaderValue::from_str(v))
{
headers.insert(name, val);
}
}
let client =
match reqwest::Client::builder().default_headers(headers).timeout(std::time::Duration::from_secs(12)).build() {
Ok(c) => c,
Err(e) => {
return McpProbeResult {
ok: false,
server_name: None,
server_version: None,
protocol_version: None,
tools: Vec::new(),
duration_ms: elapsed_ms(),
error: Some(format!("HTTP client error: {e}")),
};
}
};
let post_rpc = |session_id: Option<String>, body: serde_json::Value| {
let client = client.clone();
let url = url.to_owned();
async move {
let mut req =
client.post(&url).header(reqwest::header::CONTENT_TYPE, "application/json").body(body.to_string());
if let Some(sid) = session_id.as_deref() {
req = req.header("Mcp-Session-Id", sid);
}
let resp = req
.send()
.await
.map_err(|e| format!("Request to `{url}` failed: {}", ide_http::client::describe(&e.without_url())))?;
let status = resp.status();
let next_session =
resp.headers().get("mcp-session-id").and_then(|v| v.to_str().ok()).map(str::to_owned).or(session_id);
let text = resp.text().await.map_err(|e| format!("Failed reading response: {e}"))?;
if !status.is_success() {
let detail = text.trim();
let msg = if detail.is_empty() {
format!("HTTP {status}")
} else {
format!("HTTP {status}: {}", detail.chars().take(240).collect::<String>())
};
return Err(msg);
}
Ok((next_session, parse_mcp_http_response(&text)?))
}
};
let init_req = serde_json::json!({
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "2024-11-05",
"capabilities": {},
"clientInfo": { "name": "OpenIDEA", "version": env!("CARGO_PKG_VERSION") },
}
});
let (session_id, init_res) = match post_rpc(None, init_req).await {
Ok(v) => v,
Err(err) => {
return McpProbeResult {
ok: false,
server_name: None,
server_version: None,
protocol_version: None,
tools: Vec::new(),
duration_ms: elapsed_ms(),
error: Some(err),
};
}
};
// Best-effort `notifications/initialized` + `tools/list`.
let mut not_req = client.post(url).header(reqwest::header::CONTENT_TYPE, "application/json").body(
serde_json::json!({
"jsonrpc": "2.0",
"method": "notifications/initialized",
"params": {},
})
.to_string(),
);
if let Some(sid) = session_id.as_deref() {
not_req = not_req.header("Mcp-Session-Id", sid);
}
let _ = not_req.send().await;
let tools_res = post_rpc(
session_id,
serde_json::json!({
"jsonrpc": "2.0",
"id": 2,
"method": "tools/list",
"params": {},
}),
)
.await
.map(|(_, v)| v)
.unwrap_or_else(|_| serde_json::json!({}));
ide_agent::mcp::parse_probe_payloads(&init_res, &tools_res, elapsed_ms())
}
fn parse_mcp_http_response(body: &str) -> Result<serde_json::Value, String> {
let trimmed = body.trim();
if trimmed.is_empty() {
return Ok(serde_json::json!({}));
}
if let Ok(msg) = serde_json::from_str::<serde_json::Value>(trimmed) {
if let Some(err) = msg.get("error") {
let em = err.get("message").and_then(serde_json::Value::as_str).unwrap_or("JSON-RPC error");
return Err(em.to_owned());
}
return Ok(msg.get("result").cloned().unwrap_or(msg));
}
// Streamable HTTP SSE frames (`data: {...}`).
for line in trimmed.lines() {
if let Some(rest) = line.strip_prefix("data:")
&& let Ok(msg) = serde_json::from_str::<serde_json::Value>(rest.trim())
&& (msg.get("result").is_some() || msg.get("error").is_some())
{
if let Some(err) = msg.get("error") {
let em = err.get("message").and_then(serde_json::Value::as_str).unwrap_or("JSON-RPC error");
return Err(em.to_owned());
}
return Ok(msg.get("result").cloned().unwrap_or(msg));
}
}
Err("Unexpected non-JSON MCP response".into())
}
/// Updates per-session MCP server enable/disable overrides on task `task`.
pub fn set_mcp_overrides(
host: &Host,
window: &str,
task: String,
overrides: std::collections::BTreeMap<String, bool>,
) -> IdeResult<AgentTask> {
host.project(window)?.agents.set_mcp_overrides(&task, overrides)
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("agent_subscribe", |c| async move { subscribe(&c.host, &c.window, c.channel("onEvent")?) });
d.add("agent_providers", |c| async move { providers(&c.host, &c.window) });
d.add("agent_refresh_models", |c| async move {
refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?, c.arg("model")?)
refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?)
});
d.add("agent_set_command", |c| async move { set_command(&c.host, &c.window, c.arg("id")?, c.arg("command")?) });
d.add("agent_set_env", |c| async move { set_env(&c.host, &c.window, c.arg("id")?, c.arg("env")?) });
@@ -849,23 +587,12 @@ pub(crate) fn register(d: &mut Dispatcher) {
d.add("agent_registry_remove", |c| async move { registry_remove(&c.host, &c.window, c.arg("id")?).await });
d.add("agent_mcp_list", |c| async move { mcp_list(&c.host, &c.window) });
d.add("agent_mcp_save", |c| async move { mcp_save(&c.host, &c.window, c.arg("input")?) });
d.add("agent_mcp_save_json", |c| async move {
mcp_save_json(&c.host, &c.window, c.arg("scope")?, c.arg("rawJson")?, c.arg("fallbackName")?, c.arg("agents")?)
});
d.add(
"agent_mcp_set_enabled",
|c| async move { mcp_set_enabled(&c.host, &c.window, c.arg("id")?, c.arg("enabled")?) },
);
d.add("agent_mcp_remove", |c| async move { mcp_remove(&c.host, &c.window, c.arg("id")?) });
d.add("agent_mcp_import", |c| async move { mcp_import(&c.host, &c.window) });
d.add("agent_mcp_discover_sources", |c| async move { mcp_discover_sources(&c.host, &c.window).await });
d.add("agent_mcp_import_selected", |c| async move {
mcp_import_selected(&c.host, &c.window, c.arg("scope")?, c.arg("selections")?, c.arg("overwrite")?).await
});
d.add("agent_mcp_test", |c| async move { mcp_test(&c.host, &c.window, c.arg("id")?).await });
d.add("agent_set_mcp_overrides", |c| async move {
set_mcp_overrides(&c.host, &c.window, c.arg("task")?, c.arg("overrides")?)
});
d.add("agent_commands", |c| async move { commands(&c.host, &c.window, c.arg("provider")?, c.arg("task")?).await });
d.add("agent_entries", |c| async move { entries(&c.host, &c.window, c.arg("task")?, c.arg("subagent")?) });
d.add("agent_create", |c| async move { create(&c.host, &c.window, c.arg("request")?).await });
-115
Переглянути файл
@@ -1,115 +0,0 @@
//! Cucumber sources: the project's `.feature` files and the JavaScript / TypeScript files
//! (`@cucumber/cucumber`, `playwright-bdd`) and Java / Kotlin files (cucumber-jvm's
//! `@Given("…")` annotations and Java 8 lambdas) that could define steps, with their text. The UI
//! owns the Gherkin and step-expression parsing and the index it feeds (as for `routes`),
//! so this side stays a cheap scan.
use crate::Host;
use ide_core::IdeResult;
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
use std::sync::Mutex;
use std::sync::atomic::{AtomicUsize, Ordering};
/// Files handed out at most, and bytes in total: a test suite's features and step
/// files fit well inside these, and the UI indexes them once.
const MAX_FILES: usize = 4096;
const MAX_BYTES: usize = 64 << 20;
/// A single source bigger than this is a bundle, not a step file.
const MAX_FILE_BYTES: u64 = 2 << 20;
/// What a step definition call starts with (`Given('…'`, `defineStep(/…/`).
const STEP_CALLS: [&str; 5] = ["Given(", "When(", "Then(", "Step(", "defineStep("];
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct StepSource {
pub path: ide_core::IpcPath,
pub text: String,
/// A Gherkin `.feature` file; otherwise a script defining steps.
pub feature: bool,
}
fn is_feature(path: &Path) -> bool {
path.extension().and_then(|e| e.to_str()).is_some_and(|e| e.eq_ignore_ascii_case("feature"))
}
fn is_script(path: &Path) -> bool {
matches!(
path.extension().and_then(|e| e.to_str()),
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt")
)
}
/// The feature files and step definition files under `root`.
pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
let found: Mutex<Vec<StepSource>> = Mutex::new(Vec::new());
let bytes = AtomicUsize::new(0);
ide_vfs::walk_files(root, excludes, |path| {
let feature = is_feature(path);
if !(feature || is_script(path)) || bytes.load(Ordering::Relaxed) >= MAX_BYTES {
return;
}
if std::fs::metadata(path).map_or(true, |m| m.len() > MAX_FILE_BYTES) {
return;
}
let Ok(text) = std::fs::read_to_string(path) else { return };
if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) {
return;
}
let Ok(mut found) = found.lock() else { return };
if found.len() >= MAX_FILES {
return;
}
bytes.fetch_add(text.len(), Ordering::Relaxed);
found.push(StepSource { path: path.to_path_buf().into(), text, feature });
});
let mut files = found.into_inner().unwrap_or_default();
files.sort_by(|a, b| a.path.cmp(&b.path));
files
}
/// Every Cucumber source of the project (its folder and the content roots outside it).
pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>> {
let project = host.project(window)?;
let mut excludes = project.search_excludes();
// Cucumber's own sources (and every other package's) are not the project's steps.
excludes.push("node_modules".to_owned());
let mut out = Vec::new();
for root in std::iter::once(project.root.clone()).chain(project.content_roots()) {
out.extend(sources_in(&root, &excludes));
}
out.sort_by(|a, b| a.path.cmp(&b.path));
out.dedup_by(|a, b| a.path == b.path);
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn features_and_step_files_are_read_and_nothing_else() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
for dir in ["features", "steps", "src", "node_modules/@cucumber/cucumber/lib"] {
std::fs::create_dir_all(root.join(dir)).unwrap();
}
std::fs::write(root.join("features/cart.feature"), "Feature: Cart\n").unwrap();
std::fs::write(root.join("steps/cart.steps.ts"), "Given('an empty cart', () => {});").unwrap();
std::fs::write(root.join("steps/bdd.mjs"), "const { When } = createBdd();\nWhen(/^I add (\\d+)$/, f);")
.unwrap();
std::fs::write(root.join("src/app.ts"), "export const app = 1;").unwrap();
std::fs::write(root.join("src/CartSteps.java"), "@Given(\"an empty cart\")\npublic void empty() {}").unwrap();
std::fs::write(root.join("src/App.java"), "class App {}").unwrap();
std::fs::write(root.join("src/notes.md"), "Given('x')").unwrap();
std::fs::write(root.join("node_modules/@cucumber/cucumber/lib/index.js"), "Given('x')").unwrap();
let files = sources_in(root, &["node_modules".to_owned()]);
let names: Vec<String> =
files.iter().map(|f| f.path.0.strip_prefix(root).unwrap().to_string_lossy().replace('\\', "/")).collect();
assert_eq!(names, ["features/cart.feature", "src/CartSteps.java", "steps/bdd.mjs", "steps/cart.steps.ts"]);
assert!(files[0].feature && !files[1].feature);
assert!(files[3].text.contains("an empty cart"));
}
}
+7 -48
Переглянути файл
@@ -311,11 +311,12 @@ pub async fn build_sync(
if completion_token.is_cancelled() {
return Err(IdeError::cancelled());
}
// Gradle may report project folders outside the project (`includeFlat`), and a Maven
// reactor may have gained or dropped modules beside it: index and list them.
project.refresh_index_scope();
let p = project.clone();
tokio::task::spawn_blocking(move || p.refresh_repositories());
if tool == BuildTool::Gradle {
// The sync may report project folders outside the project (`includeFlat`): index and list them.
project.refresh_index_scope();
let p = project.clone();
tokio::task::spawn_blocking(move || p.refresh_repositories());
}
// New source folders and dependency versions: the Project view and External Libraries reload.
project.sink.emit(ide_core::IdeEvent::ProjectRootsChanged { root: project.root.clone().into() });
if tool == BuildTool::Maven
@@ -467,15 +468,7 @@ pub async fn gradle_dependencies(
gradle_command: Some(gradle.command.clone()),
..Default::default()
};
let dependencies =
ide_build::gradle_dependencies(&scope.root, gradle, &options, &gradle_path, &configuration, &token)?;
// What plugins read of the build (`build.dependencies`) instead of running Gradle.
let report = ide_build::GradleReport { project: gradle_path, configuration, dependencies };
let cache = ide_build::gradle::cache_dir(&scope.cache, &gradle.dir);
if let Err(e) = ide_build::save_gradle_report(&scope.root, &cache, gradle, &report) {
tracing::debug!("keeping the dependencies report of {}: {e}", report.project);
}
Ok(report.dependencies)
ide_build::gradle_dependencies(&scope.root, gradle, &options, &gradle_path, &configuration, &token)
})
.await
.map_err(join_err);
@@ -483,40 +476,6 @@ pub async fn gradle_dependencies(
result?
}
/// What the Dependency Analyzer has of the builds of `project` at `root` (the project, or one
/// of its workspace members), without running a build tool: the Maven modules as last synced
/// and the Gradle reports read since the build files last changed.
pub(crate) fn analyzed_dependencies(
project: &Project,
config: &Path,
root: &Path,
) -> IdeResult<crate::plugins::BuildGraph> {
let mut graph = crate::plugins::BuildGraph::default();
for scope in workspace::scopes(project, config)?.iter().filter(|s| root == project.root || s.root == root) {
let settings = &scope.settings;
let model = ide_build::load_linked(
&scope.root,
&scope.cache,
ide_sdk::apply::maven_local_repository(&scope.root, settings),
&settings.languages.java.maven,
&settings.languages.java.gradle,
);
graph.maven.extend(model.maven.into_iter().flat_map(|m| m.projects));
for build in &model.gradle {
let reports =
ide_build::gradle_reports(&scope.root, &ide_build::gradle::cache_dir(&scope.cache, &build.dir), build);
// buildSrc can't be analyzed from the build, as in the Dependency Analyzer.
for p in build.projects.iter().filter(|p| !p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc"))) {
graph.gradle.push(crate::plugins::GradleModule {
path: p.path.clone(),
reports: reports.iter().filter(|r| r.project == p.path).cloned().collect(),
});
}
}
}
Ok(graph)
}
/// Where the direct dependency `dependency` of the Maven module `pom` is declared.
pub async fn maven_dependency_declaration(
host: &Host,
-4
Переглянути файл
@@ -88,10 +88,6 @@ pub(super) fn load_scopes(root: &Path, scopes: &[Scope]) -> BuildModel {
}
}
combined.gradle.extend(model.gradle);
for b in model.sbt.iter_mut().filter(|_| scope.root != root) {
b.dir = absolute(&scope.root, &b.dir);
}
combined.sbt.extend(model.sbt);
}
combined
}
-32
Переглянути файл
@@ -532,35 +532,3 @@ fn console_dir(host: &Host, id: &str) -> IdeResult<PathBuf> {
std::fs::create_dir_all(&dir)?;
Ok(dir)
}
/// Runs a client tool against target `id` until it exits or the request is cancelled.
/// Desktop only: the file paths come from local dialogs.
pub async fn run_tool(
host: &Host,
window: &str,
request: RequestId,
id: &str,
executable: &std::path::Path,
job: &ide_db::tools::DbToolJob,
on_output: impl FnMut(Vec<ide_db::tools::ToolLine>),
) -> IdeResult<Option<i32>> {
let db = host.project(window)?.db.clone();
let cancel = host.begin_request(request);
let result = db.run_tool(id, executable, job, &cancel, on_output).await;
host.end_request(request);
result
}
pub fn tool_preview(
host: &Host,
window: &str,
id: &str,
executable: &std::path::Path,
job: &ide_db::tools::DbToolJob,
) -> IdeResult<String> {
host.project(window)?.db.tool_preview(id, executable, job)
}
pub async fn server_version(host: &Host, window: &str, id: &str) -> IdeResult<u32> {
host.project(window)?.db.server_version(id).await
}
+1 -86
Переглянути файл
@@ -31,8 +31,6 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
} else {
None
};
let agents = if is_jvm_launch(&config) { ide_run::java_agent::current() } else { Default::default() };
let config = add_java_agents(config, &agents.options);
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
if config.adapter == "debugpy"
&& config.request == "launch"
@@ -121,15 +119,6 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
let server_port = debug_server_port(&config);
let result = host.debugger.start_with(config, owner, custom).await;
flush_output();
if let Ok(id) = &result {
let sink = host.window_sink(label);
for note in &agents.notes {
sink.emit(ide_core::IdeEvent::Debug {
session: *id,
event: ide_core::event::DebugEvent::Output { category: "console".into(), output: format!("{note}\n") },
});
}
}
if result.is_err()
&& let Some(pid) = unity_pid
{
@@ -165,54 +154,10 @@ fn debug_server_port(config: &LaunchConfig) -> Option<u16> {
fn attach_jvm_inspector(host: &Host, window: &str, session: DebugSessionId, port: u16) {
let Ok(project) = host.project(window) else { return };
let Some(module) = project.lsp.java_debug_server_module(port) else { return };
let inspector = std::sync::Arc::new(ide_lsp::JdtJvmInspector::new(project.lsp.clone(), module.clone()));
let inspector = std::sync::Arc::new(ide_lsp::JdtJvmInspector::new(project.lsp.clone(), module));
if let Err(e) = host.debugger.set_jvm_inspector(session, inspector) {
tracing::debug!("jvm inspector for session {session:?}: {e}");
return;
}
let tracer = std::sync::Arc::new(ide_lsp::JdtStreamTracer::new(project.lsp.clone(), module));
if let Err(e) = host.debugger.set_stream_tracer(session, tracer) {
tracing::debug!("stream tracer for session {session:?}: {e}");
}
}
/// A JVM the debugger starts itself: an Application or Spring Boot configuration, launched by
/// java-debug or the Kotlin debugger (JAR Application debugs through a run with a JDWP agent).
fn is_jvm_launch(config: &LaunchConfig) -> bool {
config.request == "launch" && matches!(config.adapter.as_str(), "java-debug" | ide_dap::kotlin::ADAPTER)
}
/// Plugins' Java agents ([`ide_run::java_agent`]) after the configuration's VM options:
/// java-debug's `vmArgs` (one line, or a list) or the Kotlin debugger's `vmArguments` (a list).
fn add_java_agents(mut config: LaunchConfig, options: &[String]) -> LaunchConfig {
if options.is_empty() || !is_jvm_launch(&config) {
return config;
}
let Some(serde_json::Value::Object(mut extra)) =
config.extra_json.as_deref().and_then(|e| serde_json::from_str(e).ok())
else {
return config;
};
let key = if config.adapter == "java-debug" { "vmArgs" } else { "vmArguments" };
let value = match extra.get(key) {
None | Some(serde_json::Value::Null) if key == "vmArgs" => {
ide_run::java_agent::add_to_vm_args_text("", options).into()
}
Some(serde_json::Value::String(text)) => ide_run::java_agent::add_to_vm_args_text(text, options).into(),
None | Some(serde_json::Value::Null) | Some(serde_json::Value::Array(_)) => {
let mut list: Vec<String> = extra
.get(key)
.and_then(serde_json::Value::as_array)
.map(|a| a.iter().filter_map(|v| v.as_str().map(str::to_owned)).collect())
.unwrap_or_default();
ide_run::java_agent::add_to_vm_args(&mut list, options);
list.into()
}
Some(_) => return config,
};
extra.insert(key.into(), value);
config.extra_json = Some(serde_json::Value::Object(extra).to_string());
config
}
/// The JVM memory tab reads the class table over the attach socket, which only exists once the
@@ -868,36 +813,6 @@ mod tests {
);
}
#[test]
fn plugin_java_agents_join_the_vm_options_of_jvm_launches() {
let agent = "-javaagent:/my plugins/agent.jar=port=0".to_owned();
let options = std::slice::from_ref(&agent);
let field = |config: &LaunchConfig, key: &str| {
serde_json::from_str::<serde_json::Value>(config.extra_json.as_deref().unwrap()).unwrap()[key].clone()
};
let debugged =
add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": "-Xmx1g"})), options);
assert_eq!(vm_args(&debugged), "-Xmx1g \"-javaagent:/my plugins/agent.jar=port=0\"");
assert_eq!(add_java_agents(debugged.clone(), options).extra_json, debugged.extra_json, "not added twice");
let none = add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": null})), options);
assert_eq!(vm_args(&none), "\"-javaagent:/my plugins/agent.jar=port=0\"");
let list = add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": ["-Xmx1g"]})), options);
assert_eq!(vm_args(&list), serde_json::json!(["-Xmx1g", agent]));
let kotlin = launch(ide_dap::kotlin::ADAPTER, "launch", serde_json::json!({"vmArguments": ["-Xmx1g"]}));
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!(["-Xmx1g", agent]));
let kotlin = launch(ide_dap::kotlin::ADAPTER, "launch", serde_json::json!({}));
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!([agent]));
// Attaching (remote debug included), other adapters, and no granted agent: unchanged.
for config in [
launch("java-debug", "attach", serde_json::json!({"vmArgs": "-Xmx1g"})),
launch("debugpy", "launch", serde_json::json!({"vmArgs": "-Xmx1g"})),
] {
assert_eq!(add_java_agents(config.clone(), options).extra_json, config.extra_json);
}
let config = launch("java-debug", "launch", serde_json::json!({"vmArgs": "-Xmx1g"}));
assert_eq!(add_java_agents(config.clone(), &[]).extra_json, config.extra_json);
}
#[test]
fn debug_server_port_only_for_local_java_debug() {
let port = |adapter: &str, request: &str, extra| debug_server_port(&launch(adapter, request, extra));
+6 -15
Переглянути файл
@@ -5,7 +5,7 @@ use crate::rpc::Dispatcher;
use ide_core::{DocId, IdeError, IdeResult, OutlineItem, Range};
use ide_language::{FoldRange, SyntaxHighlights};
use ide_text::LineEnding;
use ide_workspace::{DocumentEncoding, DocumentInfo, DocumentLanguage, HistoryEntry};
use ide_workspace::{DocumentEncoding, DocumentInfo, HistoryEntry};
use std::path::PathBuf;
/// Runs blocking work (disk I/O, parsing, large copies) on the blocking pool,
@@ -32,17 +32,11 @@ pub async fn doc_open_virtual(host: &Host, window: &str, uri: String) -> IdeResu
.await
}
/// The language and CodeMirror mode `path` is shown with in an editor, without opening
/// it: previews of closed files and diffs. `first_line` is the shown text's (a revision's)
/// for hashbang detection; without it the file's on disk counts.
pub async fn doc_language(
host: &Host,
window: &str,
path: PathBuf,
first_line: Option<String>,
) -> IdeResult<DocumentLanguage> {
/// The CodeMirror mode `path` gets when opened (`DocumentInfo::ui_mode`),
/// without opening it: previews of closed files.
pub async fn doc_ui_mode(host: &Host, window: &str, path: PathBuf) -> IdeResult<Option<String>> {
let project = host.project(window)?;
blocking(move || Ok(project.documents.language_of(&path, first_line.as_deref()))).await
blocking(move || Ok(project.documents.ui_mode_of(&path))).await
}
/// "Reload with Encoding" (`reload`) or "Convert to Encoding"; returns the new encoding and BOM state.
@@ -215,10 +209,7 @@ pub fn history_content(host: &Host, window: &str, id: String) -> IdeResult<Strin
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("doc_open_virtual", |c| async move { doc_open_virtual(&c.host, &c.window, c.arg("uri")?).await });
d.add(
"doc_language",
|c| async move { doc_language(&c.host, &c.window, c.arg("path")?, c.arg("firstLine")?).await },
);
d.add("doc_ui_mode", |c| async move { doc_ui_mode(&c.host, &c.window, c.arg("path")?).await });
d.add("doc_set_encoding", |c| async move {
doc_set_encoding(&c.host, &c.window, c.arg("doc")?, c.arg("encoding")?, c.arg("reload")?).await
});
+6 -41
Переглянути файл
@@ -97,8 +97,6 @@ async fn resolve_launch(
tokio::task::spawn_blocking(move || {
let _external_build = external_build;
let local_repo = ide_sdk::apply::maven_local_repository(&project.root, &settings);
// Module outputs the launch runs from a snapshot of: the originals must not come back.
let mut snapshotted = Vec::new();
let built = if delegated {
let rebuild_on_jdt_errors = rebuild_on_jdt_errors(policy, prefer_maven, info.error_count);
let outputs = project.java_launch_snapshots.lock().build(
@@ -111,7 +109,6 @@ async fn resolve_launch(
)?;
let copies = use_snapshot(&mut info, &outputs.originals, &outputs.snapshot);
apply_external_build_result(&mut info, outputs.failure, outputs.authoritative);
snapshotted = outputs.originals;
copies
} else if external {
let built = compile::build_for_launch(&project.root, &model, &module, test, build_kind, &cancel)?;
@@ -140,7 +137,7 @@ async fn resolve_launch(
&project.build_cache_dir(),
&cancel,
);
merge_maven_launch_classpath(&mut class_paths, &mut info, maven_cp, &snapshotted)?;
merge_maven_launch_classpath(&mut class_paths, &mut info, maven_cp)?;
} else {
append_unique_class_paths(&mut class_paths, std::mem::take(&mut info.class_paths));
}
@@ -301,23 +298,17 @@ fn same_entry(a: &str, b: &str, windows: bool) -> bool {
/// Merge the Maven launch classpath without turning a recoverable probe failure into a
/// failed launch. Cancellation still propagates; ordinary failures keep jdtls' classpath
/// and leave the reason in the run console. Maven lists the module's and its reactor
/// siblings' `target/classes`; those in `snapshotted` already run from their snapshot,
/// and listing both would make every resource (MyBatis mapper XML) load twice.
/// and leave the reason in the run console.
fn merge_maven_launch_classpath(
class_paths: &mut Vec<String>,
info: &mut JavaLaunchInfo,
classpath: IdeResult<String>,
snapshotted: &[PathBuf],
) -> IdeResult<()> {
match classpath {
Ok(classpath) => {
let snapshotted: Vec<_> = snapshotted.iter().map(|p| p.to_string_lossy()).collect();
append_unique_class_paths(
class_paths,
std::env::split_paths(&classpath)
.map(|path| path.to_string_lossy().into_owned())
.filter(|path| !snapshotted.iter().any(|original| same_entry(path, original, cfg!(windows)))),
std::env::split_paths(&classpath).map(|path| path.to_string_lossy().into_owned()),
);
Ok(())
}
@@ -480,46 +471,20 @@ mod tests {
let mut class_paths = vec!["snapshot.jar".to_owned()];
let mut info =
JavaLaunchInfo { class_paths: vec!["snapshot.jar".into(), "jdtls.jar".into()], ..Default::default() };
merge_maven_launch_classpath(&mut class_paths, &mut info, Ok(maven), &[]).unwrap();
merge_maven_launch_classpath(&mut class_paths, &mut info, Ok(maven)).unwrap();
assert_eq!(class_paths, ["snapshot.jar", "maven.jar"]);
merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::internal("offline dependency")), &[])
merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::internal("offline dependency")))
.unwrap();
assert_eq!(class_paths, ["snapshot.jar", "maven.jar", "jdtls.jar"]);
assert!(info.hints[0].contains("offline dependency"), "{:?}", info.hints);
}
/// Maven's launch classpath lists the module's and its reactor siblings' outputs, which
/// the launch already runs from a snapshot: listed twice, MyBatis loads each mapper XML
/// twice and fails with "XML fragments parsed from previous mappers already contains value".
#[test]
fn maven_classpath_leaves_out_outputs_the_launch_runs_from_a_snapshot() {
let web = PathBuf::from("/work/haoke/haoke-web/target/classes");
let service = PathBuf::from("/work/haoke/haoke-service/target/classes");
let maven = std::env::join_paths([
"/work/haoke/haoke-web/target/classes/",
"/work/haoke/haoke-service/target/classes",
"/work/haoke/haoke-api/target/classes",
"/m2/mybatis.jar",
])
.unwrap()
.to_string_lossy()
.into_owned();
let mut class_paths = vec!["/cache/launch-x/0".to_owned(), "/cache/launch-x/1".to_owned()];
let mut info = JavaLaunchInfo::default();
merge_maven_launch_classpath(&mut class_paths, &mut info, Ok(maven), &[web, service]).unwrap();
assert_eq!(
class_paths,
["/cache/launch-x/0", "/cache/launch-x/1", "/work/haoke/haoke-api/target/classes", "/m2/mybatis.jar"]
);
}
#[test]
fn cancelled_maven_classpath_probe_propagates_without_fallback() {
let mut class_paths = vec!["snapshot.jar".to_owned()];
let mut info = JavaLaunchInfo { class_paths: vec!["jdtls.jar".into()], ..Default::default() };
let error =
merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::cancelled()), &[]).unwrap_err();
let error = merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::cancelled())).unwrap_err();
assert_eq!(error.kind, ErrorKind::Cancelled);
assert_eq!(class_paths, ["snapshot.jar"]);
assert!(info.hints.is_empty());
-241
Переглянути файл
@@ -550,24 +550,6 @@ pub async fn lsp_implementations(
result
}
/// Refines the implementations `targets` of the method at `pos` to their declarations (Java
/// dependencies' class files point at the start of the class). Cancel with
/// `cancel_request(request)`.
pub async fn lsp_implementation_locations(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
pos: Pos,
targets: Vec<Location>,
) -> IdeResult<Vec<Location>> {
let lsp = host.project(window)?.lsp.clone();
let (_, cancel) = begin_position_request(host, window, request, doc, pos).await?;
let result = lsp.implementation_locations(doc, pos, targets, cancel).await;
host.end_request(request);
result
}
/// Go to Implementation of the symbol at `pos`. Implementations found before a slower
/// search for the rest (Java: the project's, before the dependencies') arrive on
/// `on_partial`; the result has them all. Cancel with `cancel_request(request)`.
@@ -1191,166 +1173,6 @@ pub async fn lsp_hierarchy_refactor(
.await
}
/// The signature of the method at `pos`, for Change Signature.
pub async fn lsp_signature_info(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
pos: Pos,
) -> IdeResult<MethodSignature> {
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.change_signature_info(doc, pos, cancel).await;
host.end_request(request);
result
}
/// Checks changing the method at `pos` to `signature` and computes the edit without applying it.
#[allow(clippy::too_many_arguments)]
pub async fn lsp_change_signature(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
pos: Pos,
signature: MethodSignature,
delegate: bool,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
let project = host.project(window)?;
let documents = project.documents.clone();
let version = blocking(move || documents.version(doc)).await?;
let cancel = host.begin_request(request);
let result = project.lsp.change_signature(doc, pos, signature, delegate, confirmation, cancel).await;
host.end_request(request);
let mut changed = result?;
blocking(move || {
if project.documents.version(doc)? != version {
return Err(ide_core::IdeError::new(
ide_core::error::ErrorKind::OutOfSync,
"document changed while computing the refactoring; request it again",
));
}
if let Some(edit) = &mut changed.edit {
project.documents.prepare_workspace_edit(edit)?;
}
Ok(changed)
})
.await
}
fn json_argument(args: &str) -> IdeResult<serde_json::Value> {
serde_json::from_str(args).map_err(|e| IdeError::invalid(format!("invalid refactoring arguments: {e}")))
}
fn json_strings(values: Vec<serde_json::Value>) -> Vec<String> {
values.iter().map(serde_json::Value::to_string).collect()
}
/// Where a Java Move code action of `kind` can go; `args` (JSON) carries the code action's own
/// arguments back unchanged, and each destination comes back as JSON.
pub async fn lsp_java_move_destinations(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
kind: String,
args: String,
) -> IdeResult<Vec<String>> {
let args = json_argument(&args)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.java_move_destinations(doc, kind, args, cancel).await;
host.end_request(request);
result.map(json_strings)
}
/// The project's Java source types, for moving a member or type into a class.
pub async fn lsp_java_source_types(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
project_name: Option<String>,
) -> IdeResult<Vec<String>> {
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.java_source_types(doc, project_name, cancel).await;
host.end_request(request);
result.map(json_strings)
}
/// Checks a Java move and computes its edit without applying it.
#[allow(clippy::too_many_arguments)]
pub async fn lsp_java_move(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
kind: String,
args: String,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
let args = json_argument(&args)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.java_move(doc, kind, args, confirmation, cancel).await;
host.end_request(request);
let mut moved = result?;
blocking(move || {
if let Some(edit) = &mut moved.edit {
project.documents.prepare_workspace_edit(edit)?;
}
Ok(moved)
})
.await
}
/// The Java class to extract an interface from: its members and the packages for the interface.
pub async fn lsp_extract_interface_info(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
pos: Pos,
) -> IdeResult<ExtractInterfaceInfo> {
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.extract_interface_info(doc, pos, cancel).await;
host.end_request(request);
result
}
/// Checks extracting a Java interface and computes its edit without applying it; `destination`
/// is one of the info's packages.
#[allow(clippy::too_many_arguments)]
pub async fn lsp_extract_interface(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
pos: Pos,
members: Vec<String>,
name: String,
destination: String,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
let destination = json_argument(&destination)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.extract_interface(doc, pos, members, name, destination, confirmation, cancel).await;
host.end_request(request);
let mut extracted = result?;
blocking(move || {
if let Some(edit) = &mut extracted.edit {
project.documents.prepare_workspace_edit(edit)?;
}
Ok(extracted)
})
.await
}
pub async fn lsp_rename(
host: &Host,
window: &str,
@@ -2005,17 +1827,6 @@ pub(crate) fn register(d: &mut Dispatcher) {
let on_partial = c.sender("onPartial")?;
lsp_goto_implementation(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, on_partial).await
});
d.add("lsp_implementation_locations", |c| async move {
lsp_implementation_locations(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("targets")?,
)
.await
});
d.add(
"lsp_resolve_class_file",
|c| async move { lsp_resolve_class_file(&c.host, &c.window, c.arg("path")?).await },
@@ -2085,58 +1896,6 @@ pub(crate) fn register(d: &mut Dispatcher) {
)
.await
});
d.add("lsp_signature_info", |c| async move {
lsp_signature_info(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_change_signature", |c| async move {
lsp_change_signature(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("signature")?,
c.arg("delegate")?,
c.arg("confirmation")?,
)
.await
});
d.add("lsp_extract_interface_info", |c| async move {
lsp_extract_interface_info(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_extract_interface", |c| async move {
lsp_extract_interface(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("members")?,
c.arg("name")?,
c.arg("destination")?,
c.arg("confirmation")?,
)
.await
});
d.add("lsp_java_move_destinations", |c| async move {
lsp_java_move_destinations(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("kind")?, c.arg("args")?)
.await
});
d.add("lsp_java_source_types", |c| async move {
lsp_java_source_types(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("projectName")?).await
});
d.add("lsp_java_move", |c| async move {
lsp_java_move(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("kind")?,
c.arg("args")?,
c.arg("confirmation")?,
)
.await
});
d.add("lsp_format", |c| async move {
lsp_format(&c.host, &c.window, c.arg("doc")?, c.arg("range")?, c.arg("options")?).await
});
-3
Переглянути файл
@@ -4,7 +4,6 @@
pub mod agent;
pub mod analysis;
pub mod bdd;
pub mod build;
pub mod bytes;
pub mod coverage;
@@ -33,7 +32,6 @@ pub mod sdk;
pub mod search;
pub mod spell;
mod ssh;
pub mod stream_trace;
pub mod syntax;
pub mod term;
pub mod tools;
@@ -89,7 +87,6 @@ pub fn register_all(d: &mut crate::rpc::Dispatcher) {
java::register(d);
debug::register(d);
heap::register(d);
stream_trace::register(d);
bytes::register(d);
vcs::register(d);
doc::register(d);
+27 -35
Переглянути файл
@@ -208,52 +208,41 @@ pub async fn nav_index_definitions(
}
/// Every Python class in the project (attached dependency roots included) and its base
/// names, answered from the project index: its symbols already carry the bases, and it
/// covers content roots, so this is the whole-project answer the UI uses for inheritance
/// gutter markers when no type-hierarchy provider exists. No file is parsed here.
/// names. The index covers content roots, so this is the whole-project answer the UI uses
/// for inheritance gutter markers when no type-hierarchy provider exists.
pub async fn nav_inheritance(host: &Host, window: &str) -> IdeResult<Vec<ClassInheritance>> {
let project = host.project(window)?;
let syntax = host.syntax();
blocking(move || {
let python = LanguageId::new("python");
let files = project.index.files_with_extensions(&["py".into(), "pyi".into()], 20_000);
let mut cache = CLASS_BASES.lock();
// Disk-backed classes come from the index: it already parsed every file once for
// symbols, so no second parse of the project is needed here.
let mut out: Vec<ClassInheritance> = project
.index
.inheritance()
.into_iter()
// The index holds classes of every language; the graph is Python's.
.filter(|c| matches!(c.path.extension().and_then(std::ffi::OsStr::to_str), Some("py" | "pyi")))
.map(|c| ClassInheritance {
path: IpcPath::from(c.path.clone()),
line: c.range.start.line,
col: c.range.start.col,
name: c.name.clone(),
bases: c.bases.clone(),
})
.collect();
// Open buffers may be unsaved, so their classes are parsed live (and cached per
// text/stamp) and replace the index's view of that file. This keeps #3359's
// "open buffer by its text" behaviour while the disk path is index-backed.
let open_files: Vec<PathBuf> = project
.index
.files_with_extensions(&["py".into(), "pyi".into()], 20_000)
.into_iter()
.filter(|path| project.documents.text_of(path).is_some())
.collect();
for path in open_files {
let mut out = Vec::new();
for path in files {
// The open (possibly unsaved) buffer is keyed by its text, a file on disk by its
// size and modification time, so only changed files are parsed again.
let open = project.documents.text_of(&path);
let stamp = match &open {
Some(text) => Stamp(text_hash(text)),
None => continue,
Some(text) => Stamp::Text(text_hash(text)),
None => match std::fs::metadata(&path) {
Ok(m) => Stamp::Disk(m.len(), m.modified().ok()),
Err(_) => continue,
},
};
let text = open.unwrap();
let classes = match cache.get(&path) {
Some((cached, classes)) if *cached == stamp => classes,
_ => &cache.entry(path.clone()).insert_entry((stamp, syntax.class_bases(&python, &text))).into_mut().1,
_ => {
let text = match open {
Some(text) => text,
None => match project.text_of(&path) {
Ok(text) => text,
Err(_) => continue,
},
};
let classes = syntax.class_bases(&python, &text);
&cache.entry(path.clone()).insert_entry((stamp, classes)).into_mut().1
}
};
out.retain(|c| c.path.0 != *path);
out.extend(classes.iter().map(|class| ClassInheritance {
path: IpcPath::from(path.clone()),
line: class.line,
@@ -268,7 +257,10 @@ pub async fn nav_inheritance(host: &Host, window: &str) -> IdeResult<Vec<ClassIn
}
#[derive(Clone, PartialEq, Eq)]
struct Stamp(u64);
enum Stamp {
Text(u64),
Disk(u64, Option<std::time::SystemTime>),
}
fn text_hash(text: &str) -> u64 {
use std::hash::{Hash, Hasher};
-3
Переглянути файл
@@ -232,9 +232,6 @@ pub fn set_settings(
if key == "ssh" || key.starts_with("ssh.") {
host.ssh.set_configs(host.global_settings.effective().ssh.configs);
}
if key == "languages" || key == "languages.java" || key.starts_with("languages.java.addedJdks") {
host.apply_added_jdks();
}
if is_proxy {
host.apply_proxy();
}
-25
Переглянути файл
@@ -301,8 +301,6 @@ async fn start_inner(
if config.command.is_empty() {
return Err(IdeError::invalid("run configuration has no command"));
}
let on_target = config.extras.target.as_deref().is_some_and(|t| !t.is_empty());
add_java_agents(&mut config, &on_output, !on_target);
// Settings › Run Targets: over SSH, or in a container.
if config.kind == "tomcat" && config.extras.target.as_deref().is_some_and(|t| !t.is_empty()) {
return Err(IdeError::invalid("Tomcat Local requires the local machine"));
@@ -448,29 +446,6 @@ async fn start_inner(
host.processes.start(&project.root, &config, &options, sink, Box::new(move |c| on_output(c)))
}
/// Plugins' Java agents (`[[contributes.javaAgents]]`, granted `java.agent`) for the JVM of an
/// Application, Spring Boot or JAR Application configuration started on this machine. A JVM on a
/// run target gets none; the console says so, and why an approved agent was left out.
fn add_java_agents(config: &mut RunConfig, on_output: &Emit<OutputChunk>, local: bool) {
if !ide_run::java_agent::applies(&config.kind) {
return;
}
let agents = ide_run::java_agent::current();
let say = |text: &str| on_output(OutputChunk::System { text: format!("{text}\n") });
if !local {
if !agents.options.is_empty() {
say(
"Plugin Java agents were not added: they load only into JVMs started on this machine, not on a run target.",
);
}
return;
}
for note in &agents.notes {
say(note);
}
ide_run::java_agent::add_to_args(&mut config.args, &agents.options);
}
/// The Ruby test reporter's directory, installed on demand, for runs that take it.
fn ruby_reporter_dir(host: &Host, config: &RunConfig) -> Option<std::path::PathBuf> {
if !ide_run::ruby_reporter::applies(config) {
-14
Переглянути файл
@@ -37,9 +37,6 @@ pub struct ProjectInterpreter {
pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
host.require_trust(window)?;
let project = host.project(window).ok();
if kind == SdkKind::Jdk {
host.apply_added_jdks();
}
let root = project.as_ref().map(|p| p.root.clone());
// The interpreter the project uses is a choice even where detection doesn't look (a
// virtualenv in a subfolder, one picked by path), so it shows by name and version.
@@ -375,20 +372,9 @@ pub async fn sdk_python_pip(
result?
}
/// The JDK whose home is `path` (a macOS bundle too), as the SDK list shows it; `None` when
/// `path` is no JDK home (Add JDK from Disk…).
pub async fn sdk_jdk_at(path: String) -> IdeResult<Option<Sdk>> {
tokio::task::spawn_blocking(move || {
ide_sdk::java::jdk_at(std::path::Path::new(&path)).map(|j| ide_sdk::jdk_sdk(&j))
})
.await
.map_err(join_err)
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("sdk_detect", |c| async move { sdk_detect(&c.host, &c.window, c.arg("kind")?).await });
d.add("sdk_jdk_at", |c| async move { sdk_jdk_at(c.arg("path")?).await });
d.add(
"sdk_python_project_interpreters",
|c| async move { sdk_python_project_interpreters(&c.host, &c.window).await },
+6 -66
Переглянути файл
@@ -62,25 +62,13 @@ pub(crate) fn search_project(
_ => None,
};
let workspace = ide_workspace::workspace::Workspace::load(root)?.is_some_and(|w| w.is_container(root));
// A directory inside a content root is searched from that root, so that the project's
// exclusions (a `.*` name) meet the paths there as in a whole-project search.
let within = match &query.scope {
ide_search::SearchScope::Directory { path } => {
project.content_roots().into_iter().filter(|r| path.0.starts_with(r)).max_by_key(|r| r.components().count())
}
_ => None,
};
let include_root = within.is_none()
&& (!workspace
|| matches!(
query.scope,
ide_search::SearchScope::Directory { .. } | ide_search::SearchScope::Files { .. }
));
let include_root = !workspace
|| matches!(query.scope, ide_search::SearchScope::Directory { .. } | ide_search::SearchScope::Files { .. });
let content_roots = match query.scope {
ide_search::SearchScope::Project
| ide_search::SearchScope::FileSet { .. }
| ide_search::SearchScope::Pattern { .. } => project.content_roots(),
_ => within.into_iter().collect(),
_ => Vec::new(),
};
let filter = |rel: &str| match set {
Some(ProjectFileSet::Production) => !roots.is_test(rel),
@@ -96,19 +84,6 @@ pub(crate) fn search_project(
let mut total = SearchSummary::default();
for dir in std::iter::once(root).filter(|_| include_root).chain(&content_roots) {
let mut remaining = query.clone();
// A root inside the project (one its walk skips) goes by its path there.
let prefix = (dir != root).then(|| match dir.strip_prefix(root) {
Ok(rel) if !workspace => rel.to_string_lossy().replace('\\', "/"),
_ => dir.file_name().unwrap_or_default().to_string_lossy().into_owned(),
});
if let Some(prefix) = &prefix {
remaining.include = rebase_masks(&query.include, prefix);
remaining.exclude = rebase_masks(&query.exclude, prefix);
// Only paths elsewhere were asked for.
if remaining.include.is_empty() && !query.include.is_empty() {
continue;
}
}
let max = if query.max_matches == 0 { 10_000 } else { query.max_matches };
remaining.max_matches = max.saturating_sub(total.matches).max(1);
let summary = ide_search::search_in_context(
@@ -119,8 +94,9 @@ pub(crate) fn search_project(
ide_search::TextSource { overlay: &|p| project.documents.search_text_of(p), decode: &decode },
cancel,
&|mut file| {
if let Some(prefix) = &prefix {
file.rel_path = format!("{prefix}/{}", file.rel_path);
if dir != root {
let name = dir.file_name().unwrap_or_default().to_string_lossy();
file.rel_path = format!("{name}/{}", file.rel_path);
}
emit(file);
},
@@ -137,41 +113,5 @@ pub(crate) fn search_project(
Ok(total)
}
/// Project-relative `masks` (each a comma-separated list) for a search from the content root
/// shown as `prefix`: paths below it lose the prefix, other paths can match nothing there and
/// are dropped, names and `**/` patterns (`*.rs`, `**/build/**`) stay as they are.
fn rebase_masks(masks: &[String], prefix: &str) -> Vec<String> {
let prefix = format!("{}/", prefix.trim_end_matches('/'));
masks
.iter()
.filter_map(|group| {
let kept: Vec<String> = group
.split(',')
.map(str::trim)
.filter(|m| !m.is_empty())
.filter_map(|mask| {
let (negated, body) = mask.strip_prefix('!').map_or(("", mask), |b| ("!", b.trim()));
let body = body.trim_start_matches("./").trim_start_matches('/');
if !body.contains('/') || body.starts_with("**/") {
return Some(mask.to_owned());
}
body.strip_prefix(&prefix).map(|rest| format!("{negated}{rest}"))
})
.collect();
(!kept.is_empty()).then(|| kept.join(","))
})
.collect()
}
#[cfg(test)]
mod tests {
#[test]
fn masks_follow_the_root_they_search() {
let masks = vec![".wt/a/src/**, src/**".into(), "*.rs".into(), "!.wt/a/out/**".into(), "**/build/**".into()];
assert_eq!(super::rebase_masks(&masks, ".wt/a"), ["src/**", "*.rs", "!out/**", "**/build/**"]);
assert_eq!(super::rebase_masks(&["src/**".into()], ".wt/a"), Vec::<String>::new());
}
}
mod commands;
pub use commands::*;
-1
Переглянути файл
@@ -65,7 +65,6 @@ pub async fn spell_check(
end: r.end,
kind: match r.kind {
SpellingKind::Comment => RegionKind::Comment,
SpellingKind::String if r.raw => RegionKind::RawString,
SpellingKind::String => RegionKind::String,
SpellingKind::Name => RegionKind::Name,
},
-466
Переглянути файл
@@ -1,466 +0,0 @@
//! Java Stream Debugger: the stream chains around a debugger stop, and traces of a chain's real run.
//! `ide_streams` finds the chains and links what the run recorded; `ide_dap` runs the trace.
use crate::Host;
use crate::ops::Channel;
use crate::rpc::Dispatcher;
use ide_core::{CancellationToken, DebugSessionId, IdeError, IdeResult, LanguageId, Range, RequestId};
use ide_dap::{StackFrame, TraceRun};
pub use ide_dap::{TracePhase, TraceProgress, TraceUnavailable};
pub use ide_jvm_inspect::{AbortState, JvmValue};
use ide_jvm_inspect::{CollectedTerminal, TraceCollected};
use ide_streams::{
BoxKind, RealRunPlan, RealRunRefusal, Record, Rejection, StopContext, StreamChain, TerminalOutcome, TraceRecording,
TraceValue, find_chains, link_trace, real_run_plan, recorded_steps,
};
pub use ide_streams::{Link, TraceBanner};
use ide_syntax::{Snapshot, StructureService};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct StreamChainInfo {
/// The `chain_index` [`debug_stream_trace`] takes for the same frame.
pub index: u32,
pub range: Range,
pub text: String,
/// Intermediate operations in call order, modifiers included. Empty, like `terminal`, for a
/// chain the search rejected.
pub steps: Vec<String>,
pub terminal: String,
pub available: bool,
/// Set exactly when `available` is false.
#[serde(default, skip_serializing_if = "Option::is_none")]
#[specta(optional)]
pub reason: Option<ChainUnavailable>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum ChainUnavailable {
NotTopFrame,
NotAtChainStart,
InsideChainLambda,
NotJavaStreamRoot {
root: String,
},
LazyTerminal {
op: String,
},
NoTerminal,
UnknownOperation {
op: String,
},
SyntaxError,
/// The session has no stream tracer: not java-debug, or its jdtls has no inspector bundle.
NoBackend,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "status", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum StreamTraceResult {
Ready {
chain: Box<StreamChainInfo>,
/// Column titles by recorded step: `steps[0]` is the root call's name (empty for a stream
/// held in a local), then each operation that records, modifiers left out.
steps: Vec<String>,
/// In recording order.
records: Vec<TraceRecordView>,
/// Parallel to `records`.
links: Vec<Link>,
terminal: TerminalView,
banners: Vec<TraceBanner>,
/// The stop the values belong to, for `debug_jvm_memory_fields`.
generation: u64,
},
Unavailable {
reason: TraceUnavailable,
},
Failed {
detail: String,
},
/// Recording was stopped, or the operation aborted, before the chain ran: nothing went wrong.
Cancelled {
detail: String,
},
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct TraceRecordView {
pub step: u16,
pub value: JvmValue,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum TerminalView {
Value { value: JvmValue },
Void,
Threw { exception: JvmValue },
}
/// The stream chains around `frame`'s line, in source order, with why each cannot be traced.
/// `top`: `frame` is the thread's top frame, the only one a trace can run from.
pub async fn debug_stream_chains(
host: &Host,
window: &str,
session: DebugSessionId,
frame: StackFrame,
top: bool,
) -> IdeResult<Vec<StreamChainInfo>> {
host.require_trust(window)?;
let backend = host.debugger.capabilities(session)?.stream_trace;
Ok(candidates(host, window, frame, top, backend).await?.into_iter().map(|c| c.info).collect())
}
/// Runs the program from `thread_id`, stopped in `frame`, through the chain `chain_index` of
/// [`debug_stream_chains`], recording each element, and leaves it stopped after the chain's
/// terminal operation. `range` is that chain's [`StreamChainInfo::range`]: an edit in between
/// can move another chain to the same index. Cancelling `request` stops recording while the
/// program runs on.
#[allow(clippy::too_many_arguments)]
pub async fn debug_stream_trace(
host: &Host,
window: &str,
session: DebugSessionId,
request: RequestId,
thread_id: i64,
frame: StackFrame,
chain_index: u32,
range: Range,
on_progress: Channel<TraceProgress>,
) -> IdeResult<StreamTraceResult> {
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
let chain = ChainRef { frame, index: chain_index, range };
let result = trace(host, window, session, thread_id, chain, &cancel, &on_progress).await;
host.end_request(request);
result
}
/// The chain the UI chose, as [`debug_stream_chains`] listed it.
struct ChainRef {
frame: StackFrame,
index: u32,
range: Range,
}
async fn trace(
host: &Host,
window: &str,
session: DebugSessionId,
thread_id: i64,
chosen: ChainRef,
cancel: &CancellationToken,
on_progress: &Channel<TraceProgress>,
) -> IdeResult<StreamTraceResult> {
let line = chosen.frame.line;
// `stream_trace` decides whether the session can trace, so the backend is assumed here.
let candidate = candidates(host, window, chosen.frame, true, true)
.await?
.into_iter()
.nth(chosen.index as usize)
.filter(|c| c.info.range == chosen.range);
let Some(candidate) = candidate else {
return Ok(StreamTraceResult::Failed { detail: "the chain changed; trace it again".into() });
};
if let Some(reason) = candidate.info.reason.clone() {
let reason = trace_unavailable(reason, line, candidate.chain.as_ref());
return Ok(StreamTraceResult::Unavailable { reason });
}
let Some(chain) = candidate.chain else {
return Err(IdeError::internal("an available stream chain has no parsed chain"));
};
let plan = real_run_plan(&chain).map_err(|e| IdeError::internal(format!("stream chain plan: {e:?}")))?;
let plan_json = serde_json::to_value(&plan).map_err(|e| IdeError::internal(e.to_string()))?;
// `stream_trace` resumes the program before it looks at `cancel`.
if cancel.is_cancelled() {
return Ok(StreamTraceResult::Cancelled { detail: "cancelled before the trace started".into() });
}
let progress = |p| {
let _ = on_progress.send(p);
};
let run = host.debugger.stream_trace(session, thread_id, plan_json, cancel.clone(), progress).await?;
Ok(match run {
TraceRun::Done { collected, generation, resumed_stops } => {
let info = candidate.info;
host.blocking(move || Ok(ready(info, &chain, &plan, collected, generation, resumed_stops))).await?
}
TraceRun::Unavailable { reason } => StreamTraceResult::Unavailable { reason },
TraceRun::Failed { detail } => StreamTraceResult::Failed { detail },
TraceRun::Cancelled { detail } => StreamTraceResult::Cancelled { detail },
})
}
/// Ends the running trace's terminal operation (Abort Operation); `None` when no trace runs.
pub async fn debug_stream_trace_abort(
host: &Host,
window: &str,
session: DebugSessionId,
) -> IdeResult<Option<AbortState>> {
host.require_trust(window)?;
host.debugger.stream_trace_abort(session).await
}
struct Candidate {
info: StreamChainInfo,
/// `None` for a chain the search rejected.
chain: Option<StreamChain>,
}
/// The file's current text (the open buffer, else the disk) searched off the command thread.
/// Frames outside readable Java sources have no chains: java-debug gives library frames
/// `jdt://contents/…` paths.
async fn candidates(
host: &Host,
window: &str,
frame: StackFrame,
top: bool,
backend: bool,
) -> IdeResult<Vec<Candidate>> {
let Some(path) = frame.path.clone() else { return Ok(Vec::new()) };
let project = host.project(window)?;
host.blocking(move || {
let path = path.into_path_buf();
let cancel = CancellationToken::new();
let search = |snap: &Snapshot| {
if snap.language.as_str() != "java" {
return Ok(Vec::new());
}
chains_at(&project.structure, snap, &frame, top, backend, &cancel)
};
if let Some(doc) = project.documents.by_path(&path) {
let snap = project.documents.text_snapshot(doc)?;
if snap.large {
return Err(IdeError::unavailable("file is too large for syntax analysis"));
}
return search(&Snapshot::doc(doc, snap.version, &snap.language, &snap.text));
}
let language: LanguageId = project.languages.detect(&path, None);
if language.as_str() != "java" {
return Ok(Vec::new());
}
let Ok(text) = project.text_of(&path) else { return Ok(Vec::new()) };
search(&Snapshot::text(&language, &text))
})
.await
}
fn chains_at(
service: &StructureService,
snap: &Snapshot,
frame: &StackFrame,
top: bool,
backend: bool,
cancel: &CancellationToken,
) -> IdeResult<Vec<Candidate>> {
let path = frame.path.as_ref().map(|p| p.0.as_path());
let file_stem = path.and_then(Path::file_stem).and_then(|s| s.to_str()).unwrap_or_default();
let stop = StopContext { line: frame.line, in_lambda: frame.name.contains("lambda$"), file_stem };
let found = find_chains(service, snap, &stop, cancel)?;
let mut candidates: Vec<Candidate> = found
.chains
.into_iter()
.map(|chain| {
let reason = refusal(&chain, frame.line, top, backend);
let info = StreamChainInfo {
index: 0,
range: chain.range,
text: chain.text.clone(),
steps: chain.ops.iter().map(|op| op.name.clone()).collect(),
terminal: chain.terminal.name.clone(),
available: reason.is_none(),
reason,
};
Candidate { info, chain: Some(chain) }
})
.collect();
candidates.extend(found.rejected.into_iter().map(|rejected| {
let reason = if top { rejection(rejected.reason) } else { ChainUnavailable::NotTopFrame };
let info = StreamChainInfo {
index: 0,
range: rejected.range,
text: rejected.text,
steps: Vec::new(),
terminal: String::new(),
available: false,
reason: Some(reason),
};
Candidate { info, chain: None }
}));
candidates.sort_by_key(|c| c.info.range);
for (i, c) in candidates.iter_mut().enumerate() {
c.info.index = i as u32;
}
Ok(candidates)
}
fn refusal(chain: &StreamChain, line: u32, top: bool, backend: bool) -> Option<ChainUnavailable> {
if !top {
return Some(ChainUnavailable::NotTopFrame);
}
// ECJ puts the first instruction of `T x =\n root…` on the root's line, not the
// statement's; the bundle makes the final call from the line table.
if line < chain.first_line || line > root_line(chain) {
return Some(ChainUnavailable::NotAtChainStart);
}
if let Err(refused) = real_run_plan(chain) {
return Some(refusal_reason(refused));
}
(!backend).then_some(ChainUnavailable::NoBackend)
}
fn root_line(chain: &StreamChain) -> u32 {
let before_root = chain.text.get(..chain.root.span.0).unwrap_or_default();
chain.range.start.line + before_root.matches('\n').count() as u32
}
fn refusal_reason(refused: RealRunRefusal) -> ChainUnavailable {
match refused {
RealRunRefusal::NotJavaStreamRoot { root } => ChainUnavailable::NotJavaStreamRoot { root },
RealRunRefusal::LazyTerminal { op } => ChainUnavailable::LazyTerminal { op },
RealRunRefusal::NoTerminal => ChainUnavailable::NoTerminal,
RealRunRefusal::UnknownOperation { op } => ChainUnavailable::UnknownOperation { op },
RealRunRefusal::InsideChainLambda => ChainUnavailable::InsideChainLambda,
RealRunRefusal::SyntaxError => ChainUnavailable::SyntaxError,
}
}
fn rejection(rejected: Rejection) -> ChainUnavailable {
match rejected {
Rejection::LazyTerminal { op } => ChainUnavailable::LazyTerminal { op },
Rejection::NoTerminal => ChainUnavailable::NoTerminal,
Rejection::UnknownOperation { op } => ChainUnavailable::UnknownOperation { op },
Rejection::InsideChainLambda => ChainUnavailable::InsideChainLambda,
Rejection::SyntaxError => ChainUnavailable::SyntaxError,
}
}
/// The same reasons as the bundle's refusals, for a chain that stopped being traceable between
/// [`debug_stream_chains`] and [`debug_stream_trace`].
fn trace_unavailable(reason: ChainUnavailable, line: u32, chain: Option<&StreamChain>) -> TraceUnavailable {
let unsupported = |detail: String| TraceUnavailable::Unsupported { detail };
match reason {
ChainUnavailable::NotAtChainStart => {
let start = chain.map_or(String::new(), |c| format!(", the chain starts on line {}", c.first_line + 1));
TraceUnavailable::NotAtChainStart { detail: format!("the stop is on line {}{start}", line + 1) }
}
ChainUnavailable::NoBackend => TraceUnavailable::NoBackend,
ChainUnavailable::NotTopFrame => unsupported("only the top frame can be traced".into()),
ChainUnavailable::InsideChainLambda => unsupported("the chain is already running".into()),
ChainUnavailable::NotJavaStreamRoot { root } => {
unsupported(format!("the stream {root} does not start in this statement"))
}
ChainUnavailable::LazyTerminal { op } => unsupported(format!("{op}() does not run the pipeline")),
ChainUnavailable::NoTerminal => unsupported("the chain has no terminal operation".into()),
ChainUnavailable::UnknownOperation { op } => unsupported(format!("unknown stream operation {op}()")),
ChainUnavailable::SyntaxError => unsupported("the statement does not parse".into()),
}
}
fn ready(
chain_info: StreamChainInfo,
chain: &StreamChain,
plan: &RealRunPlan,
collected: TraceCollected,
generation: u64,
resumed_stops: u32,
) -> StreamTraceResult {
let recording = TraceRecording {
records: collected.records.iter().map(|(step, v)| Record { step: *step, value: trace_value(v) }).collect(),
dropped: collected.dropped,
terminal: match &collected.terminal {
CollectedTerminal::Value(v) => TerminalOutcome::Value { value: trace_value(v) },
CollectedTerminal::Void => TerminalOutcome::Void,
CollectedTerminal::Threw(e) => TerminalOutcome::Threw { exception: trace_value(e) },
},
};
let mut linked = link_trace(plan, &recording, collected.skipped_breakpoints);
// A stream made parallel before the chain's statement, which the bundle found so at run time.
if collected.sequentialized && !plan.sequentialize {
linked.banners.push(TraceBanner::Sequentialized);
}
if resumed_stops > 0 {
linked.banners.push(TraceBanner::BreakpointsResumed { count: resumed_stops });
}
StreamTraceResult::Ready {
chain: Box::new(chain_info),
steps: recorded_steps(chain),
records: collected.records.into_iter().map(|(step, value)| TraceRecordView { step, value }).collect(),
links: linked.links,
terminal: match collected.terminal {
CollectedTerminal::Value(value) => TerminalView::Value { value },
CollectedTerminal::Void => TerminalView::Void,
CollectedTerminal::Threw(exception) => TerminalView::Threw { exception },
},
banners: linked.banners,
generation,
}
}
fn trace_value(value: &JvmValue) -> TraceValue {
match value {
JvmValue::Null => TraceValue::Null,
JvmValue::Boxed { id, type_name, text } => match box_kind(type_name) {
Some(class) => TraceValue::Boxed { id: *id, class, value: text.clone() },
None => TraceValue::Object { id: *id, class: type_name.clone() },
},
JvmValue::Str { id, text, .. } => {
TraceValue::Str { id: *id, value: text.clone().unwrap_or_default(), truncated: text.is_none() }
}
JvmValue::Object { id, type_name } | JvmValue::Array { id, type_name, .. } => {
TraceValue::Object { id: *id, class: type_name.clone() }
}
// The recorder boxes every element, so only a terminal's result is primitive, and linking
// never reads that.
JvmValue::Primitive { type_name, text } => match box_kind(type_name) {
Some(class) => TraceValue::Boxed { id: 0, class, value: text.clone() },
None => TraceValue::Null,
},
}
}
/// Wrapper class names (boxed values) and primitive type names (primitive values) alike.
fn box_kind(type_name: &str) -> Option<BoxKind> {
Some(match type_name {
"java.lang.Boolean" | "boolean" => BoxKind::Boolean,
"java.lang.Byte" | "byte" => BoxKind::Byte,
"java.lang.Character" | "char" => BoxKind::Char,
"java.lang.Short" | "short" => BoxKind::Short,
"java.lang.Integer" | "int" => BoxKind::Int,
"java.lang.Long" | "long" => BoxKind::Long,
"java.lang.Float" | "float" => BoxKind::Float,
"java.lang.Double" | "double" => BoxKind::Double,
_ => return None,
})
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("debug_stream_chains", |c| async move {
debug_stream_chains(&c.host, &c.window, c.arg("session")?, c.arg("frame")?, c.arg("top")?).await
});
d.add("debug_stream_trace", |c| async move {
debug_stream_trace(
&c.host,
&c.window,
c.arg("session")?,
c.arg("request")?,
c.arg("threadId")?,
c.arg("frame")?,
c.arg("chainIndex")?,
c.arg("range")?,
c.sender("onProgress")?,
)
.await
});
d.add("debug_stream_trace_abort", |c| async move {
debug_stream_trace_abort(&c.host, &c.window, c.arg("session")?).await
});
}
#[cfg(test)]
mod tests;
-461
Переглянути файл
@@ -1,461 +0,0 @@
use super::*;
use ide_core::{CancellationToken, LanguageId};
use ide_language::{Syntax, SyntaxCache};
use ide_streams::BoxKind;
use serde_json::json;
use std::sync::{Arc, OnceLock};
const SOURCE: &str = r#"import java.util.*;
import java.util.stream.*;
class Chains {
Stream<Integer> items;
void run(List<Integer> nums) {
List<Integer> evens = nums.stream() // C_EVENS
.filter(x -> x % 2 == 0) // C_EVENS_FILTER
.collect(Collectors.toList());
List<Integer> out = // C_DECL
nums.stream() // C_ROOT
.map(x -> x + 1) // C_ROOT_MAP
.collect(Collectors.toList());
long n = this.items.filter(x -> x > 0).count(); // C_FIELD
Iterator<Integer> it = nums.stream().map(x -> x).iterator(); // C_LAZY
List<String> a = nums.stream().filter(x -> x % 2 == 0).map(x -> x * 10 + 1).sorted().map(String::valueOf).collect(Collectors.toList()); // C_SPIKE
}
}
"#;
fn service() -> &'static StructureService {
static S: OnceLock<StructureService> = OnceLock::new();
S.get_or_init(|| StructureService::new(Arc::new(SyntaxCache::new(Arc::new(Syntax::new())))))
}
fn line_of(marker: &str) -> u32 {
let tag = format!("// {marker}");
let found = SOURCE.lines().position(|l| l.trim_end().ends_with(&tag));
found.unwrap_or_else(|| panic!("no line marked {marker}")) as u32
}
fn frame(line: u32) -> StackFrame {
StackFrame {
id: 1,
name: "Chains.run(List)".into(),
path: Some("/project/src/Chains.java".into()),
line,
column: 8,
presentation_hint: None,
}
}
fn chains_on(line: u32, top: bool, backend: bool) -> Vec<StreamChainInfo> {
let java = LanguageId::new("java");
let snap = Snapshot::text(&java, SOURCE);
let found = chains_at(service(), &snap, &frame(line), top, backend, &CancellationToken::new()).expect("search");
found.into_iter().map(|c| c.info).collect()
}
fn availability(info: &StreamChainInfo) -> serde_json::Value {
let mut v = serde_json::to_value(info).unwrap();
let map = v.as_object_mut().unwrap();
json!({ "available": map.remove("available"), "reason": map.remove("reason") })
}
#[test]
fn chains_refuse_non_top_frame() {
let infos = chains_on(line_of("C_EVENS"), false, true);
assert!(!infos.is_empty());
for info in &infos {
assert_eq!(availability(info), json!({"available": false, "reason": {"kind": "notTopFrame"}}), "{info:?}");
}
}
#[test]
fn chains_need_first_line() {
let infos = chains_on(line_of("C_EVENS_FILTER"), true, true);
assert_eq!(infos.len(), 1, "{infos:?}");
assert_eq!(availability(&infos[0]), json!({"available": false, "reason": {"kind": "notAtChainStart"}}));
let mid = chains_on(line_of("C_ROOT_MAP"), true, true);
assert_eq!(availability(&mid[0]), json!({"available": false, "reason": {"kind": "notAtChainStart"}}));
}
/// ECJ puts a declaration's first instruction on the line of its initializer's root call.
#[test]
fn chains_accept_the_root_line_of_a_declaration() {
let at_root = chains_on(line_of("C_ROOT"), true, true);
assert_eq!(at_root.len(), 1, "{at_root:?}");
assert_eq!(availability(&at_root[0]), json!({"available": true, "reason": null}));
let at_head = chains_on(line_of("C_DECL"), true, true);
assert_eq!(availability(&at_head[0]), json!({"available": true, "reason": null}));
}
#[test]
fn chains_list_rejections() {
let field = chains_on(line_of("C_FIELD"), true, true);
assert_eq!(field.len(), 1, "{field:?}");
assert_eq!(
availability(&field[0]),
json!({"available": false, "reason": {"kind": "notJavaStreamRoot", "root": "this.items"}})
);
let lazy = chains_on(line_of("C_LAZY"), true, true);
assert_eq!(lazy.len(), 1, "{lazy:?}");
assert_eq!(
availability(&lazy[0]),
json!({"available": false, "reason": {"kind": "lazyTerminal", "op": "iterator"}})
);
}
#[test]
fn chains_without_a_tracer_have_no_backend() {
let infos = chains_on(line_of("C_EVENS"), true, false);
assert_eq!(availability(&infos[0]), json!({"available": false, "reason": {"kind": "noBackend"}}));
}
#[test]
fn chain_info_json_shape() {
let infos = chains_on(line_of("C_EVENS"), true, true);
let v = serde_json::to_value(&infos[0]).unwrap();
assert_eq!(v["index"], 0);
assert_eq!(v["steps"], json!(["filter"]));
assert_eq!(v["terminal"], "collect");
assert_eq!(v["range"]["start"]["line"], line_of("C_EVENS"));
assert_eq!(v["available"], true);
assert!(v.get("reason").is_none(), "{v}");
}
#[test]
fn jvm_value_to_trace_value() {
let boxed = JvmValue::Boxed { id: 4, type_name: "java.lang.Integer".into(), text: "8".into() };
assert_eq!(trace_value(&boxed), TraceValue::Boxed { id: 4, class: BoxKind::Int, value: "8".into() });
let long_text = JvmValue::Str { id: 5, text: None, length: 50_000 };
assert_eq!(trace_value(&long_text), TraceValue::Str { id: 5, value: String::new(), truncated: true });
let short_text = JvmValue::Str { id: 6, text: Some("81".into()), length: 2 };
assert_eq!(trace_value(&short_text), TraceValue::Str { id: 6, value: "81".into(), truncated: false });
let object = JvmValue::Object { id: 7, type_name: "com.x.Order".into() };
assert_eq!(trace_value(&object), TraceValue::Object { id: 7, class: "com.x.Order".into() });
let array = JvmValue::Array { id: 8, type_name: "int[]".into(), length: 3 };
assert_eq!(trace_value(&array), TraceValue::Object { id: 8, class: "int[]".into() });
assert_eq!(trace_value(&JvmValue::Null), TraceValue::Null);
let odd_box = JvmValue::Boxed { id: 9, type_name: "java.math.BigInteger".into(), text: "1".into() };
assert_eq!(trace_value(&odd_box), TraceValue::Object { id: 9, class: "java.math.BigInteger".into() });
let count = JvmValue::Primitive { type_name: "long".into(), text: "4".into() };
assert_eq!(trace_value(&count), TraceValue::Boxed { id: 0, class: BoxKind::Long, value: "4".into() });
let odd_primitive = JvmValue::Primitive { type_name: "void".into(), text: String::new() };
assert_eq!(trace_value(&odd_primitive), TraceValue::Null);
}
/// The log measured on `source -> filter -> map -> sorted -> map` (see ide-streams' spike test),
/// as the bundle reports it: every `peek` re-boxes, so no two boxes share an id.
fn spike_collected() -> TraceCollected {
let steps_values: [(u16, &str); 24] = [
(0, "5"),
(0, "3"),
(0, "8"),
(1, "8"),
(2, "81"),
(0, "1"),
(0, "4"),
(1, "4"),
(2, "41"),
(0, "2"),
(1, "2"),
(2, "21"),
(0, "9"),
(0, "6"),
(1, "6"),
(2, "61"),
(3, "21"),
(4, "21"),
(3, "41"),
(4, "41"),
(3, "61"),
(4, "61"),
(3, "81"),
(4, "81"),
];
let records = steps_values
.iter()
.enumerate()
.map(|(i, &(step, text))| {
let id = 100 + i as u64;
let value = if step == 4 {
JvmValue::Str { id, text: Some(text.into()), length: text.len() as u32 }
} else {
JvmValue::Boxed { id, type_name: "java.lang.Integer".into(), text: text.into() }
};
(step, value)
})
.collect();
TraceCollected {
records,
dropped: 3,
terminal: CollectedTerminal::Value(JvmValue::Object { id: 7, type_name: "java.util.ArrayList".into() }),
skipped_breakpoints: 2,
sequentialized: false,
}
}
#[test]
fn ready_links_the_collected_records() {
let java = LanguageId::new("java");
let snap = Snapshot::text(&java, SOURCE);
let found = chains_at(service(), &snap, &frame(line_of("C_SPIKE")), true, true, &CancellationToken::new()).unwrap();
let Candidate { info, chain } = found.into_iter().next().unwrap();
let chain = chain.unwrap();
let plan = real_run_plan(&chain).unwrap();
let collected = spike_collected();
let expected_records: Vec<TraceRecordView> =
collected.records.iter().map(|(step, value)| TraceRecordView { step: *step, value: value.clone() }).collect();
let StreamTraceResult::Ready { chain: shown, steps, records, links, terminal, banners, generation } =
ready(info.clone(), &chain, &plan, collected, 9, 0)
else {
panic!("not ready");
};
assert_eq!(*shown, info);
assert_eq!(steps, ["stream", "filter", "map", "sorted", "map"]);
assert_eq!(records, expected_records);
assert_eq!(links.len(), records.len());
assert_eq!(links[0], Link { parent: None, ambiguous: false });
// `1=8` comes from the `0=8` just before it, and `2=81` from that.
assert_eq!(links[3].parent, Some(2));
assert_eq!(links[4].parent, Some(3));
// `sorted` emits `3=21` after the whole upstream ran: it is the `2=21` of record 11, linked by
// value although the box was re-made.
assert_eq!(links[16], Link { parent: Some(11), ambiguous: false });
assert_eq!(links[17].parent, Some(16));
assert_eq!(links[22].parent, Some(4));
assert_eq!(
terminal,
TerminalView::Value { value: JvmValue::Object { id: 7, type_name: "java.util.ArrayList".into() } }
);
assert_eq!(banners, [TraceBanner::Truncated { dropped: 3 }, TraceBanner::BreakpointsSkipped { count: 2 }]);
assert_eq!(generation, 9);
}
#[test]
fn ready_says_how_many_stops_were_resumed() {
let java = LanguageId::new("java");
let snap = Snapshot::text(&java, SOURCE);
let found = chains_at(service(), &snap, &frame(line_of("C_SPIKE")), true, true, &CancellationToken::new()).unwrap();
let Candidate { info, chain } = found.into_iter().next().unwrap();
let chain = chain.unwrap();
let plan = real_run_plan(&chain).unwrap();
let StreamTraceResult::Ready { banners, .. } = ready(info, &chain, &plan, spike_collected(), 9, 3) else {
panic!("not ready");
};
assert_eq!(
banners,
[
TraceBanner::Truncated { dropped: 3 },
TraceBanner::BreakpointsSkipped { count: 2 },
TraceBanner::BreakpointsResumed { count: 3 }
]
);
}
const WINDOW: &str = "main";
/// A real `Host` with a trusted project holding `src/Chains.java` (= [`SOURCE`]).
struct Fixture {
host: Host,
source: std::path::PathBuf,
_temp: tempfile::TempDir,
}
impl Fixture {
async fn new() -> Self {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("project");
std::fs::create_dir_all(root.join("src")).unwrap();
let source = root.join("src/Chains.java");
std::fs::write(&source, SOURCE).unwrap();
let host = Host::new(crate::HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(|_| {})),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
host.open_project(WINDOW, &root).unwrap();
host.set_project_trust(&root, true, false).await.unwrap();
Self { host, source, _temp: temp }
}
fn frame(&self, line: u32) -> StackFrame {
StackFrame { path: Some(self.source.as_path().into()), ..frame(line) }
}
async fn chains(&self, frame: StackFrame) -> Vec<StreamChainInfo> {
candidates(&self.host, WINDOW, frame, true, true).await.unwrap().into_iter().map(|c| c.info).collect()
}
async fn trace(&self, request: u32, frame: StackFrame, index: u32, range: Range) -> StreamTraceResult {
let request = RequestId(request);
debug_stream_trace(
&self.host,
WINDOW,
DebugSessionId(404),
request,
1,
frame,
index,
range,
Channel::new(|_| {}),
)
.await
.unwrap()
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn chains_skip_frames_without_a_readable_java_source() {
let f = Fixture::new().await;
assert_eq!(f.chains(f.frame(line_of("C_EVENS"))).await.len(), 1, "the file on disk is read");
let library = StackFrame {
path: Some("jdt://contents/rt.jar/java.util.stream/ReferencePipeline.class?=java/rt.jar".into()),
..frame(120)
};
assert_eq!(f.chains(library).await, []);
let missing = StackFrame { path: Some(f.source.with_file_name("Missing.java").as_path().into()), ..frame(3) };
assert_eq!(f.chains(missing).await, []);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn trace_refuses_a_chain_that_changed() {
let f = Fixture::new().await;
let at = f.frame(line_of("C_EVENS"));
let listed = f.chains(at.clone()).await.remove(0);
let changed = StreamTraceResult::Failed { detail: "the chain changed; trace it again".into() };
let mut moved = listed.range;
moved.end.col += 1;
assert_eq!(f.trace(1, at.clone(), listed.index, moved).await, changed);
assert_eq!(f.trace(2, at, listed.index + 1, listed.range).await, changed);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn trace_reports_an_unavailable_chain_like_the_bundle() {
let f = Fixture::new().await;
let mid = f.frame(line_of("C_EVENS_FILTER"));
let listed = f.chains(mid.clone()).await.remove(0);
let detail = format!(
"the stop is on line {}, the chain starts on line {}",
line_of("C_EVENS_FILTER") + 1,
line_of("C_EVENS") + 1
);
assert_eq!(
f.trace(1, mid, listed.index, listed.range).await,
StreamTraceResult::Unavailable { reason: TraceUnavailable::NotAtChainStart { detail } }
);
let field = f.frame(line_of("C_FIELD"));
let listed = f.chains(field.clone()).await.remove(0);
let detail = "the stream this.items does not start in this statement".to_string();
assert_eq!(
f.trace(2, field, listed.index, listed.range).await,
StreamTraceResult::Unavailable { reason: TraceUnavailable::Unsupported { detail } }
);
}
/// The session id names no session: reaching `stream_trace` would fail the call.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn trace_cancelled_before_it_starts_does_not_run() {
let f = Fixture::new().await;
let at = f.frame(line_of("C_EVENS"));
let listed = f.chains(at.clone()).await.remove(0);
f.host.cancel_request(RequestId(7));
assert_eq!(
f.trace(7, at, listed.index, listed.range).await,
StreamTraceResult::Cancelled { detail: "cancelled before the trace started".into() }
);
assert_eq!(
serde_json::to_value(StreamTraceResult::Cancelled { detail: "x".into() }).unwrap(),
json!({"status": "cancelled", "detail": "x"})
);
}
#[test]
fn ready_result_json_shape() {
let info = chains_on(line_of("C_EVENS"), true, true).remove(0);
let value = JvmValue::Boxed { id: 4, type_name: "java.lang.Integer".into(), text: "8".into() };
let ready = StreamTraceResult::Ready {
chain: Box::new(info),
steps: vec!["stream".into(), "filter".into()],
records: vec![TraceRecordView { step: 0, value: value.clone() }],
links: vec![Link { parent: None, ambiguous: false }],
terminal: TerminalView::Threw { exception: JvmValue::Object { id: 9, type_name: "java.lang.X".into() } },
banners: vec![TraceBanner::Truncated { dropped: 2 }, TraceBanner::BreakpointsSkipped { count: 1 }],
generation: 3,
};
let v = serde_json::to_value(&ready).unwrap();
assert_eq!(v["status"], "ready");
assert_eq!(v["chain"]["available"], true);
assert_eq!(v["steps"], json!(["stream", "filter"]));
assert_eq!(
v["records"],
json!([{"step": 0, "value": {"kind": "boxed", "id": 4, "typeName": "java.lang.Integer", "text": "8"}}])
);
assert_eq!(v["links"], json!([{"parent": null, "ambiguous": false}]));
assert_eq!(
v["terminal"],
json!({"kind": "threw", "exception": {"kind": "object", "id": 9, "typeName": "java.lang.X"}})
);
assert_eq!(v["banners"], json!([{"kind": "truncated", "dropped": 2}, {"kind": "breakpointsSkipped", "count": 1}]));
assert_eq!(v["generation"], 3);
assert_eq!(serde_json::to_value(TerminalView::Value { value }).unwrap()["kind"], "value");
assert_eq!(serde_json::to_value(TerminalView::Void).unwrap(), json!({"kind": "void"}));
}
#[test]
fn other_results_json_shape() {
let unavailable =
StreamTraceResult::Unavailable { reason: TraceUnavailable::NotAtChainStart { detail: "line 4".into() } };
assert_eq!(
serde_json::to_value(&unavailable).unwrap(),
json!({"status": "unavailable", "reason": {"kind": "notAtChainStart", "detail": "line 4"}})
);
assert_eq!(
serde_json::to_value(StreamTraceResult::Failed { detail: "boom".into() }).unwrap(),
json!({"status": "failed", "detail": "boom"})
);
let progress = TraceProgress { phase: TracePhase::RecordingStopped, records: 5, dropped: 0, elapsed_ms: 40 };
assert_eq!(
serde_json::to_value(&progress).unwrap(),
json!({"phase": "recordingStopped", "records": 5, "dropped": 0, "elapsedMs": 40})
);
let stuck = AbortState::Stuck { holders: vec![(3, "main".into())] };
assert_eq!(serde_json::to_value(&stuck).unwrap(), json!({"kind": "stuck", "holders": [[3, "main"]]}));
assert_eq!(serde_json::to_value(AbortState::Interrupted).unwrap(), json!({"kind": "interrupted"}));
}
#[test]
fn chain_info_steps_keep_modifiers() {
let java = LanguageId::new("java");
let source = "class Chains { void run(java.util.List<Integer> nums) {\n\
long n = nums.parallelStream().filter(x -> x > 0).unordered().map(x -> x).count();\n} }";
let snap = Snapshot::text(&java, source);
let found = chains_at(service(), &snap, &frame(1), true, true, &CancellationToken::new()).unwrap();
assert_eq!(found[0].info.steps, ["filter", "unordered", "map"]);
}
#[test]
fn ready_says_a_stream_found_parallel_at_run_time_ran_sequentially() {
let java = LanguageId::new("java");
let snap = Snapshot::text(&java, SOURCE);
let found = chains_at(service(), &snap, &frame(line_of("C_SPIKE")), true, true, &CancellationToken::new()).unwrap();
let Candidate { info, chain } = found.into_iter().next().unwrap();
let chain = chain.unwrap();
let plan = real_run_plan(&chain).unwrap();
assert!(!plan.sequentialize);
let collected = TraceCollected { sequentialized: true, ..spike_collected() };
let StreamTraceResult::Ready { banners, .. } = ready(info, &chain, &plan, collected, 9, 0) else {
panic!("not ready");
};
assert!(banners.contains(&TraceBanner::Sequentialized), "{banners:?}");
}
-22
Переглянути файл
@@ -1304,25 +1304,6 @@ pub async fn vcs_create_patch(
.await
}
/// The changes a commit with `options` would make in `repo`, as one patch (what Commit
/// commits: the index with the selection applied, partial files' chosen hunks only).
pub async fn vcs_pending_patch(
host: &Host,
window: &str,
repo: Option<PathBuf>,
options: CommitOptions,
) -> IdeResult<String> {
const MAX_PATCH: usize = 1 << 20;
let project = host.project(window)?;
blocking(move || {
project.with_repo_at(repo.as_deref(), |r| {
let changes = r.pending_changes(&options, MAX_PATCH, &|path| project.vcs_encoding(path, None))?;
Ok(changes.into_iter().filter_map(|c| c.diff).collect())
})
})
.await
}
pub async fn vcs_patch_preview(
host: &Host,
window: &str,
@@ -1682,9 +1663,6 @@ pub(crate) fn register(d: &mut Dispatcher) {
d.add("vcs_create_patch", |c| async move {
vcs_create_patch(&c.host, &c.window, c.arg("repo")?, c.arg("source")?).await
});
d.add("vcs_pending_patch", |c| async move {
vcs_pending_patch(&c.host, &c.window, c.arg("repo")?, c.arg("options")?).await
});
d.add("vcs_patch_preview", |c| async move {
vcs_patch_preview(&c.host, &c.window, c.arg("repo")?, c.arg("patch")?).await
});
+9 -30
Переглянути файл
@@ -112,11 +112,6 @@ pub trait PluginWorkspace: Send + Sync {
) -> Result<serde_json::Value, HostError> {
Err(HostError::NotFound(format!("no language server `{server}` is running for this project")))
}
/// What the IDE has resolved of the Maven / Gradle builds of the project at `root`;
/// never runs a build tool.
fn build_graph(&self, _root: &Path) -> Result<super::BuildGraph, HostError> {
Ok(super::BuildGraph::default())
}
/// Current index of the project rooted at `root`; never reads disk or calls LSP.
fn symbols(
&self,
@@ -239,7 +234,7 @@ fn network_error(error: reqwest::Error) -> HostError {
}
source = e.source();
}
HostError::Failed(ide_http::client::describe(&error))
HostError::Failed(error.to_string())
}
fn redirect_capability(from: &reqwest::Url, to: &reqwest::Url) -> Result<Capability, String> {
@@ -1556,8 +1551,13 @@ impl HostApi for PluginApi {
}
Ok(())
}
fn open_diff(&self, client: &str, diff: ide_plugin::FileDiff, file_name: Option<String>) -> Result<(), HostError> {
super::execution::validate_file_diff(&diff)?;
fn open_diff(
&self,
client: &str,
diff: ide_plugin::ContentDiff,
file_name: Option<String>,
) -> Result<(), HostError> {
super::execution::validate_diff(&diff)?;
if let Some(name) = &file_name {
super::execution::label(name, 256)?;
}
@@ -2229,20 +2229,6 @@ impl HostApi for PluginApi {
Ok(result.to_string())
}
fn build_dependencies(
&self,
root: &Path,
module: Option<&str>,
) -> Result<Vec<ide_plugin::DependencyNode>, HostError> {
self.require_api("`build`", 10)?;
let workspace = self.shared.workspace().ok_or_else(|| HostError::NotFound("no project is open".into()))?;
// The graph comes from running the project's build, as `vcs.read` does git.
if !workspace.trusted(root) {
return Err(HostError::Denied("project is not trusted".into()));
}
super::build_graph::dependency_nodes(&workspace.build_graph(root)?, module)
}
fn find_files(&self, root: &Path, glob: &str, limit: usize) -> Result<Vec<String>, HostError> {
let matcher = globset::GlobBuilder::new(glob)
.literal_separator(true)
@@ -2845,7 +2831,7 @@ impl HostApi for PluginApi {
}
fn post_view_message(&self, view: &str, message: String) -> Result<(), HostError> {
let declared = super::ui_points::WEB_POINTS
let declared = [super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
.iter()
.any(|point| self.shared.ui.items(point, Some(self.id())).iter().any(|i| i.key == view));
if !declared {
@@ -3393,13 +3379,6 @@ impl PluginWorkspace for HostWorkspace {
})
}
fn build_graph(&self, root: &Path) -> Result<super::BuildGraph, HostError> {
let host = self.0.upgrade().ok_or(HostError::Cancelled)?;
let project = HostWorkspace::project_covering(self, root)
.ok_or_else(|| HostError::NotFound("the project is no longer open".into()))?;
crate::ops::build::analyzed_dependencies(&project, &host.config_dir, root).map_err(failed)
}
fn trusted(&self, root: &Path) -> bool {
// A workspace member is as trusted as the group's project it was opened with.
HostWorkspace::project_covering(self, root).is_some_and(|p| p.is_trusted())
-337
Переглянути файл
@@ -1,337 +0,0 @@
//! `build.dependencies`: the Dependency Analyzer's Maven / Gradle trees as the flat
//! list the plugin API passes (records can't nest), each module a root.
use ide_build::{GradleDependency, GradleReport, MavenDependency, MavenProject, Omission};
use ide_plugin::{DependencyNode, DependencyStatus, HostError};
/// Most nodes one call returns.
const MAX_NODES: usize = 100_000;
/// What the IDE has resolved of a project's builds, without running a build tool.
#[derive(Clone, Debug, Default)]
pub struct BuildGraph {
/// Maven modules with their dependencies (with the transitive ones after a sync).
pub maven: Vec<MavenProject>,
pub gradle: Vec<GradleModule>,
}
/// A Gradle project and the reports the Dependency Analyzer read for it.
#[derive(Clone, Debug, Default)]
pub struct GradleModule {
/// Gradle path (`:`, `:app`).
pub path: String,
/// One per configuration read.
pub reports: Vec<GradleReport>,
}
/// The graph of `module` (a Maven `groupId:artifactId` or a Gradle path), or of every module.
pub fn dependency_nodes(graph: &BuildGraph, module: Option<&str>) -> Result<Vec<DependencyNode>, HostError> {
let mut out = Nodes(Vec::new());
let mut found = false;
for p in graph.maven.iter().filter(|p| module.is_none_or(|m| m == p.key())) {
found = true;
let root = out.push(DependencyNode {
group: p.group_id.clone(),
artifact: p.artifact_id.clone(),
version: p.version.clone(),
scope: String::new(),
status: DependencyStatus::Resolved,
requested_version: None,
parent: None,
})?;
out.maven(&p.dependencies, root)?;
}
for g in graph.gradle.iter().filter(|g| module.is_none_or(|m| m == g.path)) {
found = true;
let root = out.push(DependencyNode {
group: String::new(),
artifact: g.path.clone(),
version: String::new(),
scope: String::new(),
status: DependencyStatus::Resolved,
requested_version: None,
parent: None,
})?;
for report in &g.reports {
out.gradle(&report.dependencies, &report.configuration, root)?;
}
}
match module {
Some(m) if !found => Err(HostError::NotFound(format!("no Maven or Gradle module `{m}` in this project"))),
_ => Ok(out.0),
}
}
struct Nodes(Vec<DependencyNode>);
impl Nodes {
fn push(&mut self, node: DependencyNode) -> Result<u32, HostError> {
if self.0.len() >= MAX_NODES {
return Err(HostError::Failed(format!(
"the dependency graph has more than {MAX_NODES} nodes; ask for one module"
)));
}
self.0.push(node);
Ok((self.0.len() - 1) as u32)
}
fn maven(&mut self, deps: &[MavenDependency], parent: u32) -> Result<(), HostError> {
for d in deps {
let version = d.version.clone().unwrap_or_default();
let (status, version, requested) = match d.omitted {
// `version` lost to `conflict_with`.
Some(Omission::Conflict) => (
DependencyStatus::OmittedForConflict,
d.conflict_with.clone().unwrap_or_else(|| version.clone()),
Some(version),
),
Some(Omission::Duplicate | Omission::Cycle) => {
(DependencyStatus::OmittedForDuplicate, version, d.managed_from.clone())
}
None if d.managed_from.is_some() => (DependencyStatus::VersionManaged, version, d.managed_from.clone()),
None => (DependencyStatus::Resolved, version, None),
};
let index = self.push(DependencyNode {
group: d.group_id.clone(),
artifact: d.artifact_id.clone(),
requested_version: requested.filter(|r| *r != version),
version,
scope: d.scope.clone(),
status,
parent: Some(parent),
})?;
self.maven(&d.children, index)?;
}
Ok(())
}
fn gradle(&mut self, deps: &[GradleDependency], configuration: &str, parent: u32) -> Result<(), HostError> {
// A constraint is not a dependency: it occurs as one elsewhere in the tree.
for d in deps.iter().filter(|d| !d.constraint) {
let (status, version, requested) = if d.project || d.unresolved {
(DependencyStatus::Resolved, String::new(), None)
} else {
match (&d.requested, &d.selected) {
(_, None) => (DependencyStatus::Resolved, d.requested.clone().unwrap_or_default(), None),
// A platform or a constraint supplies the version.
(None, Some(selected)) => (DependencyStatus::VersionManaged, selected.clone(), None),
// Conflict resolution picked another version than this exact request.
(Some(requested), Some(selected)) if exact_version(requested) => {
(DependencyStatus::OmittedForConflict, selected.clone(), Some(requested.clone()))
}
// A range or a rich version (`1.+`, `{strictly 2.0}`) resolved as asked.
(Some(requested), Some(selected)) => {
(DependencyStatus::Resolved, selected.clone(), Some(requested.clone()))
}
}
};
let status = if d.repeated && status == DependencyStatus::Resolved {
DependencyStatus::OmittedForDuplicate
} else {
status
};
let index = self.push(DependencyNode {
group: d.group.clone(),
artifact: d.name.clone(),
requested_version: requested.filter(|r| *r != version),
version,
scope: configuration.to_owned(),
status,
parent: Some(parent),
})?;
self.gradle(&d.children, configuration, index)?;
}
Ok(())
}
}
/// `1.2.3`, not a range, dynamic or rich version (`[1,2)`, `1.+`, `latest.release`, `{strictly 1}`).
fn exact_version(v: &str) -> bool {
!v.is_empty() && !v.starts_with("latest.") && !v.contains(['[', ']', '(', ')', ',', '+', '{', '}', ' '])
}
#[cfg(test)]
mod tests {
use super::*;
fn maven(group: &str, artifact: &str, version: &str, scope: &str) -> MavenDependency {
MavenDependency {
group_id: group.into(),
artifact_id: artifact.into(),
version: Some(version.into()),
kind: "jar".into(),
scope: scope.into(),
..Default::default()
}
}
fn gradle(group: &str, name: &str, requested: Option<&str>, selected: Option<&str>) -> GradleDependency {
GradleDependency {
group: group.into(),
name: name.into(),
requested: requested.map(Into::into),
selected: selected.map(Into::into),
..Default::default()
}
}
/// (group, artifact, version, scope, status, requested, parent) of every node.
type Row<'a> = (&'a str, &'a str, &'a str, &'a str, DependencyStatus, Option<&'a str>, Option<u32>);
fn rows(nodes: &[DependencyNode]) -> Vec<Row<'_>> {
nodes
.iter()
.map(|n| {
(
n.group.as_str(),
n.artifact.as_str(),
n.version.as_str(),
n.scope.as_str(),
n.status,
n.requested_version.as_deref(),
n.parent,
)
})
.collect()
}
fn graph() -> BuildGraph {
let mut lang3_lost = maven("org.apache.commons", "commons-lang3", "3.12.0", "compile");
lang3_lost.omitted = Some(Omission::Conflict);
lang3_lost.conflict_with = Some("3.14.0".into());
let mut text = maven("org.apache.commons", "commons-text", "1.11.0", "compile");
text.children = vec![lang3_lost];
let mut logging = maven("commons-logging", "commons-logging", "1.3.0", "compile");
logging.managed_from = Some("1.2".into());
let mut junit_again = maven("junit", "junit", "4.13.2", "test");
junit_again.omitted = Some(Omission::Duplicate);
let mut hamcrest = maven("org.hamcrest", "hamcrest", "2.2", "test");
hamcrest.children = vec![junit_again];
let app = MavenProject {
group_id: "com.example".into(),
artifact_id: "app".into(),
version: "1.0".into(),
dependencies: vec![
maven("org.apache.commons", "commons-lang3", "3.14.0", "compile"),
text,
logging,
hamcrest,
],
..Default::default()
};
let mut databind = gradle("com.fasterxml.jackson.core", "jackson-databind", Some("2.15.0"), Some("2.15.3"));
databind.repeated = true;
let mut web = gradle("org.springframework.boot", "spring-boot-starter-web", None, Some("3.2.0"));
web.children = vec![databind];
let mut constraint = gradle("com.google.guava", "guava", Some("32.1.3-jre"), None);
constraint.constraint = true;
let mut core = gradle("", ":core", None, None);
core.project = true;
core.children = vec![constraint];
let mut failed = gradle("org.missing", "gone", Some("9"), None);
failed.unresolved = true;
let report = GradleReport {
project: ":web".into(),
configuration: "runtimeClasspath".into(),
dependencies: vec![
web,
core,
gradle("org.slf4j", "slf4j-api", Some("2.+"), Some("2.0.13")),
gradle("org.yaml", "snakeyaml", Some("2.2"), None),
failed,
],
};
BuildGraph {
maven: vec![app],
gradle: vec![
GradleModule { path: ":web".into(), reports: vec![report] },
GradleModule { path: ":".into(), reports: Vec::new() },
],
}
}
#[test]
fn modules_are_roots_with_their_trees_flattened_under_them() {
use DependencyStatus::*;
let nodes = dependency_nodes(&graph(), None).unwrap();
assert_eq!(
rows(&nodes),
[
("com.example", "app", "1.0", "", Resolved, None, None),
("org.apache.commons", "commons-lang3", "3.14.0", "compile", Resolved, None, Some(0)),
("org.apache.commons", "commons-text", "1.11.0", "compile", Resolved, None, Some(0)),
(
"org.apache.commons",
"commons-lang3",
"3.14.0",
"compile",
OmittedForConflict,
Some("3.12.0"),
Some(2)
),
("commons-logging", "commons-logging", "1.3.0", "compile", VersionManaged, Some("1.2"), Some(0)),
("org.hamcrest", "hamcrest", "2.2", "test", Resolved, None, Some(0)),
("junit", "junit", "4.13.2", "test", OmittedForDuplicate, None, Some(5)),
("", ":web", "", "", Resolved, None, None),
(
"org.springframework.boot",
"spring-boot-starter-web",
"3.2.0",
"runtimeClasspath",
VersionManaged,
None,
Some(7)
),
(
"com.fasterxml.jackson.core",
"jackson-databind",
"2.15.3",
"runtimeClasspath",
OmittedForConflict,
Some("2.15.0"),
Some(8)
),
("", ":core", "", "runtimeClasspath", Resolved, None, Some(7)),
("org.slf4j", "slf4j-api", "2.0.13", "runtimeClasspath", Resolved, Some("2.+"), Some(7)),
("org.yaml", "snakeyaml", "2.2", "runtimeClasspath", Resolved, None, Some(7)),
("org.missing", "gone", "", "runtimeClasspath", Resolved, None, Some(7)),
("", ":", "", "", Resolved, None, None),
]
);
}
#[test]
fn one_module_by_its_maven_key_or_gradle_path() {
let maven = dependency_nodes(&graph(), Some("com.example:app")).unwrap();
assert_eq!((maven.len(), maven[0].artifact.as_str()), (7, "app"));
let gradle = dependency_nodes(&graph(), Some(":web")).unwrap();
assert_eq!((gradle.len(), gradle[0].artifact.as_str(), gradle[1].parent), (7, ":web", Some(0)));
// A Gradle project with no report read yet is known, with nothing under it.
assert_eq!(dependency_nodes(&graph(), Some(":")).unwrap().len(), 1);
let err = dependency_nodes(&graph(), Some("app")).unwrap_err();
assert!(matches!(err, HostError::NotFound(_)), "{err:?}");
assert!(dependency_nodes(&BuildGraph::default(), None).unwrap().is_empty());
}
#[test]
fn a_graph_too_large_for_one_call_fails() {
let app = MavenProject {
group_id: "g".into(),
artifact_id: "a".into(),
dependencies: vec![maven("g", "d", "1", "compile"); MAX_NODES],
..Default::default()
};
let graph = BuildGraph { maven: vec![app], gradle: Vec::new() };
assert!(matches!(dependency_nodes(&graph, None), Err(HostError::Failed(_))));
}
#[test]
fn exact_versions() {
for v in ["1.0", "32.1.3-jre", "2.15.0"] {
assert!(exact_version(v), "{v}");
}
for v in ["", "1.+", "[1.0,2.0)", "latest.release", "{strictly 1.0}"] {
assert!(!exact_version(v), "{v}");
}
}
}
Loaded 100 of 995 files, more files were not shown because too many files have changed in this diff. Show more