дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-18 15:46:14 +02:00
Порівняти коміти
1
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
55a19bbbe1 |
No files matched your search
@@ -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"
|
||||
Бінарний файл не відображається.
|
До Ширина: | Висота: | Розмір: 160 KiB |
Бінарний файл не відображається.
|
Після Ширина: | Висота: | Розмір: 86 KiB |
Створено
+6
-131
@@ -199,7 +199,7 @@ dependencies = [
|
||||
"wayland-backend",
|
||||
"wayland-client",
|
||||
"wayland-protocols",
|
||||
"zbus 5.19.0",
|
||||
"zbus",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -5722,20 +5722,6 @@ dependencies = [
|
||||
"serde_repr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "mac-notification-sys"
|
||||
version = "0.6.15"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fd604973958ddcc11b561193c0fb96ba146506ef2f231ef2e7c35fd2cbc9beca"
|
||||
dependencies = [
|
||||
"cc",
|
||||
"log",
|
||||
"objc2 0.6.5",
|
||||
"objc2-foundation 0.3.2",
|
||||
"time",
|
||||
"uuid",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "mach2"
|
||||
version = "0.6.0"
|
||||
@@ -6008,20 +5994,6 @@ dependencies = [
|
||||
"windows-sys 0.60.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "notify-rust"
|
||||
version = "4.19.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "57da5b5d3b7809bf71858da5a2818c3404ca4688c02c8abecdda0fcdec235df3"
|
||||
dependencies = [
|
||||
"futures-lite",
|
||||
"log",
|
||||
"mac-notification-sys",
|
||||
"serde",
|
||||
"tauri-winrt-notification",
|
||||
"zbus 6.3.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "notify-types"
|
||||
version = "2.1.0"
|
||||
@@ -6694,7 +6666,6 @@ dependencies = [
|
||||
"tauri-build",
|
||||
"tauri-plugin-dialog",
|
||||
"tauri-plugin-mcp-bridge",
|
||||
"tauri-plugin-notification",
|
||||
"tauri-plugin-opener",
|
||||
"tauri-plugin-single-instance",
|
||||
"tauri-plugin-updater",
|
||||
@@ -8182,7 +8153,7 @@ dependencies = [
|
||||
"once_cell",
|
||||
"serde",
|
||||
"sha2 0.11.1",
|
||||
"zbus 5.19.0",
|
||||
"zbus",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -9458,26 +9429,6 @@ dependencies = [
|
||||
"windows-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tauri-plugin-notification"
|
||||
version = "2.8.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "14a226bfb8189ec4ab2c1936e66330ad06c44d9f6c54a674338208491dee177f"
|
||||
dependencies = [
|
||||
"log",
|
||||
"notify-rust",
|
||||
"rand 0.10.3",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"serde_repr",
|
||||
"tauri",
|
||||
"tauri-plugin",
|
||||
"thiserror 2.0.21",
|
||||
"time",
|
||||
"url",
|
||||
"zbus 5.19.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tauri-plugin-opener"
|
||||
version = "2.7.2"
|
||||
@@ -9497,7 +9448,7 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
"url",
|
||||
"windows",
|
||||
"zbus 5.19.0",
|
||||
"zbus",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -9513,7 +9464,7 @@ dependencies = [
|
||||
"tokio",
|
||||
"tracing",
|
||||
"windows-sys 0.61.2",
|
||||
"zbus 5.19.0",
|
||||
"zbus",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -9696,17 +9647,6 @@ dependencies = [
|
||||
"toml 1.1.8+spec-1.1.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tauri-winrt-notification"
|
||||
version = "0.8.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f37a6c354fd28fc9e322ed9bd47e3959576dad28c9d58ea1cf888cce1c7ccb36"
|
||||
dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
"windows",
|
||||
"windows-version",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tempfile"
|
||||
version = "3.27.0"
|
||||
@@ -12197,38 +12137,11 @@ dependencies = [
|
||||
"uuid",
|
||||
"windows-sys 0.61.2",
|
||||
"winnow 1.0.4",
|
||||
"zbus_macros 5.19.0",
|
||||
"zbus_macros",
|
||||
"zbus_names",
|
||||
"zvariant",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus"
|
||||
version = "6.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6b4aae740b23927ceabed962431abab2cdefb9f7f885e5bbab062da09bf580e4"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"bitflags 2.13.2",
|
||||
"endi",
|
||||
"futures-core",
|
||||
"hex",
|
||||
"libc",
|
||||
"ordered-stream",
|
||||
"rustix",
|
||||
"serde",
|
||||
"serde_repr",
|
||||
"socket2",
|
||||
"uds_windows",
|
||||
"uuid",
|
||||
"windows-sys 0.61.2",
|
||||
"winnow 1.0.4",
|
||||
"zbus_macros 6.3.0",
|
||||
"zbus_utils",
|
||||
"zcheapstr",
|
||||
"zruntime",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus-secret-service-keyring-store"
|
||||
version = "1.0.1"
|
||||
@@ -12237,7 +12150,7 @@ checksum = "74801d001b9e7729adb4f1825b67b398185fed424749aa3d8bacf70417137d9a"
|
||||
dependencies = [
|
||||
"keyring-core",
|
||||
"secret-service",
|
||||
"zbus 5.19.0",
|
||||
"zbus",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -12255,18 +12168,6 @@ dependencies = [
|
||||
"zvariant_utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus_macros"
|
||||
version = "6.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "37c9dd4beaf145c16fcb2902862f50da86e54aed13dd368ddf64a1d17e6b8529"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 3.0.9",
|
||||
"zbus_utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus_names"
|
||||
version = "4.3.5"
|
||||
@@ -12278,19 +12179,6 @@ dependencies = [
|
||||
"zvariant",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus_utils"
|
||||
version = "6.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "af55e52da295311b368c45bcae221f020e28e97a2420360170ce389218e76ec7"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"serde",
|
||||
"syn 3.0.9",
|
||||
"winnow 1.0.4",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zcheapstr"
|
||||
version = "1.1.0"
|
||||
@@ -12447,19 +12335,6 @@ dependencies = [
|
||||
"simd-adler32",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zruntime"
|
||||
version = "0.2.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ce6a55d4f521760475a30f7b96779508fe8c40dc834478709454dd1d5f0ebc72"
|
||||
dependencies = [
|
||||
"futures-core",
|
||||
"futures-io",
|
||||
"rustix",
|
||||
"socket2",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zune-core"
|
||||
version = "0.5.3"
|
||||
|
||||
+1
-1
@@ -68,7 +68,7 @@ the [official plugins](plugins/official). The plugin API is still a preview.
|
||||
- [Discord](https://discord.gg/2Zy4yn7gP) — questions, feedback and release news.
|
||||
- WeChat group — scan to join:
|
||||
|
||||
<img src=".github/assets/wechat-group-3.png" alt="WeChat group QR code" width="200">
|
||||
<img src=".github/assets/wechat-group.png" alt="WeChat group QR code" width="200">
|
||||
|
||||
- Contributing: see [CONTRIBUTING.md](CONTRIBUTING.md) and the [contributor docs](https://openidea.sh/en/contribute/setup).
|
||||
|
||||
|
||||
+1
-1
@@ -68,7 +68,7 @@ Eklentileri Ayarlar › Eklentiler (Settings › Plugins) bölümünden kur ya d
|
||||
- [Discord](https://discord.gg/2Zy4yn7gP): sorular, geri bildirim ve sürüm haberleri.
|
||||
- WeChat grubu, katılmak için kodu okut:
|
||||
|
||||
<img src=".github/assets/wechat-group-3.png" alt="WeChat grubu QR kodu" width="200">
|
||||
<img src=".github/assets/wechat-group.png" alt="WeChat grubu QR kodu" width="200">
|
||||
|
||||
- Katkıda bulunmak için: [CONTRIBUTING.md](CONTRIBUTING.md) ve [katkıcı belgeleri](https://openidea.sh/en/contribute/setup).
|
||||
|
||||
|
||||
@@ -66,7 +66,7 @@ WebAssembly 组件运行;主题、图标主题和语言无需编写代码。
|
||||
- [Discord](https://discord.gg/2Zy4yn7gP):提问、反馈和版本发布消息。
|
||||
- 微信群,扫码加入:
|
||||
|
||||
<img src=".github/assets/wechat-group-3.png" alt="微信群二维码" width="200">
|
||||
<img src=".github/assets/wechat-group.png" alt="微信群二维码" width="200">
|
||||
|
||||
- 参与贡献:参见 [CONTRIBUTING.md](CONTRIBUTING.md) 和[贡献者文档](https://openidea.sh/zh/contribute/setup)。
|
||||
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -109,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());
|
||||
@@ -204,14 +203,6 @@ impl AgentCatalogs {
|
||||
.unwrap_or_else(|| Self::fallback(shared, provider))
|
||||
}
|
||||
|
||||
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));
|
||||
AgentModelCatalog {
|
||||
@@ -481,43 +472,6 @@ async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<
|
||||
.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).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).await
|
||||
}
|
||||
Err(err) => Err(err.message),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -2,8 +2,8 @@
|
||||
//! the agent reports them over ACP.
|
||||
|
||||
use crate::model::{
|
||||
AgentCommand, AgentCommandSource, AgentConfigChoice, AgentConfigOption, AgentConfigValue, AgentConfigVia,
|
||||
AgentCost, AgentLimit, AgentModelPricing, AgentUsage,
|
||||
AgentCommand, AgentCommandSource, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit,
|
||||
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,
|
||||
},
|
||||
],
|
||||
});
|
||||
@@ -54,30 +52,6 @@ pub(crate) fn bypass_approvals(config: &[AgentConfigOption]) -> bool {
|
||||
.any(|category| selected(category).zip(bypass_value(category)).is_some_and(|(value, bypass)| bypass(value)))
|
||||
}
|
||||
|
||||
/// Whether `value` of `option` approves everything without asking.
|
||||
pub(crate) fn approves_everything(option: &AgentConfigOption, value: &str) -> bool {
|
||||
option.category.as_deref().and_then(bypass_value).is_some_and(|bypass| bypass(value))
|
||||
}
|
||||
|
||||
/// The choices that keep a session asking before it changes anything: `wanted` without values
|
||||
/// that approve everything, and an asking value for each option of `options` that approves
|
||||
/// everything as it stands.
|
||||
pub(crate) fn asking_choices(options: &[AgentConfigOption], wanted: &[AgentConfigChoice]) -> Vec<AgentConfigChoice> {
|
||||
let mut out: Vec<AgentConfigChoice> = wanted
|
||||
.iter()
|
||||
.filter(|c| !options.iter().any(|o| o.id == c.id && approves_everything(o, &c.value)))
|
||||
.cloned()
|
||||
.collect();
|
||||
let mut asking = options.to_vec();
|
||||
ask_for_approvals(&mut asking);
|
||||
for (before, after) in options.iter().zip(&asking) {
|
||||
let Some(value) = after.current.as_ref().filter(|v| before.current.as_ref() != Some(*v)) else { continue };
|
||||
out.retain(|c| c.id != after.id);
|
||||
out.push(AgentConfigChoice { id: after.id.clone(), value: value.clone() });
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// For an option of `category` that can approve everything, what tells its approving values.
|
||||
fn bypass_value(category: &str) -> Option<fn(&str) -> bool> {
|
||||
match category {
|
||||
@@ -314,7 +288,6 @@ fn legacy(
|
||||
description: str_of(m, "description"),
|
||||
cost_category: None,
|
||||
usage_multiplier: None,
|
||||
pricing: pricing_of(m),
|
||||
value,
|
||||
})
|
||||
})
|
||||
@@ -351,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)
|
||||
}
|
||||
@@ -488,22 +453,6 @@ mod tests {
|
||||
assert_eq!(ids(&c), [("allow_all", Some("off")), ("approval", Some("ask"))]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn asking_choices_drop_and_override_values_that_approve_everything() {
|
||||
let codex = options_of(&json!({"modes": {"currentModeId": "full-access",
|
||||
"availableModes": [{"id": "read-only"}, {"id": "ask"}, {"id": "auto"}, {"id": "full-access"}]}}));
|
||||
let mode = codex[0].id.clone();
|
||||
let choice = |id: &str, value: &str| AgentConfigChoice { id: id.into(), value: value.into() };
|
||||
// The source task's Full Access goes; the session's own Full Access is turned to Ask.
|
||||
let wanted = asking_choices(&codex, &[choice(&mode, "full-access"), choice("model", "gpt")]);
|
||||
assert_eq!(wanted, [choice("model", "gpt"), choice(&mode, "ask")]);
|
||||
// A mode that already asks is left alone.
|
||||
let mut auto = codex.clone();
|
||||
auto[0].current = Some("auto".into());
|
||||
assert_eq!(asking_choices(&auto, &[choice(&mode, "auto")]), [choice(&mode, "auto")]);
|
||||
assert!(approves_everything(&codex[0], "full-access") && !approves_everything(&codex[0], "auto"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn effort_and_fast_categories_are_inferred_from_ids() {
|
||||
let mut c = options_of(&json!({
|
||||
|
||||
@@ -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})]);
|
||||
|
||||
@@ -70,8 +70,6 @@ pub(crate) const LIMITS_UPDATE: &str = "openidea_limits";
|
||||
/// A native agent's own update: the background tasks its session runs
|
||||
/// (see [`TaskState::background_tasks`]).
|
||||
pub(crate) const BACKGROUND_TASKS_UPDATE: &str = "openidea_background_tasks";
|
||||
/// A native agent's diagnostic, including warnings emitted before a session exists.
|
||||
pub(crate) const WARNING_NOTIFICATION: &str = "_openidea/warning";
|
||||
/// Referenced files up to this size are embedded in the prompt (when the agent takes it).
|
||||
const MAX_EMBED: u64 = 256 * 1024;
|
||||
/// How long a probe waits for the agent to answer `initialize`.
|
||||
@@ -123,13 +121,6 @@ type Connector = Arc<
|
||||
/// Returns the configured MCP servers (User and Workspace) for this project.
|
||||
pub type McpServersFn = dyn Fn() -> Vec<McpServer> + Send + Sync;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
||||
struct CopilotBinaryKey {
|
||||
command: String,
|
||||
modified: Option<std::time::SystemTime>,
|
||||
len: Option<u64>,
|
||||
}
|
||||
|
||||
struct Shared {
|
||||
paths: AgentPaths,
|
||||
runtime: tokio::runtime::Handle,
|
||||
@@ -141,13 +132,9 @@ struct Shared {
|
||||
providers: RwLock<Vec<provider::ProviderSpec>>,
|
||||
/// Last probe of each provider.
|
||||
probes: Mutex<HashMap<String, AgentProbe>>,
|
||||
/// Copilot CLI installs where `--headless` failed and fell back to `--acp`.
|
||||
copilot_acp_fallback: Mutex<HashSet<CopilotBinaryKey>>,
|
||||
/// [`IDLE_RELEASE`], in milliseconds (shorter in tests).
|
||||
idle_release_ms: AtomicU64,
|
||||
mcp_servers_hook: RwLock<Option<Arc<McpServersFn>>>,
|
||||
/// Monotonic id for [`AgentEvent::Attention`] episodes.
|
||||
attention_seq: AtomicU64,
|
||||
}
|
||||
|
||||
/// What an agent offered in its last session, for the New Task page.
|
||||
@@ -180,29 +167,6 @@ impl Shared {
|
||||
self.paths.env_secrets.as_deref()
|
||||
}
|
||||
|
||||
fn copilot_binary_key(&self, spec: &provider::ProviderSpec) -> CopilotBinaryKey {
|
||||
let resolved = spec.clone().resolve_for_launch(&self.paths.project_root);
|
||||
let executable = dunce::canonicalize(&resolved.command).unwrap_or_else(|_| PathBuf::from(&resolved.command));
|
||||
let metadata = std::fs::metadata(&executable).ok();
|
||||
CopilotBinaryKey {
|
||||
command: executable.to_string_lossy().into_owned(),
|
||||
modified: metadata.as_ref().and_then(|m| m.modified().ok()),
|
||||
len: metadata.as_ref().map(std::fs::Metadata::len),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn uses_copilot_acp_fallback(&self, spec: &provider::ProviderSpec) -> bool {
|
||||
let key = self.copilot_binary_key(spec);
|
||||
self.copilot_acp_fallback.lock().contains(&key)
|
||||
}
|
||||
|
||||
pub(crate) fn mark_copilot_acp_fallback(&self, spec: &provider::ProviderSpec) {
|
||||
let key = self.copilot_binary_key(spec);
|
||||
if self.copilot_acp_fallback.lock().insert(key) {
|
||||
self.paths.catalogs.evict_if_idle(self, &spec.id);
|
||||
}
|
||||
}
|
||||
|
||||
fn emit(&self, event: AgentEvent) {
|
||||
let sink = self.sink.read().clone();
|
||||
if let Some(sink) = sink {
|
||||
@@ -210,19 +174,10 @@ impl Shared {
|
||||
}
|
||||
}
|
||||
|
||||
fn mcp_servers_for_session(
|
||||
&self,
|
||||
provider: &str,
|
||||
init: &acp::Negotiated,
|
||||
overrides: &BTreeMap<String, bool>,
|
||||
) -> Vec<Value> {
|
||||
let mut servers = if overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false) {
|
||||
Vec::new()
|
||||
} else {
|
||||
mcp_servers_for(init.mcp_stdio(), &self.paths.project_root)
|
||||
};
|
||||
fn mcp_servers_for_session(&self, provider: &str, init: &acp::Negotiated) -> Vec<Value> {
|
||||
let mut servers = mcp_servers_for(init.mcp_stdio(), &self.paths.project_root);
|
||||
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
|
||||
servers.extend(mcp::acp_mcp_servers(&configured, provider, init, overrides));
|
||||
servers.extend(mcp::acp_mcp_servers(&configured, provider, init));
|
||||
servers
|
||||
}
|
||||
|
||||
@@ -383,8 +338,6 @@ struct TaskState {
|
||||
/// A running agent and its session.
|
||||
#[derive(Clone)]
|
||||
struct Live {
|
||||
provider: String,
|
||||
driver: provider::Driver,
|
||||
sign_in_message: String,
|
||||
peer: acp::Conn,
|
||||
session: String,
|
||||
@@ -420,8 +373,6 @@ struct Task {
|
||||
/// Bumped when the agent's last background task finishes: an idle release scheduled
|
||||
/// before that is void, the usual delay starts over from the report.
|
||||
idle_epoch: AtomicU64,
|
||||
/// Turned on when per-session MCP overrides changed while a turn was busy; dropped once idle.
|
||||
mcp_reload_pending: AtomicBool,
|
||||
/// Settings already sent this session (`(option, value)`), so a refusal is not retried.
|
||||
config_sent: Mutex<HashSet<(String, String)>>,
|
||||
dirty: Mutex<BTreeSet<(Session, usize)>>,
|
||||
@@ -447,7 +398,6 @@ impl AgentManager {
|
||||
}
|
||||
provider::Driver::Codex => native::codex::connect(spec, cwd, client, on_stderr),
|
||||
provider::Driver::Claude => native::claude::connect(spec, cwd, client, on_stderr),
|
||||
provider::Driver::Copilot => native::copilot::connect(spec, cwd, client, on_stderr),
|
||||
});
|
||||
Self::with_connector(paths, runtime, connector)
|
||||
}
|
||||
@@ -465,10 +415,8 @@ impl AgentManager {
|
||||
known,
|
||||
providers,
|
||||
probes: Mutex::new(HashMap::new()),
|
||||
copilot_acp_fallback: Mutex::new(HashSet::new()),
|
||||
idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),
|
||||
mcp_servers_hook: RwLock::new(None),
|
||||
attention_seq: AtomicU64::new(0),
|
||||
});
|
||||
shared.paths.catalogs.subscribe(&shared);
|
||||
let mut tasks = HashMap::new();
|
||||
@@ -599,7 +547,6 @@ impl AgentManager {
|
||||
let specs = provider::load(self.shared.paths.custom_agents_dir.as_deref(), self.shared.env_secrets());
|
||||
*self.shared.providers.write() = specs;
|
||||
self.shared.probes.lock().clear();
|
||||
self.shared.copilot_acp_fallback.lock().clear();
|
||||
self.shared.emit(AgentEvent::Providers);
|
||||
}
|
||||
|
||||
@@ -639,9 +586,14 @@ impl AgentManager {
|
||||
}
|
||||
offered = self.shared.known_commands(&provider);
|
||||
}
|
||||
for command in builtin_commands(&provider) {
|
||||
if !offered.iter().any(|c| c.name == command.name) {
|
||||
offered.push(command);
|
||||
for &(name, description) in builtin_commands(&provider) {
|
||||
if !offered.iter().any(|c| c.name == name) {
|
||||
offered.push(AgentCommand {
|
||||
name: name.to_owned(),
|
||||
description: description.to_owned(),
|
||||
hint: None,
|
||||
source: AgentCommandSource::Command,
|
||||
});
|
||||
}
|
||||
}
|
||||
if provider != "claude" && provider != "claude-acp" {
|
||||
@@ -732,7 +684,6 @@ impl AgentManager {
|
||||
resets_ms: None,
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
};
|
||||
let handle = self.register(TaskFile {
|
||||
task: task.clone(),
|
||||
@@ -824,7 +775,6 @@ impl AgentManager {
|
||||
resets_ms: None,
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: req.mcp_overrides,
|
||||
};
|
||||
let handle = self.register(TaskFile {
|
||||
task: task.clone(),
|
||||
@@ -891,8 +841,6 @@ impl AgentManager {
|
||||
let prompt = clean(req.prompt).ok_or_else(|| IdeError::invalid("describe the topic first"))?;
|
||||
let title = title_of(&prompt);
|
||||
let mut config = self.merged_config(&spec.id, &req.config);
|
||||
// The source task's choices may approve everything; the side conversation asks.
|
||||
let wanted = config::asking_choices(&config, &req.config);
|
||||
config::ask_for_approvals(&mut config);
|
||||
if config::bypass_approvals(&config) {
|
||||
return Err(IdeError::invalid(
|
||||
@@ -928,14 +876,13 @@ impl AgentManager {
|
||||
resets_ms: None,
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: req.mcp_overrides,
|
||||
config,
|
||||
};
|
||||
let handle = self.register(TaskFile {
|
||||
task: task.clone(),
|
||||
session_id: None,
|
||||
entries: Vec::new(),
|
||||
wanted,
|
||||
wanted: req.config,
|
||||
before,
|
||||
saved: None,
|
||||
touched: None,
|
||||
@@ -1052,9 +999,6 @@ impl AgentManager {
|
||||
if !o.values.iter().any(|v| v.value == value) {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", o.name)));
|
||||
}
|
||||
if s.ephemeral && config::approves_everything(o, &value) {
|
||||
return Err(IdeError::invalid("a side conversation asks before changing anything"));
|
||||
}
|
||||
o.clone()
|
||||
};
|
||||
let previous = target.current.clone();
|
||||
@@ -1106,7 +1050,6 @@ impl AgentManager {
|
||||
o.current = Some(value);
|
||||
}
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
sync_usage_context_size(&mut s.task);
|
||||
let provider = s.task.provider.clone();
|
||||
let config = s.task.config.clone();
|
||||
let model = s.task.model.clone().filter(|_| model_options);
|
||||
@@ -1133,21 +1076,15 @@ impl AgentManager {
|
||||
if !live.capabilities.fork || (keep < total && !live.capabilities.rollback) {
|
||||
return Err(IdeError::invalid("this agent can't copy a conversation from there"));
|
||||
}
|
||||
let (cwd, provider_id, mcp_overrides) = {
|
||||
let s = source.state.lock();
|
||||
(s.task.cwd.0.clone(), s.task.provider.clone(), s.task.mcp_overrides.clone())
|
||||
};
|
||||
let mcp_servers = source.shared.mcp_servers_for_session(&provider_id, &live.init, &mcp_overrides);
|
||||
let cwd = source.state.lock().task.cwd.0.clone();
|
||||
let provider_id = source.state.lock().task.provider.clone();
|
||||
let mcp_servers = source.shared.mcp_servers_for_session(&provider_id, &live.init);
|
||||
let cwd_s = dunce::canonicalize(&cwd).unwrap_or(cwd).to_string_lossy().into_owned();
|
||||
let reply: Value = live
|
||||
.peer
|
||||
.request(
|
||||
"session/fork",
|
||||
{
|
||||
let mut params = session_params(&cwd_s, &mcp_servers, &mcp_overrides);
|
||||
params["sessionId"] = json!(live.session);
|
||||
params
|
||||
},
|
||||
json!({ "sessionId": live.session, "cwd": cwd_s, "mcpServers": mcp_servers }),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
@@ -1275,30 +1212,12 @@ impl AgentManager {
|
||||
if !refresh && let Some(p) = self.shared.probes.lock().get(provider) {
|
||||
return Ok(p.clone());
|
||||
}
|
||||
let raw_spec =
|
||||
self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?;
|
||||
let can_fallback =
|
||||
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
|
||||
let mut active_spec = if raw_spec.driver == provider::Driver::Copilot && !can_fallback {
|
||||
native::copilot::acp_fallback_spec(&raw_spec)
|
||||
} else {
|
||||
raw_spec.clone()
|
||||
};
|
||||
let reply = match self.probe_once(&active_spec).await {
|
||||
Ok(reply) => Ok(reply),
|
||||
Err((err, allow_fallback)) if can_fallback && allow_fallback => {
|
||||
tracing::warn!("Copilot headless probe failed ({err}); falling back to `copilot --acp`");
|
||||
self.shared.mark_copilot_acp_fallback(&raw_spec);
|
||||
active_spec = native::copilot::acp_fallback_spec(&raw_spec);
|
||||
self.probe_once(&active_spec).await.map_err(|(e, _)| e)
|
||||
}
|
||||
Err((err, _)) => Err(err),
|
||||
};
|
||||
let spec = self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?;
|
||||
let mut probe = AgentProbe {
|
||||
provider: active_spec.id.clone(),
|
||||
provider: spec.id.clone(),
|
||||
name: None,
|
||||
version: None,
|
||||
protocol: match active_spec.driver {
|
||||
protocol: match spec.driver {
|
||||
provider::Driver::Acp => "ACP".into(),
|
||||
_ => "native".into(),
|
||||
},
|
||||
@@ -1306,6 +1225,31 @@ impl AgentManager {
|
||||
auth_methods: Vec::new(),
|
||||
error: None,
|
||||
};
|
||||
let stderr: Arc<Mutex<Vec<String>>> = Arc::default();
|
||||
let lines = stderr.clone();
|
||||
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(move |l| lines.lock().push(l));
|
||||
let started = (self.shared.connector)(
|
||||
&spec,
|
||||
&self.shared.paths.project_root,
|
||||
Arc::new(ide_jsonrpc::NoopHandler),
|
||||
on_stderr,
|
||||
);
|
||||
let reply = match started {
|
||||
Err(e) => Err(format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command)),
|
||||
Ok(peer) => {
|
||||
let params = acp::initialize_params(&client_info());
|
||||
let r = tokio::time::timeout(PROBE_TIMEOUT, peer.request::<_, Value>("initialize", params, None)).await;
|
||||
peer.kill();
|
||||
match r {
|
||||
Ok(Ok(v)) => Ok(v),
|
||||
Ok(Err(e)) => Err(match stderr.lock().last() {
|
||||
Some(line) => format!("{e}: {line}"),
|
||||
None => e.to_string(),
|
||||
}),
|
||||
Err(_) => Err("the agent did not answer".into()),
|
||||
}
|
||||
}
|
||||
};
|
||||
match reply {
|
||||
Ok(reply) => {
|
||||
let init = acp::Negotiated::from_initialize(&reply);
|
||||
@@ -1313,7 +1257,7 @@ impl AgentManager {
|
||||
let text = |k: &str| info.get(k).and_then(Value::as_str).map(str::to_owned);
|
||||
probe.name = text("title").or_else(|| text("name"));
|
||||
probe.version = text("version");
|
||||
if active_spec.driver == provider::Driver::Acp {
|
||||
if spec.driver == provider::Driver::Acp {
|
||||
probe.protocol = format!("ACP v{}", init.generation);
|
||||
}
|
||||
probe.capabilities = capabilities_of(&init).0;
|
||||
@@ -1326,47 +1270,11 @@ impl AgentManager {
|
||||
Err(e) => probe.error = Some(e),
|
||||
}
|
||||
if probe.error.is_none() {
|
||||
self.shared.probes.lock().insert(active_spec.id, probe.clone());
|
||||
self.shared.probes.lock().insert(spec.id, probe.clone());
|
||||
}
|
||||
Ok(probe)
|
||||
}
|
||||
|
||||
async fn probe_once(&self, spec: &provider::ProviderSpec) -> Result<Value, (String, bool)> {
|
||||
let stderr: Arc<Mutex<Vec<String>>> = Arc::default();
|
||||
let lines = stderr.clone();
|
||||
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(move |l| lines.lock().push(l));
|
||||
let started = (self.shared.connector)(
|
||||
spec,
|
||||
&self.shared.paths.project_root,
|
||||
Arc::new(ide_jsonrpc::NoopHandler),
|
||||
on_stderr,
|
||||
);
|
||||
match started {
|
||||
Err(e) => Err((
|
||||
format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command),
|
||||
!native::copilot::is_missing_binary_error(&e),
|
||||
)),
|
||||
Ok(peer) => {
|
||||
let params = acp::initialize_params(&client_info());
|
||||
let r = tokio::time::timeout(PROBE_TIMEOUT, peer.request::<_, Value>("initialize", params, None)).await;
|
||||
peer.kill();
|
||||
match r {
|
||||
Ok(Ok(v)) => Ok(v),
|
||||
Ok(Err(e)) => {
|
||||
let is_auth =
|
||||
matches!(&e, RpcError::Server { code, message, .. } if acp::auth_required(*code, message));
|
||||
let msg = match stderr.lock().last() {
|
||||
Some(line) => format!("{e}: {line}"),
|
||||
None => e.to_string(),
|
||||
};
|
||||
Err((msg, !is_auth))
|
||||
}
|
||||
Err(_) => Err(("the agent did not answer".into(), true)),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Stops the current turn (`session/cancel`); pending permission requests are cancelled.
|
||||
/// Queued messages stay queued. With `subagent`, stops only that subagent's work.
|
||||
pub fn cancel(&self, id: &str, subagent: Option<String>) -> IdeResult<()> {
|
||||
@@ -1625,43 +1533,6 @@ impl AgentManager {
|
||||
.await
|
||||
}
|
||||
|
||||
/// Updates per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
|
||||
/// When the task is idle and holds a resumable live session without running background tasks,
|
||||
/// stops the idle process so the next turn reloads the session with the updated MCP servers;
|
||||
/// when busy, schedules the reload for as soon as the turn finishes.
|
||||
pub fn set_mcp_overrides(&self, id: &str, overrides: BTreeMap<String, bool>) -> IdeResult<AgentTask> {
|
||||
let task = self.task(id)?;
|
||||
let cleaned: BTreeMap<String, bool> = overrides
|
||||
.into_iter()
|
||||
.filter_map(|(k, v)| {
|
||||
let k = k.trim();
|
||||
(!k.is_empty()).then(|| (k.to_owned(), v))
|
||||
})
|
||||
.collect();
|
||||
let (changed, busy, has_bg, out) = {
|
||||
let mut s = task.state.lock();
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
let changed = s.task.mcp_overrides != cleaned;
|
||||
if changed {
|
||||
s.task.mcp_overrides = cleaned;
|
||||
s.task.updated_ms = now_ms();
|
||||
}
|
||||
(changed, s.busy, !s.background_tasks.is_empty(), s.task.clone())
|
||||
};
|
||||
if changed {
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
if busy || has_bg || !task.permissions.lock().is_empty() {
|
||||
task.mcp_reload_pending.store(true, Ordering::Release);
|
||||
} else {
|
||||
task.recycle_resumable_session();
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Stops every agent (project closed).
|
||||
pub fn shutdown(&self) {
|
||||
for task in self.tasks.read().values() {
|
||||
@@ -1706,7 +1577,6 @@ impl Task {
|
||||
turn_started: AtomicBool::new(false),
|
||||
turns: AtomicU64::new(0),
|
||||
idle_epoch: AtomicU64::new(0),
|
||||
mcp_reload_pending: AtomicBool::new(false),
|
||||
config_sent: Mutex::new(HashSet::new()),
|
||||
dirty: Mutex::new(BTreeSet::new()),
|
||||
streamed: Mutex::new(HashMap::new()),
|
||||
@@ -1764,7 +1634,7 @@ impl Task {
|
||||
|
||||
fn emit_task(&self) {
|
||||
let task = self.state.lock().task.clone();
|
||||
self.shared.emit(AgentEvent::Task { task: Box::new(task) });
|
||||
self.shared.emit(AgentEvent::Task { task });
|
||||
}
|
||||
|
||||
/// Shows (or clears) the agent's pending retry; emitted only when it changes.
|
||||
@@ -1825,28 +1695,6 @@ impl Task {
|
||||
self.emit_task();
|
||||
}
|
||||
|
||||
fn emit_attention(&self, reason: AgentAttentionReason) {
|
||||
let n = self.shared.attention_seq.fetch_add(1, Ordering::Relaxed);
|
||||
let tag = match reason {
|
||||
AgentAttentionReason::Finished => "finished",
|
||||
AgentAttentionReason::Input => "input",
|
||||
AgentAttentionReason::Failed => "failed",
|
||||
};
|
||||
self.shared.emit(AgentEvent::Attention {
|
||||
task: self.id.clone(),
|
||||
event_id: format!("{}:{tag}:{n}", self.id),
|
||||
reason,
|
||||
});
|
||||
}
|
||||
|
||||
/// After NeedsInput + optional auto-approve: notify only when the user must still answer.
|
||||
fn emit_attention_if_input_pending(&self) {
|
||||
let waiting = !self.permissions.lock().is_empty() && self.state.lock().task.status == AgentStatus::NeedsInput;
|
||||
if waiting {
|
||||
self.emit_attention(AgentAttentionReason::Input);
|
||||
}
|
||||
}
|
||||
|
||||
fn persist(&self) {
|
||||
// Held from snapshot to rename, so saves land in order and none follows a delete.
|
||||
let deleted = self.deleted.lock();
|
||||
@@ -1949,17 +1797,8 @@ impl Task {
|
||||
}
|
||||
match (next, result) {
|
||||
(Some(queued), _) => prompt = queued.prompt,
|
||||
(None, Ok(stop)) => {
|
||||
(None, Ok(_)) => {
|
||||
self.set_status(AgentStatus::Ready, None);
|
||||
if stop != "cancelled" {
|
||||
self.emit_attention(AgentAttentionReason::Finished);
|
||||
}
|
||||
if self.mcp_reload_pending.swap(false, Ordering::AcqRel)
|
||||
&& self.state.lock().background_tasks.is_empty()
|
||||
{
|
||||
self.recycle_resumable_session();
|
||||
return;
|
||||
}
|
||||
return self.release_when_idle();
|
||||
}
|
||||
(None, Err(failure)) => return self.fail(failure),
|
||||
@@ -1967,20 +1806,6 @@ impl Task {
|
||||
}
|
||||
}
|
||||
|
||||
/// Drops an idle resumable live session so the next turn reloads it with fresh MCP servers.
|
||||
fn recycle_resumable_session(&self) {
|
||||
self.mcp_reload_pending.store(false, Ordering::Release);
|
||||
let live = {
|
||||
let mut live = self.live.lock();
|
||||
if live.as_ref().is_some_and(|l| l.resumable && !l.peer.is_closed()) { live.take() } else { None }
|
||||
};
|
||||
if let Some(live) = live {
|
||||
tracing::debug!("agent task {}: restarting idle resumable session for MCP override update", self.id);
|
||||
live.peer.kill();
|
||||
self.clear_shown_background();
|
||||
}
|
||||
}
|
||||
|
||||
/// Stops the agent's process once the task has stayed idle for [`IDLE_RELEASE`], so
|
||||
/// finished tasks don't keep an agent (and what it started) running. Only an agent that
|
||||
/// reloads its session: the next message starts it again with the conversation intact.
|
||||
@@ -2044,7 +1869,6 @@ impl Task {
|
||||
}
|
||||
None => self.set_status(AgentStatus::Failed, Some(failure.message)),
|
||||
}
|
||||
self.emit_attention(AgentAttentionReason::Failed);
|
||||
}
|
||||
|
||||
/// Adds `prompt` to the running turn when the agent takes that; gives it back otherwise.
|
||||
@@ -2116,7 +1940,7 @@ impl Task {
|
||||
// Launching the agent can take a while (`npx` fetches its adapter on first use).
|
||||
let starting = self.live.lock().as_ref().is_none_or(|l| l.peer.is_closed());
|
||||
self.set_status(if starting { AgentStatus::Starting } else { AgentStatus::Running }, None);
|
||||
let mut live = self.ensure_session().await.map_err(Failure::from)?;
|
||||
let live = self.ensure_session().await.map_err(Failure::from)?;
|
||||
// Stopped while the agent started: the prompt is never sent.
|
||||
if self.cancel_pending.load(Ordering::Acquire) {
|
||||
return Ok("cancelled".into());
|
||||
@@ -2138,34 +1962,9 @@ impl Task {
|
||||
None => prompt.clone(),
|
||||
}
|
||||
};
|
||||
let mut content = self.content(&live, &prompt).await;
|
||||
let mut result: Result<Value, RpcError> =
|
||||
let content = self.content(&live, &prompt).await;
|
||||
let result: Result<Value, RpcError> =
|
||||
live.peer.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None).await;
|
||||
if live.driver == provider::Driver::Copilot
|
||||
&& !self.turn_started.load(Ordering::Acquire)
|
||||
&& let Err(RpcError::Server { code, ref message, .. }) = result
|
||||
&& is_headless_protocol_error(code)
|
||||
&& !acp::auth_required(code, message)
|
||||
{
|
||||
tracing::warn!(
|
||||
"agent task {}: Copilot headless prompt failed ({message}); falling back to `copilot --acp`",
|
||||
self.id
|
||||
);
|
||||
if let Some(raw_spec) = self.shared.spec(&live.provider) {
|
||||
self.shared.mark_copilot_acp_fallback(&raw_spec);
|
||||
}
|
||||
live.peer.kill();
|
||||
*self.live.lock() = None;
|
||||
live = self.ensure_session().await.map_err(Failure::from)?;
|
||||
if !prompt.images.is_empty() && !live.capabilities.images {
|
||||
return Err(Failure::from("This agent can't read images.".to_owned()));
|
||||
}
|
||||
content = self.content(&live, &prompt).await;
|
||||
result = live
|
||||
.peer
|
||||
.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None)
|
||||
.await;
|
||||
}
|
||||
match result {
|
||||
Ok(v) => Ok(v.get("stopReason").and_then(Value::as_str).unwrap_or("end_turn").to_owned()),
|
||||
Err(e) => Err(self.failure(e)),
|
||||
@@ -2245,43 +2044,11 @@ impl Task {
|
||||
let s = self.state.lock();
|
||||
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone())
|
||||
};
|
||||
let raw_spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
|
||||
let can_fallback =
|
||||
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
|
||||
let primary_spec = if raw_spec.driver == provider::Driver::Copilot && !can_fallback {
|
||||
native::copilot::acp_fallback_spec(&raw_spec)
|
||||
} else {
|
||||
raw_spec.clone()
|
||||
};
|
||||
let live = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone()).await {
|
||||
Ok(live) => live,
|
||||
Err(err) if can_fallback && err.allow_acp_fallback => {
|
||||
tracing::warn!(
|
||||
"agent task {}: Copilot headless session setup failed ({}); falling back to `copilot --acp`",
|
||||
self.id,
|
||||
err.message
|
||||
);
|
||||
self.shared.mark_copilot_acp_fallback(&raw_spec);
|
||||
let acp_spec = native::copilot::acp_fallback_spec(&raw_spec);
|
||||
self.open_session(&provider_id, acp_spec, &cwd, saved).await.map_err(|e| e.message)?
|
||||
}
|
||||
Err(err) => return Err(err.message),
|
||||
};
|
||||
*self.live.lock() = Some(live.clone());
|
||||
Ok(live)
|
||||
}
|
||||
|
||||
async fn open_session(
|
||||
self: &Arc<Self>,
|
||||
provider_id: &str,
|
||||
spec: provider::ProviderSpec,
|
||||
cwd: &Path,
|
||||
saved: Option<String>,
|
||||
) -> Result<Live, SessionOpenError> {
|
||||
let launch_cwd = cwd.to_path_buf();
|
||||
let spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
|
||||
let launch_cwd = cwd.clone();
|
||||
let spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
.await
|
||||
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?;
|
||||
.map_err(|e| e.to_string())?;
|
||||
self.stderr.lock().clear();
|
||||
self.config_sent.lock().clear();
|
||||
let weak = Arc::downgrade(self);
|
||||
@@ -2296,32 +2063,23 @@ impl Task {
|
||||
});
|
||||
// Speaks ACP v1 or v2, whichever the agent chooses; the task sees v1 either way.
|
||||
let client = acp::Dialect::wrap(Arc::new(Client { task: Arc::downgrade(self) }));
|
||||
let raw_peer =
|
||||
(self.shared.connector)(&spec, cwd, client.clone(), on_stderr).map_err(|e| SessionOpenError {
|
||||
message: format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command),
|
||||
allow_acp_fallback: !native::copilot::is_missing_binary_error(&e),
|
||||
})?;
|
||||
let mut stop_on_err = KillOnDrop(Some(raw_peer.clone()));
|
||||
let peer = acp::Conn::new(raw_peer, client);
|
||||
let peer = (self.shared.connector)(&spec, &cwd, client.clone(), on_stderr)
|
||||
.map(|peer| acp::Conn::new(peer, client))
|
||||
.map_err(|e| format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command))?;
|
||||
|
||||
let init = peer.initialize(&client_info()).await.map_err(|e| {
|
||||
let is_auth = matches!(&e, RpcError::Server { code, message, .. } if acp::auth_required(*code, message));
|
||||
SessionOpenError { message: self.describe(e), allow_acp_fallback: !is_auth }
|
||||
})?;
|
||||
let init = peer.initialize(&client_info()).await.map_err(|e| self.describe(e))?;
|
||||
let sign_in_message = spec.sign_in_message(&init.auth_methods);
|
||||
let can_load = init.load_session();
|
||||
let (capabilities, embedded) = capabilities_of(&init);
|
||||
let mcp_overrides = self.state.lock().task.mcp_overrides.clone();
|
||||
let mcp_servers = self.shared.mcp_servers_for_session(provider_id, &init, &mcp_overrides);
|
||||
let mcp_servers = self.shared.mcp_servers_for_session(&provider_id, &init);
|
||||
// Agents that compare canonical paths fail in a symlinked directory (macOS `/tmp`).
|
||||
let cwd_s = dunce::canonicalize(cwd).unwrap_or_else(|_| cwd.to_path_buf()).to_string_lossy().into_owned();
|
||||
let cwd_s = dunce::canonicalize(&cwd).unwrap_or(cwd).to_string_lossy().into_owned();
|
||||
|
||||
let mut tried_auth = false;
|
||||
let mut session = None;
|
||||
if let (Some(id), true) = (saved, can_load) {
|
||||
self.replaying.store(true, Ordering::Release);
|
||||
let mut params = session_params(&cwd_s, &mcp_servers, &mcp_overrides);
|
||||
params["sessionId"] = json!(&id);
|
||||
let params = json!({ "sessionId": &id, "cwd": &cwd_s, "mcpServers": &mcp_servers });
|
||||
let loaded = self.request_with_auth(&peer, &init, &mut tried_auth, "session/load", params).await;
|
||||
tokio::time::sleep(REPLAY_GRACE).await;
|
||||
self.replaying.store(false, Ordering::Release);
|
||||
@@ -2334,21 +2092,12 @@ impl Task {
|
||||
let (session_id, result) = match session {
|
||||
Some(s) => s,
|
||||
None => {
|
||||
let params = session_params(&cwd_s, &mcp_servers, &mcp_overrides);
|
||||
let v = self.request_with_auth(&peer, &init, &mut tried_auth, "session/new", params).await.map_err(
|
||||
|e| match self.sign_in_error(&e, Some(&sign_in_message)) {
|
||||
Some(msg) => SessionOpenError { message: msg, allow_acp_fallback: false },
|
||||
None => SessionOpenError { message: self.describe(e), allow_acp_fallback: true },
|
||||
},
|
||||
)?;
|
||||
let id = v
|
||||
.get("sessionId")
|
||||
.and_then(Value::as_str)
|
||||
.ok_or_else(|| SessionOpenError {
|
||||
message: "the agent returned no session".into(),
|
||||
allow_acp_fallback: true,
|
||||
})?
|
||||
.to_owned();
|
||||
let params = json!({ "cwd": &cwd_s, "mcpServers": &mcp_servers });
|
||||
let v = self
|
||||
.request_with_auth(&peer, &init, &mut tried_auth, "session/new", params)
|
||||
.await
|
||||
.map_err(|e| self.sign_in_error(&e, Some(&sign_in_message)).unwrap_or_else(|| self.describe(e)))?;
|
||||
let id = v.get("sessionId").and_then(Value::as_str).ok_or("the agent returned no session")?.to_owned();
|
||||
(id, v)
|
||||
}
|
||||
};
|
||||
@@ -2371,16 +2120,13 @@ impl Task {
|
||||
let reported = config::options_of(&result);
|
||||
let known = !reported.is_empty();
|
||||
if known {
|
||||
self.shared.remember(provider_id, Some(&reported), None, model_of(&reported).as_deref());
|
||||
self.shared.remember(&provider_id, Some(&reported), None, model_of(&reported).as_deref());
|
||||
}
|
||||
let (mut options, mut wanted) = {
|
||||
let s = self.state.lock();
|
||||
let options = if known { reported } else { s.task.config.clone() };
|
||||
// A side conversation asks before anything, whatever mode the agent starts in.
|
||||
let wanted = if s.ephemeral { config::asking_choices(&options, &s.wanted) } else { s.wanted.clone() };
|
||||
(options, wanted)
|
||||
(if known { reported } else { s.task.config.clone() }, s.wanted.clone())
|
||||
};
|
||||
config::add_client_options(provider_id, &mut options);
|
||||
config::add_client_options(&provider_id, &mut options);
|
||||
// Changing model can replace the effort / context-tier choices; validate those only afterwards.
|
||||
wanted.sort_by_key(|c| match options.iter().find(|o| o.id == c.id) {
|
||||
Some(o) if o.category.as_deref() == Some("model") => 0,
|
||||
@@ -2426,7 +2172,7 @@ impl Task {
|
||||
}
|
||||
}
|
||||
let model = model_of(&options).filter(|_| model_options);
|
||||
self.shared.remember(provider_id, Some(&options), None, model.as_deref());
|
||||
self.shared.remember(&provider_id, Some(&options), None, model.as_deref());
|
||||
{
|
||||
let mut s = self.state.lock();
|
||||
s.task.model = model_of(&options).or(s.task.model.take());
|
||||
@@ -2439,18 +2185,10 @@ impl Task {
|
||||
}
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
stop_on_err.0 = None;
|
||||
Ok(Live {
|
||||
provider: provider_id.to_owned(),
|
||||
driver: spec.driver,
|
||||
sign_in_message,
|
||||
peer,
|
||||
session: session_id,
|
||||
capabilities,
|
||||
embedded,
|
||||
resumable: can_load,
|
||||
init,
|
||||
})
|
||||
let live =
|
||||
Live { sign_in_message, peer, session: session_id, capabilities, embedded, resumable: can_load, init };
|
||||
*self.live.lock() = Some(live.clone());
|
||||
Ok(live)
|
||||
}
|
||||
|
||||
/// Sends the user's choices that the session offers only now: an option advertised
|
||||
@@ -2492,7 +2230,6 @@ impl Task {
|
||||
o.current = Some(value);
|
||||
}
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
sync_usage_context_size(&mut s.task);
|
||||
// As in `set_config`: a copy without per-model options can't vouch for them.
|
||||
let model = s.task.model.clone().filter(|_| {
|
||||
reply.get("configOptions").is_some()
|
||||
@@ -2568,20 +2305,11 @@ impl Task {
|
||||
if let Some(title) = title {
|
||||
// Check and write under one lock: a rename landing between them would be lost.
|
||||
let mut s = self.state.lock();
|
||||
let user_named = update.get("userNamed").and_then(Value::as_bool) == Some(true);
|
||||
let flag_changed = user_named && !s.title_renamed;
|
||||
if user_named {
|
||||
s.title_renamed = true;
|
||||
}
|
||||
if (user_named || !s.title_renamed) && s.task.title != title {
|
||||
if !s.title_renamed && s.task.title != title {
|
||||
s.task.title = title.to_owned();
|
||||
drop(s);
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
} else if flag_changed {
|
||||
drop(s);
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
}
|
||||
}
|
||||
return;
|
||||
@@ -2772,7 +2500,6 @@ impl Task {
|
||||
self.permissions.lock().insert(id, tx);
|
||||
self.set_status(AgentStatus::NeedsInput, None);
|
||||
self.approve_pending();
|
||||
self.emit_attention_if_input_pending();
|
||||
|
||||
let answer = rx.recv().ok().flatten();
|
||||
let answers = answer
|
||||
@@ -2856,7 +2583,6 @@ impl Task {
|
||||
});
|
||||
self.permissions.lock().insert(id, tx);
|
||||
self.set_status(AgentStatus::NeedsInput, None);
|
||||
self.emit_attention_if_input_pending();
|
||||
let reply = rx.recv().ok().flatten();
|
||||
let (response, chosen) = elicitation::answer(&form, reply.as_deref());
|
||||
self.settle(entry, chosen);
|
||||
@@ -2931,15 +2657,6 @@ struct Client {
|
||||
|
||||
impl Handler for Client {
|
||||
fn on_notification(&self, method: &str, params: Value) {
|
||||
if method == WARNING_NOTIFICATION {
|
||||
if let Some(task) = self.task.upgrade()
|
||||
&& let Some(message) = params.get("message").and_then(Value::as_str).filter(|s| !s.trim().is_empty())
|
||||
{
|
||||
task.push_entry(AgentEntry::Error { message: message.to_owned() });
|
||||
task.persist();
|
||||
}
|
||||
return;
|
||||
}
|
||||
if method == "session/update"
|
||||
&& let (Some(task), Some(update)) = (self.task.upgrade(), params.get("update"))
|
||||
{
|
||||
@@ -3150,13 +2867,9 @@ fn embeddable(path: &Path) -> Option<String> {
|
||||
/// A task file from before a field existed, with that field's empty value.
|
||||
fn upgrade(mut file: Value) -> Value {
|
||||
if let Some(task) = file.get_mut("task").and_then(Value::as_object_mut) {
|
||||
for (key, empty) in [
|
||||
("config", json!([])),
|
||||
("commands", json!([])),
|
||||
("usage", Value::Null),
|
||||
("queue", json!([])),
|
||||
("mcpOverrides", json!({})),
|
||||
] {
|
||||
for (key, empty) in
|
||||
[("config", json!([])), ("commands", json!([])), ("usage", Value::Null), ("queue", json!([]))]
|
||||
{
|
||||
task.entry(key).or_insert(empty);
|
||||
}
|
||||
}
|
||||
@@ -3270,22 +2983,6 @@ fn turn_starts(entries: &[AgentEntry]) -> Vec<usize> {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The session parameters `session/new`, `session/load` and `session/fork` share: the MCP
|
||||
/// servers, and the ones switched off for this session, so an agent that also loads its own
|
||||
/// configuration (Claude Code) can keep a same-named server of it off too.
|
||||
fn session_params(cwd: &str, servers: &[Value], overrides: &BTreeMap<String, bool>) -> Value {
|
||||
let off: Vec<&str> = overrides
|
||||
.iter()
|
||||
.filter(|(name, on)| !**on && name.as_str() != mcp::BUILTIN_MCP_NAME)
|
||||
.map(|(name, _)| name.as_str())
|
||||
.collect();
|
||||
let mut params = json!({ "cwd": cwd, "mcpServers": servers });
|
||||
if !off.is_empty() {
|
||||
params["_meta"] = json!({ "openidea": { "mcpServersOff": off } });
|
||||
}
|
||||
params
|
||||
}
|
||||
|
||||
fn is_false(b: &bool) -> bool {
|
||||
!*b
|
||||
}
|
||||
@@ -3319,20 +3016,13 @@ fn model_of(config: &[AgentConfigOption]) -> Option<String> {
|
||||
config.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.clone())
|
||||
}
|
||||
|
||||
/// Commands the agent implements on its own and never lists in `availableCommands`.
|
||||
fn builtin_commands(provider: &str) -> Vec<AgentCommand> {
|
||||
/// Commands the agent implements on its own and never lists in `availableCommands` —
|
||||
/// its CLI builtins, passed through as prompt text (e.g. `/compact`). `(name, description)`.
|
||||
fn builtin_commands(provider: &str) -> &'static [(&'static str, &'static str)] {
|
||||
match provider {
|
||||
// Codex app-server has no command-list API, so the native adapter supplies its
|
||||
// stable builtins and merges the session's dynamic skills separately.
|
||||
"codex" => native::codex::builtin_commands(),
|
||||
// OpenCode ACP handles `/compact` via session.summarize but omits it from its command list.
|
||||
"opencode" => vec![AgentCommand {
|
||||
name: "compact".into(),
|
||||
description: "compact the conversation".into(),
|
||||
hint: None,
|
||||
source: AgentCommandSource::Command,
|
||||
}],
|
||||
_ => Vec::new(),
|
||||
"opencode" => &[("compact", "compact the conversation")],
|
||||
_ => &[],
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3484,55 +3174,3 @@ fn entry_event(
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct SessionOpenError {
|
||||
message: String,
|
||||
allow_acp_fallback: bool,
|
||||
}
|
||||
|
||||
struct KillOnDrop(Option<Peer>);
|
||||
|
||||
impl Drop for KillOnDrop {
|
||||
fn drop(&mut self) {
|
||||
if let Some(peer) = self.0.take() {
|
||||
peer.kill();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn is_headless_protocol_error(code: i64) -> bool {
|
||||
matches!(
|
||||
code,
|
||||
ide_jsonrpc::codes::PARSE_ERROR
|
||||
| ide_jsonrpc::codes::INVALID_REQUEST
|
||||
| ide_jsonrpc::codes::METHOD_NOT_FOUND
|
||||
| ide_jsonrpc::codes::INVALID_PARAMS
|
||||
)
|
||||
}
|
||||
|
||||
/// Keeps `task.usage.size` aligned with the active model and `context_tier` when pricing
|
||||
/// metadata reports the selected tier's token limit.
|
||||
fn sync_usage_context_size(task: &mut AgentTask) {
|
||||
let Some(usage) = task.usage.as_mut() else { return };
|
||||
let Some(model_opt) = task.config.iter().find(|o| o.category.as_deref() == Some("model")) else { return };
|
||||
let Some(model_id) = model_opt.current.as_deref() else { return };
|
||||
let Some(pricing) = model_opt.values.iter().find(|v| v.value == model_id).and_then(|v| v.pricing.as_deref()) else {
|
||||
return;
|
||||
};
|
||||
let tier = task
|
||||
.config
|
||||
.iter()
|
||||
.find(|o| config::is_context_option(&o.id))
|
||||
.and_then(|o| o.current.as_deref())
|
||||
.unwrap_or("default");
|
||||
if let Some(tokens) = pricing
|
||||
.tiers
|
||||
.get(tier)
|
||||
.or_else(|| pricing.tiers.get("default"))
|
||||
.or_else(|| pricing.tiers.get("long_context"))
|
||||
.and_then(|t| t.context_tokens)
|
||||
.filter(|&n| n > 0)
|
||||
{
|
||||
usage.size = tokens;
|
||||
}
|
||||
}
|
||||
@@ -1,24 +1,13 @@
|
||||
//! Model Context Protocol (MCP) server configurations stored in OpenIDEA's own settings
|
||||
//! (global `settings.toml` and project `.openidea/settings.toml`), passed to ACP agents in
|
||||
//! `session/new`, `session/load`, and `session/fork`, plus discovery and one-way import from
|
||||
//! external CLI and workspace MCP configuration files.
|
||||
//! `session/new`, `session/load`, and `session/fork`, plus one-way import from `.mcp.json` /
|
||||
//! `.vscode/mcp.json`.
|
||||
|
||||
use crate::acp::Negotiated;
|
||||
use crate::{
|
||||
AgentMcpServer, McpDiscoveredServer, McpExternalSource, McpImportSelection, McpKeyValue, McpProbeResult, McpScope,
|
||||
McpServer, McpServerInput, McpToolSummary, McpTransport,
|
||||
};
|
||||
use ide_core::IpcPath;
|
||||
use crate::{AgentMcpServer, McpKeyValue, McpScope, McpServer, McpServerInput, McpTransport};
|
||||
use serde_json::{Value, json};
|
||||
use std::collections::{BTreeMap, HashSet};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
/// Reserved server name for OpenIDEA's built-in IDE MCP server in per-session overrides.
|
||||
pub const BUILTIN_MCP_NAME: &str = "openidea";
|
||||
|
||||
const PROBE_TIMEOUT: Duration = Duration::from_secs(12);
|
||||
const PROBE_PROTOCOL_VERSION: &str = "2024-11-05";
|
||||
use std::path::Path;
|
||||
|
||||
/// Stable ID for a server in a given scope (`"user::<name>"` or `"workspace::<name>"`).
|
||||
pub fn server_id(scope: McpScope, name: &str) -> String {
|
||||
@@ -67,7 +56,6 @@ fn to_mcp_server(scope: McpScope, name: &str, cfg: &AgentMcpServer) -> McpServer
|
||||
url: cfg.url.clone(),
|
||||
headers: cfg.headers.iter().map(|(k, v)| McpKeyValue { name: k.clone(), value: v.clone() }).collect(),
|
||||
agents: cfg.agents.clone(),
|
||||
unapproved: false,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -87,15 +75,8 @@ fn matches_agent(agents: &[String], provider: &str) -> bool {
|
||||
}
|
||||
|
||||
/// Builds the ACP `mcpServers` array for `session/new`, `session/load`, and `session/fork`.
|
||||
/// Workspace entries take precedence over User entries with the same name. Per-session
|
||||
/// `overrides` (`server_name` -> `enabled`) can enable a disabled server or disable an enabled one
|
||||
/// for this session only.
|
||||
pub(crate) fn acp_mcp_servers(
|
||||
all: &[McpServer],
|
||||
provider: &str,
|
||||
init: &Negotiated,
|
||||
overrides: &BTreeMap<String, bool>,
|
||||
) -> Vec<Value> {
|
||||
/// Workspace entries take precedence over User entries with the same name.
|
||||
pub(crate) fn acp_mcp_servers(all: &[McpServer], provider: &str, init: &Negotiated) -> Vec<Value> {
|
||||
let supports_stdio = init.mcp_stdio();
|
||||
let supports_http = init.mcp("http");
|
||||
let supports_sse = init.mcp("sse");
|
||||
@@ -106,16 +87,7 @@ pub(crate) fn acp_mcp_servers(
|
||||
all.iter().filter(|s| s.scope == McpScope::Workspace).chain(all.iter().filter(|s| s.scope == McpScope::User));
|
||||
|
||||
for srv in ordered {
|
||||
if srv.unapproved {
|
||||
continue;
|
||||
}
|
||||
let explicit = overrides.get(&srv.name).copied();
|
||||
let active = explicit.unwrap_or(srv.enabled);
|
||||
if !active || !seen.insert(srv.name.clone()) {
|
||||
continue;
|
||||
}
|
||||
// An explicit per-session enable (`Some(true)`) overrides the server's default agent filter.
|
||||
if explicit != Some(true) && !matches_agent(&srv.agents, provider) {
|
||||
if !srv.enabled || !matches_agent(&srv.agents, provider) || !seen.insert(srv.name.clone()) {
|
||||
continue;
|
||||
}
|
||||
match srv.transport {
|
||||
@@ -304,306 +276,6 @@ pub fn apply_import(workspace: &mut BTreeMap<String, AgentMcpServer>, workspace_
|
||||
added
|
||||
}
|
||||
|
||||
/// Parses a raw MCP JSON snippet pasted by the user and merges its servers into `user` or
|
||||
/// `workspace`. Supports `{"mcpServers": {...}}`, `{"servers": {...}}`, top-level server maps
|
||||
/// (`{"my-server": {"command": ...}}`), and single-server objects when `fallback_name` is given.
|
||||
pub fn apply_save_json(
|
||||
user: &mut BTreeMap<String, AgentMcpServer>,
|
||||
workspace: &mut BTreeMap<String, AgentMcpServer>,
|
||||
has_workspace: bool,
|
||||
scope: McpScope,
|
||||
raw_json: &str,
|
||||
fallback_name: Option<&str>,
|
||||
agents: Vec<String>,
|
||||
) -> Result<Vec<String>, String> {
|
||||
if scope == McpScope::Workspace && !has_workspace {
|
||||
return Err("Open a project to configure workspace MCP servers".into());
|
||||
}
|
||||
let parsed = parse_mcp_json_text(raw_json, fallback_name)?;
|
||||
if parsed.is_empty() {
|
||||
return Err("No valid MCP servers found in JSON".into());
|
||||
}
|
||||
let normalized_agents = normalize_agents_list(agents);
|
||||
let target = match scope {
|
||||
McpScope::User => user,
|
||||
McpScope::Workspace => workspace,
|
||||
};
|
||||
let mut saved_names = Vec::with_capacity(parsed.len());
|
||||
for (name, mut srv) in parsed {
|
||||
if srv.agents.is_empty() && !normalized_agents.is_empty() {
|
||||
srv.agents = normalized_agents.clone();
|
||||
}
|
||||
saved_names.push(name.clone());
|
||||
target.insert(name, srv);
|
||||
}
|
||||
Ok(saved_names)
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
enum SourceFormat {
|
||||
Jsonc,
|
||||
CodexToml,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct SourceSpec {
|
||||
id: &'static str,
|
||||
label: &'static str,
|
||||
path: PathBuf,
|
||||
format: SourceFormat,
|
||||
suggested_scope: McpScope,
|
||||
native_provider: Option<&'static str>,
|
||||
claude_project_lookup: bool,
|
||||
}
|
||||
|
||||
fn external_source_specs(home_dir: Option<&Path>, workspace_root: Option<&Path>) -> Vec<SourceSpec> {
|
||||
let mut specs = Vec::new();
|
||||
if let Some(root) = workspace_root {
|
||||
specs.push(SourceSpec {
|
||||
id: "workspace-mcp",
|
||||
label: "Project (.mcp.json)",
|
||||
path: root.join(".mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: Some("claude"),
|
||||
claude_project_lookup: false,
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "vscode-mcp",
|
||||
label: "VS Code (.vscode/mcp.json)",
|
||||
path: root.join(".vscode").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: None,
|
||||
claude_project_lookup: false,
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "cursor-project",
|
||||
label: "Cursor Project (.cursor/mcp.json)",
|
||||
path: root.join(".cursor").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: Some("cursor"),
|
||||
claude_project_lookup: false,
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "codex-project",
|
||||
label: "Codex Project (.codex/config.toml)",
|
||||
path: root.join(".codex").join("config.toml"),
|
||||
format: SourceFormat::CodexToml,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: Some("codex"),
|
||||
claude_project_lookup: false,
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "gemini-project",
|
||||
label: "Gemini Project (.gemini/settings.json)",
|
||||
path: root.join(".gemini").join("settings.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: Some("gemini"),
|
||||
claude_project_lookup: false,
|
||||
});
|
||||
}
|
||||
if let Some(home) = home_dir {
|
||||
specs.push(SourceSpec {
|
||||
id: "copilot-cli",
|
||||
label: "GitHub Copilot CLI",
|
||||
path: home.join(".copilot").join("mcp-config.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("copilot"),
|
||||
claude_project_lookup: false,
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "claude-code",
|
||||
label: "Claude Code",
|
||||
path: home.join(".claude.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("claude"),
|
||||
claude_project_lookup: true,
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "codex",
|
||||
label: "Codex",
|
||||
path: home.join(".codex").join("config.toml"),
|
||||
format: SourceFormat::CodexToml,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("codex"),
|
||||
claude_project_lookup: false,
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "cursor",
|
||||
label: "Cursor",
|
||||
path: home.join(".cursor").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("cursor"),
|
||||
claude_project_lookup: false,
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "gemini",
|
||||
label: "Gemini CLI",
|
||||
path: home.join(".gemini").join("settings.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("gemini"),
|
||||
claude_project_lookup: false,
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "jetbrains-air",
|
||||
label: "JetBrains Air",
|
||||
path: home.join(".jetbrains").join("mcp").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: None,
|
||||
claude_project_lookup: false,
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "copilot-intellij",
|
||||
label: "GitHub Copilot (JetBrains)",
|
||||
path: home.join(".config").join("github-copilot").join("intellij").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: None,
|
||||
claude_project_lookup: false,
|
||||
});
|
||||
}
|
||||
specs
|
||||
}
|
||||
|
||||
fn read_source_servers(spec: &SourceSpec, workspace_root: Option<&Path>) -> BTreeMap<String, AgentMcpServer> {
|
||||
let Ok(text) = std::fs::read_to_string(&spec.path) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
if spec.format == SourceFormat::CodexToml {
|
||||
return parse_codex_toml_servers(&text);
|
||||
}
|
||||
let Ok(root) = parse_jsonc_value(&text) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
let mut servers = extract_servers_from_root(&root, None);
|
||||
if spec.claude_project_lookup
|
||||
&& let Some(ws) = workspace_root
|
||||
&& let Some(projects) = root.get("projects").and_then(Value::as_object)
|
||||
{
|
||||
let ws_canon = dunce::canonicalize(ws).unwrap_or_else(|_| ws.to_path_buf());
|
||||
for (proj_key, proj_val) in projects {
|
||||
let matches = Path::new(proj_key) == ws || dunce::canonicalize(proj_key).is_ok_and(|c| c == ws_canon);
|
||||
if matches {
|
||||
for (name, srv) in extract_servers_from_root(proj_val, None) {
|
||||
servers.insert(name, srv);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
servers
|
||||
}
|
||||
|
||||
fn parse_codex_toml_servers(text: &str) -> BTreeMap<String, AgentMcpServer> {
|
||||
let Ok(doc) = toml::from_str::<toml::Value>(text) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
let Ok(json_doc) = serde_json::to_value(doc) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
let Some(table) = json_doc.get("mcp_servers").or_else(|| json_doc.get("mcpServers")).and_then(Value::as_object)
|
||||
else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
let mut out = BTreeMap::new();
|
||||
for (name, raw) in table {
|
||||
let name = name.trim();
|
||||
let Some(mut obj) = raw.as_object().cloned().filter(|_| !name.is_empty()) else {
|
||||
continue;
|
||||
};
|
||||
if !obj.contains_key("headers")
|
||||
&& let Some(http_headers) = obj.remove("http_headers")
|
||||
{
|
||||
obj.insert("headers".to_owned(), http_headers);
|
||||
}
|
||||
if let Some(srv) = parse_one_server_def(&obj) {
|
||||
out.insert(name.to_owned(), srv);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Discovers external MCP configuration files on disk (without exposing secret values).
|
||||
pub fn discover_external_sources(home_dir: Option<&Path>, workspace_root: Option<&Path>) -> Vec<McpExternalSource> {
|
||||
let mut out = Vec::new();
|
||||
for spec in external_source_specs(home_dir, workspace_root) {
|
||||
let map = read_source_servers(&spec, workspace_root);
|
||||
if map.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let servers = map
|
||||
.into_iter()
|
||||
.map(|(name, cfg)| McpDiscoveredServer {
|
||||
name,
|
||||
transport: cfg.transport,
|
||||
enabled: cfg.enabled,
|
||||
command: cfg.command,
|
||||
args: cfg.args,
|
||||
url: cfg.url,
|
||||
env_keys: cfg.env.into_keys().collect(),
|
||||
header_keys: cfg.headers.into_keys().collect(),
|
||||
})
|
||||
.collect();
|
||||
out.push(McpExternalSource {
|
||||
id: spec.id.to_owned(),
|
||||
label: spec.label.to_owned(),
|
||||
path: IpcPath(spec.path),
|
||||
suggested_scope: spec.suggested_scope,
|
||||
native_provider: spec.native_provider.map(str::to_owned),
|
||||
servers,
|
||||
});
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Imports selected `(source_id, name)` entries from discovered external MCP config files into
|
||||
/// `user` or `workspace` without modifying the external files. Returns imported server names.
|
||||
pub fn apply_import_selected(
|
||||
user: &mut BTreeMap<String, AgentMcpServer>,
|
||||
workspace: &mut BTreeMap<String, AgentMcpServer>,
|
||||
home_dir: Option<&Path>,
|
||||
workspace_root: Option<&Path>,
|
||||
scope: McpScope,
|
||||
selections: &[McpImportSelection],
|
||||
overwrite: bool,
|
||||
) -> Result<Vec<String>, String> {
|
||||
if scope == McpScope::Workspace && workspace_root.is_none() {
|
||||
return Err("Open a project to import workspace MCP servers".into());
|
||||
}
|
||||
let specs = external_source_specs(home_dir, workspace_root);
|
||||
let mut by_source: BTreeMap<&str, BTreeMap<String, AgentMcpServer>> = BTreeMap::new();
|
||||
for spec in &specs {
|
||||
if selections.iter().any(|s| s.source_id == spec.id) {
|
||||
by_source.insert(spec.id, read_source_servers(spec, workspace_root));
|
||||
}
|
||||
}
|
||||
let target = match scope {
|
||||
McpScope::User => user,
|
||||
McpScope::Workspace => workspace,
|
||||
};
|
||||
let mut imported = Vec::new();
|
||||
for sel in selections {
|
||||
let Some(source_map) = by_source.get(sel.source_id.as_str()) else {
|
||||
continue;
|
||||
};
|
||||
let Some(srv) = source_map.get(&sel.name) else {
|
||||
continue;
|
||||
};
|
||||
if overwrite || !target.contains_key(&sel.name) {
|
||||
target.insert(sel.name.clone(), srv.clone());
|
||||
imported.push(sel.name.clone());
|
||||
}
|
||||
}
|
||||
Ok(imported)
|
||||
}
|
||||
|
||||
fn normalize_agents_list(agents: Vec<String>) -> Vec<String> {
|
||||
let mut out = Vec::new();
|
||||
for a in agents {
|
||||
@@ -615,376 +287,73 @@ fn normalize_agents_list(agents: Vec<String>) -> Vec<String> {
|
||||
out
|
||||
}
|
||||
|
||||
/// Strips `//` line comments, `/* ... */` block comments, and trailing commas before `}` or `]`
|
||||
/// outside JSON string literals so JSONC config files parse cleanly with `serde_json`.
|
||||
pub(crate) fn strip_jsonc(input: &str) -> String {
|
||||
let bytes = input.as_bytes();
|
||||
let mut out = String::with_capacity(input.len());
|
||||
let mut i = 0;
|
||||
let mut in_str = false;
|
||||
while i < bytes.len() {
|
||||
if in_str {
|
||||
let ch = input[i..].chars().next().unwrap();
|
||||
out.push(ch);
|
||||
i += ch.len_utf8();
|
||||
if ch == '\\' && i < bytes.len() {
|
||||
let next = input[i..].chars().next().unwrap();
|
||||
out.push(next);
|
||||
i += next.len_utf8();
|
||||
} else if ch == '"' {
|
||||
in_str = false;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if bytes[i] == b'"' {
|
||||
in_str = true;
|
||||
out.push('"');
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
if bytes[i] == b'/' && i + 1 < bytes.len() && bytes[i + 1] == b'/' {
|
||||
i += 2;
|
||||
while i < bytes.len() && bytes[i] != b'\n' {
|
||||
i += 1;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if bytes[i] == b'/' && i + 1 < bytes.len() && bytes[i + 1] == b'*' {
|
||||
i += 2;
|
||||
while i + 1 < bytes.len() && !(bytes[i] == b'*' && bytes[i + 1] == b'/') {
|
||||
if bytes[i] == b'\n' {
|
||||
out.push('\n');
|
||||
i += 1;
|
||||
} else {
|
||||
let ch = input[i..].chars().next().unwrap();
|
||||
i += ch.len_utf8();
|
||||
}
|
||||
}
|
||||
i = (i + 2).min(bytes.len());
|
||||
continue;
|
||||
}
|
||||
let ch = input[i..].chars().next().unwrap();
|
||||
out.push(ch);
|
||||
i += ch.len_utf8();
|
||||
}
|
||||
remove_trailing_commas(&out)
|
||||
}
|
||||
|
||||
fn remove_trailing_commas(input: &str) -> String {
|
||||
let bytes = input.as_bytes();
|
||||
let mut out = String::with_capacity(input.len());
|
||||
let mut i = 0;
|
||||
let mut in_str = false;
|
||||
while i < bytes.len() {
|
||||
if in_str {
|
||||
let ch = input[i..].chars().next().unwrap();
|
||||
out.push(ch);
|
||||
i += ch.len_utf8();
|
||||
if ch == '\\' && i < bytes.len() {
|
||||
let next = input[i..].chars().next().unwrap();
|
||||
out.push(next);
|
||||
i += next.len_utf8();
|
||||
} else if ch == '"' {
|
||||
in_str = false;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if bytes[i] == b'"' {
|
||||
in_str = true;
|
||||
out.push('"');
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
if bytes[i] == b',' {
|
||||
let mut j = i + 1;
|
||||
while j < bytes.len() && bytes[j].is_ascii_whitespace() {
|
||||
j += 1;
|
||||
}
|
||||
if j < bytes.len() && (bytes[j] == b'}' || bytes[j] == b']') {
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
let ch = input[i..].chars().next().unwrap();
|
||||
out.push(ch);
|
||||
i += ch.len_utf8();
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn parse_jsonc_value(raw: &str) -> Result<Value, String> {
|
||||
let trimmed = raw.trim().trim_start_matches('\u{feff}');
|
||||
serde_json::from_str::<Value>(trimmed)
|
||||
.or_else(|_| serde_json::from_str::<Value>(&strip_jsonc(trimmed)))
|
||||
.map_err(|e| format!("Invalid JSON: {e}"))
|
||||
}
|
||||
|
||||
pub fn parse_mcp_json_text(raw: &str, fallback_name: Option<&str>) -> Result<BTreeMap<String, AgentMcpServer>, String> {
|
||||
let root = parse_jsonc_value(raw)?;
|
||||
Ok(extract_servers_from_root(&root, fallback_name))
|
||||
}
|
||||
|
||||
fn is_server_def_object(obj: &serde_json::Map<String, Value>) -> bool {
|
||||
obj.get("command").and_then(Value::as_str).is_some_and(|s| !s.trim().is_empty())
|
||||
|| obj.get("url").and_then(Value::as_str).is_some_and(|s| !s.trim().is_empty())
|
||||
|| obj.get("serverUrl").and_then(Value::as_str).is_some_and(|s| !s.trim().is_empty())
|
||||
}
|
||||
|
||||
fn parse_one_server_def(obj: &serde_json::Map<String, Value>) -> Option<AgentMcpServer> {
|
||||
let disabled = obj.get("disabled").and_then(Value::as_bool).unwrap_or(false)
|
||||
|| obj.get("enabled").and_then(Value::as_bool) == Some(false);
|
||||
let type_str = obj.get("type").and_then(Value::as_str).unwrap_or_default().to_ascii_lowercase();
|
||||
let url = obj
|
||||
.get("url")
|
||||
.or_else(|| obj.get("serverUrl"))
|
||||
.and_then(Value::as_str)
|
||||
.map(str::trim)
|
||||
.filter(|s| !s.is_empty())
|
||||
.map(str::to_owned);
|
||||
let command =
|
||||
obj.get("command").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned);
|
||||
|
||||
let transport = match type_str.as_str() {
|
||||
"sse" => McpTransport::Sse,
|
||||
"http" | "streamable-http" | "streamable_http" => McpTransport::Http,
|
||||
"stdio" | "local" => McpTransport::Stdio,
|
||||
_ if url.is_some() && command.is_none() => McpTransport::Http,
|
||||
_ => McpTransport::Stdio,
|
||||
fn read_external_file(path: &Path) -> BTreeMap<String, AgentMcpServer> {
|
||||
let Ok(bytes) = std::fs::read(path) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
let Ok(root) = serde_json::from_slice::<Value>(&bytes) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
let Some(servers_obj) = root.get("mcpServers").or_else(|| root.get("servers")).and_then(Value::as_object) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
|
||||
match transport {
|
||||
McpTransport::Stdio => command.as_ref()?,
|
||||
McpTransport::Http | McpTransport::Sse => url.as_ref()?,
|
||||
};
|
||||
|
||||
let args = obj
|
||||
.get("args")
|
||||
.and_then(Value::as_array)
|
||||
.map(|arr| arr.iter().filter_map(|v| v.as_str().map(str::to_owned)).collect())
|
||||
.unwrap_or_default();
|
||||
|
||||
let agents = obj
|
||||
.get("agents")
|
||||
.and_then(Value::as_array)
|
||||
.map(|arr| normalize_agents_list(arr.iter().filter_map(|v| v.as_str().map(str::to_owned)).collect()))
|
||||
.unwrap_or_default();
|
||||
|
||||
Some(AgentMcpServer {
|
||||
transport,
|
||||
enabled: !disabled,
|
||||
command,
|
||||
args,
|
||||
env: parse_key_values_map(obj.get("env")),
|
||||
url,
|
||||
headers: parse_key_values_map(obj.get("headers")),
|
||||
agents,
|
||||
})
|
||||
}
|
||||
|
||||
fn extract_servers_from_root(root: &Value, fallback_name: Option<&str>) -> BTreeMap<String, AgentMcpServer> {
|
||||
let mut out = BTreeMap::new();
|
||||
let Some(root_obj) = root.as_object() else {
|
||||
return out;
|
||||
};
|
||||
|
||||
// Single server definition object pasted directly (`{"command": "npx", ...}`).
|
||||
if is_server_def_object(root_obj) {
|
||||
let name = root_obj
|
||||
.get("name")
|
||||
for (name, def) in servers_obj {
|
||||
let name = name.trim();
|
||||
let Some(obj) = def.as_object().filter(|_| !name.is_empty()) else {
|
||||
continue;
|
||||
};
|
||||
let disabled = obj.get("disabled").and_then(Value::as_bool).unwrap_or(false)
|
||||
|| obj.get("enabled").and_then(Value::as_bool) == Some(false);
|
||||
let type_str = obj.get("type").and_then(Value::as_str).unwrap_or_default().to_ascii_lowercase();
|
||||
let url = obj
|
||||
.get("url")
|
||||
.or_else(|| obj.get("serverUrl"))
|
||||
.and_then(Value::as_str)
|
||||
.map(str::trim)
|
||||
.filter(|s| !s.is_empty())
|
||||
.or_else(|| fallback_name.map(str::trim).filter(|s| !s.is_empty()));
|
||||
if let (Some(name), Some(srv)) = (name, parse_one_server_def(root_obj)) {
|
||||
out.insert(name.to_owned(), srv);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
.map(str::to_owned);
|
||||
let command =
|
||||
obj.get("command").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned);
|
||||
|
||||
let servers_obj =
|
||||
root_obj.get("mcpServers").or_else(|| root_obj.get("servers")).and_then(Value::as_object).unwrap_or(root_obj);
|
||||
|
||||
for (name, def) in servers_obj {
|
||||
let name = name.trim();
|
||||
if name.is_empty() || matches!(name, "$schema" | "inputs" | "version") {
|
||||
continue;
|
||||
}
|
||||
let Some(obj) = def.as_object() else {
|
||||
continue;
|
||||
let transport = match type_str.as_str() {
|
||||
"sse" => McpTransport::Sse,
|
||||
"http" | "streamable-http" | "streamable_http" => McpTransport::Http,
|
||||
"stdio" | "local" => McpTransport::Stdio,
|
||||
_ if url.is_some() && command.is_none() => McpTransport::Http,
|
||||
_ => McpTransport::Stdio,
|
||||
};
|
||||
if !is_server_def_object(obj) {
|
||||
continue;
|
||||
}
|
||||
if let Some(srv) = parse_one_server_def(obj) {
|
||||
out.insert(name.to_owned(), srv);
|
||||
|
||||
match transport {
|
||||
McpTransport::Stdio if command.is_none() => continue,
|
||||
McpTransport::Http | McpTransport::Sse if url.is_none() => continue,
|
||||
_ => {}
|
||||
}
|
||||
|
||||
let args = obj
|
||||
.get("args")
|
||||
.and_then(Value::as_array)
|
||||
.map(|arr| arr.iter().filter_map(|v| v.as_str().map(str::to_owned)).collect())
|
||||
.unwrap_or_default();
|
||||
|
||||
out.insert(
|
||||
name.to_owned(),
|
||||
AgentMcpServer {
|
||||
transport,
|
||||
enabled: !disabled,
|
||||
command,
|
||||
args,
|
||||
env: parse_key_values_map(obj.get("env")),
|
||||
url,
|
||||
headers: parse_key_values_map(obj.get("headers")),
|
||||
agents: Vec::new(),
|
||||
},
|
||||
);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn read_external_file(path: &Path) -> BTreeMap<String, AgentMcpServer> {
|
||||
let Ok(text) = std::fs::read_to_string(path) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
let Ok(root) = parse_jsonc_value(&text) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
extract_servers_from_root(&root, None)
|
||||
}
|
||||
|
||||
/// Probes a stdio MCP server by launching its command, performing the MCP `initialize` handshake,
|
||||
/// and requesting `tools/list`. For HTTP/SSE servers, use `ide-host`'s HTTP probe helper.
|
||||
pub async fn probe_stdio_server(server: &AgentMcpServer, cwd: &Path) -> McpProbeResult {
|
||||
let started = Instant::now();
|
||||
let elapsed_ms = || u32::try_from(started.elapsed().as_millis()).unwrap_or(u32::MAX);
|
||||
let Some(raw_cmd) = server.command.as_deref().map(str::trim).filter(|s| !s.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("Command is empty".into()),
|
||||
};
|
||||
};
|
||||
|
||||
let mut env: Vec<(String, String)> = ide_core::process::shell_env()
|
||||
.map(|(k, v)| (k.to_string_lossy().into_owned(), v.to_string_lossy().into_owned()))
|
||||
.collect();
|
||||
for (k, v) in &server.env {
|
||||
if let Some((_, existing)) = env.iter_mut().find(|(ek, _)| ek == k) {
|
||||
*existing = v.clone();
|
||||
} else {
|
||||
env.push((k.clone(), v.clone()));
|
||||
}
|
||||
}
|
||||
let search_path = env
|
||||
.iter()
|
||||
.find(|(k, _)| k.eq_ignore_ascii_case("PATH"))
|
||||
.map(|(_, v)| std::ffi::OsString::from(v))
|
||||
.or_else(|| ide_core::process::host_var_os("PATH"))
|
||||
.unwrap_or_default();
|
||||
let program = ide_core::process::find_executable(raw_cmd, &search_path)
|
||||
.map(|p| p.to_string_lossy().into_owned())
|
||||
.unwrap_or_else(|| raw_cmd.to_owned());
|
||||
|
||||
let stderr_lines = std::sync::Arc::new(parking_lot::Mutex::new(Vec::<String>::new()));
|
||||
let stderr_capture = stderr_lines.clone();
|
||||
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(move |line| {
|
||||
let mut guard = stderr_capture.lock();
|
||||
if guard.len() < 12 && !line.trim().is_empty() {
|
||||
guard.push(line);
|
||||
}
|
||||
});
|
||||
|
||||
let peer = match ide_jsonrpc::Peer::spawn_framed(
|
||||
&program,
|
||||
&server.args,
|
||||
cwd,
|
||||
&env,
|
||||
std::sync::Arc::new(ide_jsonrpc::NoopHandler),
|
||||
on_stderr,
|
||||
ide_jsonrpc::Framing::Lines,
|
||||
) {
|
||||
Ok(peer) => peer,
|
||||
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!("Failed to launch `{raw_cmd}`: {e}")),
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
let outcome = tokio::time::timeout(PROBE_TIMEOUT, async {
|
||||
let init: Value = peer
|
||||
.request(
|
||||
"initialize",
|
||||
json!({
|
||||
"protocolVersion": PROBE_PROTOCOL_VERSION,
|
||||
"capabilities": {},
|
||||
"clientInfo": crate::client_info(),
|
||||
}),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
let _ = peer.notify("notifications/initialized", json!({}));
|
||||
let tools_reply: Value = peer.request("tools/list", json!({}), None).await.unwrap_or_else(|_| json!({}));
|
||||
Ok::<(Value, Value), String>((init, tools_reply))
|
||||
})
|
||||
.await;
|
||||
|
||||
peer.kill();
|
||||
|
||||
match outcome {
|
||||
Ok(Ok((init, tools_reply))) => parse_probe_payloads(&init, &tools_reply, elapsed_ms()),
|
||||
Ok(Err(err)) => {
|
||||
let tail = stderr_lines.lock().join("\n");
|
||||
let error = if tail.is_empty() { err } else { format!("{err}\n{tail}") };
|
||||
McpProbeResult {
|
||||
ok: false,
|
||||
server_name: None,
|
||||
server_version: None,
|
||||
protocol_version: None,
|
||||
tools: Vec::new(),
|
||||
duration_ms: elapsed_ms(),
|
||||
error: Some(error),
|
||||
}
|
||||
}
|
||||
Err(_) => {
|
||||
let tail = stderr_lines.lock().join("\n");
|
||||
let error = if tail.is_empty() {
|
||||
format!("Timed out after {}s waiting for MCP handshake", PROBE_TIMEOUT.as_secs())
|
||||
} else {
|
||||
format!("Timed out after {}s waiting for MCP handshake:\n{tail}", PROBE_TIMEOUT.as_secs())
|
||||
};
|
||||
McpProbeResult {
|
||||
ok: false,
|
||||
server_name: None,
|
||||
server_version: None,
|
||||
protocol_version: None,
|
||||
tools: Vec::new(),
|
||||
duration_ms: elapsed_ms(),
|
||||
error: Some(error),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse_probe_payloads(init: &Value, tools_reply: &Value, duration_ms: u32) -> McpProbeResult {
|
||||
let server_name = init.pointer("/serverInfo/name").and_then(Value::as_str).map(str::to_owned);
|
||||
let server_version = init.pointer("/serverInfo/version").and_then(Value::as_str).map(str::to_owned);
|
||||
let protocol_version = init.get("protocolVersion").and_then(Value::as_str).map(str::to_owned);
|
||||
let tools = tools_reply
|
||||
.get("tools")
|
||||
.and_then(Value::as_array)
|
||||
.map(|arr| {
|
||||
arr.iter()
|
||||
.filter_map(|t| {
|
||||
let name = t.get("name")?.as_str()?.trim();
|
||||
if name.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let description = t
|
||||
.get("description")
|
||||
.and_then(Value::as_str)
|
||||
.map(str::trim)
|
||||
.filter(|s| !s.is_empty())
|
||||
.map(str::to_owned);
|
||||
Some(McpToolSummary { name: name.to_owned(), description })
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
McpProbeResult { ok: true, server_name, server_version, protocol_version, tools, duration_ms, error: None }
|
||||
}
|
||||
|
||||
fn parse_key_values_map(val: Option<&Value>) -> BTreeMap<String, String> {
|
||||
match val {
|
||||
Some(Value::Object(map)) => map
|
||||
@@ -1088,29 +457,22 @@ mod tests {
|
||||
let init_http = Negotiated::from_initialize(&json!({
|
||||
"agentCapabilities": { "mcpCapabilities": { "http": true, "sse": false } }
|
||||
}));
|
||||
let empty_overrides = BTreeMap::new();
|
||||
let claude_servers = acp_mcp_servers(&list, "claude-acp", &init_http, &empty_overrides);
|
||||
let claude_servers = acp_mcp_servers(&list, "claude-acp", &init_http);
|
||||
assert_eq!(claude_servers.len(), 2);
|
||||
assert_eq!(claude_servers[0]["name"], "shared");
|
||||
assert_eq!(claude_servers[0]["args"], json!(["-y", "workspace-pkg"]));
|
||||
assert_eq!(claude_servers[1]["name"], "claude-http");
|
||||
assert_eq!(claude_servers[1]["type"], "http");
|
||||
|
||||
let codex_servers = acp_mcp_servers(&list, "codex", &init_http, &empty_overrides);
|
||||
let codex_servers = acp_mcp_servers(&list, "codex", &init_http);
|
||||
assert_eq!(codex_servers.len(), 1);
|
||||
assert_eq!(codex_servers[0]["name"], "shared");
|
||||
|
||||
// Per-session overrides can disable an enabled server or enable an agent-scoped server.
|
||||
let overrides = BTreeMap::from([("shared".to_owned(), false), ("claude-http".to_owned(), true)]);
|
||||
let codex_overridden = acp_mcp_servers(&list, "codex", &init_http, &overrides);
|
||||
assert_eq!(codex_overridden.len(), 1);
|
||||
assert_eq!(codex_overridden[0]["name"], "claude-http");
|
||||
|
||||
// Disable workspace `shared` and remove user `claude-http`.
|
||||
apply_set_enabled(&mut user, &mut workspace, "workspace::shared", false).unwrap();
|
||||
apply_remove(&mut user, &mut workspace, "user::claude-http").unwrap();
|
||||
let list = servers_from_settings(&user, &workspace);
|
||||
let after = acp_mcp_servers(&list, "claude", &init_http, &empty_overrides);
|
||||
let after = acp_mcp_servers(&list, "claude", &init_http);
|
||||
assert_eq!(after.len(), 1);
|
||||
assert_eq!(after[0]["args"], json!(["-y", "user-pkg"]));
|
||||
}
|
||||
@@ -1142,124 +504,4 @@ mod tests {
|
||||
assert_eq!(std::fs::read_to_string(&mcp_json).unwrap(), raw_mcp);
|
||||
assert_eq!(std::fs::read_to_string(&vscode_mcp).unwrap(), raw_vscode);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn discovers_cli_sources_top_level_maps_and_jsonc_and_imports_selected() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let home = tmp.path().join("home");
|
||||
let proj = tmp.path().join("project");
|
||||
std::fs::create_dir_all(home.join(".copilot")).unwrap();
|
||||
std::fs::create_dir_all(home.join(".codex")).unwrap();
|
||||
std::fs::create_dir_all(home.join(".gemini")).unwrap();
|
||||
std::fs::create_dir_all(home.join(".jetbrains").join("mcp")).unwrap();
|
||||
std::fs::create_dir_all(home.join(".config").join("github-copilot").join("intellij")).unwrap();
|
||||
std::fs::create_dir_all(&proj).unwrap();
|
||||
|
||||
std::fs::write(
|
||||
home.join(".copilot").join("mcp-config.json"),
|
||||
r#"{"mcpServers":{"github":{"type":"http","url":"https://api.githubcopilot.com/mcp/","headers":{"Authorization":"Bearer tok"}},"slack":{"type":"local","command":"npx","args":["-y","slack-mcp"],"env":{"SLACK_TOKEN":"xoxb"}}}}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// Codex `~/.codex/config.toml` `[mcp_servers]` format.
|
||||
std::fs::write(
|
||||
home.join(".codex").join("config.toml"),
|
||||
"[mcp_servers.postgres]\ncommand = \"npx\"\nargs = [\"-y\", \"@modelcontextprotocol/server-postgres\"]\n\n[mcp_servers.remote_api]\nurl = \"https://mcp.example.com/sse\"\ntype = \"sse\"\nhttp_headers = { Authorization = \"Bearer codex-tok\" }\n",
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// Gemini `~/.gemini/settings.json` with unrelated top-level settings alongside `mcpServers`.
|
||||
std::fs::write(
|
||||
home.join(".gemini").join("settings.json"),
|
||||
r#"{"theme":"Default","mcpServers":{"fetch":{"command":"uvx","args":["mcp-server-fetch"]}}}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// JetBrains Air top-level server map (not nested under `mcpServers`).
|
||||
std::fs::write(
|
||||
home.join(".jetbrains").join("mcp").join("mcp.json"),
|
||||
r#"{"linear":{"type":"stdio","command":"npx","args":["-y","mcp-remote","https://mcp.linear.app/mcp"]}}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// JSONC comments + trailing commas.
|
||||
std::fs::write(
|
||||
home.join(".config").join("github-copilot").join("intellij").join("mcp.json"),
|
||||
"// comment with https://url/inside\n{\n /* block comment */\n \"servers\": {\n \"docs\": { \"command\": \"uvx\", \"args\": [\"docs-mcp\",], },\n },\n}\n",
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let sources = discover_external_sources(Some(&home), Some(&proj));
|
||||
assert_eq!(sources.len(), 5);
|
||||
let copilot = sources.iter().find(|s| s.id == "copilot-cli").unwrap();
|
||||
assert_eq!(copilot.native_provider.as_deref(), Some("copilot"));
|
||||
assert_eq!(copilot.servers.len(), 2);
|
||||
let gh_srv = copilot.servers.iter().find(|s| s.name == "github").unwrap();
|
||||
assert_eq!(gh_srv.header_keys, vec!["Authorization".to_string()]);
|
||||
|
||||
let codex = sources.iter().find(|s| s.id == "codex").unwrap();
|
||||
assert_eq!(codex.native_provider.as_deref(), Some("codex"));
|
||||
assert_eq!(codex.servers.len(), 2);
|
||||
|
||||
let gemini = sources.iter().find(|s| s.id == "gemini").unwrap();
|
||||
assert_eq!(gemini.servers[0].name, "fetch");
|
||||
|
||||
let air = sources.iter().find(|s| s.id == "jetbrains-air").unwrap();
|
||||
assert_eq!(air.servers[0].name, "linear");
|
||||
|
||||
let ij = sources.iter().find(|s| s.id == "copilot-intellij").unwrap();
|
||||
assert_eq!(ij.servers[0].name, "docs");
|
||||
|
||||
let mut user = BTreeMap::new();
|
||||
let mut workspace = BTreeMap::new();
|
||||
let imported = apply_import_selected(
|
||||
&mut user,
|
||||
&mut workspace,
|
||||
Some(&home),
|
||||
Some(&proj),
|
||||
McpScope::User,
|
||||
&[
|
||||
McpImportSelection { source_id: "copilot-cli".into(), name: "github".into() },
|
||||
McpImportSelection { source_id: "jetbrains-air".into(), name: "linear".into() },
|
||||
],
|
||||
false,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(imported, vec!["github".to_string(), "linear".to_string()]);
|
||||
assert_eq!(user["github"].headers.get("Authorization").map(String::as_str), Some("Bearer tok"));
|
||||
assert_eq!(user["linear"].command.as_deref(), Some("npx"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn apply_save_json_accepts_mcp_servers_map_and_single_server_object() {
|
||||
let mut user = BTreeMap::new();
|
||||
let mut workspace = BTreeMap::new();
|
||||
|
||||
let names = apply_save_json(
|
||||
&mut user,
|
||||
&mut workspace,
|
||||
true,
|
||||
McpScope::User,
|
||||
r#"{"mcpServers":{"playwright":{"command":"npx","args":["@playwright/mcp@latest"]}}}"#,
|
||||
None,
|
||||
vec!["copilot".into(), "claude".into()],
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(names, vec!["playwright".to_string()]);
|
||||
assert_eq!(user["playwright"].agents, vec!["copilot".to_string(), "claude".to_string()]);
|
||||
|
||||
let single = apply_save_json(
|
||||
&mut user,
|
||||
&mut workspace,
|
||||
true,
|
||||
McpScope::Workspace,
|
||||
r#"{"type":"sse","serverUrl":"https://sse.example.com/events"}"#,
|
||||
Some("events-sse"),
|
||||
Vec::new(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(single, vec!["events-sse".to_string()]);
|
||||
assert_eq!(workspace["events-sse"].transport, McpTransport::Sse);
|
||||
assert_eq!(workspace["events-sse"].url.as_deref(), Some("https://sse.example.com/events"));
|
||||
}
|
||||
}
|
||||
@@ -5,15 +5,6 @@ use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
/// Why a task needs the user's attention (native / in-app notify).
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AgentAttentionReason {
|
||||
Finished,
|
||||
Input,
|
||||
Failed,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AgentStatus {
|
||||
@@ -50,13 +41,12 @@ pub struct AgentCapabilities {
|
||||
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,
|
||||
}
|
||||
|
||||
@@ -108,9 +98,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.
|
||||
@@ -136,40 +123,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")]
|
||||
@@ -185,10 +138,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.
|
||||
@@ -596,7 +545,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.
|
||||
@@ -609,9 +558,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
|
||||
@@ -683,7 +629,7 @@ pub struct AgentModelCatalog {
|
||||
pub enum AgentEvent {
|
||||
/// A task was created or its metadata changed.
|
||||
Task {
|
||||
task: Box<AgentTask>,
|
||||
task: AgentTask,
|
||||
},
|
||||
Removed {
|
||||
id: String,
|
||||
@@ -720,12 +666,6 @@ pub enum AgentEvent {
|
||||
},
|
||||
/// The installed or configured agent providers changed.
|
||||
Providers,
|
||||
/// The task needs attention once (finished turn, explicit input, or failure).
|
||||
Attention {
|
||||
task: String,
|
||||
event_id: String,
|
||||
reason: AgentAttentionReason,
|
||||
},
|
||||
}
|
||||
|
||||
pub use ide_core::settings::{AgentMcpServer, McpTransport};
|
||||
@@ -763,9 +703,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.
|
||||
@@ -798,69 +735,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)]
|
||||
|
||||
@@ -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(¶ms), Start::New { id: id.clone() }, false, ¶ms);
|
||||
let session = self.add_session(
|
||||
&id,
|
||||
self.cwd_of(¶ms),
|
||||
Start::New { id: id.clone() },
|
||||
false,
|
||||
mcp_config(¶ms),
|
||||
);
|
||||
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, ¶ms);
|
||||
let session = self.add_session(id, cwd, start, pending, mcp_config(¶ms));
|
||||
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, ¶ms);
|
||||
let session = self.add_session(&id, source.cwd.clone(), start, true, mcp_config(¶ms));
|
||||
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()?;
|
||||
|
||||
@@ -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"}}));
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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"))
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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
@@ -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())
|
||||
}
|
||||
@@ -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)
|
||||
);
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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};
|
||||
|
||||
@@ -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)]
|
||||
@@ -57,13 +55,7 @@ const BUILTIN: &[(&str, &str, Driver, &[&str], &str)] = &[
|
||||
"Run `codex login` in a terminal.",
|
||||
),
|
||||
("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."),
|
||||
@@ -250,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.
|
||||
@@ -629,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) => {
|
||||
@@ -658,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;
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -54,8 +54,6 @@ struct FakeAgent {
|
||||
/// Advertises steering as OMP does (`_meta.steering` at the top of `initialize`)
|
||||
/// instead of `_meta.openidea.steer`.
|
||||
session_steering: bool,
|
||||
/// Records the `mcpServers` array passed to `session/new`, `session/load`, and `session/fork`.
|
||||
mcp_calls: Mutex<Vec<(String, Vec<String>)>>,
|
||||
}
|
||||
|
||||
impl FakeAgent {
|
||||
@@ -155,18 +153,6 @@ impl Handler for FakeAgent {
|
||||
// Let the prompt's permission request reach the task before the mode changes.
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
if matches!(method, "session/new" | "session/load" | "session/fork") {
|
||||
let names = params
|
||||
.get("mcpServers")
|
||||
.and_then(Value::as_array)
|
||||
.map(|arr| {
|
||||
arr.iter()
|
||||
.filter_map(|v| v.get("name").and_then(Value::as_str).map(str::to_owned))
|
||||
.collect::<Vec<_>>()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
self.mcp_calls.lock().push((method.to_owned(), names));
|
||||
}
|
||||
let session = params.get("sessionId").and_then(Value::as_str).unwrap_or("s1").to_owned();
|
||||
match method {
|
||||
"initialize" => {
|
||||
@@ -470,7 +456,6 @@ async fn saved_conversation_reads_do_not_start_or_load_the_agent() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -664,7 +649,6 @@ async fn authentication_failures_name_the_session_executable_at_start_and_during
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -715,7 +699,6 @@ async fn sign_in_errors_preserve_details_and_leave_unrelated_errors_unchanged()
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -771,7 +754,6 @@ async fn registry_sign_in_errors_use_the_advertised_terminal_login() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -819,7 +801,6 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -902,30 +883,14 @@ async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr_a, &task.id, AgentStatus::NeedsInput).await;
|
||||
assert_eq!(names(mgr_a.commands("claude", None).await.unwrap()), ["review", "triage"]);
|
||||
assert_eq!(names(mgr_a.commands("claude", Some(&task.id)).await.unwrap()), ["review", "triage"]);
|
||||
// Other agents get only what they offered, plus verified native builtins.
|
||||
assert_eq!(
|
||||
names(mgr_a.commands("codex", None).await.unwrap()),
|
||||
[
|
||||
"plan",
|
||||
"mcp",
|
||||
"skills",
|
||||
"status",
|
||||
"review",
|
||||
"review-branch",
|
||||
"review-commit",
|
||||
"compact",
|
||||
"goal",
|
||||
"rename",
|
||||
"logout",
|
||||
]
|
||||
);
|
||||
// Other agents get only what they offered.
|
||||
assert!(mgr_a.commands("codex", None).await.unwrap().is_empty());
|
||||
mgr_a.cancel(&task.id, None).unwrap();
|
||||
wait_for(&mgr_a, &task.id, AgentStatus::Ready).await;
|
||||
mgr_a.shutdown();
|
||||
@@ -945,27 +910,9 @@ async fn builtin_commands_only_fill_verified_gaps_and_preserve_advertised_metada
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager_at(tmp.path(), &tmp.path().join("models.json"), agent);
|
||||
for provider in ["claude", "claude-acp", "opencode2", "custom"] {
|
||||
for provider in ["claude", "claude-acp", "opencode2", "codex", "custom"] {
|
||||
assert!(mgr.commands(provider, None).await.unwrap().is_empty(), "{provider}");
|
||||
}
|
||||
let commands = mgr.commands("codex", None).await.unwrap();
|
||||
assert_eq!(
|
||||
commands.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(),
|
||||
[
|
||||
"plan",
|
||||
"mcp",
|
||||
"skills",
|
||||
"status",
|
||||
"review",
|
||||
"review-branch",
|
||||
"review-commit",
|
||||
"compact",
|
||||
"goal",
|
||||
"rename",
|
||||
"logout",
|
||||
]
|
||||
);
|
||||
assert_eq!(commands[1].hint.as_deref(), Some("[reconnect]"));
|
||||
let commands = mgr.commands("opencode", None).await.unwrap();
|
||||
assert_eq!(commands.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["compact"]);
|
||||
let task = mgr
|
||||
@@ -976,7 +923,6 @@ async fn builtin_commands_only_fill_verified_gaps_and_preserve_advertised_metada
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1035,7 +981,6 @@ async fn a_task_runs_asks_for_permission_and_survives_a_restart() {
|
||||
config: vec![AgentConfigChoice { id: "model".into(), value: "small".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1159,7 +1104,6 @@ async fn steers_through_session_steering() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1196,7 +1140,6 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1252,7 +1195,6 @@ async fn subagents_get_their_own_conversation() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1348,7 +1290,6 @@ async fn claude_questions_keep_the_answer_object_as_the_option_id() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1398,7 +1339,6 @@ async fn qwen_questions_answer_by_index_beside_the_submit_option() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1467,7 +1407,6 @@ async fn skipped_qwen_questions_cancel_the_request() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1507,7 +1446,6 @@ async fn cancelling_resolves_the_open_permission_and_delete_forgets_the_task() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1529,8 +1467,7 @@ async fn cancelling_resolves_the_open_permission_and_delete_forgets_the_task() {
|
||||
provider: "codex".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
base: None
|
||||
})
|
||||
.await
|
||||
.is_err()
|
||||
@@ -1579,7 +1516,6 @@ async fn real_claude_task_in_a_worktree() {
|
||||
config: vec![AgentConfigChoice { id: "model".into(), value: "haiku".into() }],
|
||||
isolation: Isolation::Worktree,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1630,18 +1566,11 @@ async fn renamed_titles_survive_updates_forks_and_restart() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
// `/rename` reports an explicit title through the same update; later automatic names
|
||||
// must not replace it even though AgentManager.rename was not called.
|
||||
handle
|
||||
.on_update(None, &json!({"sessionUpdate": "session_info_update", "title": "Command title", "userNamed": true}));
|
||||
handle.on_update(None, &json!({"sessionUpdate": "session_info_update", "title": "Automatic title"}));
|
||||
assert_eq!(handle.state.lock().task.title, "Command title");
|
||||
assert!(mgr.rename(&task.id, " ").is_err());
|
||||
let initial = handle.state.lock().task.title.clone();
|
||||
for title in [initial, "My task".to_owned(), "名".repeat(205)] {
|
||||
@@ -1662,67 +1591,6 @@ async fn renamed_titles_survive_updates_forks_and_restart() {
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn startup_warnings_survive_replay_and_restart_without_failing_the_task() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask { provider: "claude".into(), prompt: text("again"), ..Default::default() })
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
handle.replaying.store(true, Ordering::Release);
|
||||
handle.turn_started.store(false, Ordering::Release);
|
||||
let client = Client { task: Arc::downgrade(&handle) };
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({"message": "Project MCP config is disabled until trusted."}));
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({"message": " "}));
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({}));
|
||||
assert_eq!(handle.state.lock().task.status, AgentStatus::Ready);
|
||||
assert!(!handle.turn_started.load(Ordering::Acquire));
|
||||
mgr.shutdown();
|
||||
let restored = manager(tmp.path(), agent);
|
||||
let handle = restored.task(&task.id).unwrap();
|
||||
assert_eq!(handle.state.lock().conversation.main.entries.iter().filter(|entry| matches!(entry, AgentEntry::Error {message} if message == "Project MCP config is disabled until trusted.")).count(), 1);
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn persistent_project_trust_needs_confirmation_even_with_bypass_and_is_denied_in_side_chats() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
.create(NewAgentTask { provider: "claude".into(), prompt: text("again"), ..Default::default() })
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
handle.state.lock().task.config = config::options_of(&json!({"configOptions": [{
|
||||
"id": "mode", "category": "mode", "type": "select", "currentValue": "full-access",
|
||||
"options": [{"value": "full-access", "name": "Full Access"}]
|
||||
}]}));
|
||||
assert!(config::bypass_approvals(&handle.state.lock().task.config));
|
||||
let params = json!({"toolCall": {"toolCallId": "trust", "kind": "edit", "title": "Trust Project in Codex"},
|
||||
"options": [
|
||||
{"optionId": "codex-trust-project", "name": "Trust Project in Codex", "kind": "allow_always"},
|
||||
{"optionId": "codex-keep-untrusted", "name": "Keep Untrusted", "kind": "reject_once"}
|
||||
]});
|
||||
let asking = {
|
||||
let handle = handle.clone();
|
||||
let params = params.clone();
|
||||
tokio::task::spawn_blocking(move || handle.ask_permission(¶ms))
|
||||
};
|
||||
wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
|
||||
assert!(!asking.is_finished());
|
||||
let id = *handle.permissions.lock().keys().next().unwrap();
|
||||
mgr.respond(&task.id, id, Some("codex-keep-untrusted".into())).unwrap();
|
||||
assert_eq!(asking.await.unwrap()["outcome"]["optionId"], "codex-keep-untrusted");
|
||||
handle.state.lock().ephemeral = true;
|
||||
assert_eq!(handle.ask_permission(¶ms)["outcome"]["optionId"], "codex-keep-untrusted");
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn forks_rollbacks_and_steering() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -1735,7 +1603,6 @@ async fn forks_rollbacks_and_steering() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
};
|
||||
let task = mgr.create(new("again")).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
@@ -1815,7 +1682,6 @@ async fn usage_limits_and_late_settings() {
|
||||
config: vec![AgentConfigChoice { id: "effort".into(), value: "high".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1869,7 +1735,6 @@ async fn remembered_settings_drop_per_model_choices_for_the_next_task() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1904,7 +1769,6 @@ async fn thinking_levels_are_remembered_per_provider_and_model() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1951,7 +1815,6 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1993,7 +1856,6 @@ async fn upfront_effort_is_validated_after_changing_model_before_the_prompt() {
|
||||
],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2025,7 +1887,6 @@ async fn unreported_model_switch_does_not_cache_the_previous_models_levels() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2050,7 +1911,6 @@ async fn cached_effort_is_not_sent_without_real_session_options() {
|
||||
config,
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
};
|
||||
let warm = mgr.create(new(vec![])).await.unwrap();
|
||||
wait_for(&mgr, &warm.id, AgentStatus::Ready).await;
|
||||
@@ -2086,7 +1946,6 @@ async fn reported_levels_refresh_even_without_a_model_option() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2140,7 +1999,6 @@ async fn cursor_approval_switch_resolves_pending_and_survives_restart() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
};
|
||||
let task = mgr.create(new()).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
|
||||
@@ -2194,7 +2052,6 @@ async fn bypass_approvals_keeps_both_question_dialects_pending_but_allows_permis
|
||||
},
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2256,7 +2113,6 @@ async fn an_agent_form_is_answered_declined_or_cancelled_even_when_approvals_are
|
||||
config: vec![AgentConfigChoice { id: config::CURSOR_APPROVAL.into(), value: "bypass".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2299,7 +2155,6 @@ async fn cursor_approval_choice_applies_before_first_prompt() {
|
||||
config: vec![AgentConfigChoice { id: config::CURSOR_APPROVAL.into(), value: "bypass".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2324,7 +2179,6 @@ async fn a_full_access_mode_approves_tool_requests() {
|
||||
config: vec![AgentConfigChoice { id: "mode".into(), value: "full-access".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2346,7 +2200,6 @@ async fn a_full_access_mode_approves_tool_requests() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2375,7 +2228,6 @@ async fn a_late_full_access_option_approves_a_pending_request() {
|
||||
config: vec![AgentConfigChoice { id: "mode".into(), value: "full-access".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2423,7 +2275,6 @@ async fn an_allow_all_permissions_option_approves_tool_requests() {
|
||||
config: vec![AgentConfigChoice { id: "allow_all".into(), value: "on".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2451,7 +2302,6 @@ async fn archived_tasks_can_be_restored_and_continue_their_session() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2504,7 +2354,6 @@ async fn task_project_root_controls_local_and_worktree_repositories() {
|
||||
config: vec![],
|
||||
isolation,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2711,7 +2560,6 @@ async fn idle_agents_stop_and_resume_their_session_on_the_next_message() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
};
|
||||
let live =
|
||||
|mgr: &AgentManager, id: &str| mgr.task(id).unwrap().live.lock().as_ref().is_some_and(|l| !l.peer.is_closed());
|
||||
@@ -2790,7 +2638,6 @@ async fn an_idle_agent_waits_for_its_background_tasks_before_it_stops() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -2825,7 +2672,6 @@ async fn the_task_shows_what_runs_in_the_background() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2878,7 +2724,6 @@ async fn a_background_task_is_stopped_on_its_own() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2966,7 +2811,6 @@ async fn delete_running_agent(no_load: bool) {
|
||||
config: vec![],
|
||||
isolation: Isolation::Worktree,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3082,7 +2926,6 @@ async fn config_choice_shows_before_the_agent_answers() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3188,7 +3031,6 @@ async fn rolling_back_restores_the_start_of_the_task_and_keeps_the_users_own_edi
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3295,7 +3137,6 @@ impl Checkout {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3502,7 +3343,6 @@ async fn security_policy_auto_approves_whitelist_and_rejects_blacklist() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3533,7 +3373,6 @@ async fn security_policy_auto_approves_whitelist_and_rejects_blacklist() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3571,7 +3410,6 @@ async fn security_policy_never_auto_approves_a_request_that_only_reads_like_a_co
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3609,7 +3447,6 @@ async fn ephemeral_tasks_stay_in_memory_only() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3624,7 +3461,6 @@ async fn ephemeral_tasks_stay_in_memory_only() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
},
|
||||
&source.id,
|
||||
)
|
||||
@@ -3726,7 +3562,6 @@ async fn ephemeral_tasks_deny_write_permissions() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3752,7 +3587,6 @@ async fn ephemeral_tasks_deny_write_permissions() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
},
|
||||
&source.id,
|
||||
)
|
||||
@@ -3785,470 +3619,3 @@ async fn ephemeral_tasks_deny_write_permissions() {
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
fn attention_reasons(events: &[AgentEvent]) -> Vec<AgentAttentionReason> {
|
||||
events
|
||||
.iter()
|
||||
.filter_map(|e| match e {
|
||||
AgentEvent::Attention { reason, .. } => Some(*reason),
|
||||
_ => None,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// `wait_for(Ready/Failed/…)` can return after status is written but before the
|
||||
/// following `emit_attention` runs on the agent thread — poll the sink instead.
|
||||
async fn wait_for_attention(events: &Mutex<Vec<AgentEvent>>, reason: AgentAttentionReason) {
|
||||
for _ in 0..500 {
|
||||
if attention_reasons(&events.lock()).contains(&reason) {
|
||||
return;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
panic!("never saw Attention::{reason:?}: {:?}", *events.lock());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn attention_finished_not_cancelled() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
|
||||
let sink = events.clone();
|
||||
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
|
||||
|
||||
let done = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &done.id, AgentStatus::Ready).await;
|
||||
wait_for_attention(&events, AgentAttentionReason::Finished).await;
|
||||
events.lock().clear();
|
||||
|
||||
let cancelled = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("wait"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &cancelled.id, AgentStatus::Running).await;
|
||||
mgr.cancel(&cancelled.id, None).unwrap();
|
||||
wait_for(&mgr, &cancelled.id, AgentStatus::Ready).await;
|
||||
// Give a late Finished emission a chance; cancellation must not produce one.
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
assert!(
|
||||
!attention_reasons(&events.lock()).contains(&AgentAttentionReason::Finished),
|
||||
"cancelled must not notify finished: {:?}",
|
||||
*events.lock()
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn attention_failed() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent {
|
||||
request_error: Some((codes::INTERNAL_ERROR, "boom".into())),
|
||||
auth_on_new: true,
|
||||
..Default::default()
|
||||
});
|
||||
let mgr = manager(tmp.path(), agent);
|
||||
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
|
||||
let sink = events.clone();
|
||||
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("Fix"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Failed).await;
|
||||
wait_for_attention(&events, AgentAttentionReason::Failed).await;
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn attention_input_not_auto_bypass() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent);
|
||||
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
|
||||
let sink = events.clone();
|
||||
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
|
||||
|
||||
let asked = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("Fix"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &asked.id, AgentStatus::NeedsInput).await;
|
||||
wait_for_attention(&events, AgentAttentionReason::Input).await;
|
||||
events.lock().clear();
|
||||
mgr.cancel(&asked.id, None).unwrap();
|
||||
wait_for(&mgr, &asked.id, AgentStatus::Ready).await;
|
||||
|
||||
let bypassed = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("Fix"),
|
||||
provider: "cursor".into(),
|
||||
config: vec![AgentConfigChoice { id: config::CURSOR_APPROVAL.into(), value: "bypass".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &bypassed.id, AgentStatus::Ready).await;
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
assert!(
|
||||
!attention_reasons(&events.lock()).contains(&AgentAttentionReason::Input),
|
||||
"auto-bypass must not notify input: {:?}",
|
||||
*events.lock()
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn attention_not_emitted_on_restore() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent);
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.shutdown();
|
||||
|
||||
let restored = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
|
||||
let sink = events.clone();
|
||||
let tasks = restored.subscribe(Arc::new(move |e| sink.lock().push(e)));
|
||||
assert!(tasks.iter().any(|t| t.id == task.id));
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
assert!(attention_reasons(&events.lock()).is_empty(), "snapshot restore must not re-notify: {:?}", *events.lock());
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn per_session_mcp_overrides_filter_session_and_reload_when_idle() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
mgr.set_mcp_servers_hook(Box::new(|| {
|
||||
vec![
|
||||
McpServer {
|
||||
id: "user::github".into(),
|
||||
name: "github".into(),
|
||||
scope: McpScope::User,
|
||||
transport: McpTransport::Stdio,
|
||||
enabled: true,
|
||||
command: Some("npx".into()),
|
||||
args: vec!["gh-mcp".into()],
|
||||
env: Vec::new(),
|
||||
url: None,
|
||||
headers: Vec::new(),
|
||||
agents: Vec::new(),
|
||||
unapproved: false,
|
||||
},
|
||||
McpServer {
|
||||
id: "user::slack".into(),
|
||||
name: "slack".into(),
|
||||
scope: McpScope::User,
|
||||
transport: McpTransport::Stdio,
|
||||
enabled: true,
|
||||
command: Some("npx".into()),
|
||||
args: vec!["slack-mcp".into()],
|
||||
env: Vec::new(),
|
||||
url: None,
|
||||
headers: Vec::new(),
|
||||
agents: Vec::new(),
|
||||
unapproved: false,
|
||||
},
|
||||
]
|
||||
}));
|
||||
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
mcp_overrides: BTreeMap::from([("slack".into(), false)]),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
|
||||
let first_mcp = agent.mcp_calls.lock().last().cloned().unwrap();
|
||||
assert_eq!(first_mcp.0, "session/new");
|
||||
assert!(first_mcp.1.contains(&"github".to_string()));
|
||||
assert!(!first_mcp.1.contains(&"slack".to_string()));
|
||||
|
||||
// Toggle `slack` back on and `github` off while idle -> recycles the resumable session,
|
||||
// so the next prompt calls `session/load` with the updated MCP servers.
|
||||
let updated =
|
||||
mgr.set_mcp_overrides(&task.id, BTreeMap::from([("github".into(), false), ("slack".into(), true)])).unwrap();
|
||||
assert_eq!(updated.mcp_overrides.get("github"), Some(&false));
|
||||
assert_eq!(updated.mcp_overrides.get("slack"), Some(&true));
|
||||
|
||||
mgr.prompt(&task.id, text("again"), false).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
|
||||
let reloaded = agent.mcp_calls.lock().last().cloned().unwrap();
|
||||
assert_eq!(reloaded.0, "session/load");
|
||||
assert!(!reloaded.1.contains(&"github".to_string()));
|
||||
assert!(reloaded.1.contains(&"slack".to_string()));
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails() {
|
||||
#[derive(Clone, Copy)]
|
||||
enum BreakAt {
|
||||
Initialize,
|
||||
SessionNew,
|
||||
Prompt,
|
||||
}
|
||||
|
||||
struct BrokenHeadless(BreakAt);
|
||||
|
||||
impl ide_jsonrpc::Handler for BrokenHeadless {
|
||||
fn on_notification(&self, _: &str, _: Value) {}
|
||||
|
||||
fn on_request(&self, method: &str, _: Value) -> Result<Value, (i64, String)> {
|
||||
match (self.0, method) {
|
||||
(BreakAt::Initialize, "initialize") => {
|
||||
Err((ide_jsonrpc::codes::METHOD_NOT_FOUND, "connect unsupported".into()))
|
||||
}
|
||||
(_, "initialize") => Ok(json!({
|
||||
"protocolVersion": 1,
|
||||
"agentCapabilities": { "loadSession": true },
|
||||
"agentInfo": { "name": "copilot", "version": "2.0.0" },
|
||||
})),
|
||||
(BreakAt::SessionNew, "session/new") => {
|
||||
Err((ide_jsonrpc::codes::INVALID_PARAMS, "session.create schema changed".into()))
|
||||
}
|
||||
(BreakAt::Prompt, "session/new") => Ok(json!({ "sessionId": "headless-sess" })),
|
||||
(BreakAt::Prompt, "session/prompt") => {
|
||||
Err((ide_jsonrpc::codes::INVALID_PARAMS, "session.send schema changed".into()))
|
||||
}
|
||||
_ => Err((ide_jsonrpc::codes::METHOD_NOT_FOUND, format!("unexpected {method}"))),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let build_mgr = |dir: &Path, break_at: BreakAt| {
|
||||
let acp_agent = Arc::new(FakeAgent::default());
|
||||
let seen_drivers = Arc::new(Mutex::new(Vec::<(provider::Driver, Vec<String>)>::new()));
|
||||
let connector: Connector = {
|
||||
let acp_agent = acp_agent.clone();
|
||||
let seen_drivers = seen_drivers.clone();
|
||||
Arc::new(move |spec, _cwd, client, _stderr| {
|
||||
seen_drivers.lock().push((spec.driver, spec.args.clone()));
|
||||
let (a, b) = duplex(1 << 20);
|
||||
let (ar, aw) = tokio::io::split(a);
|
||||
let (br, bw) = tokio::io::split(b);
|
||||
let server = match spec.driver {
|
||||
provider::Driver::Copilot => {
|
||||
Peer::connect_framed(br, bw, Arc::new(BrokenHeadless(break_at)), Framing::Lines)
|
||||
}
|
||||
_ => Peer::connect_framed(br, bw, acp_agent.clone(), Framing::Lines),
|
||||
};
|
||||
acp_agent.servers.lock().push(server);
|
||||
Ok(Peer::connect_framed(ar, aw, client, Framing::Lines))
|
||||
})
|
||||
};
|
||||
let mgr = AgentManager::with_connector(
|
||||
AgentPaths {
|
||||
project_root: dir.to_path_buf(),
|
||||
store_dir: dir.join("store"),
|
||||
worktrees_dir: dir.join("worktrees"),
|
||||
models_file: dir.join("models.json"),
|
||||
custom_agents_dir: None,
|
||||
home_dir: None,
|
||||
env_secrets: None,
|
||||
catalogs: Arc::default(),
|
||||
},
|
||||
tokio::runtime::Handle::current(),
|
||||
connector,
|
||||
);
|
||||
(mgr, seen_drivers)
|
||||
};
|
||||
|
||||
// 1. Probe failure on headless falls back to `copilot --acp`.
|
||||
let tmp1 = tempfile::tempdir().unwrap();
|
||||
let (mgr1, seen1) = build_mgr(tmp1.path(), BreakAt::Initialize);
|
||||
let probe = mgr1.probe("copilot", false).await.unwrap();
|
||||
assert!(probe.error.is_none(), "{probe:?}");
|
||||
assert!(probe.protocol.starts_with("ACP v"), "{probe:?}");
|
||||
{
|
||||
let launches = seen1.lock().clone();
|
||||
assert_eq!(launches.len(), 2, "{launches:?}");
|
||||
assert_eq!(launches[0].0, provider::Driver::Copilot);
|
||||
assert_eq!(launches[1], (provider::Driver::Acp, vec!["--acp".to_owned()]));
|
||||
}
|
||||
mgr1.shutdown();
|
||||
|
||||
// 2. `session/new` (`session.create`) failure on headless falls back to `copilot --acp`.
|
||||
let tmp2 = tempfile::tempdir().unwrap();
|
||||
let (mgr2, seen2) = build_mgr(tmp2.path(), BreakAt::SessionNew);
|
||||
let task2 = mgr2
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "copilot".into(),
|
||||
config: vec![AgentConfigChoice { id: "context_tier".into(), value: "long_context".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr2, &task2.id, AgentStatus::Ready).await;
|
||||
{
|
||||
let launches = seen2.lock().clone();
|
||||
assert_eq!(launches.len(), 2, "{launches:?}");
|
||||
assert_eq!(launches[0].0, provider::Driver::Copilot);
|
||||
assert_eq!(launches[1], (provider::Driver::Acp, vec!["--acp".to_owned()]));
|
||||
}
|
||||
mgr2.shutdown();
|
||||
|
||||
// 3. `session/prompt` (`session.send`) protocol error before streaming falls back to `copilot --acp`.
|
||||
let tmp3 = tempfile::tempdir().unwrap();
|
||||
let (mgr3, seen3) = build_mgr(tmp3.path(), BreakAt::Prompt);
|
||||
let task3 = mgr3
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "copilot".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr3, &task3.id, AgentStatus::Ready).await;
|
||||
{
|
||||
let launches = seen3.lock().clone();
|
||||
assert_eq!(launches.len(), 2, "{launches:?}");
|
||||
assert_eq!(launches[0].0, provider::Driver::Copilot);
|
||||
assert_eq!(launches[1], (provider::Driver::Acp, vec!["--acp".to_owned()]));
|
||||
}
|
||||
mgr3.shutdown();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn copilot_catalog_discovery_falls_back_to_acp_when_headless_exits() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agents_dir = tmp.path().join("agents");
|
||||
std::fs::create_dir_all(&agents_dir).unwrap();
|
||||
let fake_copilot = tmp.path().join("copilot");
|
||||
let script = r#"#!/bin/sh
|
||||
for arg in "$@"; do
|
||||
if [ "$arg" = "--headless" ]; then
|
||||
echo "unknown option: --headless" >&2
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
while IFS= read -r line; do
|
||||
case "$line" in
|
||||
*'"initialize"'*)
|
||||
echo '{"jsonrpc":"2.0","id":1,"result":{"protocolVersion":1,"agentCapabilities":{"loadSession":true},"agentInfo":{"name":"copilot","version":"1.0.112"}}}'
|
||||
;;
|
||||
*'"session/new"'*)
|
||||
echo '{"jsonrpc":"2.0","id":2,"result":{"sessionId":"acp-disc-1","configOptions":[{"id":"model","name":"Model","category":"model","type":"select","currentValue":"claude-sonnet-5.5","options":[{"value":"claude-sonnet-5.5","name":"Claude Sonnet 5.5","_meta":{"copilotPriceCategory":"medium"}}]},{"id":"reasoning_effort","name":"Effort","category":"thought_level","type":"select","currentValue":"medium","options":[{"value":"low","name":"Low"},{"value":"medium","name":"Medium"},{"value":"high","name":"High"}]}]}}'
|
||||
;;
|
||||
esac
|
||||
done
|
||||
"#;
|
||||
std::fs::write(&fake_copilot, script).unwrap();
|
||||
std::fs::set_permissions(&fake_copilot, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
std::fs::write(
|
||||
agents_dir.join("copilot.toml"),
|
||||
format!("name = \"GitHub Copilot\"\ncommand = {:?}\nargs = [\"--acp\"]\n", fake_copilot.to_string_lossy()),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let mgr = AgentManager::new(
|
||||
AgentPaths {
|
||||
project_root: tmp.path().to_path_buf(),
|
||||
store_dir: tmp.path().join("store"),
|
||||
worktrees_dir: tmp.path().join("worktrees"),
|
||||
models_file: tmp.path().join("models.json"),
|
||||
custom_agents_dir: Some(agents_dir),
|
||||
home_dir: None,
|
||||
env_secrets: None,
|
||||
catalogs: Arc::default(),
|
||||
},
|
||||
tokio::runtime::Handle::current(),
|
||||
);
|
||||
mgr.commands("copilot", None).await.unwrap();
|
||||
let copilot = mgr.providers().into_iter().find(|p| p.id == "copilot").unwrap();
|
||||
let models = copilot.config.iter().find(|o| o.category.as_deref() == Some("model")).expect("ACP fallback models");
|
||||
assert_eq!(models.current.as_deref(), Some("claude-sonnet-5.5"));
|
||||
assert_eq!(
|
||||
copilot.thought_levels["claude-sonnet-5.5"]
|
||||
.iter()
|
||||
.find(|o| o.id == "reasoning_effort")
|
||||
.and_then(|o| o.current.as_deref()),
|
||||
Some("medium")
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn session_params_name_the_servers_switched_off() {
|
||||
let overrides = BTreeMap::from([
|
||||
("github".to_owned(), false),
|
||||
("docs".to_owned(), true),
|
||||
(mcp::BUILTIN_MCP_NAME.to_owned(), false),
|
||||
]);
|
||||
let params = session_params("/p", &[json!({ "name": "docs" })], &overrides);
|
||||
assert_eq!(params["cwd"], "/p");
|
||||
assert_eq!(params["mcpServers"][0]["name"], "docs");
|
||||
assert_eq!(params["_meta"]["openidea"]["mcpServersOff"], json!(["github"]));
|
||||
assert!(session_params("/p", &[], &BTreeMap::new()).get("_meta").is_none());
|
||||
}
|
||||
@@ -310,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) => {
|
||||
@@ -326,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.
|
||||
@@ -338,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,
|
||||
));
|
||||
@@ -360,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)));
|
||||
@@ -416,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)),
|
||||
@@ -452,31 +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);
|
||||
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)?;
|
||||
@@ -495,62 +482,23 @@ fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
|
||||
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() {
|
||||
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);
|
||||
if 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<()> {
|
||||
@@ -698,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"));
|
||||
}
|
||||
|
||||
@@ -745,9 +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"))
|
||||
);
|
||||
assert!(javac.args.windows(2).any(|w| w[0] == "-d" && w[1].ends_with("build/classes/production/p")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -864,45 +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 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());
|
||||
}
|
||||
}
|
||||
@@ -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,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,7 +13,6 @@ pub mod kotlin_bridge;
|
||||
pub mod maven;
|
||||
pub mod pom_edit;
|
||||
mod process;
|
||||
pub mod sbt;
|
||||
mod sync;
|
||||
pub mod web;
|
||||
mod xml;
|
||||
@@ -21,7 +20,6 @@ mod xml;
|
||||
pub use gradle::{GradleModel, GradleProject, GradleTask};
|
||||
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):
|
||||
@@ -334,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))
|
||||
@@ -353,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))
|
||||
@@ -372,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"]);
|
||||
}
|
||||
|
||||
@@ -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"]);
|
||||
}
|
||||
}
|
||||
@@ -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__",
|
||||
|
||||
@@ -71,8 +71,6 @@ pub struct Settings {
|
||||
pub scopes: Vec<NamedScope>,
|
||||
/// Appearance & Behavior › File Colors.
|
||||
pub file_colors: FileColorSettings,
|
||||
/// Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes.
|
||||
pub database: DatabaseSettings,
|
||||
/// Plugin settings (`[contributes.settings]`): plugin id → its values by key.
|
||||
#[specta(type = BTreeMap<String, BTreeMap<String, specta_typescript::Unknown>>)]
|
||||
pub plugins: BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
|
||||
@@ -510,7 +508,6 @@ impl Default for Settings {
|
||||
agent_security: AgentSecuritySettings::default(),
|
||||
scopes: Vec::new(),
|
||||
file_colors: FileColorSettings::default(),
|
||||
database: DatabaseSettings::default(),
|
||||
plugins: BTreeMap::new(),
|
||||
}
|
||||
}
|
||||
@@ -650,20 +647,13 @@ impl Default for DateFormatSettings {
|
||||
pub struct NotificationSettings {
|
||||
pub balloons: bool,
|
||||
pub sound: bool,
|
||||
/// Mirror balloon notifications to the OS when no OpenIDEA window is focused.
|
||||
#[serde(default = "default_true")]
|
||||
pub system_notifications: bool,
|
||||
/// Group id → display; groups not listed use their default.
|
||||
pub groups: BTreeMap<String, NotificationGroupSettings>,
|
||||
}
|
||||
|
||||
fn default_true() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
impl Default for NotificationSettings {
|
||||
fn default() -> Self {
|
||||
Self { balloons: true, sound: false, system_notifications: true, groups: BTreeMap::new() }
|
||||
Self { balloons: true, sound: false, groups: BTreeMap::new() }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1347,9 +1337,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.
|
||||
|
||||
@@ -241,30 +241,6 @@ impl Default for LogLevelColors {
|
||||
}
|
||||
}
|
||||
|
||||
/// Database settings: Query Execution and SQL Resolution Scopes.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct DatabaseSettings {
|
||||
/// A console's result sets show under the statements that produced them, in the editor,
|
||||
/// instead of in the Services view's result tabs.
|
||||
pub in_editor_results: bool,
|
||||
/// Languages & Frameworks › SQL Resolution Scopes: the data source SQL in a file or folder
|
||||
/// resolves against (completion, inspections, navigation), most specific path first.
|
||||
pub resolution_scopes: Vec<SqlResolutionScope>,
|
||||
}
|
||||
|
||||
/// One row of SQL Resolution Scopes.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct SqlResolutionScope {
|
||||
/// Project-relative file or folder, `/`-separated; empty for the whole project.
|
||||
pub path: String,
|
||||
/// Data source id.
|
||||
pub data_source: String,
|
||||
/// Schema unqualified names resolve in; empty for the data source's default.
|
||||
pub schema: String,
|
||||
}
|
||||
|
||||
/// Build, Execution, Deployment › Console.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
|
||||
@@ -120,12 +120,6 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
|
||||
"stdio",
|
||||
"Install GDB 14 or newer (apt install gdb, dnf install gdb, brew install gdb)",
|
||||
),
|
||||
"unity" => cfg(
|
||||
"unity-debug",
|
||||
&[],
|
||||
"stdio",
|
||||
"Install Unity Debugger in Settings > Language Servers, or configure the unity-debug tool path",
|
||||
),
|
||||
"rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
|
||||
// A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
|
||||
"java-debug" => cfg(
|
||||
|
||||
@@ -12,7 +12,6 @@ use std::path::Path;
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AttachKind {
|
||||
Unity,
|
||||
Java,
|
||||
Node,
|
||||
Python,
|
||||
|
||||
@@ -19,7 +19,6 @@ mod jvm_memory;
|
||||
pub mod kotlin;
|
||||
pub mod kotlin_lsp;
|
||||
mod session;
|
||||
pub mod unity;
|
||||
|
||||
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
|
||||
use connection::{Connection, DapError};
|
||||
@@ -1122,16 +1121,6 @@ impl DebugManager {
|
||||
let _ = tokio::time::timeout(INIT_TIMEOUT, initialized.wait_for(|v| *v)).await;
|
||||
}
|
||||
|
||||
if s.adapter == "unity" {
|
||||
if launch_result.is_none()
|
||||
&& let Some(launch) = launch.as_mut()
|
||||
{
|
||||
launch.await?;
|
||||
launch_result = Some(());
|
||||
}
|
||||
unity::wait_for_threads(s).await?;
|
||||
}
|
||||
|
||||
// A fresh adapter has no breakpoints, so a file with none enabled needs no request; the
|
||||
// others go out together, as VS Code sends them, instead of one round trip per file.
|
||||
let (files, idle): (Vec<_>, Vec<_>) = self
|
||||
@@ -1213,10 +1202,6 @@ impl DebugManager {
|
||||
if let Some(link) = s.jdwp_link.lock().as_ref() {
|
||||
link.release();
|
||||
}
|
||||
if s.adapter == "unity" {
|
||||
unity::settle_startup(s).await;
|
||||
s.emit(ide_core::event::DebugEvent::Initialized);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1244,18 +1229,11 @@ impl DebugManager {
|
||||
// rdbg's terminate exits the Ruby process without terminating its children.
|
||||
let graceful =
|
||||
terminate && s.request == "launch" && s.adapter != "rdbg" && s.supports("supportsTerminateRequest");
|
||||
// A program suspended in the debugger cannot act on SIGTERM, and on macOS not even die of
|
||||
// SIGKILL while the debugger holds it: it is killed (with what it started) and the adapter
|
||||
// is told to end it. A killed program has no shutdown output to wait for.
|
||||
let killed = own_terminate && !graceful && s.suspended.get();
|
||||
if killed {
|
||||
crate::session::signal_debuggee(s, true).await;
|
||||
}
|
||||
if !s.conn.is_closed() {
|
||||
if graceful {
|
||||
let _ = s.conn.request_timeout("terminate", json!({ "restart": false }), SHUTDOWN_TIMEOUT).await;
|
||||
}
|
||||
if !graceful && (!own_terminate || killed) {
|
||||
if !graceful && !own_terminate {
|
||||
let _ = s
|
||||
.conn
|
||||
.request_timeout(
|
||||
@@ -1266,7 +1244,7 @@ impl DebugManager {
|
||||
.await;
|
||||
}
|
||||
}
|
||||
if own_terminate && !graceful && !killed {
|
||||
if own_terminate && !graceful {
|
||||
// Signal before anything else: waiting on a request the adapter may not answer
|
||||
// would delay the shutdown the console is supposed to show.
|
||||
crate::session::signal_debuggee(s, false).await;
|
||||
@@ -1285,7 +1263,7 @@ impl DebugManager {
|
||||
// lets Run start again into an occupied port, so wait for the program first — with the
|
||||
// connection still open, so a second Stop can find the session and kill it.
|
||||
crate::session::wait_for_debuggee(s, terminate).await;
|
||||
if terminate && s.request == "launch" && !killed {
|
||||
if terminate && s.request == "launch" {
|
||||
// The adapter reports `terminated` only after it has drained the program's console
|
||||
// (java-debug waits up to 5 s for the pump): closing before that drops the last
|
||||
// shutdown lines from the console.
|
||||
|
||||
@@ -17,7 +17,7 @@ use std::process::Stdio;
|
||||
use std::sync::Arc;
|
||||
use std::sync::Weak;
|
||||
use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
|
||||
use std::time::{Duration, Instant};
|
||||
use std::time::Duration;
|
||||
use tokio::io::{AsyncRead, AsyncReadExt};
|
||||
use tokio::process::Child;
|
||||
use tokio::sync::{mpsc, watch};
|
||||
@@ -116,7 +116,6 @@ pub(crate) struct Session {
|
||||
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
|
||||
/// 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>,
|
||||
}
|
||||
|
||||
/// Which threads of the program are suspended: each from its `stopped` event until a
|
||||
@@ -271,7 +270,6 @@ impl Session {
|
||||
kotlin_mirror: Mutex::new(None),
|
||||
jvm_memory: tokio::sync::Mutex::default(),
|
||||
quirks: kotlin_lsp::Quirks::default(),
|
||||
unity_startup_activity: Mutex::new(Instant::now()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -718,15 +716,6 @@ pub(crate) async fn event_loop(
|
||||
}
|
||||
|
||||
async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut body: Value) {
|
||||
if s.adapter == "unity"
|
||||
&& event == "output"
|
||||
&& body
|
||||
.get("output")
|
||||
.and_then(Value::as_str)
|
||||
.is_some_and(|text| text.starts_with("Loaded assembly:") || text.starts_with("Resolved pending breakpoint"))
|
||||
{
|
||||
*s.unity_startup_activity.lock() = Instant::now();
|
||||
}
|
||||
if let Some(mirror) = s.kotlin_mirror.lock().as_ref() {
|
||||
mirror.translate(&mut body);
|
||||
}
|
||||
@@ -735,9 +724,7 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
|
||||
match event {
|
||||
"initialized" => {
|
||||
s.initialized.send_replace(true);
|
||||
if s.adapter != "unity" {
|
||||
s.emit(DebugEvent::Initialized);
|
||||
}
|
||||
s.emit(DebugEvent::Initialized);
|
||||
}
|
||||
"stopped" => {
|
||||
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
|
||||
|
||||
@@ -158,7 +158,6 @@ struct Script {
|
||||
/// `launch`, and a `configurationDone` sent while it runs is refused with `notStopped`.
|
||||
gdb15_starts_at_launch: bool,
|
||||
launch_after_configuration: bool,
|
||||
empty_thread_responses: usize,
|
||||
/// Requests of the adapter's own (js-debug's `setCustomBreakpoints`…) answered with an empty body.
|
||||
accept: &'static [&'static str],
|
||||
/// Requests of the adapter's own answered with a body and followed by events.
|
||||
@@ -199,7 +198,6 @@ impl Default for Script {
|
||||
close_during_startup: false,
|
||||
gdb15_starts_at_launch: false,
|
||||
launch_after_configuration: false,
|
||||
empty_thread_responses: 0,
|
||||
accept: &[],
|
||||
custom: None,
|
||||
}
|
||||
@@ -246,8 +244,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
let mut held: Vec<Value> = Vec::new();
|
||||
let mut stopped = false;
|
||||
let mut running = false;
|
||||
let mut thread_requests = 0;
|
||||
let mut unity = false;
|
||||
macro_rules! send {
|
||||
($v:expr) => {{
|
||||
let mut v: Value = $v;
|
||||
@@ -272,14 +268,13 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
}
|
||||
match msg["command"].as_str().unwrap_or_default() {
|
||||
"initialize" => {
|
||||
unity = msg["arguments"]["adapterID"] == "unity";
|
||||
if let Some(delay) = script.delay_initialize {
|
||||
tokio::time::sleep(delay).await;
|
||||
}
|
||||
ok!(
|
||||
msg,
|
||||
json!({
|
||||
"supportsConfigurationDoneRequest": !unity,
|
||||
"supportsConfigurationDoneRequest": true,
|
||||
"supportsCompletionsRequest": true,
|
||||
"supportsTerminateRequest": script.supports_terminate,
|
||||
"supportsSetVariable": true,
|
||||
@@ -298,15 +293,8 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
// defers it sends late).
|
||||
send!(json!({"type": "event", "event": "initialized"}));
|
||||
}
|
||||
if unity {
|
||||
send!(json!({"type": "event", "event": "initialized"}));
|
||||
}
|
||||
}
|
||||
"launch" | "attach" => {
|
||||
if unity {
|
||||
ok!(msg, Value::Null);
|
||||
continue;
|
||||
}
|
||||
if script.gdb15_starts_at_launch {
|
||||
// GDB 15 starts the program here and answers `launch` right away.
|
||||
running = true;
|
||||
@@ -460,14 +448,7 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
ok!(msg, json!({"threads": [{"id": 1, "name": "\"main\"@1"}]}));
|
||||
}
|
||||
"threads" => {
|
||||
thread_requests += 1;
|
||||
if thread_requests <= script.empty_thread_responses {
|
||||
ok!(msg, json!({"threads": []}));
|
||||
} else {
|
||||
ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]}));
|
||||
}
|
||||
}
|
||||
"threads" => ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]})),
|
||||
"stackTrace" => ok!(
|
||||
msg,
|
||||
json!({"stackFrames": [
|
||||
@@ -527,14 +508,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
}
|
||||
}
|
||||
"disconnect" => {
|
||||
// Like Delve: the adapter ends the program it launched.
|
||||
#[cfg(unix)]
|
||||
if msg["arguments"]["terminateDebuggee"] == true
|
||||
&& let Some(pid) = script.debuggee_pid
|
||||
{
|
||||
// SAFETY: plain syscall on the test's own child process.
|
||||
unsafe { libc::kill(pid as i32, libc::SIGKILL) };
|
||||
}
|
||||
ok!(msg, Value::Null);
|
||||
let _ = w.lock().await.shutdown().await;
|
||||
break;
|
||||
@@ -905,32 +878,6 @@ async fn stop_terminates_and_disconnects() {
|
||||
assert!(h.manager.threads(id).await.is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unity_attach_waits_for_mono_and_disconnects_without_terminating_editor() {
|
||||
let h = harness(Script { empty_thread_responses: 2, ..Script::default() });
|
||||
h.manager.set_breakpoints(PathBuf::from("/p/a.cs"), vec![bp(4)]).await.unwrap();
|
||||
let start = h.start(LaunchConfig {
|
||||
adapter: "unity".into(),
|
||||
request: "attach".into(),
|
||||
program: None,
|
||||
extra_json: Some(json!({ "name": "Unity Editor (42)", "__exceptionOptions": [] }).to_string()),
|
||||
..config()
|
||||
});
|
||||
let ready = async {
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
|
||||
let commands = h.commands();
|
||||
let before_breakpoints = commands.iter().take_while(|c| *c != "setBreakpoints");
|
||||
assert!(before_breakpoints.filter(|c| *c == "threads").count() >= 3);
|
||||
assert!(commands.iter().any(|c| c == "setBreakpoints"));
|
||||
};
|
||||
let (id, ()) = tokio::join!(start, ready);
|
||||
let id = id.unwrap();
|
||||
assert_eq!(h.request("attach")["arguments"]["name"], "Unity Editor (42)");
|
||||
h.manager.stop(id).await.unwrap();
|
||||
assert!(!h.commands().iter().any(|c| c == "launch" || c == "terminate"));
|
||||
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], false);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn concurrent_sessions_are_independent() {
|
||||
let h = harness(Script::default());
|
||||
@@ -2327,44 +2274,6 @@ async fn stop_waits_for_the_launched_program_to_exit() {
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Terminated)).await;
|
||||
}
|
||||
|
||||
/// Delve and other adapters without `terminate`: a program stopped at a breakpoint cannot
|
||||
/// handle the SIGTERM Stop sends, so Stop has the adapter end it instead of waiting out the grace period.
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn stop_kills_a_program_suspended_at_a_breakpoint_at_once() {
|
||||
let mut child = std::process::Command::new("python3")
|
||||
.args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(30)"])
|
||||
.spawn()
|
||||
.unwrap();
|
||||
let pid = child.id();
|
||||
let exited = Arc::new(AtomicBool::new(false));
|
||||
{
|
||||
let exited = exited.clone();
|
||||
std::thread::spawn(move || {
|
||||
let _ = child.wait();
|
||||
exited.store(true, Ordering::Release);
|
||||
});
|
||||
}
|
||||
let h = harness(Script { debuggee_pid: Some(pid), supports_terminate: false, ..Default::default() });
|
||||
let id = h.start(config()).await.unwrap();
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
|
||||
let session = h.manager.session(id).unwrap();
|
||||
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid) {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(200)).await; // let the program install its trap
|
||||
let started = Instant::now();
|
||||
h.manager.stop(id).await.unwrap();
|
||||
let elapsed = started.elapsed();
|
||||
assert!(elapsed < Duration::from_secs(3), "stop waited {elapsed:?} for a suspended program");
|
||||
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], true);
|
||||
let deadline = Instant::now() + Duration::from_secs(2);
|
||||
while !exited.load(Ordering::Acquire) {
|
||||
assert!(Instant::now() < deadline, "the suspended program was left running");
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn a_second_stop_kills_the_program_instead_of_waiting() {
|
||||
|
||||
@@ -1,187 +0,0 @@
|
||||
//! Lists the Unity Editors to attach to through UnityDebug's discovery (`unity-debug list`).
|
||||
|
||||
use crate::{
|
||||
adapter,
|
||||
attach::{AttachKind, AttachableProcess},
|
||||
};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::{path::PathBuf, process::Stdio, time::Duration};
|
||||
|
||||
/// Waits until Mono reports its threads.
|
||||
pub(crate) async fn wait_for_threads(session: &crate::session::Session) -> IdeResult<()> {
|
||||
tokio::time::timeout(Duration::from_secs(20), async {
|
||||
loop {
|
||||
let body = session.conn.request_timeout("threads", serde_json::json!({}), Duration::from_secs(5)).await?;
|
||||
if body.get("threads").and_then(serde_json::Value::as_array).is_some_and(|t| !t.is_empty()) {
|
||||
return Ok(());
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.map_err(|_| {
|
||||
IdeError::unavailable(
|
||||
"Unity debugger did not become ready. Enable Editor Attaching and Debug Mode in Unity, then retry.",
|
||||
)
|
||||
})?
|
||||
}
|
||||
|
||||
// Mono binds breakpoints asynchronously and resumes threads itself during startup: wait for that burst to end.
|
||||
pub(crate) async fn settle_startup(session: &crate::session::Session) {
|
||||
*session.unity_startup_activity.lock() = std::time::Instant::now();
|
||||
let _ = tokio::time::timeout(Duration::from_secs(3), async {
|
||||
while session.unity_startup_activity.lock().elapsed() < Duration::from_secs(1) {
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
}
|
||||
})
|
||||
.await;
|
||||
}
|
||||
|
||||
pub fn require_runtime(cwd: &std::path::Path) -> IdeResult<()> {
|
||||
if cfg!(unix) && ide_core::tool_path::find_command("mono", &ide_core::tool_path::search_path(), cwd).is_none() {
|
||||
return Err(IdeError::unavailable(
|
||||
"Unity Debugger requires Mono. Install Mono, make sure mono is on PATH, then refresh the Unity process list.",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
const NOT_INSTALLED: &str = "debug adapter `unity` not found. Install Unity Debugger in Settings > Language Servers or configure the unity-debug tool path";
|
||||
|
||||
pub async fn editors(command: Option<String>, cwd: PathBuf) -> IdeResult<Vec<AttachableProcess>> {
|
||||
require_runtime(&cwd)?;
|
||||
let command = command.unwrap_or_else(|| "unity-debug".into());
|
||||
let lookup = command.clone();
|
||||
let dir = cwd.clone();
|
||||
let binary = tokio::task::spawn_blocking(move || adapter::resolve_binary(&lookup, &dir))
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
.ok_or_else(|| IdeError::unavailable(NOT_INSTALLED))?;
|
||||
let mut cmd = tokio::process::Command::new(binary);
|
||||
ide_core::process::prepare(cmd.as_std_mut());
|
||||
cmd.arg("list")
|
||||
.current_dir(&cwd)
|
||||
.env("PATH", ide_core::tool_path::search_path())
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.kill_on_drop(true);
|
||||
let out = tokio::time::timeout(Duration::from_secs(15), cmd.output())
|
||||
.await
|
||||
.map_err(|_| {
|
||||
IdeError::unavailable("Unity process discovery timed out. Check that Unity Editor is responsive.")
|
||||
})?
|
||||
.map_err(|e| IdeError::unavailable(format!("Cannot start Unity process discovery: {e}")))?;
|
||||
if !out.status.success() {
|
||||
return Err(IdeError::unavailable(format!(
|
||||
"Unity process discovery failed: {}",
|
||||
String::from_utf8_lossy(&out.stderr).trim()
|
||||
)));
|
||||
}
|
||||
let mut rows = parse_editors(&String::from_utf8_lossy(&out.stdout));
|
||||
#[cfg(windows)]
|
||||
if !rows.is_empty() {
|
||||
match editor_process_ids() {
|
||||
Ok(editors) => rows.retain(|p| editors.contains(&p.pid)),
|
||||
Err(error) => tracing::warn!(%error, "Unity process filtering failed; using adapter discovery results"),
|
||||
}
|
||||
}
|
||||
// The Editor of the open project comes first; the user picks which one to attach to.
|
||||
let path = cwd.join("Library/EditorInstance.json");
|
||||
let pid = std::fs::File::open(path).ok().and_then(|file| {
|
||||
use std::io::Read;
|
||||
let json: serde_json::Value = serde_json::from_reader(file.take(4096)).ok()?;
|
||||
json.get("process_id")?.as_u64().and_then(|n| u32::try_from(n).ok())
|
||||
});
|
||||
for row in &mut rows {
|
||||
if Some(row.pid) == pid {
|
||||
row.command_line = cwd.to_string_lossy().into_owned();
|
||||
}
|
||||
}
|
||||
rows.sort_by_key(|p| Some(p.pid) != pid);
|
||||
Ok(rows)
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn editor_process_ids() -> IdeResult<std::collections::HashSet<u32>> {
|
||||
use std::collections::HashMap;
|
||||
use windows_sys::Win32::{
|
||||
Foundation::{CloseHandle, INVALID_HANDLE_VALUE},
|
||||
System::Diagnostics::ToolHelp::{
|
||||
CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW, TH32CS_SNAPPROCESS,
|
||||
},
|
||||
};
|
||||
|
||||
let mut unity = HashMap::new();
|
||||
// The adapter also finds the asset import worker processes: keep the Unity processes whose parent isn't Unity.
|
||||
unsafe {
|
||||
let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
|
||||
if snapshot == INVALID_HANDLE_VALUE {
|
||||
return Err(std::io::Error::last_os_error().into());
|
||||
}
|
||||
let mut entry = PROCESSENTRY32W { dwSize: std::mem::size_of::<PROCESSENTRY32W>() as u32, ..std::mem::zeroed() };
|
||||
let mut found = Process32FirstW(snapshot, &mut entry);
|
||||
if found == 0 {
|
||||
let error = std::io::Error::last_os_error();
|
||||
CloseHandle(snapshot);
|
||||
return Err(error.into());
|
||||
}
|
||||
while found != 0 {
|
||||
let end = entry.szExeFile.iter().position(|c| *c == 0).unwrap_or(entry.szExeFile.len());
|
||||
let name = String::from_utf16_lossy(&entry.szExeFile[..end]);
|
||||
if name.eq_ignore_ascii_case("Unity.exe") {
|
||||
unity.insert(entry.th32ProcessID, entry.th32ParentProcessID);
|
||||
}
|
||||
found = Process32NextW(snapshot, &mut entry);
|
||||
}
|
||||
CloseHandle(snapshot);
|
||||
}
|
||||
Ok(unity.iter().filter_map(|(&pid, parent)| (!unity.contains_key(parent)).then_some(pid)).collect())
|
||||
}
|
||||
|
||||
pub fn parse_editors(output: &str) -> Vec<AttachableProcess> {
|
||||
let mut editors = Vec::new();
|
||||
for line in output.lines() {
|
||||
let line = line.trim().trim_start_matches('\u{feff}');
|
||||
if !line.starts_with("Unity Editor (") {
|
||||
continue;
|
||||
}
|
||||
// 3.0.1 prints `Unity Editor (Unity) (123)`; later versions append the project name.
|
||||
let Some((name, pid, project)) = line.match_indices(" (").find_map(|(at, _)| {
|
||||
let (id, project) = line[at + 2..].split_once(')')?;
|
||||
let pid = id.parse::<u32>().ok().filter(|n| *n > 0)?;
|
||||
Some((&line[..at], pid, project))
|
||||
}) else {
|
||||
continue;
|
||||
};
|
||||
if editors.iter().any(|p: &AttachableProcess| p.pid == pid) {
|
||||
continue;
|
||||
}
|
||||
editors.push(AttachableProcess {
|
||||
pid,
|
||||
name: "Unity Editor".into(),
|
||||
command_line: if project.trim().is_empty() { name.into() } else { project.trim().into() },
|
||||
kind: AttachKind::Unity,
|
||||
adapter: "unity".into(),
|
||||
host: None,
|
||||
port: None,
|
||||
});
|
||||
}
|
||||
editors.sort_by(|a, b| a.command_line.cmp(&b.command_line).then(a.pid.cmp(&b.pid)));
|
||||
editors
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn parses_editor_ids_and_projects_without_mistaking_players_or_logs_for_editors() {
|
||||
let rows = parse_editors(
|
||||
"\u{feff}Unity Editor (Unity) (42) Game (Test)\r\nUnity Editor (7) My Game\nUnity Editor (42) duplicate\nWindowsPlayer (123) Player\nUnity Hub (44)\nUnity Editor (invalid)\nUnity Editor (0)\nlog text",
|
||||
);
|
||||
assert_eq!(rows.len(), 2);
|
||||
assert_eq!((rows[0].pid, rows[0].command_line.as_str()), (42, "Game (Test)"));
|
||||
assert_eq!(rows[1].pid, 7);
|
||||
assert!(rows.iter().all(|p| p.kind == AttachKind::Unity && p.adapter == "unity"));
|
||||
}
|
||||
}
|
||||
@@ -1,187 +0,0 @@
|
||||
//! Attaches to a real Unity Editor, with its own temporary project and Editor instance.
|
||||
//! OPENIDEA_UNITY_EDITOR=<Unity.exe> OPENIDEA_UNITY_ADAPTER=<UnityDebug.exe>
|
||||
//! cargo test -p ide-dap --test unity -- --ignored --nocapture
|
||||
|
||||
use ide_core::{IdeEvent, SharedSink, event::DebugEvent};
|
||||
use ide_dap::{Breakpoint, DebugManager, LaunchConfig, SessionOwner, StepKind};
|
||||
use ide_language::LanguageRegistry;
|
||||
use parking_lot::Mutex;
|
||||
use std::{collections::BTreeMap, path::PathBuf, sync::Arc, time::Duration};
|
||||
|
||||
const SCRIPT: &str = r#"using System.IO;
|
||||
using UnityEditor;
|
||||
using UnityEngine;
|
||||
[InitializeOnLoad]
|
||||
public static class OpenIdeaAttachProbe
|
||||
{
|
||||
static readonly string Root = Directory.GetParent(Application.dataPath).FullName;
|
||||
static OpenIdeaAttachProbe()
|
||||
{
|
||||
EditorApplication.update += Tick;
|
||||
}
|
||||
static void Tick()
|
||||
{
|
||||
if (EditorApplication.isCompiling || EditorApplication.isUpdating) return;
|
||||
if (!File.Exists(Path.Combine(Root, "ready")))
|
||||
File.WriteAllText(Path.Combine(Root, "ready"), System.Diagnostics.Process.GetCurrentProcess().Id.ToString());
|
||||
if (File.Exists(Path.Combine(Root, "exit"))) { EditorApplication.Exit(0); return; }
|
||||
if (!File.Exists(Path.Combine(Root, "go"))) return;
|
||||
File.Delete(Path.Combine(Root, "go"));
|
||||
int result = Hit(41);
|
||||
File.WriteAllText(Path.Combine(Root, "done"), result.ToString());
|
||||
}
|
||||
static int Hit(int seed)
|
||||
{
|
||||
int answer = seed + 1;
|
||||
return answer;
|
||||
}
|
||||
}
|
||||
"#;
|
||||
|
||||
async fn stopped(events: &Mutex<Vec<IdeEvent>>, expected_reason: &str) -> i64 {
|
||||
for _ in 0..600 {
|
||||
if let Some(thread) = events.lock().iter().find_map(|e| match e {
|
||||
IdeEvent::Debug { event: DebugEvent::Stopped { thread_id, reason, .. }, .. }
|
||||
if reason == expected_reason =>
|
||||
{
|
||||
Some(*thread_id)
|
||||
}
|
||||
_ => None,
|
||||
}) {
|
||||
return thread;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
}
|
||||
let events = events.lock();
|
||||
panic!("No breakpoint/step event: {:?}", &events[events.len().saturating_sub(16)..]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
#[ignore = "needs a licensed Unity Editor and the Unity DAP adapter"]
|
||||
async fn real_editor_attach_breakpoint_step_variables_and_detach() {
|
||||
let editor = std::env::var("OPENIDEA_UNITY_EDITOR").expect("OPENIDEA_UNITY_EDITOR");
|
||||
let adapter = std::env::var("OPENIDEA_UNITY_ADAPTER").expect("OPENIDEA_UNITY_ADAPTER");
|
||||
let target = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target").canonicalize().unwrap();
|
||||
// Keep the Editor log for diagnosing a failure.
|
||||
let root = tempfile::Builder::new().prefix("unity-dap-smoke-").tempdir_in(target).unwrap().keep();
|
||||
let root = root.to_string_lossy().trim_start_matches(r"\\?\").replace('\\', "/");
|
||||
let root = PathBuf::from(root);
|
||||
std::fs::create_dir_all(root.join("Assets/Editor")).unwrap();
|
||||
std::fs::create_dir(root.join("ProjectSettings")).unwrap();
|
||||
std::fs::create_dir(root.join("Packages")).unwrap();
|
||||
std::fs::write(
|
||||
root.join("ProjectSettings/ProjectVersion.txt"),
|
||||
format!(
|
||||
"m_EditorVersion: {}\n",
|
||||
PathBuf::from(&editor).ancestors().nth(2).and_then(|p| p.file_name()).unwrap().to_string_lossy()
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::write(root.join("Packages/manifest.json"), r#"{"dependencies":{}}"#).unwrap();
|
||||
let source = root.join("Assets/Editor/OpenIdeaAttachProbe.cs");
|
||||
std::fs::write(&source, SCRIPT).unwrap();
|
||||
let mut command = tokio::process::Command::new(&editor);
|
||||
ide_core::process::prepare(command.as_std_mut());
|
||||
// The test project has no packages: skip the package manager.
|
||||
command
|
||||
.args(["-batchmode", "-nographics", "-noUpm", "-debugCodeOptimization", "-projectPath"])
|
||||
.arg(&root)
|
||||
.arg("-logFile")
|
||||
.arg(root.join("Editor.log"))
|
||||
.current_dir(&root)
|
||||
.kill_on_drop(true);
|
||||
let mut child = command.spawn().unwrap();
|
||||
let pid = child.id().unwrap();
|
||||
eprintln!("Isolated Unity pid {pid}, project {}", root.display());
|
||||
for _ in 0..1200 {
|
||||
if root.join("ready").exists() {
|
||||
break;
|
||||
}
|
||||
assert!(child.try_wait().unwrap().is_none(), "Unity exited; inspect {}/Editor.log", root.display());
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
assert!(root.join("ready").exists(), "Editor failed to load the test script");
|
||||
let rows = ide_dap::unity::editors(Some(adapter.clone()), root.clone()).await.unwrap();
|
||||
assert!(rows.iter().any(|p| p.pid == pid), "test Editor absent: {rows:?}");
|
||||
let events: Arc<Mutex<Vec<IdeEvent>>> = Arc::default();
|
||||
let saved = events.clone();
|
||||
let sink: SharedSink = Arc::new(move |event| saved.lock().push(event));
|
||||
let manager = DebugManager::new(Arc::new(LanguageRegistry::from_configs(Vec::new())));
|
||||
let line = SCRIPT.lines().position(|l| l.contains("int answer =")).unwrap() as u32;
|
||||
manager
|
||||
.set_breakpoints(
|
||||
source.clone(),
|
||||
vec![Breakpoint { line, condition: None, hit_condition: None, log_message: None, enabled: true }],
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let start = || {
|
||||
manager.start_with(
|
||||
LaunchConfig {
|
||||
name: format!("Unity Editor ({pid})"),
|
||||
adapter: "unity".into(),
|
||||
request: "attach".into(),
|
||||
program: None,
|
||||
args: vec![],
|
||||
cwd: Some(root.clone().into()),
|
||||
env: BTreeMap::new(),
|
||||
extra_json: Some(
|
||||
serde_json::json!({ "name": format!("Unity Editor ({pid})"), "__exceptionOptions": [] })
|
||||
.to_string(),
|
||||
),
|
||||
},
|
||||
SessionOwner::new("smoke", sink.clone()),
|
||||
|_| Some(adapter.clone()),
|
||||
)
|
||||
};
|
||||
let session = start().await.unwrap();
|
||||
eprintln!("Attached; breakpoint states: {:?}", manager.breakpoint_states(&source));
|
||||
// Mono is ready to run once the start returns.
|
||||
assert!(!manager.threads(session).await.unwrap().is_empty());
|
||||
std::fs::write(root.join("go"), "").unwrap();
|
||||
let thread = stopped(&events, "breakpoint").await;
|
||||
let frames = manager.stack_trace(session, thread).await.unwrap();
|
||||
assert!(!frames.is_empty(), "Empty breakpoint stack: {:?}", events.lock());
|
||||
assert_eq!(frames[0].line, line);
|
||||
let scopes = manager.scopes(session, frames[0].id).await.unwrap();
|
||||
let variables = manager.variables(session, scopes[0].variables_reference).await.unwrap();
|
||||
assert!(variables.iter().any(|v| v.name == "seed" && v.value == "41"), "{variables:?}");
|
||||
assert_eq!(manager.evaluate(session, Some(frames[0].id), "seed + 1".into()).await.unwrap().value, "42");
|
||||
events.lock().clear();
|
||||
manager.step(session, thread, StepKind::Over).await.unwrap();
|
||||
let thread = stopped(&events, "step").await;
|
||||
let frames = manager.stack_trace(session, thread).await.unwrap();
|
||||
assert!(!frames.is_empty(), "Empty step stack: {:?}", events.lock());
|
||||
assert!(frames[0].line > line);
|
||||
// Detaching at a breakpoint resumes the Editor.
|
||||
manager.stop(session).await.unwrap();
|
||||
verify_resumed(&root, &mut child).await;
|
||||
|
||||
// Attaching again to the same Editor hits the existing breakpoint.
|
||||
std::fs::remove_file(root.join("done")).unwrap();
|
||||
events.lock().clear();
|
||||
let session = start().await.unwrap_or_else(|error| {
|
||||
let events = events.lock();
|
||||
panic!("Reattach failed: {error:?}, recent events: {:?}", &events[events.len().saturating_sub(12)..]);
|
||||
});
|
||||
std::fs::write(root.join("go"), "").unwrap();
|
||||
let thread = stopped(&events, "breakpoint").await;
|
||||
assert_eq!(manager.stack_trace(session, thread).await.unwrap()[0].line, line);
|
||||
manager.stop(session).await.unwrap();
|
||||
verify_resumed(&root, &mut child).await;
|
||||
std::fs::write(root.join("exit"), "").unwrap();
|
||||
assert!(tokio::time::timeout(Duration::from_secs(30), child.wait()).await.unwrap().unwrap().success());
|
||||
eprintln!("Verified discovery, attachment, breakpoint, locals, evaluation, step, detach and reattachment");
|
||||
}
|
||||
|
||||
async fn verify_resumed(root: &std::path::Path, child: &mut tokio::process::Child) {
|
||||
let path = root.join("done");
|
||||
for _ in 0..100 {
|
||||
assert!(child.try_wait().unwrap().is_none(), "disconnect terminated the Unity Editor");
|
||||
if std::fs::read_to_string(&path).is_ok_and(|text| text == "42") {
|
||||
return;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
panic!("Unity did not complete the script after disconnect: {:?}", std::fs::read_to_string(path));
|
||||
}
|
||||
@@ -279,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"))
|
||||
}
|
||||
@@ -1091,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| {
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -133,98 +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(())
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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::*;
|
||||
|
||||
@@ -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,
|
||||
}))
|
||||
|
||||
@@ -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))
|
||||
|
||||
@@ -748,15 +748,9 @@ 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();
|
||||
// The project folder and the content roots its walk does not cover: those outside it and
|
||||
// those inside it that it skips as ignored.
|
||||
// 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() || ide_index::walk_skips(&root, r)),
|
||||
)
|
||||
.chain(call.project().content_roots().into_iter().filter(|r| relative_to_root(&root, r).is_none()))
|
||||
.collect();
|
||||
let host = call.host();
|
||||
let walk = Walk {
|
||||
|
||||
@@ -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};
|
||||
@@ -478,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)?;
|
||||
@@ -510,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
|
||||
@@ -539,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)
|
||||
}
|
||||
|
||||
@@ -553,289 +538,39 @@ 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: {e}"))?;
|
||||
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")?) });
|
||||
@@ -852,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 });
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -12,25 +12,6 @@ use std::path::PathBuf;
|
||||
/// Starts a session owned by this window: its events (and those of child sessions) go here only.
|
||||
pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> IdeResult<DebugSessionId> {
|
||||
host.require_trust(window)?;
|
||||
let unity_pid = if config.adapter == "unity" {
|
||||
if config.request != "attach" {
|
||||
return Err(ide_core::IdeError::invalid("Unity debugging only supports attachment to a running Editor"));
|
||||
}
|
||||
let arguments = launch_arguments(&config)?;
|
||||
let pid = arguments["name"]
|
||||
.as_str()
|
||||
.and_then(|name| name.strip_prefix("Unity Editor ("))
|
||||
.and_then(|name| name.strip_suffix(')'))
|
||||
.and_then(|pid| pid.parse::<u32>().ok());
|
||||
if let Some(pid) = pid {
|
||||
require_unity_editor(pid)?;
|
||||
}
|
||||
let cwd = config.cwd.as_ref().map(|path| path.as_ref()).unwrap_or_else(|| std::path::Path::new("."));
|
||||
unity::require_runtime(cwd)?;
|
||||
pid
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
|
||||
if config.adapter == "debugpy"
|
||||
&& config.request == "launch"
|
||||
@@ -119,26 +100,12 @@ 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 result.is_err()
|
||||
&& let Some(pid) = unity_pid
|
||||
{
|
||||
require_unity_editor(pid)?;
|
||||
}
|
||||
if let (Ok(id), Some(port)) = (&result, server_port) {
|
||||
attach_jvm_inspector(host, window, *id, port);
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn require_unity_editor(pid: u32) -> IdeResult<()> {
|
||||
if !ide_core::process::process_alive(pid) {
|
||||
return Err(ide_core::IdeError::unavailable(format!(
|
||||
"Unity Editor (PID {pid}) is no longer running. Refresh the Unity process list and select a running Editor."
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The port of the java-debug server this machine's jdtls started; `debugServer` as `host:port`
|
||||
/// names an adapter on another machine, whose jdtls is not ours to ask.
|
||||
fn debug_server_port(config: &LaunchConfig) -> Option<u16> {
|
||||
@@ -493,17 +460,6 @@ pub async fn debug_free_port(host: &Host, window: &str) -> IdeResult<u16> {
|
||||
ide_dap::adapter::free_port().map_err(ide_core::IdeError::from)
|
||||
}
|
||||
|
||||
pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
if ide_workspace::unity::detect(&project.root).is_none() {
|
||||
return Err(ide_core::IdeError::invalid("Open a Unity project before attaching to the Editor"));
|
||||
}
|
||||
let command = ide_sdk::apply::tool_command(&project.root, &project.settings.effective(), "unity-debug")
|
||||
.map(|p| p.to_string_lossy().into_owned());
|
||||
unity::editors(command, project.root.clone()).await
|
||||
}
|
||||
|
||||
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
|
||||
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
|
||||
pub async fn debug_listen_for_jvm(
|
||||
@@ -708,7 +664,6 @@ pub(crate) fn register(d: &mut Dispatcher) {
|
||||
});
|
||||
d.add("debug_attachable_processes", |c| async move { debug_attachable_processes(&c.host, &c.window).await });
|
||||
d.add("debug_free_port", |c| async move { debug_free_port(&c.host, &c.window).await });
|
||||
d.add("debug_unity_processes", |c| async move { debug_unity_processes(&c.host, &c.window).await });
|
||||
d.add("debug_listen_for_jvm", |c| async move {
|
||||
debug_listen_for_jvm(&c.host, &c.window, c.arg("request")?, c.arg("host")?, c.arg("port")?).await
|
||||
});
|
||||
|
||||
@@ -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
|
||||
});
|
||||
|
||||
@@ -4,7 +4,6 @@
|
||||
|
||||
pub mod agent;
|
||||
pub mod analysis;
|
||||
pub mod bdd;
|
||||
pub mod build;
|
||||
pub mod bytes;
|
||||
pub mod coverage;
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
|
||||
@@ -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 },
|
||||
|
||||
@@ -95,12 +95,8 @@ pub(crate) fn search_project(
|
||||
cancel,
|
||||
&|mut file| {
|
||||
if dir != root {
|
||||
// A root inside the project (one its walk skips) goes by its path there.
|
||||
let prefix = match dir.strip_prefix(root) {
|
||||
Ok(rel) if include_root => rel.to_string_lossy().replace('\\', "/"),
|
||||
_ => dir.file_name().unwrap_or_default().to_string_lossy().into_owned(),
|
||||
};
|
||||
file.rel_path = format!("{prefix}/{}", file.rel_path);
|
||||
let name = dir.file_name().unwrap_or_default().to_string_lossy();
|
||||
file.rel_path = format!("{name}/{}", file.rel_path);
|
||||
}
|
||||
emit(file);
|
||||
},
|
||||
|
||||
@@ -677,14 +677,9 @@ impl Shared {
|
||||
}
|
||||
let previous =
|
||||
self.setting_snapshots.lock().insert((client.map(str::to_owned), pkg.id().into()), current.clone());
|
||||
match previous {
|
||||
// First contact since the plugin loaded (fresh install, update,
|
||||
// re-enable): hand over every current key, so the synthetic
|
||||
// post-install `settings-changed` wakes the plugin instead of being
|
||||
// dropped for having no diff yet.
|
||||
None => current.into_keys().collect(),
|
||||
Some(old) => current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect(),
|
||||
}
|
||||
previous
|
||||
.map(|old| current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
pub fn status_snapshot(&self, client: &str) -> Vec<super::PluginStatusItem> {
|
||||
@@ -2831,7 +2826,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 {
|
||||
|
||||
@@ -1489,8 +1489,9 @@ impl PluginHost {
|
||||
}
|
||||
|
||||
fn declared_view(&self, id: &str, view: &str) -> IdeResult<()> {
|
||||
let declared =
|
||||
ui_points::WEB_POINTS.iter().any(|point| self.ui.items(point, Some(id)).iter().any(|i| i.key == view));
|
||||
let declared = [ui_points::VIEWS, ui_points::CUSTOM_EDITORS]
|
||||
.iter()
|
||||
.any(|point| self.ui.items(point, Some(id)).iter().any(|i| i.key == view));
|
||||
if declared { Ok(()) } else { Err(IdeError::not_found(format!("plugin {id:?} declares no view {view:?}"))) }
|
||||
}
|
||||
|
||||
|
||||
@@ -89,7 +89,6 @@ pub fn register_builtin_points(
|
||||
registry.register(Arc::new(UiPoint::new(p::SETTINGS, ui.clone(), p::settings)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::VIEWS, ui.clone(), p::view)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::CUSTOM_EDITORS, ui.clone(), p::custom_editor)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::EDITOR_PANELS, ui.clone(), p::editor_panel)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::MARKER_ICONS, ui.clone(), p::marker_icon)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::FILE_ICONS, ui.clone(), p::file_icon)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::FILE_TEMPLATES, ui.clone(), p::file_template)))?;
|
||||
|
||||
@@ -36,12 +36,6 @@
|
||||
//! layout = "tab" # or "split" / "preview": beside the text editor
|
||||
//! web = "web/index.html" # a web page from the package instead of rendered content
|
||||
//!
|
||||
//! [[contributes.editorPanels]]
|
||||
//! id = "minimap"
|
||||
//! web = "web/index.html" # beside each editor group's text editor; needs `editor.read`
|
||||
//! width = 110 # pixels, 40–400
|
||||
//! when = "plugin.<id>.enabled" # optional
|
||||
//!
|
||||
//! [[contributes.fileIcons]]
|
||||
//! id = "drawing"
|
||||
//! patterns = ["*.excalidraw"]
|
||||
@@ -79,9 +73,6 @@ pub const STATUS_BAR: &str = "statusBar";
|
||||
pub const SETTINGS: &str = "settings";
|
||||
pub const VIEWS: &str = "views";
|
||||
pub const CUSTOM_EDITORS: &str = "customEditors";
|
||||
pub const EDITOR_PANELS: &str = "editorPanels";
|
||||
/// The points whose declarations can name a `web` page (served, messaged, sent view events).
|
||||
pub const WEB_POINTS: [&str; 3] = [VIEWS, CUSTOM_EDITORS, EDITOR_PANELS];
|
||||
pub const FILE_ICONS: &str = "fileIcons";
|
||||
pub const MARKER_ICONS: &str = "markerIcons";
|
||||
pub const FILE_TEMPLATES: &str = "fileTemplates";
|
||||
@@ -754,41 +745,6 @@ pub(super) fn custom_editor(pkg: &Package, decl: toml::Value) -> Result<UiDecl,
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct EditorPanelDecl {
|
||||
id: String,
|
||||
web: String,
|
||||
width: u32,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
when: Option<String>,
|
||||
}
|
||||
|
||||
const EDITOR_PANEL_WIDTH: std::ops::RangeInclusive<u32> = 40..=400;
|
||||
|
||||
/// `[[contributes.editorPanels]]` (API 1.9): a web page at the right edge of every
|
||||
/// editor group, beside its text editor. It sees each file the group shows, so it
|
||||
/// needs `editor.read`.
|
||||
pub(super) fn editor_panel(pkg: &Package, decl: toml::Value) -> Result<UiDecl, String> {
|
||||
let d: EditorPanelDecl = decode(EDITOR_PANELS, decl)?;
|
||||
pkg.manifest.needs_api(&format!("contributes.{EDITOR_PANELS}"), 9)?;
|
||||
validate_item_id(&d.id, "editor panel id")?;
|
||||
let what = format!("editor panel {:?}", d.id);
|
||||
if !EDITOR_PANEL_WIDTH.contains(&d.width) {
|
||||
return Err(format!("{what}: `width` is {}–{} pixels", EDITOR_PANEL_WIDTH.start(), EDITOR_PANEL_WIDTH.end()));
|
||||
}
|
||||
if let Some(when) = &d.when {
|
||||
validate_when(when).map_err(|e| format!("{what}: {e}"))?;
|
||||
}
|
||||
if !pkg.manifest.capabilities.all().any(|c| *c == ide_extension::Capability::EditorRead) {
|
||||
return Err(format!("{what}: needs the `editor.read` capability (the page sees the files editors show)"));
|
||||
}
|
||||
let files = super::web::web_files(pkg, &d.web, &what)?;
|
||||
let mut out = UiDecl::new(d.id.clone(), d.id.clone(), json(&d)?);
|
||||
out.files = files;
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
#[serde(rename_all = "camelCase", deny_unknown_fields)]
|
||||
struct FileIconDecl {
|
||||
@@ -1240,46 +1196,6 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn editor_panels_validate_api_width_when_capability_and_page() {
|
||||
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/editor-panel");
|
||||
let source = std::fs::read_to_string(root.join("plugin.toml")).unwrap();
|
||||
let check = |source: &str| {
|
||||
let manifest = ide_extension::Manifest::parse(source)?;
|
||||
let decl = manifest.declarations(EDITOR_PANELS).into_iter().next().unwrap();
|
||||
editor_panel(&Package::new(manifest, root.clone()), decl)
|
||||
};
|
||||
let valid = check(&source).unwrap();
|
||||
assert_eq!(valid.key, "minimap");
|
||||
assert_eq!(valid.json, serde_json::json!({ "id": "minimap", "web": "web/index.html", "width": 110 }));
|
||||
assert_eq!(valid.files, [PathBuf::from("web/index.html")]);
|
||||
let when = source.replace("width = 110", "width = 110\nwhen = \"plugin.editor-panel.enabled\"");
|
||||
assert_eq!(check(&when).unwrap().json["when"], "plugin.editor-panel.enabled");
|
||||
for width in ["40", "400"] {
|
||||
assert!(check(&source.replace("width = 110", &format!("width = {width}"))).is_ok(), "{width}");
|
||||
}
|
||||
for (bad, error) in [
|
||||
(source.replace("^1.9", "^1.8"), "1.9"),
|
||||
(source.replace("width = 110", "width = 39"), "40–400"),
|
||||
(source.replace("width = 110", "width = 401"), "40–400"),
|
||||
(source.replace("width = 110", "width = -1"), "u32"),
|
||||
(source.replace("width = 110\n", ""), "width"),
|
||||
(source.replace("width = 110", "width = 110\nwhen = \"a &&\""), "when"),
|
||||
(source.replace("width = 110", "width = 110\nside = \"left\""), "side"),
|
||||
(source.replace(r#"required = ["editor.read"]"#, "required = []"), "editor.read"),
|
||||
(source.replace("web/index.html", "index.html"), "directory of its own"),
|
||||
(source.replace("web/index.html", "web/missing.html"), "no such file"),
|
||||
(source.replace("web/index.html", "../web/index.html"), "web"),
|
||||
(source.replace(r#"id = "minimap""#, r#"id = "Mini Map""#), "id"),
|
||||
] {
|
||||
let err = check(&bad).unwrap_err();
|
||||
assert!(err.contains(error), "{bad}\n→ {err}");
|
||||
}
|
||||
// Declared as optional, the capability is still shown at install.
|
||||
let optional = source.replace("required = [", "optional = [");
|
||||
assert!(check(&optional).is_ok());
|
||||
}
|
||||
|
||||
fn package_with_catalogs(files: &[(&str, &str)]) -> (tempfile::TempDir, Package) {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
std::fs::create_dir(dir.path().join(LOCALES_DIR)).unwrap();
|
||||
|
||||
@@ -335,7 +335,7 @@ impl PluginHost {
|
||||
|
||||
/// The web roots `plugin` declares (entry directories, package-relative, `/`-terminated).
|
||||
fn web_dirs(&self, plugin: &str) -> Vec<String> {
|
||||
super::ui_points::WEB_POINTS
|
||||
[super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
|
||||
.iter()
|
||||
.flat_map(|point| self.ui.items(point, Some(plugin)))
|
||||
.filter_map(|item| item.decl.get("web").and_then(|w| w.as_str()).map(str::to_owned))
|
||||
@@ -356,7 +356,7 @@ impl PluginHost {
|
||||
if !plugin.status().is_live() {
|
||||
return Err(IdeError::unavailable(format!("plugin {plugin_id:?} is not enabled")));
|
||||
}
|
||||
let entry = super::ui_points::WEB_POINTS
|
||||
let entry = [super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
|
||||
.iter()
|
||||
.flat_map(|point| self.ui.items(point, Some(plugin_id)))
|
||||
.find(|item| item.key == view)
|
||||
|
||||
@@ -144,7 +144,7 @@ impl Host {
|
||||
let lsp = LspManager::new(root.clone(), languages.clone(), sink.clone());
|
||||
crate::plugins::injections::configure_lsp(&lsp);
|
||||
lsp.set_execution_allowed(trusted.load(Ordering::Acquire));
|
||||
lsp.set_content_roots(language_server_roots(&root, extra_roots.clone()));
|
||||
lsp.set_content_roots(extra_roots.clone());
|
||||
lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
|
||||
&root,
|
||||
&settings.effective().languages.java.maven.linked_projects,
|
||||
@@ -1224,7 +1224,7 @@ impl Project {
|
||||
return;
|
||||
}
|
||||
let (roots, excludes) = (self.content_roots(), self.exclude_globs());
|
||||
self.lsp.set_content_roots(language_server_roots(&self.root, roots.clone()));
|
||||
self.lsp.set_content_roots(roots.clone());
|
||||
self.lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
|
||||
&self.root,
|
||||
&self.settings.effective().languages.java.maven.linked_projects,
|
||||
@@ -1350,20 +1350,15 @@ pub(crate) fn workspace_member_roots(root: &Path) -> Vec<PathBuf> {
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Workspace members in manifest order, or the attached projects outside the project and
|
||||
/// those inside it that its walk skips as ignored (a git worktree under an ignored folder),
|
||||
/// extra Project Structure directories, Gradle project folders outside the project, and
|
||||
/// directories of Maven POMs linked from outside it (`build_cache` is the Gradle sync cache).
|
||||
/// Workspace members in manifest order, or extra Project Structure directories, Gradle
|
||||
/// project folders outside the project, and directories of Maven POMs linked from
|
||||
/// outside it (`build_cache` is the Gradle sync cache).
|
||||
fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cache: &Path) -> Vec<PathBuf> {
|
||||
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root) {
|
||||
if workspace.is_container(root) {
|
||||
return workspace.projects;
|
||||
}
|
||||
let mut roots = workspace
|
||||
.projects
|
||||
.into_iter()
|
||||
.filter(|p| !p.starts_with(root) || ide_index::walk_skips(root, p))
|
||||
.collect::<Vec<_>>();
|
||||
let mut roots = workspace.projects.into_iter().filter(|p| !p.starts_with(root)).collect::<Vec<_>>();
|
||||
for path in extra_content_roots(settings, root, build_cache) {
|
||||
if !roots.contains(&path) {
|
||||
roots.push(path);
|
||||
@@ -1374,22 +1369,6 @@ fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cac
|
||||
extra_content_roots(settings, root, build_cache)
|
||||
}
|
||||
|
||||
/// The content roots plus the projects attached inside this one. The index covers those
|
||||
/// already, but each is a project of its own (a git worktree under the project, a nested
|
||||
/// Cargo workspace), so its files get a language server rooted there, not at this root.
|
||||
fn language_server_roots(root: &Path, mut roots: Vec<PathBuf>) -> Vec<PathBuf> {
|
||||
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root)
|
||||
&& !workspace.is_container(root)
|
||||
{
|
||||
for path in workspace.projects {
|
||||
if path != root && path.starts_with(root) && !roots.contains(&path) {
|
||||
roots.push(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
roots
|
||||
}
|
||||
|
||||
/// The roots a file may navigate into: its own root (the workspace member containing it, or
|
||||
/// the project root) plus that root's configured dependencies. A workspace member depends
|
||||
/// only on the roots picked per member in Project Structure › Dependencies —
|
||||
@@ -2184,25 +2163,4 @@ mod content_roots_tests {
|
||||
let roots = content_roots(&settings, &root, &tmp.path().join("build"));
|
||||
assert_eq!(roots, vec![shared, dep]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn projects_attached_inside_the_root_get_their_own_language_server_root() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ws = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let (root, nested, other) = (ws.join("app"), ws.join("app/.wt/feature"), ws.join("other"));
|
||||
for dir in [&nested, &other] {
|
||||
std::fs::create_dir_all(dir).unwrap();
|
||||
}
|
||||
let settings = ide_core::settings::Settings::default();
|
||||
let build = ws.join("build");
|
||||
assert!(super::language_server_roots(&root, content_roots(&settings, &root, &build)).is_empty());
|
||||
|
||||
ide_workspace::workspace::Workspace::attach(&root, "app", vec![root.clone(), nested.clone(), other.clone()])
|
||||
.unwrap();
|
||||
// The index walks the nested project as part of the root ...
|
||||
let roots = content_roots(&settings, &root, &build);
|
||||
assert_eq!(roots, vec![other.clone()]);
|
||||
// ... while its files go to a language server of its own.
|
||||
assert_eq!(super::language_server_roots(&root, roots), vec![other, nested]);
|
||||
}
|
||||
}
|
||||
@@ -547,13 +547,9 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
|
||||
| "agent_registry_remove"
|
||||
| "agent_mcp_list"
|
||||
| "agent_mcp_save"
|
||||
| "agent_mcp_save_json"
|
||||
| "agent_mcp_set_enabled"
|
||||
| "agent_mcp_remove"
|
||||
| "agent_mcp_import"
|
||||
| "agent_mcp_discover_sources"
|
||||
| "agent_mcp_import_selected"
|
||||
| "agent_set_mcp_overrides"
|
||||
| "coverage_import"
|
||||
| "system_font_families"
|
||||
| "user_font_data"
|
||||
|
||||
@@ -594,31 +594,6 @@ fn agent_process(h: &Harness, name: &str) -> ide_core::RunId {
|
||||
h.host.processes.list().into_iter().filter(|r| r.config_id == id && r.running).map(|r| r.id).max().unwrap()
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn run_command_returns_once_a_server_prints_its_ready_line() {
|
||||
let h = Harness::new();
|
||||
h.trust().await;
|
||||
h.host.mcp_requests.set_ready("main", true);
|
||||
h.host
|
||||
.global_settings
|
||||
.set(ide_workspace::SettingsScope::Global, "mcpServer.runWithoutConfirmation", json!(true))
|
||||
.unwrap();
|
||||
let _started = run_tool_window(&h);
|
||||
// A server started with its ready line returns once it prints it, long before the timeout.
|
||||
let started_at = std::time::Instant::now();
|
||||
let up = h
|
||||
.json(
|
||||
"run_command",
|
||||
json!({"name": "web", "command": "sleep 1; echo Listening on 8080; sleep 30", "pattern": "Listening on", "timeout": 60000}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!((up["waitEnded"].as_str(), up["state"].as_str()), (Some("matched"), Some("running")), "{up}");
|
||||
assert!(up["output"].as_str().unwrap().contains("Listening on 8080"), "{up}");
|
||||
assert!(started_at.elapsed() < std::time::Duration::from_secs(20), "returned after {:?}", started_at.elapsed());
|
||||
h.json("stop_run", json!({"name": "web", "force": true, "timeout": 10000})).await;
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
|
||||
|
||||
@@ -6271,15 +6271,10 @@ fn api14_settings_and_input_events_use_other_and_capture_the_editor() {
|
||||
assert!(f.host.wait_events(Duration::from_secs(5)));
|
||||
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
|
||||
let events = received.as_array().unwrap();
|
||||
assert_eq!(events.len(), 4, "{received}");
|
||||
// The first synthetic post hands over the current keys ("enabled": false);
|
||||
// the second is a real diff to true. Keys come from the recomputed
|
||||
// snapshot, never from the event payload ("another-plugin-key").
|
||||
assert_eq!(events.len(), 3, "{received}");
|
||||
assert_eq!(events[0]["kind"], "settings-changed");
|
||||
assert_eq!(events[0]["data"], "[\"enabled\"]");
|
||||
assert_eq!(events[1]["kind"], "settings-changed");
|
||||
assert_eq!(events[1]["data"], "[\"enabled\"]");
|
||||
assert_eq!(events[3]["kind"], "input-mode-changed");
|
||||
assert_eq!(events[2]["kind"], "input-mode-changed");
|
||||
assert_eq!(events[2]["editor"][0], path);
|
||||
assert_eq!(events[2]["editor"][1][0], serde_json::json!([0, 0, 0, 0]));
|
||||
}
|
||||
@@ -7021,22 +7016,3 @@ fn the_language_server_grant_needs_api_1_9() {
|
||||
let err = f.host.install_from_dir(&pkg, &Consent::all()).unwrap_err();
|
||||
assert!(err.message.contains("new in plugin API 1.9"), "{err:?}");
|
||||
}
|
||||
|
||||
/// The UI's synthetic post-install `SettingsChanged([])` reaches a plugin that
|
||||
/// subscribes to `on-event:settings-changed`, though it carries no keys.
|
||||
#[test]
|
||||
fn a_freshly_installed_plugin_gets_the_post_install_settings_event() {
|
||||
let f = fixture(Limits::default());
|
||||
f.install(&sample("api14"));
|
||||
use ide_plugin::WorkbenchEvent as E;
|
||||
// What refreshEventKinds() posts right after commandsChanged (install).
|
||||
f.host.post_events(Some("main"), vec![E::SettingsChanged(Vec::new())]);
|
||||
f.host.flush_events_at(Instant::now() + Duration::from_secs(2));
|
||||
assert!(f.host.wait_events(Duration::from_secs(5)));
|
||||
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
|
||||
let events = received.as_array().unwrap();
|
||||
assert!(
|
||||
events.iter().any(|e| e["kind"] == "settings-changed"),
|
||||
"freshly installed plugin got no post-install event: {received}"
|
||||
);
|
||||
}
|
||||
@@ -105,70 +105,6 @@ async fn linked_projects_share_navigation_but_keep_files_repositories_and_run_di
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_project_attached_inside_the_root_is_searched_and_indexed_once() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let root = base.join("app");
|
||||
// `.wt/feature` is its own repository, which the outer one ignores; `lib` is not ignored.
|
||||
let (ignored, covered) = (root.join(".wt/feature"), root.join("lib"));
|
||||
for dir in [&root, &ignored, &covered] {
|
||||
std::fs::create_dir_all(dir).unwrap();
|
||||
}
|
||||
for repo in [&root, &ignored] {
|
||||
assert!(std::process::Command::new("git").args(["init", "-q"]).current_dir(repo).status().unwrap().success());
|
||||
}
|
||||
std::fs::write(root.join(".git/info/exclude"), "/.wt/\n").unwrap();
|
||||
std::fs::write(root.join("main.txt"), "needle\n").unwrap();
|
||||
std::fs::write(ignored.join("feature.txt"), "needle\n").unwrap();
|
||||
std::fs::write(covered.join("lib.txt"), "needle\n").unwrap();
|
||||
let host = Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("data"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(NullSink)),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
});
|
||||
for dir in [&root, &ignored, &covered] {
|
||||
host.trust.decide(dir, true, false).unwrap();
|
||||
}
|
||||
let project = host.open_project("main", &root).unwrap();
|
||||
ops::project::attach_workspace(&host, "main", &ignored).unwrap();
|
||||
ops::project::attach_workspace(&host, "main", &covered).unwrap();
|
||||
assert_eq!(project.content_roots(), vec![ignored.clone()], "the root's walk covers `lib`");
|
||||
|
||||
assert!(project.index.wait_idle(Duration::from_secs(10)));
|
||||
let files = project.index.find_files(".txt", 100);
|
||||
let mut indexed = files.iter().map(|f| f.rel_path.clone()).collect::<Vec<_>>();
|
||||
indexed.sort();
|
||||
assert_eq!(indexed, [".wt/feature/feature.txt", "lib/lib.txt", "main.txt"]);
|
||||
|
||||
let hits = Arc::new(Mutex::new(Vec::new()));
|
||||
let out = hits.clone();
|
||||
let query = serde_json::from_value(serde_json::json!({"pattern":"needle", "isRegex":false, "caseSensitive":false,"wholeWord":false,"include":[],"exclude":[],"scope":{"kind":"project"},"maxMatches":100})).unwrap();
|
||||
ops::search::start(
|
||||
&host,
|
||||
"main",
|
||||
RequestId::next(),
|
||||
query,
|
||||
Arc::new(move |event| {
|
||||
if let ops::search::SearchEvent::File { file } = event {
|
||||
out.lock().unwrap().push(file.rel_path);
|
||||
}
|
||||
}),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let mut found = hits.lock().unwrap().clone();
|
||||
found.sort();
|
||||
assert_eq!(found, [".wt/feature/feature.txt", "lib/lib.txt", "main.txt"]);
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn python_effective_interpreter_falls_back_to_the_primary_project() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -34,16 +34,6 @@ pub struct RunInput<'a> {
|
||||
/// variables, missing includes) fail; transport errors are part of the exchange.
|
||||
pub async fn run(input: RunInput<'_>, cancel: &CancellationToken) -> IdeResult<HttpExchange> {
|
||||
let request = prepare(&input)?;
|
||||
send(request, input.file, cancel).await
|
||||
}
|
||||
|
||||
/// Sends an already prepared request (one the user approved as shown); `file` is the
|
||||
/// request file it came from, for the history.
|
||||
pub async fn send(
|
||||
request: PreparedRequest,
|
||||
file: Option<&Path>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<HttpExchange> {
|
||||
let time_ms = std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|d| d.as_secs_f64() * 1000.0)
|
||||
@@ -67,7 +57,7 @@ pub async fn send(
|
||||
url: request.url.clone(),
|
||||
status: response.as_ref().map(|r| r.status),
|
||||
total_ms: response.as_ref().map(|r| r.total_ms),
|
||||
file: file.map(IpcPath::from),
|
||||
file: input.file.map(IpcPath::from),
|
||||
error,
|
||||
},
|
||||
request,
|
||||
|
||||
@@ -52,29 +52,6 @@ fn root_ignores(root: &Path) -> Gitignore {
|
||||
gi.build().unwrap_or_else(|_| Gitignore::empty())
|
||||
}
|
||||
|
||||
/// Whether walking `root` leaves out `dir`, a folder below it: `dir` or a folder between
|
||||
/// them is ignored (`.gitignore`, `.ignore`, `info/exclude`, the global excludes). Such a
|
||||
/// folder can be a root of its own, with its own rules, without its files being walked twice.
|
||||
pub fn walk_skips(root: &Path, dir: &Path) -> bool {
|
||||
if dir == root || !dir.starts_with(root) || !dir.is_dir() {
|
||||
return false;
|
||||
}
|
||||
let target = dir.to_path_buf();
|
||||
let walker = WalkBuilder::new(root)
|
||||
.hidden(false)
|
||||
.parents(true)
|
||||
.ignore(true)
|
||||
.git_ignore(true)
|
||||
.git_global(true)
|
||||
.git_exclude(true)
|
||||
.require_git(ide_core::ignored::inside_git_repo(root))
|
||||
.follow_links(false)
|
||||
// Only the folders on the way down to `dir`.
|
||||
.filter_entry(move |e| target.starts_with(e.path()))
|
||||
.build();
|
||||
!walker.flatten().any(|e| e.path() == dir)
|
||||
}
|
||||
|
||||
fn rel_string(rel: &Path) -> String {
|
||||
let mut out = String::new();
|
||||
for c in rel.components() {
|
||||
@@ -138,18 +115,12 @@ impl PathFilter {
|
||||
let mut extra: Vec<ExtraRoot> = Vec::new();
|
||||
for r in &extra_roots.folders {
|
||||
let path = dunce::canonicalize(r).unwrap_or_else(|_| r.clone());
|
||||
// A folder inside the root is a root of its own only when the root's walk skips it.
|
||||
let inside = path.starts_with(root) && !walk_skips(root, &path);
|
||||
let nested = (extra_roots.include_root && (inside || root.starts_with(&path)))
|
||||
let nested = (extra_roots.include_root && (path.starts_with(root) || root.starts_with(&path)))
|
||||
|| extra.iter().any(|e| path.starts_with(&e.path) || e.path.starts_with(&path));
|
||||
if nested || !path.is_dir() {
|
||||
continue;
|
||||
}
|
||||
// Inside the root it goes by its path there, elsewhere by its folder name.
|
||||
let name = match path.strip_prefix(root) {
|
||||
Ok(rel) if extra_roots.include_root => rel_string(rel),
|
||||
_ => path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),
|
||||
};
|
||||
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
|
||||
extra.push(ExtraRoot { gitignore: root_ignores(&path), name, path });
|
||||
}
|
||||
Self {
|
||||
@@ -205,11 +176,13 @@ impl PathFilter {
|
||||
|
||||
/// The root containing `path`, its display prefix (`None` for the project root) and ignore rules.
|
||||
fn base_of(&self, path: &Path) -> Option<(&Path, Option<&str>, &Gitignore)> {
|
||||
// An extra root inside the project root wins: its own rules apply below it.
|
||||
if let Some(e) = self.extra.iter().find(|e| path.starts_with(&e.path)) {
|
||||
return Some((e.path.as_path(), Some(e.name.as_str()), &e.gitignore));
|
||||
if self.include_root && path.starts_with(&self.root) {
|
||||
return Some((&self.root, None, &self.gitignore));
|
||||
}
|
||||
(self.include_root && path.starts_with(&self.root)).then_some((self.root.as_path(), None, &self.gitignore))
|
||||
self.extra
|
||||
.iter()
|
||||
.find(|e| path.starts_with(&e.path))
|
||||
.map(|e| (e.path.as_path(), Some(e.name.as_str()), &e.gitignore))
|
||||
}
|
||||
|
||||
/// Whether `path` is (at or) below one of the roots.
|
||||
@@ -234,7 +207,7 @@ impl PathFilter {
|
||||
/// Key of `path` in the persistent store: only files below the project root
|
||||
/// are persisted (extra content roots are rescanned when the project opens).
|
||||
pub(crate) fn store_key(&self, path: &Path) -> Option<String> {
|
||||
if !self.include_root || self.extra.iter().any(|e| path.starts_with(&e.path)) {
|
||||
if !self.include_root {
|
||||
return None;
|
||||
}
|
||||
let rel = rel_string(path.strip_prefix(&self.root).ok()?);
|
||||
@@ -564,35 +537,4 @@ src/local/
|
||||
assert!(filter.same_config(&vec![shared.clone(), root.join("src")].into(), &["target".into()]));
|
||||
assert!(!filter.same_config(&vec![shared].into(), &["target".into()]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_ignored_folder_inside_the_root_is_a_root_with_its_own_rules() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(dir.path()).unwrap();
|
||||
let nested = root.join(".wt/feature");
|
||||
for f in ["src/a.rs", "lib/d.rs", ".wt/feature/src/b.rs", ".wt/feature/out/c.rs"] {
|
||||
touch(&root, f);
|
||||
}
|
||||
// A git worktree kept inside the repository it belongs to, which ignores it.
|
||||
std::fs::create_dir_all(root.join(".git/info")).unwrap();
|
||||
std::fs::write(root.join(".git/info/exclude"), "/.wt/\n").unwrap();
|
||||
std::fs::write(nested.join(".git"), "gitdir: ../../.git/worktrees/feature\n").unwrap();
|
||||
std::fs::write(nested.join(".gitignore"), "out/\n").unwrap();
|
||||
assert!(walk_skips(&root, &nested));
|
||||
assert!(!walk_skips(&root, &root.join("lib")));
|
||||
|
||||
let filter = PathFilter::new(&root, &vec![nested.clone(), root.join("lib")].into(), &[]);
|
||||
assert_eq!(filter.roots().count(), 2, "a folder the root's walk covers is not a root of its own");
|
||||
let mut found: Vec<String> = filter
|
||||
.roots()
|
||||
.flat_map(|r| filter.walk(r, &AtomicBool::new(false)))
|
||||
.filter_map(|f| filter.rel(&f.path))
|
||||
.collect();
|
||||
found.sort();
|
||||
assert_eq!(found, [".wt/feature/.gitignore", ".wt/feature/src/b.rs", "lib/d.rs", "src/a.rs"]);
|
||||
assert_eq!(filter.store_key(&nested.join("src/b.rs")), None, "extra roots are not persisted");
|
||||
assert!(!filter.is_excluded(&nested.join("src/new.rs"), false));
|
||||
assert!(filter.is_excluded(&nested.join("out/new.rs"), false));
|
||||
assert!(filter.is_excluded(&root.join(".wt/other/x.rs"), false));
|
||||
}
|
||||
}
|
||||
@@ -21,7 +21,6 @@ mod matching;
|
||||
mod store;
|
||||
mod worker;
|
||||
|
||||
pub use filter::walk_skips;
|
||||
pub use worker::MAX_SYMBOL_FILE;
|
||||
use worker::{Job, MAX_RECENT, Shared};
|
||||
|
||||
|
||||
@@ -33,7 +33,6 @@ const BUILTIN: &[(&str, &str)] = &[
|
||||
("gdscript", include_str!("../../../languages/gdscript.toml")),
|
||||
("gdshader", include_str!("../../../languages/gdshader.toml")),
|
||||
("go", include_str!("../../../languages/go.toml")),
|
||||
("gherkin", include_str!("../../../languages/gherkin.toml")),
|
||||
("gomod", include_str!("../../../languages/gomod.toml")),
|
||||
("gowork", include_str!("../../../languages/gowork.toml")),
|
||||
("godot-resource", include_str!("../../../languages/godot-resource.toml")),
|
||||
@@ -627,7 +626,6 @@ mod tests {
|
||||
"Vue",
|
||||
"Angular Template",
|
||||
"Angular TypeScript",
|
||||
"Thymeleaf",
|
||||
"ERB",
|
||||
"JSP",
|
||||
"Astro",
|
||||
@@ -680,7 +678,7 @@ mod tests {
|
||||
let got: Vec<(&str, bool)> = cfg
|
||||
.language_servers
|
||||
.iter()
|
||||
.filter(|s| !s.require_root_marker && s.features.is_empty())
|
||||
.filter(|s| !s.require_root_marker)
|
||||
.map(|s| (s.name.as_str(), s.fallback))
|
||||
.collect();
|
||||
let expected: Vec<(&str, bool)> = servers.iter().enumerate().map(|(i, name)| (*name, i > 0)).collect();
|
||||
@@ -780,26 +778,13 @@ mod tests {
|
||||
assert_eq!(served("lib/src/Parser.php"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pylsp_adds_only_rope_refactorings_to_python() {
|
||||
let reg = reg();
|
||||
let cfg = reg.get(&LanguageId::new("python")).unwrap();
|
||||
let pylsp = cfg.language_servers.iter().find(|s| s.name == "pylsp").unwrap();
|
||||
assert!(!pylsp.fallback && !pylsp.require_root_marker);
|
||||
assert_eq!(pylsp.features, ["code-action"]);
|
||||
assert_eq!(pylsp.code_action_kinds, ["refactor"]);
|
||||
let plugins = pylsp.initialization_options.as_ref().unwrap()["pylsp"]["plugins"].as_table().unwrap();
|
||||
assert_eq!(plugins["jedi_completion"]["enabled"].as_bool(), Some(false));
|
||||
assert!(plugins.values().all(|p| p["enabled"].as_bool() == Some(false)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ruff_serves_python_files_only_below_its_config() {
|
||||
let reg = reg();
|
||||
let cfg = reg.get(&LanguageId::new("python")).unwrap();
|
||||
let names: Vec<&str> = cfg.language_servers.iter().map(|s| s.name.as_str()).collect();
|
||||
// After the fallbacks: hover, rename and symbols stay with the type checker.
|
||||
assert_eq!(names, ["basedpyright", "pyright", "ty", "pyrefly", "ruff", "pylsp"]);
|
||||
assert_eq!(names, ["basedpyright", "pyright", "ty", "pyrefly", "ruff"]);
|
||||
let ruff = cfg.language_servers.iter().find(|s| s.name == "ruff").unwrap();
|
||||
assert_eq!((ruff.command.as_str(), ruff.args.as_slice()), ("ruff", ["server".to_string()].as_slice()));
|
||||
assert!(ruff.require_root_marker && !ruff.fallback);
|
||||
@@ -841,23 +826,6 @@ mod tests {
|
||||
assert!(!reg.is_framework_marker(&root.join("apps/admin/package.json")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spring_template_folders_make_html_thymeleaf() {
|
||||
let reg = reg();
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path();
|
||||
let mode = |file: &str| reg.framework_ui_mode(&LanguageId::new("html"), &root.join(file), Some(root));
|
||||
std::fs::create_dir_all(root.join("web/src/main/resources/templates/fragments")).unwrap();
|
||||
std::fs::create_dir_all(root.join("docs")).unwrap();
|
||||
for file in
|
||||
["web/src/main/resources/templates/index.html", "web/src/main/resources/templates/fragments/nav.html"]
|
||||
{
|
||||
assert_eq!(mode(file).as_deref(), Some("Thymeleaf"), "{file}");
|
||||
}
|
||||
assert_eq!(mode("docs/index.html"), None);
|
||||
assert!(reg.is_framework_marker(&root.join("web/src/main/resources/templates")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn django_projects_make_html_in_templates_folders_templates() {
|
||||
let reg = reg();
|
||||
@@ -1089,7 +1057,6 @@ mod tests {
|
||||
("CMakeLists.txt", "cmake"),
|
||||
("api.proto", "proto"),
|
||||
("schema.graphql", "graphql"),
|
||||
("checkout.feature", "gherkin"),
|
||||
("schema.prisma", "prisma"),
|
||||
("main.tf", "terraform"),
|
||||
("prod.tfvars", "terraform-vars"),
|
||||
|
||||
@@ -6,15 +6,11 @@
|
||||
|
||||
use crate::LspManager;
|
||||
use crate::server::Server;
|
||||
use ide_core::{CancellationToken, DocId, Pos, Range};
|
||||
use ide_core::{DocId, Pos, Range};
|
||||
use serde::Deserialize;
|
||||
use std::collections::HashMap;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Command, Stdio};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::Ordering;
|
||||
use std::time::Duration;
|
||||
use tokio::io::AsyncReadExt;
|
||||
|
||||
pub(crate) const CHECK_UPGRADES: &str = "gopls.check_upgrades";
|
||||
/// gopls answers code lenses once it has loaded the module.
|
||||
@@ -22,43 +18,6 @@ const ATTEMPTS: u32 = 10;
|
||||
const RETRY: Duration = Duration::from_secs(2);
|
||||
/// Producer of the deprecation diagnostics (one full set per go.mod).
|
||||
const DEPRECATIONS: &str = "go-mod-deprecations";
|
||||
// This optional background check must not wait indefinitely on a proxy or toolchain download.
|
||||
const QUERY_TIMEOUT: Duration = Duration::from_secs(60);
|
||||
const OUTPUT_LIMIT: u64 = 8 * 1024 * 1024;
|
||||
|
||||
#[derive(Default)]
|
||||
pub(crate) struct Queries {
|
||||
generation: u64,
|
||||
running: HashMap<DocId, (u64, CancellationToken)>,
|
||||
}
|
||||
|
||||
impl Queries {
|
||||
fn begin(&mut self, doc: DocId) -> (u64, CancellationToken) {
|
||||
self.cancel(doc);
|
||||
self.generation += 1;
|
||||
let cancel = CancellationToken::new();
|
||||
self.running.insert(doc, (self.generation, cancel.clone()));
|
||||
(self.generation, cancel)
|
||||
}
|
||||
|
||||
fn finish(&mut self, doc: DocId, generation: u64) {
|
||||
if self.running.get(&doc).is_some_and(|(current, _)| *current == generation) {
|
||||
self.running.remove(&doc);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn cancel(&mut self, doc: DocId) {
|
||||
if let Some((_, cancel)) = self.running.remove(&doc) {
|
||||
cancel.cancel();
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn cancel_all(&mut self) {
|
||||
for (_, (_, cancel)) in self.running.drain() {
|
||||
cancel.cancel();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn is_go_mod(path: &Path) -> bool {
|
||||
path.file_name().is_some_and(|n| n == "go.mod")
|
||||
@@ -107,15 +66,6 @@ impl LspManager {
|
||||
}
|
||||
|
||||
async fn report_deprecated_modules(&self, doc: DocId, server: &Server) {
|
||||
let (generation, cancel) = self.go_mod_queries.lock().begin(doc);
|
||||
self.report_deprecated_modules_query(doc, server, &cancel).await;
|
||||
self.go_mod_queries.lock().finish(doc, generation);
|
||||
}
|
||||
|
||||
async fn report_deprecated_modules_query(&self, doc: DocId, server: &Server, cancel: &CancellationToken) {
|
||||
if self.shutting_down.load(Ordering::Acquire) || !self.execution_allowed.load(Ordering::Acquire) {
|
||||
return;
|
||||
}
|
||||
let Some((path, text)) = self.docs.lock().get(&doc).map(|d| (d.path.clone(), d.text.as_str().to_owned()))
|
||||
else {
|
||||
return;
|
||||
@@ -128,9 +78,10 @@ impl LspManager {
|
||||
let search = crate::launch::server_search_path(&config);
|
||||
let Some(dir) = path.parent().map(Path::to_path_buf) else { return };
|
||||
let modules: Vec<String> = required.iter().map(|r| r.path.clone()).collect();
|
||||
let Some(deprecated) = list_deprecations(&dir, &search, &modules, cancel).await else { return };
|
||||
let listed = tokio::task::spawn_blocking(move || list_deprecations(&dir, &search, &modules)).await;
|
||||
let Ok(Some(deprecated)) = listed else { return };
|
||||
// The document changed meanwhile: its own save runs again.
|
||||
if cancel.is_cancelled() || self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
|
||||
if self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
|
||||
return;
|
||||
}
|
||||
let items = required
|
||||
@@ -206,100 +157,22 @@ struct ListedModule {
|
||||
}
|
||||
|
||||
/// `(module, message)` of each deprecated module in `modules`; `None` when `go` failed.
|
||||
async fn list_deprecations(
|
||||
dir: &Path,
|
||||
search: &std::ffi::OsStr,
|
||||
modules: &[String],
|
||||
cancel: &CancellationToken,
|
||||
) -> Option<Vec<(String, String)>> {
|
||||
let (dir, search, modules) = (dir.to_path_buf(), search.to_owned(), modules.to_vec());
|
||||
let command = tokio::task::spawn_blocking(move || {
|
||||
let go: PathBuf = ide_core::tool_path::find_command("go", &search, &dir)?;
|
||||
let mut command = Command::new(go);
|
||||
command.args(["list", "-m", "-u", "-e", "-json"]).args(modules).current_dir(dir).env("PATH", search);
|
||||
Some(command)
|
||||
})
|
||||
.await
|
||||
.ok()??;
|
||||
let output = run_query(command, cancel, QUERY_TIMEOUT).await?;
|
||||
if output.is_empty() {
|
||||
fn list_deprecations(dir: &Path, search: &std::ffi::OsStr, modules: &[String]) -> Option<Vec<(String, String)>> {
|
||||
let go: PathBuf = ide_core::tool_path::find_command("go", search, dir)?;
|
||||
let output = ide_core::process::prepare(&mut std::process::Command::new(go))
|
||||
.args(["list", "-m", "-u", "-e", "-json"])
|
||||
.args(modules)
|
||||
.current_dir(dir)
|
||||
.env("PATH", search)
|
||||
.stdin(std::process::Stdio::null())
|
||||
.stderr(std::process::Stdio::null())
|
||||
.output()
|
||||
.ok()?;
|
||||
if output.stdout.is_empty() {
|
||||
tracing::debug!("go list -m -u in {}: {}", dir.display(), output.status);
|
||||
return None;
|
||||
}
|
||||
tokio::task::spawn_blocking(move || parse_deprecations(&output)).await.ok()
|
||||
}
|
||||
|
||||
async fn run_query(command: Command, cancel: &CancellationToken, timeout: Duration) -> Option<Vec<u8>> {
|
||||
let cancel = cancel.child_token();
|
||||
let _cancel_on_drop = cancel.clone().drop_guard();
|
||||
// The supervisor owns cleanup even if the caller's future is dropped.
|
||||
tokio::spawn(async move { supervise_query(command, &cancel, timeout).await }).await.ok().flatten()
|
||||
}
|
||||
|
||||
async fn supervise_query(mut command: Command, cancel: &CancellationToken, timeout: Duration) -> Option<Vec<u8>> {
|
||||
if cancel.is_cancelled() {
|
||||
return None;
|
||||
}
|
||||
ide_core::process::prepare(&mut command);
|
||||
ide_core::process::own_group(&mut command);
|
||||
command.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
|
||||
let mut command = tokio::process::Command::from(command);
|
||||
command.kill_on_drop(true);
|
||||
let mut child = command.spawn().ok()?;
|
||||
#[cfg(windows)]
|
||||
let job = child.id().and_then(ide_core::process::Job::for_pid);
|
||||
let stdout = child.stdout.take()?;
|
||||
let mut reader = tokio::spawn(async move {
|
||||
let mut output = Vec::new();
|
||||
stdout.take(OUTPUT_LIMIT + 1).read_to_end(&mut output).await.ok()?;
|
||||
if output.len() as u64 > OUTPUT_LIMIT {
|
||||
tracing::debug!("go module query exceeded stdout budget");
|
||||
return None;
|
||||
}
|
||||
Some(output)
|
||||
});
|
||||
let deadline = tokio::time::sleep(timeout);
|
||||
tokio::pin!(deadline);
|
||||
// Drain before reaping: if a descendant holds stdout open, the root's id
|
||||
// still belongs to this child when cancellation kills its process tree.
|
||||
let output = tokio::select! {
|
||||
biased;
|
||||
() = cancel.cancelled() => None,
|
||||
() = &mut deadline => {
|
||||
tracing::debug!("go module query timed out");
|
||||
None
|
||||
},
|
||||
result = &mut reader => result.ok().flatten(),
|
||||
};
|
||||
if let Some(bytes) = output {
|
||||
let status = tokio::select! {
|
||||
biased;
|
||||
() = cancel.cancelled() => None,
|
||||
() = &mut deadline => {
|
||||
tracing::debug!("go module query timed out");
|
||||
None
|
||||
},
|
||||
status = child.wait() => Some(status),
|
||||
};
|
||||
if let Some(status) = status {
|
||||
return status.ok().map(|_| bytes);
|
||||
}
|
||||
}
|
||||
// The root is still unreaped here, so its process/group id cannot be reused.
|
||||
if let Some(pid) = child.id() {
|
||||
let _ = tokio::task::spawn_blocking(move || {
|
||||
#[cfg(windows)]
|
||||
if let Some(job) = job {
|
||||
job.terminate();
|
||||
return;
|
||||
}
|
||||
ide_core::process::kill_tree_of(pid);
|
||||
})
|
||||
.await;
|
||||
}
|
||||
let _ = child.start_kill();
|
||||
let _ = child.wait().await;
|
||||
reader.abort();
|
||||
None
|
||||
Some(parse_deprecations(&output.stdout))
|
||||
}
|
||||
|
||||
fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
|
||||
@@ -314,231 +187,6 @@ fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn queries_cancel_only_the_superseded_document() {
|
||||
let mut queries = Queries::default();
|
||||
let (first, old) = queries.begin(DocId(1));
|
||||
let (_, other) = queries.begin(DocId(2));
|
||||
let (second, new) = queries.begin(DocId(1));
|
||||
assert!(old.is_cancelled());
|
||||
assert!(!other.is_cancelled());
|
||||
assert!(!new.is_cancelled());
|
||||
queries.finish(DocId(1), first);
|
||||
assert_eq!(queries.running.len(), 2);
|
||||
queries.finish(DocId(1), second);
|
||||
assert_eq!(queries.running.len(), 1);
|
||||
queries.cancel_all();
|
||||
assert!(other.is_cancelled());
|
||||
assert!(queries.running.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn closing_one_document_does_not_cancel_another() {
|
||||
let mut queries = Queries::default();
|
||||
let (_, closed) = queries.begin(DocId(1));
|
||||
let (_, other) = queries.begin(DocId(2));
|
||||
queries.cancel(DocId(1));
|
||||
assert!(closed.is_cancelled());
|
||||
assert!(!other.is_cancelled());
|
||||
assert_eq!(queries.running.len(), 1);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn shell(script: &str) -> Command {
|
||||
let mut command = Command::new("sh");
|
||||
command.args(["-c", script]);
|
||||
command
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
async fn assert_stopped(pid: u32) {
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while let Ok(stat) = std::fs::read_to_string(format!("/proc/{pid}/stat")) {
|
||||
if stat.rsplit_once(") ").unwrap().1.split_whitespace().next() == Some("Z") {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn cancelled_query_never_spawns() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
cancel.cancel();
|
||||
let mut command = shell("touch started");
|
||||
command.current_dir(dir.path());
|
||||
assert!(run_query(command, &cancel, Duration::from_secs(5)).await.is_none());
|
||||
assert!(!dir.path().join("started").exists());
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn queries_keep_working_directories_and_environments_separate() {
|
||||
let a = tempfile::tempdir().unwrap();
|
||||
let b = tempfile::tempdir().unwrap();
|
||||
std::fs::write(a.path().join("value"), "directory-a").unwrap();
|
||||
std::fs::write(b.path().join("value"), "directory-b").unwrap();
|
||||
let mut ca = shell("printf '%s:' \"$QUERY_VALUE\"; cat value");
|
||||
ca.current_dir(a.path()).env("QUERY_VALUE", "env-a");
|
||||
let mut cb = shell("printf '%s:' \"$QUERY_VALUE\"; cat value");
|
||||
cb.current_dir(b.path()).env("QUERY_VALUE", "env-b");
|
||||
let cancel = CancellationToken::new();
|
||||
let (a, b) = tokio::join!(
|
||||
run_query(ca, &cancel, Duration::from_secs(5)),
|
||||
run_query(cb, &cancel, Duration::from_secs(5)),
|
||||
);
|
||||
assert_eq!(a.unwrap(), b"env-a:directory-a");
|
||||
assert_eq!(b.unwrap(), b"env-b:directory-b");
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn timeout_kills_and_reaps_the_query() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut command = shell("echo $$ > pid; exec sleep 2");
|
||||
command.current_dir(dir.path());
|
||||
let output = run_query(command, &CancellationToken::new(), Duration::from_secs(1)).await;
|
||||
assert!(output.is_none());
|
||||
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap().trim().parse().unwrap();
|
||||
assert!(!ide_core::process::process_alive(pid));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn cancellation_kills_the_running_query_and_its_child() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut command = shell("sleep 30 & echo $$ $! > pids; wait");
|
||||
command.current_dir(dir.path());
|
||||
let cancel = CancellationToken::new();
|
||||
let token = cancel.clone();
|
||||
let task = tokio::spawn(async move { run_query(command, &token, Duration::from_secs(10)).await });
|
||||
let pids = dir.path().join("pids");
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while !std::fs::read_to_string(&pids).is_ok_and(|s| s.split_whitespace().count() == 2) {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let text = std::fs::read_to_string(pids).unwrap();
|
||||
let pids: Vec<u32> = text.split_whitespace().map(|p| p.parse().unwrap()).collect();
|
||||
cancel.cancel();
|
||||
assert!(task.await.unwrap().is_none());
|
||||
assert!(!ide_core::process::process_alive(pids[0]));
|
||||
// An orphaned child may remain a zombie until the host's init reaps it.
|
||||
#[cfg(target_os = "linux")]
|
||||
assert_stopped(pids[1]).await;
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while ide_core::process::process_alive(pids[1]) {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn dropping_the_caller_still_reaps_its_query() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut command = shell("sleep 30 & echo $$ $! > pid; wait");
|
||||
command.current_dir(dir.path());
|
||||
let task =
|
||||
tokio::spawn(async move { run_query(command, &CancellationToken::new(), Duration::from_secs(10)).await });
|
||||
let file = dir.path().join("pid");
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while !std::fs::read_to_string(&file).is_ok_and(|s| s.split_whitespace().count() == 2) {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let text = std::fs::read_to_string(file).unwrap();
|
||||
let pids: Vec<u32> = text.split_whitespace().map(|p| p.parse().unwrap()).collect();
|
||||
let pid = pids[0];
|
||||
task.abort();
|
||||
let _ = task.await;
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while ide_core::process::process_alive(pid) {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
#[cfg(target_os = "linux")]
|
||||
assert_stopped(pids[1]).await;
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while ide_core::process::process_alive(pids[1]) {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
#[tokio::test]
|
||||
async fn timeout_cleans_up_a_child_holding_stdout_after_root_exit() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut command = shell("sleep 30 & echo $! > pid; exit 0");
|
||||
command.current_dir(dir.path());
|
||||
assert!(run_query(command, &CancellationToken::new(), Duration::from_secs(1)).await.is_none());
|
||||
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap();
|
||||
assert_stopped(pid.trim().parse().unwrap()).await;
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn output_at_the_limit_is_not_truncated() {
|
||||
let output = run_query(shell("head -c 8388608 /dev/zero"), &CancellationToken::new(), Duration::from_secs(5))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(output.len() as u64, OUTPUT_LIMIT);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn oversized_output_kills_the_query() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut command = shell("echo $$ > pid; head -c 8388609 /dev/zero; exec sleep 30");
|
||||
command.current_dir(dir.path());
|
||||
assert!(run_query(command, &CancellationToken::new(), Duration::from_secs(5)).await.is_none());
|
||||
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap().trim().parse().unwrap();
|
||||
assert!(!ide_core::process::process_alive(pid));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn preserves_output_from_a_nonzero_exit() {
|
||||
assert_eq!(
|
||||
run_query(shell("printf partial; exit 1"), &CancellationToken::new(), Duration::from_secs(5))
|
||||
.await
|
||||
.unwrap(),
|
||||
b"partial"
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn failed_spawn_does_not_poison_a_following_query() {
|
||||
assert!(
|
||||
run_query(Command::new("/no/such/go-query"), &CancellationToken::new(), Duration::from_secs(5))
|
||||
.await
|
||||
.is_none()
|
||||
);
|
||||
assert_eq!(
|
||||
run_query(shell("printf ok"), &CancellationToken::new(), Duration::from_secs(5)).await.unwrap(),
|
||||
b"ok"
|
||||
);
|
||||
}
|
||||
|
||||
fn at(line: u32, from: u32, to: u32) -> Range {
|
||||
Range { start: Pos { line, col: from }, end: Pos { line, col: to } }
|
||||
}
|
||||
|
||||
@@ -19,13 +19,10 @@ use std::time::{Duration, Instant};
|
||||
pub(crate) const SERVER: &str = "jdtls";
|
||||
|
||||
pub(crate) mod configuration;
|
||||
mod extract_interface;
|
||||
mod formatter;
|
||||
mod hierarchy;
|
||||
pub(crate) mod jvm_inspect;
|
||||
mod move_refactoring;
|
||||
pub(crate) mod reserved_names;
|
||||
mod signature;
|
||||
pub use formatter::configure_formatter;
|
||||
/// First start imports the Maven / Gradle model, which can take minutes.
|
||||
const READY_TIMEOUT: Duration = Duration::from_secs(240);
|
||||
|
||||
@@ -1,128 +0,0 @@
|
||||
//! Extract Interface through jdtls' own requests: `java/checkExtractInterfaceStatus` lists the
|
||||
//! members of the file's class an interface can declare and the packages it can go to,
|
||||
//! `java/getRefactorEdit` (`extractInterface`) creates the interface, makes the class implement
|
||||
//! it and uses it where possible. The UI picks the name, package and members and applies the edit.
|
||||
use super::COMMAND_TIMEOUT;
|
||||
use super::signature::{RefactorEdit, changed};
|
||||
use crate::types::{ExtractInterfaceInfo, InterfaceMember, ProblemSeverity, RefactoringProblem, ServerRefactored};
|
||||
use crate::{LspManager, convert};
|
||||
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, Pos};
|
||||
use serde::Deserialize;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
const FEATURE: &str = "Extract Interface";
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct Status {
|
||||
#[serde(default)]
|
||||
members: Vec<InterfaceMember>,
|
||||
#[serde(default)]
|
||||
sub_type_name: String,
|
||||
#[serde(default)]
|
||||
destination_response: Destinations,
|
||||
}
|
||||
|
||||
#[derive(Default, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct Destinations {
|
||||
#[serde(default)]
|
||||
destinations: Vec<Value>,
|
||||
}
|
||||
|
||||
fn info_of(status: Option<Status>) -> IdeResult<ExtractInterfaceInfo> {
|
||||
let status = status
|
||||
.filter(|s| !s.sub_type_name.is_empty())
|
||||
.ok_or_else(|| IdeError::invalid("The file should declare a class"))?;
|
||||
Ok(ExtractInterfaceInfo {
|
||||
class_name: status.sub_type_name,
|
||||
members: status.members,
|
||||
packages: status.destination_response.destinations.iter().map(Value::to_string).collect(),
|
||||
})
|
||||
}
|
||||
|
||||
impl LspManager {
|
||||
/// The class of the file at `doc`, its members and the packages for the interface.
|
||||
pub async fn extract_interface_info(
|
||||
&self,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<ExtractInterfaceInfo> {
|
||||
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let params = Self::signature_context(&snap, &t, pos);
|
||||
let status: Option<Status> =
|
||||
self.call(&t, "java/checkExtractInterfaceStatus", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
info_of(status)
|
||||
}
|
||||
|
||||
/// Checks extracting `members` into the interface `name` in `package` (a package from
|
||||
/// [`Self::extract_interface_info`]) and computes the edit without applying it.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub async fn extract_interface(
|
||||
&self,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
members: Vec<String>,
|
||||
name: String,
|
||||
package: Value,
|
||||
confirmation: Option<String>,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<ServerRefactored> {
|
||||
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let mut params = json!({
|
||||
"command": "extractInterface",
|
||||
"context": Self::signature_context(&snap, &t, pos),
|
||||
"options": { "tabSize": 4, "insertSpaces": true },
|
||||
"commandArguments": [members, name, package],
|
||||
});
|
||||
if let Some(token) = confirmation {
|
||||
params["confirmationToken"] = json!(token);
|
||||
}
|
||||
let answer: Option<RefactorEdit> =
|
||||
self.call(&t, "java/getRefactorEdit", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
// jdtls answers nothing when its checks fail, and reports why in a message of its own.
|
||||
let Some(answer) = answer else {
|
||||
return Ok(ServerRefactored {
|
||||
problems: vec![RefactoringProblem {
|
||||
severity: ProblemSeverity::Fatal,
|
||||
message: "The interface could not be extracted".to_owned(),
|
||||
}],
|
||||
edit: None,
|
||||
confirmation: None,
|
||||
});
|
||||
};
|
||||
let conv = self.conv(t.enc());
|
||||
Ok(changed(answer, |e| convert::workspace_edit(&conv, e)))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn reads_the_members_and_packages() {
|
||||
let status: Status = serde_json::from_value(json!({
|
||||
"members": [
|
||||
{ "name": "area", "typeName": "double", "parameters": [], "handleIdentifier": "=p/src<a{Shape.java[Shape~area" },
|
||||
{ "name": "UNIT", "typeName": "int", "handleIdentifier": "=p/src<a{Shape.java[Shape^UNIT" },
|
||||
],
|
||||
"subTypeName": "Shape",
|
||||
"destinationResponse": { "destinations": [{ "displayName": "a", "isParentOfSelectedFile": true }] },
|
||||
}))
|
||||
.unwrap();
|
||||
let info = info_of(Some(status)).unwrap();
|
||||
assert_eq!(info.class_name, "Shape");
|
||||
assert_eq!(info.members[0].parameters.as_deref(), Some(&[][..]));
|
||||
assert_eq!(info.members[1].parameters, None);
|
||||
assert_eq!(serde_json::from_str::<Value>(&info.packages[0]).unwrap()["displayName"], "a");
|
||||
assert!(info_of(None).is_err());
|
||||
}
|
||||
}
|
||||
@@ -1,116 +0,0 @@
|
||||
//! Move (F6) through jdtls' own requests. jdtls offers Move as code actions whose command the
|
||||
//! client runs (`java.action.applyRefactoringCommand` with `moveFile`, `moveType`,
|
||||
//! `moveStaticMember` or `moveInstanceMethod`); the UI picks the destination from
|
||||
//! `java/getMoveDestinations` or `java/searchSymbols` and `java/move` checks the move and
|
||||
//! computes the edit, which the UI applies itself. Requests carry the code action's own
|
||||
//! arguments back unchanged.
|
||||
use super::COMMAND_TIMEOUT;
|
||||
use super::signature::{RefactorEdit, changed};
|
||||
use crate::types::ServerRefactored;
|
||||
use crate::{LspManager, convert};
|
||||
use ide_core::{CancellationToken, DocId, IdeError, IdeResult};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
const FEATURE: &str = "Move";
|
||||
/// What `java/getMoveDestinations` and `java/move` accept as `moveKind`.
|
||||
const KINDS: [&str; 6] =
|
||||
["moveResource", "moveInstanceMethod", "moveStaticMember", "moveTypeToNewFile", "moveTypeToClass", "moveType"];
|
||||
|
||||
fn move_params(kind: &str, request: &Value) -> IdeResult<Value> {
|
||||
if !KINDS.contains(&kind) {
|
||||
return Err(IdeError::invalid(format!("unknown move kind `{kind}`")));
|
||||
}
|
||||
let mut params = json!({
|
||||
"moveKind": kind,
|
||||
"sourceUris": request.get("sourceUris").cloned().unwrap_or(json!([])),
|
||||
"params": request.get("params").cloned().unwrap_or(Value::Null),
|
||||
});
|
||||
if let Some(destination) = request.get("destination").filter(|d| !d.is_null()) {
|
||||
params["destination"] = destination.clone();
|
||||
}
|
||||
Ok(params)
|
||||
}
|
||||
|
||||
impl LspManager {
|
||||
/// Where the move of `kind` can go (packages, or the fields and parameters an instance
|
||||
/// method can move to); an invalid-input error carries jdtls' reason when there is none.
|
||||
pub async fn java_move_destinations(
|
||||
&self,
|
||||
doc: DocId,
|
||||
kind: String,
|
||||
request: Value,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<Vec<Value>> {
|
||||
let (_, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let params = move_params(&kind, &request)?;
|
||||
let answer: Value = self.call(&t, "java/getMoveDestinations", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
if let Some(message) = answer.get("errorMessage").and_then(Value::as_str).filter(|m| !m.is_empty()) {
|
||||
return Err(IdeError::invalid(message.to_owned()));
|
||||
}
|
||||
Ok(answer.get("destinations").and_then(Value::as_array).cloned().unwrap_or_default())
|
||||
}
|
||||
|
||||
/// The project's source types (`java/searchSymbols`), for moving a member or type into a class.
|
||||
pub async fn java_source_types(
|
||||
&self,
|
||||
doc: DocId,
|
||||
project: Option<String>,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<Vec<Value>> {
|
||||
let (_, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let params = json!({ "query": "*", "projectName": project, "sourceOnly": true });
|
||||
let answer: Option<Vec<Value>> =
|
||||
self.call(&t, "java/searchSymbols", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
Ok(answer.unwrap_or_default())
|
||||
}
|
||||
|
||||
/// Checks the move and computes the edit without applying it; `confirmation` accepts the
|
||||
/// warnings an earlier check returned with it.
|
||||
pub async fn java_move(
|
||||
&self,
|
||||
doc: DocId,
|
||||
kind: String,
|
||||
request: Value,
|
||||
confirmation: Option<String>,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<ServerRefactored> {
|
||||
let (_, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let mut params = move_params(&kind, &request)?;
|
||||
params["updateReferences"] = json!(true);
|
||||
if let Some(token) = confirmation {
|
||||
params["confirmationToken"] = json!(token);
|
||||
}
|
||||
let answer: Option<RefactorEdit> = self.call(&t, "java/move", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let conv = self.conv(t.enc());
|
||||
Ok(changed(answer.unwrap_or_default(), |e| convert::workspace_edit(&conv, e)))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn passes_the_code_action_arguments_back_for_known_kinds_only() {
|
||||
let request = json!({
|
||||
"sourceUris": ["file:///p/A.java"],
|
||||
"params": { "textDocument": { "uri": "file:///p/A.java" } },
|
||||
"destination": { "displayName": "com.example" },
|
||||
});
|
||||
let params = move_params("moveResource", &request).unwrap();
|
||||
assert_eq!(params["moveKind"], "moveResource");
|
||||
assert_eq!(params["sourceUris"][0], "file:///p/A.java");
|
||||
assert_eq!(params["destination"]["displayName"], "com.example");
|
||||
assert!(move_params("moveResource", &json!({})).unwrap().get("destination").is_none());
|
||||
assert!(move_params("deleteEverything", &request).is_err());
|
||||
}
|
||||
}
|
||||
@@ -1,181 +0,0 @@
|
||||
//! Change Signature through jdtls' own requests: `java/getChangeSignatureInfo` reads the method at
|
||||
//! a position, `java/getRefactorEdit` (`changeSignature`) checks the new signature and computes the
|
||||
//! edit. The UI edits the signature and applies the edit itself.
|
||||
use super::{COMMAND_TIMEOUT, SERVER};
|
||||
use crate::types::{MethodSignature, ProblemSeverity, RefactoringProblem, ServerRefactored};
|
||||
use crate::{DocSnap, LspManager, Target, convert};
|
||||
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, Pos};
|
||||
use serde::Deserialize;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
const FEATURE: &str = "Change Signature";
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct Info {
|
||||
#[serde(flatten)]
|
||||
signature: Option<MethodSignature>,
|
||||
error_message: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Default, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub(super) struct RefactorEdit {
|
||||
edit: Option<lsp_types::WorkspaceEdit>,
|
||||
error_message: Option<String>,
|
||||
confirmation_token: Option<String>,
|
||||
}
|
||||
|
||||
/// A `java/getRefactorEdit` or `java/move` answer as the result: an error message alone is fatal;
|
||||
/// with a confirmation token it lists warnings to accept before the edit is computed.
|
||||
pub(super) fn changed(
|
||||
answer: RefactorEdit,
|
||||
convert_edit: impl FnOnce(lsp_types::WorkspaceEdit) -> ide_core::WorkspaceEdit,
|
||||
) -> ServerRefactored {
|
||||
let problem = |severity| {
|
||||
answer
|
||||
.error_message
|
||||
.as_deref()
|
||||
.filter(|m| !m.trim().is_empty())
|
||||
.map(|message| RefactoringProblem { severity, message: message.trim().to_owned() })
|
||||
};
|
||||
if let Some(token) = answer.confirmation_token {
|
||||
return ServerRefactored {
|
||||
problems: problem(ProblemSeverity::Warning).into_iter().collect(),
|
||||
edit: None,
|
||||
confirmation: Some(token),
|
||||
};
|
||||
}
|
||||
match answer.edit {
|
||||
Some(edit) if answer.error_message.is_none() => {
|
||||
ServerRefactored { problems: Vec::new(), edit: Some(convert_edit(edit)), confirmation: None }
|
||||
}
|
||||
_ => ServerRefactored {
|
||||
problems: problem(ProblemSeverity::Fatal).into_iter().collect(),
|
||||
edit: None,
|
||||
confirmation: None,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
impl LspManager {
|
||||
pub(super) async fn jdtls_target(&self, doc: DocId, feature: &str) -> IdeResult<(DocSnap, Target)> {
|
||||
let (snap, targets) = self.doc_targets(doc, feature, |_| true).await?;
|
||||
let t = targets
|
||||
.into_iter()
|
||||
.find(|t| t.server.name == SERVER)
|
||||
.ok_or_else(|| IdeError::unavailable(format!("{feature} needs the Java language server (jdtls)")))?;
|
||||
Ok((snap, t))
|
||||
}
|
||||
|
||||
pub(super) fn signature_context(snap: &DocSnap, t: &Target, pos: Pos) -> Value {
|
||||
let at = snap.position(t, pos);
|
||||
json!({
|
||||
"textDocument": { "uri": snap.uri },
|
||||
"range": { "start": at, "end": at },
|
||||
"context": { "diagnostics": [] },
|
||||
})
|
||||
}
|
||||
|
||||
/// The signature of the method at `pos`; an invalid-input error says why it can't be changed.
|
||||
pub async fn change_signature_info(
|
||||
&self,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<MethodSignature> {
|
||||
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let params = Self::signature_context(&snap, &t, pos);
|
||||
let info: Option<Info> =
|
||||
self.call(&t, "java/getChangeSignatureInfo", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
match info {
|
||||
Some(Info { error_message: Some(message), .. }) => Err(IdeError::invalid(message)),
|
||||
Some(Info { signature: Some(signature), .. }) => Ok(signature),
|
||||
_ => Err(IdeError::invalid("Caret should be on a method declaration")),
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks changing the method at `pos` to `signature` and computes the edit without applying it.
|
||||
/// `confirmation` accepts the warnings an earlier check returned with it.
|
||||
pub async fn change_signature(
|
||||
&self,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
signature: MethodSignature,
|
||||
delegate: bool,
|
||||
confirmation: Option<String>,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<ServerRefactored> {
|
||||
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let MethodSignature { method_identifier, modifier, return_type, method_name, parameters, exceptions } =
|
||||
signature;
|
||||
let mut params = json!({
|
||||
"command": "changeSignature",
|
||||
"context": Self::signature_context(&snap, &t, pos),
|
||||
"options": { "tabSize": 4, "insertSpaces": true },
|
||||
"commandArguments": [
|
||||
method_identifier, delegate, method_name, modifier, return_type, parameters, exceptions, false
|
||||
],
|
||||
});
|
||||
if let Some(token) = confirmation {
|
||||
params["confirmationToken"] = json!(token);
|
||||
}
|
||||
let answer: Option<RefactorEdit> =
|
||||
self.call(&t, "java/getRefactorEdit", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let answer = answer.unwrap_or_default();
|
||||
let conv = self.conv(t.enc());
|
||||
Ok(changed(answer, |e| convert::workspace_edit(&conv, e)))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn answer(v: Value) -> RefactorEdit {
|
||||
serde_json::from_value(v).unwrap()
|
||||
}
|
||||
fn no_edit(_: lsp_types::WorkspaceEdit) -> ide_core::WorkspaceEdit {
|
||||
ide_core::WorkspaceEdit::default()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_the_signature_or_why_there_is_none() {
|
||||
let info: Info = serde_json::from_value(json!({
|
||||
"methodIdentifier": "=p/src<p{A.java[A~m~I",
|
||||
"modifier": "public",
|
||||
"returnType": "void",
|
||||
"methodName": "m",
|
||||
"parameters": [{ "type": "int", "name": "a", "defaultValue": "null", "originalIndex": 0 }],
|
||||
"exceptions": [{ "type": "java.io.IOException", "typeHandleIdentifier": "=x" }],
|
||||
"errorMessage": null,
|
||||
}))
|
||||
.unwrap();
|
||||
let s = info.signature.unwrap();
|
||||
assert_eq!((s.method_name.as_str(), s.parameters[0].type_name.as_str()), ("m", "int"));
|
||||
assert_eq!(s.exceptions[0].type_name, "java.io.IOException");
|
||||
let refused: Info = serde_json::from_value(json!({ "errorMessage": "Cannot change signature." })).unwrap();
|
||||
assert!(refused.signature.is_none());
|
||||
assert_eq!(refused.error_message.as_deref(), Some("Cannot change signature."));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn errors_are_fatal_and_tokens_ask_for_confirmation() {
|
||||
let fatal = changed(answer(json!({ "errorMessage": "Duplicate parameter name" })), no_edit);
|
||||
assert_eq!(fatal.problems[0].severity, ProblemSeverity::Fatal);
|
||||
assert!(fatal.edit.is_none() && fatal.confirmation.is_none());
|
||||
|
||||
let warn = changed(answer(json!({ "errorMessage": "Overrides a method", "confirmationToken": "t1" })), no_edit);
|
||||
assert_eq!(warn.problems[0].severity, ProblemSeverity::Warning);
|
||||
assert_eq!(warn.confirmation.as_deref(), Some("t1"));
|
||||
|
||||
let ok = changed(answer(json!({ "edit": { "changes": {} } })), no_edit);
|
||||
assert!(ok.problems.is_empty() && ok.edit.is_some());
|
||||
}
|
||||
}
|
||||
@@ -240,7 +240,6 @@ pub struct LspManager {
|
||||
shown_messages: Mutex<HashSet<(String, String)>>,
|
||||
/// go.mod files whose upgrades gopls has been asked to check this session.
|
||||
go_mod_checked: Mutex<HashSet<PathBuf>>,
|
||||
go_mod_queries: Mutex<go_mod::Queries>,
|
||||
/// Virtual (non-`file:`) URIs a server returned, by the server that owns them.
|
||||
virtual_origins: Mutex<HashMap<String, ide_core::ServerId>>,
|
||||
/// Contents fetched for virtual URIs.
|
||||
@@ -434,11 +433,6 @@ async fn library_sources(snap: &DocSnap, root: &Path, pos: Pos, locs: Vec<Locati
|
||||
|
||||
const JAVA_IMPLEMENTATIONS: &str = "openidea.java.implementations";
|
||||
|
||||
/// jdtls' locations of the implementations of the method at a position in the classes named
|
||||
/// with it, for implementation classes in dependencies: its standard request puts those at the
|
||||
/// start of the decompiled class instead of at the method.
|
||||
const JAVA_IMPLEMENTATION_LOCATIONS: &str = "openidea.java.implementationLocations";
|
||||
|
||||
/// The answer of [`JAVA_IMPLEMENTATIONS`]: `complete` when the type is declared in the
|
||||
/// sources, so no dependency can implement it.
|
||||
#[derive(serde::Deserialize)]
|
||||
@@ -447,13 +441,6 @@ struct SourceImplementations {
|
||||
complete: bool,
|
||||
}
|
||||
|
||||
/// The answer of [`JAVA_IMPLEMENTATION_LOCATIONS`]: one entry per requested class, `None` when
|
||||
/// it has no implementation of the method.
|
||||
#[derive(serde::Deserialize)]
|
||||
struct TargetImplementations {
|
||||
locations: Vec<Option<lsp::Location>>,
|
||||
}
|
||||
|
||||
/// Receives the implementations found so far, before a slower search for the rest.
|
||||
type Partial<'a> = Option<&'a (dyn Fn(Vec<Location>) + Send + Sync)>;
|
||||
|
||||
@@ -529,7 +516,6 @@ impl LspManager {
|
||||
configuration_cache: Arc::new(Mutex::new(Default::default())),
|
||||
shown_messages: Mutex::new(HashSet::new()),
|
||||
go_mod_checked: Mutex::new(HashSet::new()),
|
||||
go_mod_queries: Mutex::new(go_mod::Queries::default()),
|
||||
virtual_origins: Mutex::new(HashMap::new()),
|
||||
virtual_docs: Mutex::new(HashMap::new()),
|
||||
virtual_stamps: Mutex::new(HashMap::new()),
|
||||
@@ -1407,7 +1393,6 @@ impl LspManager {
|
||||
}
|
||||
|
||||
fn close_document(&self, doc: DocId) {
|
||||
self.go_mod_queries.lock().cancel(doc);
|
||||
let (d, compose_removed) = {
|
||||
let mut docs = self.docs.lock();
|
||||
let Some(d) = docs.remove(&doc) else { return };
|
||||
@@ -1822,84 +1807,6 @@ impl LspManager {
|
||||
out
|
||||
}
|
||||
|
||||
/// jdtls: where the implementation methods of the method at `pos` are declared in the
|
||||
/// dependency classes `locs` point at. Its standard request answers those with `0:0`, the
|
||||
/// start of the class file's decompiled source; [`JAVA_IMPLEMENTATION_LOCATIONS`] resolves
|
||||
/// the declaration itself.
|
||||
async fn java_implementation_locations(
|
||||
&self,
|
||||
snap: &DocSnap,
|
||||
t: &Target,
|
||||
pos: Pos,
|
||||
locs: Vec<Location>,
|
||||
cancel: Option<&CancellationToken>,
|
||||
) -> Vec<Location> {
|
||||
if t.server.name != "jdtls" || !t.caps().commands().iter().any(|c| c == JAVA_IMPLEMENTATION_LOCATIONS) {
|
||||
return locs;
|
||||
}
|
||||
let targets: Vec<(usize, String)> = locs
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(i, l)| {
|
||||
let uri = l.uri.as_deref()?;
|
||||
(virtual_doc::scheme(uri) == "jdt" && l.range.start.line == 0).then(|| (i, uri.to_owned()))
|
||||
})
|
||||
.collect();
|
||||
if targets.is_empty() {
|
||||
return locs;
|
||||
}
|
||||
let params = snap.pos_params(t, pos);
|
||||
let arguments = json!([
|
||||
params["textDocument"]["uri"],
|
||||
params["position"]["line"],
|
||||
params["position"]["character"],
|
||||
targets.iter().map(|(_, uri)| uri).collect::<Vec<_>>(),
|
||||
]);
|
||||
let result: IdeResult<TargetImplementations> = self
|
||||
.call(
|
||||
t,
|
||||
"workspace/executeCommand",
|
||||
json!({ "command": JAVA_IMPLEMENTATION_LOCATIONS, "arguments": arguments }),
|
||||
cancel,
|
||||
LONG_TIMEOUT,
|
||||
)
|
||||
.await;
|
||||
let found = match result {
|
||||
Ok(found) if found.locations.len() == targets.len() => found,
|
||||
Ok(_) => return locs,
|
||||
Err(e) => {
|
||||
tracing::debug!("{JAVA_IMPLEMENTATION_LOCATIONS}: {}", e.message);
|
||||
return locs;
|
||||
}
|
||||
};
|
||||
let mut out = locs;
|
||||
for ((i, _), loc) in targets.into_iter().zip(found.locations) {
|
||||
if let Some(loc) = loc.as_ref().and_then(|l| self.conv(t.enc()).location(l)) {
|
||||
out[i] = loc;
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Refines the implementation `locs` of the method at `pos`: jdtls puts an implementation in
|
||||
/// a dependency at the start of its decompiled class instead of at the method, which matters
|
||||
/// when the gutter marker's targets are opened one by one.
|
||||
pub async fn implementation_locations(
|
||||
&self,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
locs: Vec<Location>,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<Vec<Location>> {
|
||||
let (_, cap, feature) = goto_method(GotoKind::Implementation);
|
||||
let (snap, targets) = self.doc_targets(doc, feature, |c| c.has(cap)).await?;
|
||||
let mut out = locs;
|
||||
for t in &targets {
|
||||
out = self.java_implementation_locations(&snap, t, pos, out, Some(&cancel)).await;
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
async fn goto_in(
|
||||
&self,
|
||||
snap: &DocSnap,
|
||||
@@ -1939,12 +1846,6 @@ impl LspManager {
|
||||
Ok(Some(r)) => {
|
||||
let locs = convert::goto_response(&self.conv(t.enc()), r);
|
||||
let locs = library_sources(snap, &self.project_root, pos, locs).await;
|
||||
// Only explicit Go to Implementation: gutter markers ask for every line.
|
||||
let locs = if method == "textDocument/implementation" && partial.is_some() {
|
||||
self.java_implementation_locations(snap, t, pos, locs, cancel).await
|
||||
} else {
|
||||
locs
|
||||
};
|
||||
self.note_virtual(&t.server, locs.iter().map(|l| l.uri.as_deref()));
|
||||
self.note_arduino_sources(&t.server, &locs);
|
||||
let locs = self.jdt_library_classes(snap, pos, locs).await;
|
||||
@@ -3812,7 +3713,6 @@ impl LspManager {
|
||||
pub fn set_execution_allowed(&self, allowed: bool) {
|
||||
let previous = self.execution_allowed.swap(allowed, Ordering::AcqRel);
|
||||
if !allowed {
|
||||
self.go_mod_queries.lock().cancel_all();
|
||||
for server in self.servers.lock().iter() {
|
||||
server.start_token().cancel();
|
||||
}
|
||||
@@ -4157,7 +4057,6 @@ impl LspManager {
|
||||
|
||||
pub async fn shutdown_all(&self) {
|
||||
self.shutting_down.store(true, Ordering::Release);
|
||||
self.go_mod_queries.lock().cancel_all();
|
||||
let _reconfigure = self.reconfigure_lock.lock().await;
|
||||
let servers: Vec<Arc<Server>> = self.servers.lock().clone();
|
||||
join_all(servers.iter().map(|s| self.stop_instance(s, true))).await;
|
||||
|
||||
@@ -504,74 +504,6 @@ pub struct HierarchyRefactored {
|
||||
pub edit: Option<WorkspaceEdit>,
|
||||
}
|
||||
|
||||
/// A parameter in Change Signature: its type, name, the value passed at existing calls when it is
|
||||
/// added, and its index in the current signature (-1 for an added one).
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct SignatureParameter {
|
||||
#[serde(rename = "type")]
|
||||
pub type_name: String,
|
||||
pub name: String,
|
||||
pub default_value: String,
|
||||
pub original_index: i32,
|
||||
}
|
||||
|
||||
/// A declared exception (`throws`), with the server's handle of its type.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct SignatureException {
|
||||
#[serde(rename = "type")]
|
||||
pub type_name: String,
|
||||
pub type_handle_identifier: String,
|
||||
}
|
||||
|
||||
/// The signature of the method at a position, as Change Signature edits it.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct MethodSignature {
|
||||
/// The server's handle of the method, passed back unchanged.
|
||||
pub method_identifier: String,
|
||||
/// `public`, `protected`, `private`, or empty for package-private.
|
||||
pub modifier: String,
|
||||
pub return_type: String,
|
||||
pub method_name: String,
|
||||
pub parameters: Vec<SignatureParameter>,
|
||||
pub exceptions: Vec<SignatureException>,
|
||||
}
|
||||
|
||||
/// A member Extract Interface can declare in the new interface.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct InterfaceMember {
|
||||
pub name: String,
|
||||
/// The method's return type or the field's type.
|
||||
pub type_name: String,
|
||||
/// The method's parameter types; `None` for a field.
|
||||
pub parameters: Option<Vec<String>>,
|
||||
/// The server's handle of the member, passed back unchanged.
|
||||
pub handle_identifier: String,
|
||||
}
|
||||
|
||||
/// What Extract Interface starts from: the file's class, the members the interface can declare and
|
||||
/// the packages it can go to (as JSON, passed back unchanged).
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ExtractInterfaceInfo {
|
||||
pub class_name: String,
|
||||
pub members: Vec<InterfaceMember>,
|
||||
pub packages: Vec<String>,
|
||||
}
|
||||
|
||||
/// A refactoring checked by the server (Change Signature, Move, Extract Interface): problems to show, the edit when
|
||||
/// none is fatal, and the token that confirms going on despite warnings.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ServerRefactored {
|
||||
pub problems: Vec<RefactoringProblem>,
|
||||
pub edit: Option<WorkspaceEdit>,
|
||||
pub confirmation: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct CallHierarchy {
|
||||
|
||||
@@ -3483,52 +3483,6 @@ async fn java_implementations_come_from_sources_first() {
|
||||
assert_eq!(s.requested("textDocument/implementation").len(), 3);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn java_dependency_implementations_point_at_the_method() {
|
||||
let caps = json!({
|
||||
"textDocumentSync": 1,
|
||||
"implementationProvider": true,
|
||||
"executeCommandProvider": { "commands": ["openidea.java.implementations", "openidea.java.implementationLocations"] },
|
||||
});
|
||||
let h = harness_for("java", "java", &[("jdtls", caps)], &[]);
|
||||
let (doc, _) = h.open("Repo.java", "interface Repo {\n void save(String item);\n}\n");
|
||||
h.wait_status("jdtls", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("jdtls");
|
||||
let class_uri = "jdt://contents/lib.jar/zoo/RepoImpl.java?=p/lib.jar%3Czoo%28RepoImpl.class";
|
||||
let method = json!({
|
||||
"uri": class_uri,
|
||||
"range": {"start":{"line":4,"character":4},"end":{"line":6,"character":5}},
|
||||
});
|
||||
let at_zero = json!({
|
||||
"uri": class_uri,
|
||||
"range": {"start":{"line":0,"character":0},"end":{"line":0,"character":0}},
|
||||
});
|
||||
let refined = method.clone();
|
||||
*s.responder.lock() = Some(Arc::new(move |_, method, params| match method {
|
||||
"workspace/executeCommand" if params["command"] == "openidea.java.implementations" => {
|
||||
Some(json!({ "locations": [], "complete": false }))
|
||||
}
|
||||
"workspace/executeCommand" if params["command"] == "openidea.java.implementationLocations" => {
|
||||
assert_eq!(params["arguments"][3], json!([class_uri]));
|
||||
Some(json!({ "locations": [refined] }))
|
||||
}
|
||||
"textDocument/implementation" => Some(json!([at_zero])),
|
||||
_ => None,
|
||||
}));
|
||||
let partial = Mutex::new(Vec::new());
|
||||
let found = h
|
||||
.mgr
|
||||
.goto_implementation(doc, Pos::new(1, 9), Default::default(), &|locs| partial.lock().push(locs.to_vec()))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(found.len(), 1);
|
||||
assert_eq!(found[0].uri.as_deref(), Some(class_uri));
|
||||
assert_eq!(found[0].range.start.line, 4);
|
||||
assert_eq!(s.requested("textDocument/implementation").len(), 1);
|
||||
let commands = s.requested("workspace/executeCommand");
|
||||
assert!(commands.iter().any(|r| r["command"] == "openidea.java.implementationLocations"));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn navigation_rename_format_and_decorations() {
|
||||
let h = harness(&[("mock", incremental_caps())]);
|
||||
|
||||
@@ -1,13 +0,0 @@
|
||||
id = "editor-panel"
|
||||
name = "Editor Panel Probe"
|
||||
version = "0.1.0"
|
||||
description = "Test fixture for [[contributes.editorPanels]]: a minimal minimap page, no code."
|
||||
engines.openidea = "^1.9"
|
||||
|
||||
[capabilities]
|
||||
required = ["editor.read"]
|
||||
|
||||
[[contributes.editorPanels]]
|
||||
id = "minimap"
|
||||
web = "web/index.html"
|
||||
width = 110
|
||||
@@ -1,196 +0,0 @@
|
||||
<!doctype html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8" />
|
||||
<title>Minimap probe</title>
|
||||
<style>
|
||||
html,
|
||||
body {
|
||||
margin: 0;
|
||||
height: 100%;
|
||||
overflow: hidden;
|
||||
}
|
||||
canvas {
|
||||
display: block;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
cursor: default;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<canvas id="map"></canvas>
|
||||
<script>
|
||||
// A minimal minimap over `openidea.editor`: each line 2px high, each character 1px wide,
|
||||
// in its highlight colour; the visible area as a frame that can be dragged; the wheel
|
||||
// scrolls the editor.
|
||||
const editor = window.openidea.editor;
|
||||
const canvas = document.getElementById("map");
|
||||
const ctx = canvas.getContext("2d");
|
||||
const LINE = 2;
|
||||
const CHUNK = 2000;
|
||||
let text = [];
|
||||
let colors = new Map();
|
||||
let loading = new Set();
|
||||
let view = null;
|
||||
let drag = null;
|
||||
let queued = false;
|
||||
|
||||
const grey = (color) => {
|
||||
const m = /rgba?\((\d+),\s*(\d+),\s*(\d+)/.exec(color);
|
||||
return !!m && Math.max(m[1], m[2], m[3]) - Math.min(m[1], m[2], m[3]) < 24;
|
||||
};
|
||||
const cssVar = (name) => (window.openidea.theme && window.openidea.theme.vars[name]) || "";
|
||||
|
||||
function layout() {
|
||||
const H = canvas.clientHeight;
|
||||
if (!view) return { H, offset: 0, top: 0, height: 0, range: 1, visible: 0 };
|
||||
const L = Math.max(1, view.lineCount);
|
||||
const visible = Math.max(0, view.lastLine - view.firstLine);
|
||||
const scrollable = Math.max(1, view.scrollHeight - view.clientHeight);
|
||||
const p = Math.min(1, Math.max(0, view.scrollTop / scrollable));
|
||||
const mapH = L * LINE;
|
||||
const offset = p * Math.max(0, mapH - H);
|
||||
const range = Math.max(1, Math.min(H, mapH) - visible * LINE);
|
||||
return { H, offset, top: view.firstLine * LINE - offset, height: visible * LINE, range, visible, L };
|
||||
}
|
||||
|
||||
function redraw() {
|
||||
if (queued) return;
|
||||
queued = true;
|
||||
requestAnimationFrame(draw);
|
||||
}
|
||||
|
||||
function draw() {
|
||||
queued = false;
|
||||
const dpr = window.devicePixelRatio || 1;
|
||||
const W = canvas.clientWidth;
|
||||
const { H, offset, top, height } = layout();
|
||||
if (canvas.width !== Math.round(W * dpr) || canvas.height !== Math.round(H * dpr)) {
|
||||
canvas.width = Math.round(W * dpr);
|
||||
canvas.height = Math.round(H * dpr);
|
||||
}
|
||||
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
|
||||
ctx.clearRect(0, 0, W, H);
|
||||
if (!view) return;
|
||||
const first = Math.floor(offset / LINE);
|
||||
const last = Math.min(text.length, Math.ceil((offset + H) / LINE));
|
||||
const missing = [];
|
||||
const muted = cssVar("--openidea-fg-muted");
|
||||
for (let i = first; i < last; i++) {
|
||||
const y = i * LINE - offset;
|
||||
const line = text[i] || "";
|
||||
// Text without a syntax colour: faint, so the coloured spans stand out.
|
||||
ctx.globalAlpha = 0.2;
|
||||
ctx.fillStyle = muted;
|
||||
for (const m of line.matchAll(/\S+/g)) ctx.fillRect(m.index, y, m[0].length, LINE - 0.5);
|
||||
ctx.globalAlpha = 1;
|
||||
const spans = colors.get(i);
|
||||
if (!spans) missing.push(i);
|
||||
else
|
||||
for (const s of spans) {
|
||||
// Greys (the plain text colour, comments) stay as faint as uncoloured text.
|
||||
if (grey(s.color)) continue;
|
||||
ctx.fillStyle = s.color;
|
||||
ctx.fillRect(s.from, y, s.to - s.from, LINE - 0.5);
|
||||
}
|
||||
}
|
||||
// The visible area: a light accent tint and a 1px border, stronger while dragged.
|
||||
const frameH = Math.max(height, 4);
|
||||
ctx.fillStyle = cssVar("--openidea-accent");
|
||||
ctx.globalAlpha = drag ? 0.16 : 0.08;
|
||||
ctx.fillRect(0, top, W, frameH);
|
||||
ctx.strokeStyle = ctx.fillStyle;
|
||||
ctx.globalAlpha = drag ? 0.9 : 0.5;
|
||||
ctx.lineWidth = 1;
|
||||
ctx.strokeRect(0.5, top + 0.5, W - 1, frameH - 1);
|
||||
ctx.globalAlpha = 1;
|
||||
if (missing.length) load(missing[0], missing[missing.length - 1] + 1);
|
||||
}
|
||||
|
||||
async function load(from, to) {
|
||||
const key = `${from}:${to}`;
|
||||
if (loading.has(key)) return;
|
||||
loading.add(key);
|
||||
const target = view && view.version;
|
||||
try {
|
||||
for (let at = from; at < to; at += CHUNK) {
|
||||
const lines = await editor.highlights(at, Math.min(to, at + CHUNK));
|
||||
lines.forEach((spans, i) => colors.set(at + i, spans));
|
||||
}
|
||||
} finally {
|
||||
loading.delete(key);
|
||||
}
|
||||
if (view && view.version === target) redraw();
|
||||
}
|
||||
|
||||
async function reload() {
|
||||
const target = await editor.get();
|
||||
colors = new Map();
|
||||
text = [];
|
||||
if (!target) {
|
||||
view = null;
|
||||
return redraw();
|
||||
}
|
||||
const doc = await editor.document.get();
|
||||
text = doc.text.split("\n");
|
||||
view = Object.assign(await editor.viewport(), { version: target.version });
|
||||
redraw();
|
||||
}
|
||||
|
||||
editor.onTarget(() => void reload());
|
||||
editor.document.onChange((doc) => {
|
||||
text = doc.text.split("\n");
|
||||
redraw();
|
||||
});
|
||||
editor.onViewport((v) => {
|
||||
view = Object.assign(v, { version: view ? view.version : 0 });
|
||||
redraw();
|
||||
});
|
||||
editor.onHighlights(({ fromLine, toLine }) => {
|
||||
for (const k of [...colors.keys()]) if (k >= fromLine && k < toLine) colors.delete(k);
|
||||
redraw();
|
||||
});
|
||||
window.openidea.onThemeChange(redraw);
|
||||
new ResizeObserver(redraw).observe(canvas);
|
||||
|
||||
// Dragging the frame (or pressing beside it, which centres it there) scrolls the editor.
|
||||
const scrollToFrameTop = (frameTop) => {
|
||||
const { range, visible, L } = layout();
|
||||
const p = Math.min(1, Math.max(0, frameTop / range));
|
||||
void editor.scrollTo(p * Math.max(0, L - visible));
|
||||
};
|
||||
canvas.addEventListener("pointerdown", (e) => {
|
||||
if (!view) return;
|
||||
const { top, height } = layout();
|
||||
const grab = e.offsetY >= top && e.offsetY <= top + height ? e.offsetY - top : height / 2;
|
||||
drag = { grab };
|
||||
try {
|
||||
canvas.setPointerCapture(e.pointerId);
|
||||
} catch {
|
||||
// A pointer that isn't down (an event a test dispatched).
|
||||
}
|
||||
scrollToFrameTop(e.offsetY - grab);
|
||||
});
|
||||
canvas.addEventListener("pointermove", (e) => {
|
||||
if (drag) scrollToFrameTop(e.offsetY - drag.grab);
|
||||
});
|
||||
const stop = () => {
|
||||
drag = null;
|
||||
redraw();
|
||||
};
|
||||
canvas.addEventListener("pointerup", stop);
|
||||
canvas.addEventListener("pointercancel", stop);
|
||||
canvas.addEventListener(
|
||||
"wheel",
|
||||
(e) => {
|
||||
e.preventDefault();
|
||||
void editor.scrollBy(e.deltaY);
|
||||
},
|
||||
{ passive: false },
|
||||
);
|
||||
|
||||
void reload();
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -56,16 +56,6 @@ pub(crate) fn detect_with_profiles(
|
||||
detect_projects_matching(root, ruby_project, detect_ruby, &mut out);
|
||||
detect_projects(root, &["rebar.config"], detect_rebar, &mut out);
|
||||
detect_projects(root, &["mix.exs"], detect_mix, &mut out);
|
||||
// A project's own `build.sbt` belongs to the build above it.
|
||||
detect_projects_matching(
|
||||
root,
|
||||
|dir| {
|
||||
dir.join("build.sbt").is_file()
|
||||
&& !dir.ancestors().skip(1).take_while(|a| a.starts_with(root)).any(|a| a.join("build.sbt").is_file())
|
||||
},
|
||||
detect_sbt,
|
||||
&mut out,
|
||||
);
|
||||
for dir in ide_core::project_roots::discover(root, &["CMakeLists.txt"]) {
|
||||
let start = out.len();
|
||||
cmake::detect(&dir, if dir == root { profiles } else { None }, &mut out);
|
||||
@@ -1372,14 +1362,6 @@ fn detect_mix(root: &Path, out: &mut Vec<RunConfig>) {
|
||||
out.push(config("mix:test", "mix test", "mix", "mix", &["test"]).test());
|
||||
}
|
||||
|
||||
/// sbt (Scala): `sbt run` and `sbt test` on the build's root project, with the build's
|
||||
/// own launcher script when it has one. Other tasks run from the sbt tool window.
|
||||
fn detect_sbt(root: &Path, out: &mut Vec<RunConfig>) {
|
||||
let sbt = wrapper(root, "sbt", "sbt.bat", "sbt");
|
||||
out.push(config("sbt:run", "sbt run", "sbt", &sbt, &["run"]));
|
||||
out.push(config("sbt:test", "sbt test", "sbt", &sbt, &["test"]).test());
|
||||
}
|
||||
|
||||
/// Godot projects (`project.godot`) at the root or one level down: "Godot Project"
|
||||
/// runs the main scene (`godot --path .`), debuggable through the editor's adapter.
|
||||
fn detect_godot(root: &Path, out: &mut Vec<RunConfig>) {
|
||||
|
||||
@@ -1206,21 +1206,3 @@ fn mix_projects() {
|
||||
let dir = project(&[("mix.exs", "defp deps do\n [{:phoenix, \"~> 1.7\"}]\nend\n")]);
|
||||
assert_eq!(cmdline(&detect(dir.path())[0]), "iex -S mix phx.server");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sbt_projects() {
|
||||
let dir = project(&[
|
||||
("build.sbt", "lazy val core = project\n"),
|
||||
("core/build.sbt", "libraryDependencies += \"a\" % \"b\" % \"1\"\n"),
|
||||
("core/src/main/scala/App.scala", "object App\n"),
|
||||
]);
|
||||
let c = detect(dir.path());
|
||||
assert_eq!(ids(&c), ["sbt:run", "sbt:test"]);
|
||||
assert_eq!(cmdline(&c[0]), "sbt run");
|
||||
assert!(c[1].is_test && c.iter().all(|c| c.kind == "sbt"));
|
||||
|
||||
let dir = project(&[("build.sbt", ""), ("sbt", "#!/bin/sh\n")]);
|
||||
if !cfg!(windows) {
|
||||
assert_eq!(cmdline(&detect(dir.path())[1]), "./sbt test");
|
||||
}
|
||||
}
|
||||
@@ -745,8 +745,7 @@ pub fn native_tsdk(root: &Path, s: &Settings) -> Option<PathBuf> {
|
||||
}
|
||||
}
|
||||
|
||||
const PYTHON_SERVERS: [&str; 8] =
|
||||
["basedpyright", "pyright", "ty", "pyrefly", "pylsp", "jedi-language-server", "ruff", "djlsp"];
|
||||
const PYTHON_SERVERS: [&str; 7] = ["basedpyright", "pyright", "ty", "pyrefly", "pylsp", "jedi-language-server", "ruff"];
|
||||
|
||||
pub(crate) fn merge(base: &mut Value, layer: Value) {
|
||||
match (base, layer) {
|
||||
@@ -980,16 +979,6 @@ pub fn resolve_run_command(config: &mut RunConfig, root: &Path, s: &Settings) {
|
||||
}
|
||||
}
|
||||
|
||||
/// The environment folder holding `python` (`<env>/bin/python`, `<env>/Scripts/python.exe`):
|
||||
/// a virtualenv, or a conda or pixi environment.
|
||||
fn environment_of(python: &Path) -> Option<PathBuf> {
|
||||
venv_of(python).or_else(|| {
|
||||
let bin = python.parent()?;
|
||||
let env = bin.parent()?;
|
||||
matches!(bin.file_name()?.to_str()?, "bin" | "Scripts").then(|| env.to_path_buf())
|
||||
})
|
||||
}
|
||||
|
||||
pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root: &Path, s: &Settings) {
|
||||
let mut path_dirs: Vec<PathBuf> = Vec::new();
|
||||
if let Some(custom) = tool_command(root, s, &cfg.command) {
|
||||
@@ -1013,13 +1002,6 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
|
||||
"basedpyright" | "pyright" => merge_init_options(cfg, json!({ "python": { "pythonPath": p } })),
|
||||
"pylsp" => merge_init_options(cfg, json!({ "pylsp": { "plugins": { "jedi": { "environment": p } } } })),
|
||||
"jedi-language-server" => merge_init_options(cfg, json!({ "workspace": { "environmentPath": p } })),
|
||||
// Django's template tags, filters and template folders are read by running a script
|
||||
// with the interpreter in one of these environment folders.
|
||||
"djlsp" => {
|
||||
if let Some(env) = environment_of(&python) {
|
||||
merge_init_options(cfg, json!({ "env_directories": [env.to_string_lossy()] }));
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
if let Some(venv) = venv_of(&python) {
|
||||
|
||||
@@ -885,8 +885,6 @@ pub fn jdk_sdk(j: &crate::java::Jdk) -> Sdk {
|
||||
"JAVA_HOME"
|
||||
} else if crate::java::is_downloaded(&j.home) {
|
||||
"downloaded"
|
||||
} else if crate::java::is_added(&j.home) {
|
||||
"added"
|
||||
} else {
|
||||
version_managers::manager_of(&j.home).unwrap_or("system")
|
||||
};
|
||||
|
||||
@@ -138,26 +138,6 @@ pub fn add_jdk_root(dir: &Path) {
|
||||
}
|
||||
}
|
||||
|
||||
/// JDK homes added by hand (Settings › SDKs › Add JDK from Disk…).
|
||||
static ADDED: Mutex<Vec<PathBuf>> = Mutex::new(Vec::new());
|
||||
|
||||
/// Sets the JDK homes added by hand; the next scan lists them (a change drops the cached scan).
|
||||
pub fn set_added_jdks(homes: impl IntoIterator<Item = PathBuf>) {
|
||||
let homes: Vec<PathBuf> = homes.into_iter().filter(|h| !h.as_os_str().is_empty()).collect();
|
||||
let mut added = ADDED.lock().unwrap_or_else(|e| e.into_inner());
|
||||
if *added != homes {
|
||||
*added = homes;
|
||||
drop(added);
|
||||
*JDKS.lock().unwrap_or_else(|e| e.into_inner()) = None;
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether `home` is a JDK added by hand.
|
||||
pub fn is_added(home: &Path) -> bool {
|
||||
let added = ADDED.lock().unwrap_or_else(|e| e.into_inner());
|
||||
added.iter().any(|h| jdk_at(h).is_some_and(|j| j.home == home))
|
||||
}
|
||||
|
||||
/// Whether `home` lies in a folder registered with [`add_jdk_root`].
|
||||
pub fn is_downloaded(home: &Path) -> bool {
|
||||
let roots = EXTRA_ROOTS.lock().unwrap_or_else(|e| e.into_inner());
|
||||
@@ -210,7 +190,6 @@ fn scan() -> Vec<Jdk> {
|
||||
for (dir, _) in ide_core::version_managers::installs(ide_core::version_managers::Tool::Java) {
|
||||
homes.extend([dir.join("Contents/Home"), dir]);
|
||||
}
|
||||
homes.extend(ADDED.lock().unwrap_or_else(|e| e.into_inner()).iter().cloned());
|
||||
let mut out: Vec<Jdk> = Vec::new();
|
||||
for h in homes {
|
||||
if let Some(jdk) = jdk_at(&h)
|
||||
@@ -1385,26 +1364,6 @@ mod tests {
|
||||
assert!(is_downloaded(&home) && !is_downloaded(Path::new("/elsewhere")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn jdks_added_by_hand_are_listed_until_removed() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
// A macOS bundle picked as its folder: listed by its `Contents/Home`.
|
||||
let bundle = tmp.path().join("odd place/my-jdk.jdk");
|
||||
let home = bundle.join("Contents/Home");
|
||||
std::fs::create_dir_all(home.join("bin")).unwrap();
|
||||
std::fs::write(home.join("release"), "JAVA_VERSION=\"17.0.9\"\nIMPLEMENTOR=\"Acme\"\n").unwrap();
|
||||
std::fs::write(home.join("bin").join(crate::exe("java")), "").unwrap();
|
||||
let home = dunce::canonicalize(&home).unwrap();
|
||||
set_added_jdks([bundle.clone()]);
|
||||
assert!(installed_jdks().iter().any(|j| j.home == home && j.major == 17));
|
||||
assert!(is_added(&home));
|
||||
let sdk = crate::jdk_sdk(&jdk_at(&bundle).unwrap());
|
||||
assert_eq!((sdk.name.as_str(), sdk.source.as_str()), ("Acme 17.0.9", "added"));
|
||||
set_added_jdks(Vec::new());
|
||||
assert!(!installed_jdks().iter().any(|j| j.home == home));
|
||||
assert!(!is_added(&home));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn jdtls_runs_on_the_chosen_server_jdk() {
|
||||
let fixtures = tempfile::tempdir().unwrap();
|
||||
@@ -1588,7 +1547,7 @@ pub fn usages_bundle(data_dir: &Path) -> Option<PathBuf> {
|
||||
install_bundle(
|
||||
data_dir,
|
||||
"java-usages",
|
||||
"1.15.0",
|
||||
"1.14.0",
|
||||
include_bytes!("../../../java/java-usages/openidea-java-usages.jar"),
|
||||
)
|
||||
}
|
||||
|
||||
@@ -190,18 +190,6 @@ fn pyright_gets_python_path_and_venv_env() {
|
||||
assert!(cfg.env["PATH"].starts_with(&*tmp.path().join(".venv").join(bin_dir()).to_string_lossy()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn djlsp_reads_django_from_the_project_environment() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let python = fake_venv(tmp.path(), "venvs/web");
|
||||
let mut s = Settings::default();
|
||||
s.languages.python.interpreter = python.to_string_lossy().into_owned();
|
||||
let mut cfg = server("djlsp");
|
||||
configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
|
||||
let opts = serde_json::to_value(cfg.initialization_options.unwrap()).unwrap();
|
||||
assert_eq!(opts["env_directories"], serde_json::json!([tmp.path().join("venvs/web").to_string_lossy()]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_run_target_interpreter_hides_local_pythons() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -338,15 +338,6 @@ pub fn env_wrapper(bin_dir: &Path, command: &str, target: &Path, env: &[(&str, &
|
||||
}
|
||||
|
||||
pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResult<PathBuf> {
|
||||
link_executable_with_runtime(bin_dir, command, target, None)
|
||||
}
|
||||
|
||||
pub fn link_executable_with_runtime(
|
||||
bin_dir: &Path,
|
||||
command: &str,
|
||||
target: &Path,
|
||||
runtime: Option<&str>,
|
||||
) -> IdeResult<PathBuf> {
|
||||
fs::create_dir_all(bin_dir)?;
|
||||
#[cfg(unix)]
|
||||
{
|
||||
@@ -356,8 +347,7 @@ pub fn link_executable_with_runtime(
|
||||
}
|
||||
let quoted = target.to_string_lossy().replace('\'', r"'\''");
|
||||
// A Node script without a shebang (e.g. js-debug's dapDebugServer.js) runs through `node`.
|
||||
let runner = runtime.or_else(|| target.extension().is_some_and(|e| e == "js").then_some("node"));
|
||||
let runner = runner.map(|r| format!("{r} ")).unwrap_or_default();
|
||||
let runner = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
|
||||
fs::write(&link, format!("#!/bin/sh\nexec {runner}'{quoted}' \"$@\"\n"))?;
|
||||
make_executable(&link)?;
|
||||
make_executable(target)?;
|
||||
@@ -366,8 +356,7 @@ pub fn link_executable_with_runtime(
|
||||
#[cfg(not(unix))]
|
||||
{
|
||||
let link = bin_dir.join(format!("{command}.cmd"));
|
||||
let runner = runtime.or_else(|| target.extension().is_some_and(|e| e == "js").then_some("node"));
|
||||
let runner = runner.map(|r| format!("{r} ")).unwrap_or_default();
|
||||
let runner = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
|
||||
fs::write(&link, format!("@echo off\r\n{runner}\"{}\" %*\r\n", cmd_path(bin_dir, target)))?;
|
||||
Ok(link)
|
||||
}
|
||||
@@ -521,35 +510,6 @@ mod tests {
|
||||
assert!(dest.join("ok.txt").exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unity_vsix_wrapper_preserves_managed_assemblies_and_uses_mono_on_unix() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let archive = tmp.path().join("unity.vsix");
|
||||
zip_file(
|
||||
&archive,
|
||||
&[
|
||||
("extension/bin/UnityDebug.exe", b"adapter", 0o644),
|
||||
("extension/bin/UnityDebug.exe.config", b"runtime config", 0o644),
|
||||
("extension/bin/Mono.Debugger.Soft.dll", b"dependency", 0o644),
|
||||
],
|
||||
);
|
||||
let dest = tmp.path().join("install with spaces");
|
||||
extract(&archive, ArchiveKind::Zip, &dest, "unity-debug", &CancellationToken::new()).unwrap();
|
||||
let target = locate(&dest, &["UnityDebug.exe".into()]).unwrap();
|
||||
let bin = dest.join("bin");
|
||||
let wrapper = link_executable_with_runtime(&bin, "unity-debug", &target, cfg!(unix).then_some("mono")).unwrap();
|
||||
let script = fs::read_to_string(wrapper).unwrap();
|
||||
#[cfg(unix)]
|
||||
assert!(script.contains(&*target.to_string_lossy()));
|
||||
#[cfg(unix)]
|
||||
assert!(script.contains("exec mono '") && script.contains("\"$@\""));
|
||||
// The shim names the adapter relative to itself (see `cmd_path`).
|
||||
#[cfg(windows)]
|
||||
assert!(script.contains(&format!("\"{}\" %*", cmd_path(&bin, &target))) && !script.contains("mono "));
|
||||
assert_eq!(fs::read(target.with_extension("exe.config")).unwrap(), b"runtime config");
|
||||
assert_eq!(fs::read(target.parent().unwrap().join("Mono.Debugger.Soft.dll")).unwrap(), b"dependency");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zip_symlinks_are_confined_to_the_destination() {
|
||||
for target in ["../outside", "/tmp/outside", "a/../../outside"] {
|
||||
|
||||
@@ -19,7 +19,6 @@ pub mod archive;
|
||||
mod bundled;
|
||||
pub mod formatter;
|
||||
pub mod jdk;
|
||||
mod moved_venv;
|
||||
pub mod platform;
|
||||
#[cfg(any(windows, test))]
|
||||
pub mod portable_update;
|
||||
@@ -48,8 +47,6 @@ use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::sync::mpsc;
|
||||
use std::time::Duration;
|
||||
|
||||
pub use moved_venv::drop_moved_venvs;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum ToolStatus {
|
||||
@@ -95,10 +92,6 @@ pub struct ToolInfo {
|
||||
/// The interchangeable servers this one belongs to, in preference order: a
|
||||
/// server and the `fallback` ones after it. Empty when it has none.
|
||||
pub alternatives: Vec<String>,
|
||||
/// A language server used for part of what its languages need (`features` in its
|
||||
/// definition: pylsp-rope's refactorings next to basedpyright). Not offered for install
|
||||
/// when missing; the Language Servers page lists it.
|
||||
pub companion: bool,
|
||||
}
|
||||
|
||||
/// Streamed install progress.
|
||||
@@ -338,7 +331,6 @@ struct Usage {
|
||||
args: Vec<String>,
|
||||
initialization_options: Option<String>,
|
||||
alternatives: Vec<String>,
|
||||
companion: bool,
|
||||
}
|
||||
|
||||
fn usages(langs: &[LanguageConfig]) -> BTreeMap<String, Usage> {
|
||||
@@ -372,11 +364,6 @@ fn usages(langs: &[LanguageConfig]) -> BTreeMap<String, Usage> {
|
||||
add(name, &d.command, ToolKind::Debugger, d.install_hint.as_ref(), &l.name);
|
||||
}
|
||||
}
|
||||
for s in langs.iter().flat_map(|l| &l.language_servers).filter(|s| !s.features.is_empty()) {
|
||||
if let Some(u) = map.get_mut(&s.name) {
|
||||
u.companion = true;
|
||||
}
|
||||
}
|
||||
for (plugin, host) in registry::PLUGIN_HOSTS {
|
||||
let languages = map.get(*host).map(|u| u.languages.clone()).unwrap_or_default();
|
||||
map.entry(plugin.to_string()).or_default().languages = languages;
|
||||
@@ -762,7 +749,6 @@ impl Tools {
|
||||
default_args: u.args.clone(),
|
||||
default_initialization_options: u.initialization_options.clone(),
|
||||
alternatives: u.alternatives.clone(),
|
||||
companion: u.companion,
|
||||
})
|
||||
.map(|info| self.apply_custom(info, None));
|
||||
};
|
||||
@@ -789,7 +775,6 @@ impl Tools {
|
||||
default_args: usage.map(|u| u.args.clone()).unwrap_or_default(),
|
||||
default_initialization_options: usage.and_then(|u| u.initialization_options.clone()),
|
||||
alternatives: usage.map(|u| u.alternatives.clone()).unwrap_or_default(),
|
||||
companion: usage.is_some_and(|u| u.companion),
|
||||
})
|
||||
.map(|info| self.apply_custom(info, Some(spec)))
|
||||
}
|
||||
@@ -1271,42 +1256,6 @@ impl Tools {
|
||||
Err(IdeError::new(ErrorKind::Io, format!("pip install {package} failed ({status})")))
|
||||
}
|
||||
|
||||
/// A command running pip, before its arguments. The interpreter's own pip when it has one;
|
||||
/// a virtualenv made by uv has none, so then pip through `uv tool run`, or another Python
|
||||
/// on `PATH` that has it.
|
||||
fn pip_command(&self, python: PathBuf, emit: Emit) -> Command {
|
||||
let has_pip = |python: &Path| {
|
||||
let mut c = self.python_command(python);
|
||||
c.args(["-m", "pip", "--version"]);
|
||||
run_quiet(c, Duration::from_secs(20)).is_some_and(|(ok, _)| ok)
|
||||
};
|
||||
let module = |python: &Path| {
|
||||
let mut c = self.python_command(python);
|
||||
c.args(["-m", "pip"]);
|
||||
c
|
||||
};
|
||||
if has_pip(&python) {
|
||||
return module(&python);
|
||||
}
|
||||
let note = format!("{} has no pip", python.display());
|
||||
if let Some(uv) = self.which("uv") {
|
||||
emit(InstallEvent::Line { text: format!("{note}; running pip with uv") });
|
||||
// pip runs in uv's own Python: the same private working directory applies.
|
||||
let mut c = self.python_command(uv);
|
||||
c.args(["tool", "run", "pip"]);
|
||||
return c;
|
||||
}
|
||||
let other = ["python3", "python"]
|
||||
.into_iter()
|
||||
.filter_map(|name| ide_core::tool_path::find_command(name, &self.system_path, &self.root))
|
||||
.find(|p| *p != python && has_pip(p));
|
||||
if let Some(other) = other {
|
||||
emit(InstallEvent::Line { text: format!("{note}; using {}", other.display()) });
|
||||
return module(&other);
|
||||
}
|
||||
module(&python)
|
||||
}
|
||||
|
||||
/// The universal (`py3-none-any`) wheel, so the copy works with every interpreter
|
||||
/// version a project selects, not just the one that installed it.
|
||||
fn install_pip_target(
|
||||
@@ -1320,8 +1269,8 @@ impl Tools {
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let lib = python_lib_dir(&self.root, spec.name);
|
||||
std::fs::create_dir_all(&lib)?;
|
||||
let mut c = self.pip_command(self.python().expect("checked"), emit);
|
||||
c.args(["install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--target"])
|
||||
let mut c = self.python_command(self.python().expect("checked"));
|
||||
c.args(["-m", "pip", "install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--target"])
|
||||
.arg(&lib)
|
||||
.args(["--only-binary=:all:", "--platform", "any", "--implementation", "py"])
|
||||
.arg(package);
|
||||
@@ -1347,14 +1296,6 @@ impl Tools {
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<sources::Download> {
|
||||
match source {
|
||||
ReleaseSource::Fixed { version, url, sha256 } => Ok(sources::Download {
|
||||
version: version.into(),
|
||||
name: url.rsplit('/').next().unwrap_or("download").into(),
|
||||
url: url.into(),
|
||||
size: None,
|
||||
sha256: Some(sha256.into()),
|
||||
checksum_url: None,
|
||||
}),
|
||||
ReleaseSource::GitHub { repo } => match http.get_text(&sources::github_latest_url(repo), cancel) {
|
||||
Ok(json) => sources::github_pick(&json, assets, self.platform),
|
||||
Err(e) if e.kind == ErrorKind::Cancelled => Err(e),
|
||||
@@ -1459,9 +1400,7 @@ impl Tools {
|
||||
let pkg = staging.join("pkg");
|
||||
let kind = archive::ArchiveKind::from_name(&dl.name);
|
||||
let main = spec.commands[0];
|
||||
// A PHP archive keeps its name and runs through `php` (Windows can't launch it itself).
|
||||
let phar = dl.name.ends_with(".phar");
|
||||
let exe_name = if phar { format!("{main}.phar") } else { self.platform.exe(main) };
|
||||
let exe_name = self.platform.exe(main);
|
||||
match kind {
|
||||
archive::ArchiveKind::Gz | archive::ArchiveKind::Raw => {
|
||||
archive::extract(&archive, kind, &pkg.join("bin"), &exe_name, cancel)?
|
||||
@@ -1503,13 +1442,7 @@ impl Tools {
|
||||
} else {
|
||||
archive::make_executable(&target)?;
|
||||
if self.exe_in(&bin, main).as_deref() != Some(target.as_path()) {
|
||||
if spec.name == "unity-debug" && cfg!(unix) {
|
||||
archive::link_executable_with_runtime(&bin, main, &target, Some("mono"))?;
|
||||
} else if phar {
|
||||
archive::link_executable_with_runtime(&bin, main, &target, Some("php"))?;
|
||||
} else {
|
||||
archive::link_executable(&bin, main, &target)?;
|
||||
}
|
||||
archive::link_executable(&bin, main, &target)?;
|
||||
}
|
||||
}
|
||||
self.write_manifest(spec.name, &Manifest { version: Some(dl.version.clone()), source: Some(dl.url.clone()) })
|
||||
|
||||
@@ -1,124 +0,0 @@
|
||||
//! Managed virtual environments only work where they were created: their launchers
|
||||
//! (uv's `.exe` trampolines, script shebangs) name the interpreter by absolute path.
|
||||
//! One moved from outside the IDE (a copied data directory, a relocated AppData) fails
|
||||
//! to start, so it is removed and installed afresh when next needed.
|
||||
|
||||
use crate::registry::{Method, TOOLS};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
/// Removes the managed virtual-environment tools under `tools_root` that no longer sit
|
||||
/// where they were created. Call at start-up, before language servers start.
|
||||
pub fn drop_moved_venvs(tools_root: &Path) {
|
||||
for spec in TOOLS.iter().filter(|spec| matches!(spec.method, Method::PipVenv { .. })) {
|
||||
let dir = tools_root.join(spec.name);
|
||||
if !venv_moved(&dir.join("venv")) {
|
||||
continue;
|
||||
}
|
||||
tracing::info!(?dir, "virtual environment was moved from where it was created; removing it to reinstall");
|
||||
if let Err(error) = std::fs::remove_dir_all(&dir) {
|
||||
tracing::warn!(?dir, %error, "cannot remove the moved virtual environment");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn venv_moved(venv: &Path) -> bool {
|
||||
let Some(created) = venv_origin(venv) else { return false };
|
||||
match (std::fs::canonicalize(&created), std::fs::canonicalize(venv)) {
|
||||
(Ok(created), Ok(venv)) => created != venv,
|
||||
// The interpreter path its launchers hold is gone.
|
||||
(Err(_), Ok(_)) => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Where a virtual environment was created: the `VIRTUAL_ENV` its activation script sets.
|
||||
fn venv_origin(venv: &Path) -> Option<PathBuf> {
|
||||
let script =
|
||||
if cfg!(windows) { venv.join("Scripts").join("activate.bat") } else { venv.join("bin").join("activate") };
|
||||
let text = std::fs::read_to_string(script).ok()?;
|
||||
text.lines().find_map(virtual_env).map(PathBuf::from)
|
||||
}
|
||||
|
||||
/// The path a line of an activation script assigns to `VIRTUAL_ENV`, as uv and CPython write them:
|
||||
/// `VIRTUAL_ENV='/v'`, `VIRTUAL_ENV="/v"`, `export VIRTUAL_ENV=$(cygpath "/v")`,
|
||||
/// `set "VIRTUAL_ENV=C:\v"`, and uv's `@for %%i in ("C:\v") do @set "VIRTUAL_ENV=%%~fi"`.
|
||||
fn virtual_env(line: &str) -> Option<&str> {
|
||||
let at = line.find("VIRTUAL_ENV=")?;
|
||||
if let Some(start) = line[..at].find("in (\"") {
|
||||
let rest = &line[start + 5..];
|
||||
return rest.find('"').map(|end| &rest[..end]).filter(|value| !value.is_empty());
|
||||
}
|
||||
let rest = line[at + "VIRTUAL_ENV=".len()..].trim_start_matches("$(cygpath ");
|
||||
let value = match rest.chars().next()? {
|
||||
quote @ ('"' | '\'') => rest[1..].split(quote).next()?,
|
||||
_ if line[..at].ends_with('"') => rest.split('"').next()?,
|
||||
_ => rest.split_whitespace().next()?.trim_end_matches(')'),
|
||||
};
|
||||
(!value.is_empty() && !value.starts_with(['$', '%'])).then_some(value)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn reads_virtual_env_as_uv_and_cpython_write_it() {
|
||||
assert_eq!(virtual_env("VIRTUAL_ENV='/data/tools/ty/venv'"), Some("/data/tools/ty/venv"));
|
||||
assert_eq!(virtual_env("VIRTUAL_ENV=\"/a b/venv\""), Some("/a b/venv"));
|
||||
assert_eq!(virtual_env(" export VIRTUAL_ENV=$(cygpath \"/a/venv\")"), Some("/a/venv"));
|
||||
assert_eq!(virtual_env(" export VIRTUAL_ENV=$(cygpath /a/venv)"), Some("/a/venv"));
|
||||
assert_eq!(virtual_env(r#"set "VIRTUAL_ENV=E:\App Data\tools\ty\venv""#), Some(r"E:\App Data\tools\ty\venv"));
|
||||
assert_eq!(
|
||||
virtual_env(r#"@for %%i in ("E:\data\tools\ty\venv") do @set "VIRTUAL_ENV=%%~fi""#),
|
||||
Some(r"E:\data\tools\ty\venv")
|
||||
);
|
||||
assert_eq!(virtual_env(" export VIRTUAL_ENV"), None);
|
||||
assert_eq!(virtual_env("unset VIRTUAL_ENV_PROMPT"), None);
|
||||
assert_eq!(virtual_env("set VIRTUAL_ENV=%~dp0.."), None);
|
||||
}
|
||||
|
||||
fn venv_created_at(tools: &Path, name: &str, origin: &Path) {
|
||||
let venv = tools.join(name).join("venv");
|
||||
let script =
|
||||
if cfg!(windows) { venv.join("Scripts").join("activate.bat") } else { venv.join("bin").join("activate") };
|
||||
std::fs::create_dir_all(script.parent().unwrap()).unwrap();
|
||||
let line = if cfg!(windows) {
|
||||
format!("@for %%i in (\"{}\") do @set \"VIRTUAL_ENV=%%~fi\"\r\n", origin.display())
|
||||
} else {
|
||||
format!("VIRTUAL_ENV='{}'\nexport VIRTUAL_ENV\n", origin.display())
|
||||
};
|
||||
std::fs::write(script, line).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn removes_only_virtual_environments_moved_from_where_they_were_created() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let tools = tmp.path().join("tools");
|
||||
// Created here.
|
||||
venv_created_at(&tools, "ty", &tools.join("ty").join("venv"));
|
||||
// Copied from another data directory that is gone.
|
||||
venv_created_at(&tools, "basedpyright", &tmp.path().join("old/tools/basedpyright/venv"));
|
||||
// Copied, the original still in place.
|
||||
let old_ruff = tmp.path().join("old-kept/tools/ruff/venv");
|
||||
std::fs::create_dir_all(&old_ruff).unwrap();
|
||||
venv_created_at(&tools, "ruff", &old_ruff);
|
||||
// No activation script to tell.
|
||||
std::fs::create_dir_all(tools.join("pyrefly").join("venv")).unwrap();
|
||||
// Not a virtual-environment tool.
|
||||
std::fs::create_dir_all(tools.join("gopls").join("bin")).unwrap();
|
||||
|
||||
drop_moved_venvs(&tools);
|
||||
|
||||
assert!(tools.join("ty").exists());
|
||||
assert!(!tools.join("basedpyright").exists());
|
||||
assert!(!tools.join("ruff").exists());
|
||||
assert!(tools.join("pyrefly").exists());
|
||||
assert!(tools.join("gopls").exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_missing_tools_directory_is_left_alone() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
drop_moved_venvs(&tmp.path().join("missing"));
|
||||
}
|
||||
}
|
||||
@@ -20,8 +20,6 @@ pub enum ToolKind {
|
||||
/// Where release archives come from.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum ReleaseSource {
|
||||
/// One pinned archive, verified against its SHA-256 before extraction.
|
||||
Fixed { version: &'static str, url: &'static str, sha256: &'static str },
|
||||
/// Latest GitHub release of `owner/repo`; assets plus links in the release notes.
|
||||
GitHub { repo: &'static str },
|
||||
/// `api.releases.hashicorp.com` product.
|
||||
@@ -82,7 +80,6 @@ impl Method {
|
||||
Method::Release { source: ReleaseSource::EclipseJdtls, .. } => "Eclipse download",
|
||||
Method::Release { source: ReleaseSource::OpenVsx { .. }, .. } => "Open VSX",
|
||||
Method::Release { source: ReleaseSource::MavenCentral { .. }, .. } => "Maven Central",
|
||||
Method::Release { source: ReleaseSource::Fixed { .. }, .. } => "Verified download",
|
||||
Method::Release { .. } => "GitHub release",
|
||||
}
|
||||
}
|
||||
@@ -134,29 +131,6 @@ const fn ver(cmd: &'static str) -> Option<(&'static str, &'static [&'static str]
|
||||
pub const TYPESCRIPT: &str = "typescript@6";
|
||||
|
||||
pub static TOOLS: &[ToolSpec] = &[
|
||||
ToolSpec {
|
||||
name: "unity-debug",
|
||||
display: "Unity Debugger",
|
||||
kind: Debugger,
|
||||
commands: &["unity-debug"],
|
||||
method: Method::Release {
|
||||
source: ReleaseSource::Fixed {
|
||||
version: "3.0.1",
|
||||
url: "https://github.com/Unity-Technologies/vscode-unity-debug/releases/download/Version-3.0.1/unity-debug-3.0.1.vsix",
|
||||
sha256: "4fa00660e0b52b0413726f80962e7d3d6efd41ac6cfd4df39520cae4a8ba5bd0",
|
||||
},
|
||||
assets: &[any_arch(Mac, "*.vsix"), any_arch(Linux, "*.vsix"), any_arch(Windows, "*.vsix")],
|
||||
locate: &["UnityDebug.exe"],
|
||||
},
|
||||
fallback: None,
|
||||
version: V,
|
||||
homepage: "https://github.com/Unity-Technologies/vscode-unity-debug",
|
||||
needs: if cfg!(windows) {
|
||||
&[]
|
||||
} else {
|
||||
&[("mono", "Mono is required to run the Unity debugger (https://www.mono-project.com)")]
|
||||
},
|
||||
},
|
||||
ToolSpec {
|
||||
name: "prettier",
|
||||
display: "Prettier",
|
||||
@@ -289,17 +263,6 @@ pub static TOOLS: &[ToolSpec] = &[
|
||||
homepage: "https://docs.astral.sh/ty/",
|
||||
needs: &[],
|
||||
},
|
||||
ToolSpec {
|
||||
name: "pylsp",
|
||||
display: "pylsp-rope (Python refactorings)",
|
||||
kind: LanguageServer,
|
||||
commands: &["pylsp"],
|
||||
method: Method::PipVenv { package: "pylsp-rope" },
|
||||
fallback: None,
|
||||
version: ver("pylsp"),
|
||||
homepage: "https://github.com/python-rope/pylsp-rope",
|
||||
needs: &[],
|
||||
},
|
||||
ToolSpec {
|
||||
name: "pyrefly",
|
||||
display: "Pyrefly (Python)",
|
||||
@@ -322,17 +285,6 @@ pub static TOOLS: &[ToolSpec] = &[
|
||||
homepage: "https://docs.astral.sh/ruff/",
|
||||
needs: &[],
|
||||
},
|
||||
ToolSpec {
|
||||
name: "djlsp",
|
||||
display: "Django Template LSP",
|
||||
kind: LanguageServer,
|
||||
commands: &["djlsp"],
|
||||
method: Method::PipVenv { package: "django-template-lsp" },
|
||||
fallback: None,
|
||||
version: ver("djlsp"),
|
||||
homepage: "https://github.com/fourdigits/django-template-lsp",
|
||||
needs: &[],
|
||||
},
|
||||
ToolSpec {
|
||||
name: "bash-language-server",
|
||||
display: "Bash Language Server",
|
||||
@@ -477,26 +429,6 @@ pub static TOOLS: &[ToolSpec] = &[
|
||||
homepage: "https://intelephense.com",
|
||||
needs: &[],
|
||||
},
|
||||
ToolSpec {
|
||||
name: "phpactor",
|
||||
display: "Phpactor (PHP)",
|
||||
kind: LanguageServer,
|
||||
commands: &["phpactor"],
|
||||
// One PHP archive for every platform, run through the project's PHP.
|
||||
method: Method::Release {
|
||||
source: ReleaseSource::GitHub { repo: "phpactor/phpactor" },
|
||||
assets: &[
|
||||
any_arch(Mac, "phpactor.phar"),
|
||||
any_arch(Linux, "phpactor.phar"),
|
||||
any_arch(Windows, "phpactor.phar"),
|
||||
],
|
||||
locate: &["phpactor.phar"],
|
||||
},
|
||||
fallback: None,
|
||||
version: ver("phpactor"),
|
||||
homepage: "https://phpactor.readthedocs.io",
|
||||
needs: &[("php", "Phpactor runs on PHP")],
|
||||
},
|
||||
ToolSpec {
|
||||
name: "laravel-lsp",
|
||||
display: "Laravel LSP",
|
||||
@@ -1232,8 +1164,6 @@ mod tests {
|
||||
fn registry_names_match_language_configs() {
|
||||
let langs = ide_language::LanguageRegistry::load(None).unwrap().all();
|
||||
let mut known = std::collections::HashSet::new();
|
||||
// The Unity debugger comes with Unity projects, apart from the C# debugger.
|
||||
known.insert(("unity-debug".to_owned(), "unity-debug".to_owned()));
|
||||
for l in &langs {
|
||||
for s in &l.language_servers {
|
||||
known.insert((s.name.clone(), s.command.clone()));
|
||||
|
||||
@@ -49,24 +49,6 @@ fn find<'a>(list: &'a [ToolInfo], name: &str) -> &'a ToolInfo {
|
||||
list.iter().find(|t| t.name == name).unwrap_or_else(|| panic!("{name} not listed"))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unity_adapter_download_is_pinned_and_checksum_verified() {
|
||||
let env = Env::new();
|
||||
let tools = env.tools();
|
||||
let spec = registry::find("unity-debug").unwrap();
|
||||
let Method::Release { source, assets, locate } = spec.method else { panic!("expected release") };
|
||||
// A fixed release resolves without a network request.
|
||||
let curl = env.sys.join(if cfg!(windows) { "curl.exe" } else { "curl" });
|
||||
fs::write(&curl, b"unused").unwrap();
|
||||
archive::make_executable(&curl).unwrap();
|
||||
let http = Http::new(env.sys.as_os_str()).unwrap();
|
||||
let download = tools.resolve_release(&http, source, assets, &CancellationToken::new()).unwrap();
|
||||
assert_eq!(download.version, "3.0.1");
|
||||
assert!(download.url.starts_with("https://github.com/Unity-Technologies/vscode-unity-debug/releases/download/"));
|
||||
assert_eq!(download.sha256.as_deref(), Some("4fa00660e0b52b0413726f80962e7d3d6efd41ac6cfd4df39520cae4a8ba5bd0"));
|
||||
assert_eq!(locate, &["UnityDebug.exe"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bundled_lombok_replaces_legacy_installs_on_every_platform_without_downloads() {
|
||||
for os in [Os::Mac, Os::Linux, Os::Windows] {
|
||||
@@ -315,10 +297,9 @@ fn concurrent_installs_of_one_tool_are_rejected() {
|
||||
|
||||
/// A second caller mid-install joins the run (the other Settings window's
|
||||
/// duplicate install) and shares the result instead of `AlreadyExists`.
|
||||
// Slot names no real install in other tests uses: tests share the process-wide slots.
|
||||
#[test]
|
||||
fn second_install_joins_the_running_one() {
|
||||
let slot = match install_slot("join-test-slot", &CancellationToken::new()) {
|
||||
let slot = match install_slot("sqls", &CancellationToken::new()) {
|
||||
Ok(slot) => slot,
|
||||
Err(_) => panic!("no install is running"),
|
||||
};
|
||||
@@ -329,7 +310,7 @@ fn second_install_joins_the_running_one() {
|
||||
slot.broadcast(InstallEvent::Line { text: format!("line {i}") });
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
release_install_slot("join-test-slot", &slot);
|
||||
release_install_slot("sqls", &slot);
|
||||
slot.finish(Err(IdeError::new(ErrorKind::Io, "compile failed")));
|
||||
})
|
||||
};
|
||||
@@ -349,8 +330,8 @@ fn second_install_joins_the_running_one() {
|
||||
assert!(texts.contains(&"Joined the install already in progress…".to_string()), "{texts:?}");
|
||||
assert!(texts.iter().any(|l| l == "line 2"), "{texts:?}");
|
||||
// The slot is released: a fresh install can start.
|
||||
match install_slot("join-test-slot", &CancellationToken::new()) {
|
||||
Ok(fresh) => release_install_slot("join-test-slot", &fresh),
|
||||
match install_slot("sqls", &CancellationToken::new()) {
|
||||
Ok(fresh) => release_install_slot("sqls", &fresh),
|
||||
Err(_) => panic!("the finished install still holds its slot"),
|
||||
}
|
||||
}
|
||||
@@ -358,7 +339,7 @@ fn second_install_joins_the_running_one() {
|
||||
/// A late caller gets the finished result without waiting.
|
||||
#[test]
|
||||
fn install_joined_after_it_finished_returns_the_result() {
|
||||
let slot = match install_slot("finished-test-slot", &CancellationToken::new()) {
|
||||
let slot = match install_slot("marksman", &CancellationToken::new()) {
|
||||
Ok(slot) => slot,
|
||||
Err(_) => panic!("no install is running"),
|
||||
};
|
||||
@@ -381,9 +362,8 @@ fn install_joined_after_it_finished_returns_the_result() {
|
||||
default_args: vec![],
|
||||
default_initialization_options: None,
|
||||
alternatives: vec![],
|
||||
companion: false,
|
||||
};
|
||||
release_install_slot("finished-test-slot", &slot);
|
||||
release_install_slot("marksman", &slot);
|
||||
slot.finish(Ok(ok));
|
||||
let info = join_install(&slot, &CancellationToken::new(), &|_| {}).unwrap();
|
||||
assert_eq!(info.version.as_deref(), Some("1.0"));
|
||||
@@ -461,51 +441,6 @@ esac"#,
|
||||
assert!(exe.exists());
|
||||
}
|
||||
|
||||
/// A PHP archive release (phpactor) keeps its `.phar` name and is launched through `php`.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn phar_release_installs_with_a_php_launcher() {
|
||||
let env = Env::new();
|
||||
let fixtures = env.root.parent().unwrap().join("fixtures");
|
||||
fs::create_dir_all(&fixtures).unwrap();
|
||||
let phar = fixtures.join("phpactor.phar");
|
||||
fs::write(&phar, b"<?php __HALT_COMPILER();").unwrap();
|
||||
let digest = sources::sha256_file(&phar).unwrap();
|
||||
let json = fixtures.join("release.json");
|
||||
fs::write(
|
||||
&json,
|
||||
format!(
|
||||
r#"{{"tag_name":"2026.10.07.0","assets":[{{"name":"phpactor.phar","browser_download_url":"https://example.invalid/phpactor.phar","size":{},"digest":"sha256:{digest}"}}]}}"#,
|
||||
fs::metadata(&phar).unwrap().len()
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
env.script(
|
||||
&env.sys,
|
||||
"curl",
|
||||
&format!(
|
||||
r#"out=""; url=""
|
||||
while [ $# -gt 0 ]; do case "$1" in -o) out="$2"; shift 2;; -A|-H|--retry|--connect-timeout) shift 2;; -*) shift;; *) url="$1"; shift;; esac; done
|
||||
case "$url" in
|
||||
https://api.github.com/*) /bin/cat '{json}';;
|
||||
*) /bin/cp '{phar}' "$out";;
|
||||
esac"#,
|
||||
json = json.display(),
|
||||
phar = phar.display()
|
||||
),
|
||||
);
|
||||
env.script(&env.sys, "php", r#"echo "php $*""#);
|
||||
|
||||
let info = env.tools().install("phpactor", &langs(), &CancellationToken::new(), &|_| {}).unwrap();
|
||||
assert_eq!(info.status, ToolStatus::Installed);
|
||||
let launcher = env.root.join("phpactor/bin/phpactor");
|
||||
assert_eq!(info.path.as_deref(), Some(launcher.as_path()));
|
||||
let archive = env.root.join("phpactor/bin/phpactor.phar");
|
||||
assert_eq!(fs::read(&archive).unwrap(), b"<?php __HALT_COMPILER();");
|
||||
let out = Command::new(&launcher).arg("language-server").env("PATH", &env.sys).output().unwrap();
|
||||
assert_eq!(String::from_utf8_lossy(&out.stdout).trim(), format!("php {} language-server", archive.display()));
|
||||
}
|
||||
|
||||
/// npm installs go to `<tools>/node_modules` with `--prefix`.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
@@ -942,14 +877,9 @@ esac
|
||||
}
|
||||
}
|
||||
|
||||
/// Installs of one tool name share a process-wide slot: tests installing debugpy take turns.
|
||||
#[cfg(unix)]
|
||||
static DEBUGPY_INSTALL: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn selected_python_is_used_for_pip_and_uv_even_with_a_versioned_filename() {
|
||||
let _guard = DEBUGPY_INSTALL.lock();
|
||||
let env = Env::new();
|
||||
env.script(&env.sys, "python3", "exit 99");
|
||||
let sdk = env._tmp.path().join("python-sdk");
|
||||
@@ -987,51 +917,6 @@ exit 1
|
||||
assert!(args.contains(&format!("--python {}", sdk.join("python3.14").display())), "{args}");
|
||||
}
|
||||
|
||||
/// A virtualenv made by uv has no pip: debugpy's private copy is made with pip through uv.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn debugpy_installs_through_uv_when_the_selected_python_has_no_pip() {
|
||||
let _guard = DEBUGPY_INSTALL.lock();
|
||||
let env = Env::new();
|
||||
let venv = env._tmp.path().join("project/.venv/bin");
|
||||
env.script(&venv, "python", "echo \"$(basename \"$0\"): No module named pip\" >&2; exit 1");
|
||||
let log = env._tmp.path().join("uv.log");
|
||||
env.script(
|
||||
&env.sys,
|
||||
"uv",
|
||||
&format!(
|
||||
r#"
|
||||
echo "$@" >> '{log}'
|
||||
while [ $# -gt 0 ]; do
|
||||
if [ "$1" = "--target" ]; then
|
||||
/bin/mkdir -p "$2/debugpy" "$2/debugpy-1.8.0.dist-info"
|
||||
/usr/bin/touch "$2/debugpy/__init__.py"
|
||||
exit 0
|
||||
fi
|
||||
shift
|
||||
done
|
||||
exit 1
|
||||
"#,
|
||||
log = log.display()
|
||||
),
|
||||
);
|
||||
let tools = env.tools().with_runtime(BTreeMap::from([("python".into(), venv.join("python"))]), BTreeMap::new());
|
||||
let lines = Mutex::new(Vec::new());
|
||||
let info = tools
|
||||
.install("debugpy", &langs(), &CancellationToken::new(), &|e| {
|
||||
if let InstallEvent::Line { text } = e {
|
||||
lines.lock().push(text);
|
||||
}
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(info.status, ToolStatus::Installed);
|
||||
assert_eq!(info.version.as_deref(), Some("1.8.0"));
|
||||
let args = fs::read_to_string(log).unwrap();
|
||||
assert!(args.starts_with("tool run pip install "), "{args}");
|
||||
assert!(args.contains("--platform any"), "{args}");
|
||||
assert!(lines.lock().iter().any(|l| l.contains("has no pip")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_cancelled_install_leaves_the_previous_one_in_place() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -1159,8 +1159,7 @@ impl Repo {
|
||||
write::stage_patch(self, patch, &|path| encoding(path).map(Into::into))
|
||||
}
|
||||
/// Discards unstaged changes: tracked paths are restored from the index (staged
|
||||
/// changes are kept), untracked files and directories are deleted. A submodule goes back
|
||||
/// to the commit the index records, with its tracked files restored.
|
||||
/// changes are kept), untracked files and directories are deleted.
|
||||
pub fn discard(&self, paths: &[PathBuf]) -> IdeResult<()> {
|
||||
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
|
||||
write::discard(self, paths)
|
||||
|
||||
@@ -12,9 +12,7 @@ use std::path::Path;
|
||||
use std::sync::{Arc, Mutex, OnceLock, Weak};
|
||||
use std::time::SystemTime;
|
||||
|
||||
// v3: summaries follow git's subject (the first paragraph on one line), not the first line.
|
||||
pub(crate) const COMMITS: TableDefinition<&str, &[u8]> = TableDefinition::new("summaries-v3");
|
||||
const STALE_COMMITS: TableDefinition<&str, &[u8]> = TableDefinition::new("summaries-v2");
|
||||
pub(crate) const COMMITS: TableDefinition<&str, &[u8]> = TableDefinition::new("summaries-v2");
|
||||
const MESSAGES: TableDefinition<&str, &str> = TableDefinition::new("messages-v1");
|
||||
const MAX_MEMORY_COMMITS: usize = 4096;
|
||||
const MAX_MEMORY_MESSAGES: usize = 1024;
|
||||
@@ -270,7 +268,6 @@ impl LogIndex {
|
||||
let mut databases = DATABASES.get_or_init(Mutex::default).lock().unwrap_or_else(|p| p.into_inner());
|
||||
self.db = databases.get(&path).and_then(Weak::upgrade).or_else(|| {
|
||||
let db = Arc::new(std::fs::create_dir_all(dir).ok().and_then(|_| Database::create(&path).ok())?);
|
||||
drop_stale_tables(&db);
|
||||
databases.insert(path, Arc::downgrade(&db));
|
||||
Some(db)
|
||||
});
|
||||
@@ -312,8 +309,8 @@ impl LogIndex {
|
||||
let author = commit.author().map_err(gx)?;
|
||||
let committer = commit.committer().map_err(gx)?;
|
||||
let raw = commit.message_raw_sloppy();
|
||||
let summary_text = subject(raw.as_bstr());
|
||||
let message_truncated = raw.trim() != summary_text.as_bytes();
|
||||
let summary = raw.split(|b| *b == b'\n').find(|l| !l.trim().is_empty()).unwrap_or_default().trim();
|
||||
let summary_text = to_string(summary.as_bstr());
|
||||
let record = Arc::new(Commit {
|
||||
id: key.clone(),
|
||||
short_id: key[..key.len().min(8)].to_string(),
|
||||
@@ -330,7 +327,7 @@ impl LogIndex {
|
||||
commit_time_ms: committer.time().map(|t| t.seconds as f64 * 1000.0).unwrap_or(0.0),
|
||||
summary: summary_text.clone(),
|
||||
message: summary_text,
|
||||
message_truncated,
|
||||
message_truncated: raw.trim() != summary,
|
||||
history_path: None,
|
||||
log_position: None,
|
||||
log_total: None,
|
||||
@@ -428,23 +425,6 @@ pub(crate) fn matches_user(query: &str, name: &str, email: &str) -> bool {
|
||||
.any(|alias| target.contains(&normalize_user(alias)))
|
||||
}
|
||||
|
||||
/// git's subject (`%s`, `git log --oneline`): the message's first paragraph on one line.
|
||||
/// A whitespace-only line ends the paragraph, as in git; `\r\n` endings count as newlines.
|
||||
fn subject(message: &gix::bstr::BStr) -> String {
|
||||
let lines = message.lines().map(|l| l.trim_end()).skip_while(|l| l.is_empty());
|
||||
let paragraph: Vec<String> = lines.take_while(|l| !l.is_empty()).map(|l| to_string(l.as_bstr())).collect();
|
||||
// git skips leading whitespace (blank lines and the first line's indent) before the subject.
|
||||
paragraph.join(" ").trim_start().to_owned()
|
||||
}
|
||||
|
||||
/// Drops tables an older version wrote, so outdated summaries don't stay on disk.
|
||||
fn drop_stale_tables(db: &Database) {
|
||||
let Ok(txn) = db.begin_write() else { return };
|
||||
if txn.delete_table(STALE_COMMITS).unwrap_or(false) {
|
||||
let _ = txn.commit();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -507,39 +487,4 @@ mod tests {
|
||||
assert_eq!(branches[1], vec!["feature".to_string(), "main".to_string()]);
|
||||
assert_eq!(branches[2], vec!["main".to_string()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn summary_is_git_subject_first_paragraph_on_one_line() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let dir = tmp.path();
|
||||
git(dir, &["init", "-q"]);
|
||||
let messages = [
|
||||
// The reporter's template: one paragraph of field lines (#3680).
|
||||
"[所属项目]:能力平台-订单\n[发布版本]:v1.2\n[需求单号]:REQ-1\n[需求描述]:导出\n[修改内容]:修复",
|
||||
"Subject only",
|
||||
"Subject\n\nBody that stays in the details",
|
||||
"Wrapped subject\ncontinues here\n\nBody",
|
||||
"CRLF subject\r\nsecond line\r\n\r\nBody",
|
||||
"Ends at a blank line\n \t\nBody",
|
||||
"\n\n Leading blank lines \nand indent kept\n",
|
||||
"Trailing spaces \n",
|
||||
];
|
||||
let mut ids = Vec::new();
|
||||
for (i, message) in messages.iter().enumerate() {
|
||||
std::fs::write(dir.join("a.txt"), i.to_string()).unwrap();
|
||||
std::fs::write(dir.join(".git/msg.txt"), message).unwrap();
|
||||
git(dir, &["add", "-A"]);
|
||||
git(dir, &["commit", "-q", "--cleanup=verbatim", "-F", ".git/msg.txt"]);
|
||||
ids.push(ObjectId::from_hex(git(dir, &["rev-parse", "HEAD"]).as_bytes()).unwrap());
|
||||
}
|
||||
let repo = gix::open(dir).unwrap();
|
||||
let mut index = LogIndex::default();
|
||||
for (id, message) in ids.iter().zip(messages) {
|
||||
let expected = git(dir, &["log", "-1", "--format=%s", &id.to_string()]);
|
||||
let commit = index.get(&repo, *id).unwrap();
|
||||
assert_eq!(commit.summary, expected, "{message:?}");
|
||||
assert_eq!(commit.message_truncated, message.trim() != expected, "{message:?}");
|
||||
}
|
||||
assert_eq!(index.get(&repo, ids[0]).unwrap().summary, messages[0].replace('\n', " "));
|
||||
}
|
||||
}
|
||||
@@ -25,19 +25,16 @@ pub(crate) fn save(r: &Repo, message: &str) -> IdeResult<()> {
|
||||
if run(r.root(), &["status", "--porcelain", "--untracked-files=no"], None)?.stdout_str().trim().is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let before = stash_top(r);
|
||||
let before = run(r.root(), &["rev-parse", "-q", "--verify", "refs/stash"], None).map(|o| o.stdout_str()).ok();
|
||||
run(r.root(), &["stash", "push", "-q", "-m", message], None)?;
|
||||
// A stash that succeeds without a new entry found nothing it saves: the status above also
|
||||
// lists submodules at another commit or with changes inside, which a stash leaves in place.
|
||||
let Some(id) = stash_top(r).filter(|id| Some(id) != before.as_ref()) else { return Ok(()) };
|
||||
std::fs::write(marker, id)?;
|
||||
let id = run(r.root(), &["rev-parse", "refs/stash"], None)?.stdout_str();
|
||||
if before.as_deref().map(str::trim) == Some(id.trim()) {
|
||||
return Err(IdeError::invalid("could not save the local changes"));
|
||||
}
|
||||
std::fs::write(marker, id.trim())?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn stash_top(r: &Repo) -> Option<String> {
|
||||
run(r.root(), &["rev-parse", "-q", "--verify", "refs/stash"], None).ok().map(|o| o.stdout_str().trim().to_owned())
|
||||
}
|
||||
|
||||
/// Brings the saved changes back once no operation is in progress. Fails when they come
|
||||
/// back with conflicts (they then also stay in the stash).
|
||||
pub(crate) fn restore(r: &Repo) -> IdeResult<()> {
|
||||
|
||||
Loaded 100 of 419 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача