дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-18 15:46:14 +02:00
Порівняти коміти
57
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
fd8bacd2bb | ||
|
|
de107e145c | ||
|
|
9adf35b097 | ||
|
|
0e473c6dac | ||
|
|
b01f70390e | ||
|
|
efc1e607b8 | ||
|
|
f4469a2f53 | ||
|
|
708cca8e4f | ||
|
|
f5b4e5ad8c | ||
|
|
77984361b6 | ||
|
|
86ba75cbf4 | ||
|
|
d50348bc94 | ||
|
|
e8c6ff8f2f | ||
|
|
5150e8e81b | ||
|
|
88a2508bee | ||
|
|
61da1bc685 | ||
|
|
4f2fc3ecb1 | ||
|
|
5b0006fa42 | ||
|
|
d986b7408b | ||
|
|
6b2bb0bb6a | ||
|
|
2b353dfe53 | ||
|
|
ead2594d72 | ||
|
|
2cb573d5ad | ||
|
|
0360690c6a | ||
|
|
f179c970ba | ||
|
|
45d34ac638 | ||
|
|
7709897dbb | ||
|
|
da3b00518f | ||
|
|
87e4dcf42b | ||
|
|
c860649b13 | ||
|
|
07afe43d0d | ||
|
|
8ca2e089a3 | ||
|
|
41a8fbc591 | ||
|
|
3a0536eafc | ||
|
|
9cbdde526b | ||
|
|
2878eb8d87 | ||
|
|
2e764d74f8 | ||
|
|
92dd70f08b | ||
|
|
484bbfc704 | ||
|
|
0b097808f1 | ||
|
|
6cc4b3779c | ||
|
|
7d9efa1997 | ||
|
|
af2e45883d | ||
|
|
17e11b7904 | ||
|
|
22aa1edd61 | ||
|
|
07c862c785 | ||
|
|
b60dad7076 | ||
|
|
148e45745a | ||
|
|
3287061ea1 | ||
|
|
223beeb374 | ||
|
|
8b9ad2e9d1 | ||
|
|
a5306bade3 | ||
|
|
aa8822d9a3 | ||
|
|
5fca9c9ed0 | ||
|
|
83805734bf | ||
|
|
0b3d1d67d9 | ||
|
|
53a26b95a4 |
No files matched your search
@@ -0,0 +1,7 @@
|
||||
# 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 |
Створено
+131
-6
@@ -199,7 +199,7 @@ dependencies = [
|
||||
"wayland-backend",
|
||||
"wayland-client",
|
||||
"wayland-protocols",
|
||||
"zbus",
|
||||
"zbus 5.19.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -5722,6 +5722,20 @@ 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"
|
||||
@@ -5994,6 +6008,20 @@ 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"
|
||||
@@ -6666,6 +6694,7 @@ dependencies = [
|
||||
"tauri-build",
|
||||
"tauri-plugin-dialog",
|
||||
"tauri-plugin-mcp-bridge",
|
||||
"tauri-plugin-notification",
|
||||
"tauri-plugin-opener",
|
||||
"tauri-plugin-single-instance",
|
||||
"tauri-plugin-updater",
|
||||
@@ -8153,7 +8182,7 @@ dependencies = [
|
||||
"once_cell",
|
||||
"serde",
|
||||
"sha2 0.11.1",
|
||||
"zbus",
|
||||
"zbus 5.19.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -9429,6 +9458,26 @@ 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"
|
||||
@@ -9448,7 +9497,7 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
"url",
|
||||
"windows",
|
||||
"zbus",
|
||||
"zbus 5.19.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -9464,7 +9513,7 @@ dependencies = [
|
||||
"tokio",
|
||||
"tracing",
|
||||
"windows-sys 0.61.2",
|
||||
"zbus",
|
||||
"zbus 5.19.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -9647,6 +9696,17 @@ 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"
|
||||
@@ -12137,11 +12197,38 @@ dependencies = [
|
||||
"uuid",
|
||||
"windows-sys 0.61.2",
|
||||
"winnow 1.0.4",
|
||||
"zbus_macros",
|
||||
"zbus_macros 5.19.0",
|
||||
"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"
|
||||
@@ -12150,7 +12237,7 @@ checksum = "74801d001b9e7729adb4f1825b67b398185fed424749aa3d8bacf70417137d9a"
|
||||
dependencies = [
|
||||
"keyring-core",
|
||||
"secret-service",
|
||||
"zbus",
|
||||
"zbus 5.19.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -12168,6 +12255,18 @@ 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"
|
||||
@@ -12179,6 +12278,19 @@ 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"
|
||||
@@ -12335,6 +12447,19 @@ 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.png" alt="WeChat group QR code" width="200">
|
||||
<img src=".github/assets/wechat-group-3.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.png" alt="WeChat grubu QR kodu" width="200">
|
||||
<img src=".github/assets/wechat-group-3.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.png" alt="微信群二维码" width="200">
|
||||
<img src=".github/assets/wechat-group-3.png" alt="微信群二维码" width="200">
|
||||
|
||||
- 参与贡献:参见 [CONTRIBUTING.md](CONTRIBUTING.md) 和[贡献者文档](https://openidea.sh/zh/contribute/setup)。
|
||||
|
||||
|
||||
@@ -17,6 +17,8 @@
|
||||
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,6 +109,7 @@ 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());
|
||||
@@ -203,6 +204,14 @@ 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 {
|
||||
@@ -472,6 +481,43 @@ 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),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
|
||||
use crate::model::{
|
||||
AgentCommand, AgentCommandSource, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit,
|
||||
AgentUsage,
|
||||
AgentModelPricing, AgentUsage,
|
||||
};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
@@ -29,6 +29,7 @@ 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(),
|
||||
@@ -36,6 +37,7 @@ 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,
|
||||
},
|
||||
],
|
||||
});
|
||||
@@ -288,6 +290,7 @@ fn legacy(
|
||||
description: str_of(m, "description"),
|
||||
cost_category: None,
|
||||
usage_multiplier: None,
|
||||
pricing: pricing_of(m),
|
||||
value,
|
||||
})
|
||||
})
|
||||
@@ -324,10 +327,18 @@ 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)
|
||||
}
|
||||
|
||||
@@ -134,7 +134,10 @@ 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").and(Some(line))
|
||||
line.get("type")
|
||||
.and_then(serde_json::Value::as_str)
|
||||
.filter(|t| *t == "session_meta")
|
||||
.map(|_| line.get("payload").unwrap_or(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);
|
||||
@@ -293,16 +296,28 @@ 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", "payload": {"type": "session_meta",
|
||||
"payload": {"id": "thread-1", "cwd": "/work/app"}}}),
|
||||
json!({"timestamp": "t", "payload": {"type": "user_message",
|
||||
"payload": {"message": "add tests"}}}),
|
||||
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"}}),
|
||||
],
|
||||
);
|
||||
write(&tmp.path().join("sessions/notes.jsonl"), &[json!({"nope": true})]);
|
||||
|
||||
@@ -121,6 +121,13 @@ 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,
|
||||
@@ -132,9 +139,13 @@ 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.
|
||||
@@ -167,6 +178,29 @@ 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 {
|
||||
@@ -338,6 +372,8 @@ 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,
|
||||
@@ -398,6 +434,7 @@ 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)
|
||||
}
|
||||
@@ -415,8 +452,10 @@ 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();
|
||||
@@ -547,6 +586,7 @@ 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);
|
||||
}
|
||||
|
||||
@@ -1050,6 +1090,7 @@ 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);
|
||||
@@ -1212,12 +1253,30 @@ impl AgentManager {
|
||||
if !refresh && let Some(p) = self.shared.probes.lock().get(provider) {
|
||||
return Ok(p.clone());
|
||||
}
|
||||
let spec = self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?;
|
||||
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 mut probe = AgentProbe {
|
||||
provider: spec.id.clone(),
|
||||
provider: active_spec.id.clone(),
|
||||
name: None,
|
||||
version: None,
|
||||
protocol: match spec.driver {
|
||||
protocol: match active_spec.driver {
|
||||
provider::Driver::Acp => "ACP".into(),
|
||||
_ => "native".into(),
|
||||
},
|
||||
@@ -1225,31 +1284,6 @@ 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);
|
||||
@@ -1257,7 +1291,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 spec.driver == provider::Driver::Acp {
|
||||
if active_spec.driver == provider::Driver::Acp {
|
||||
probe.protocol = format!("ACP v{}", init.generation);
|
||||
}
|
||||
probe.capabilities = capabilities_of(&init).0;
|
||||
@@ -1270,11 +1304,47 @@ impl AgentManager {
|
||||
Err(e) => probe.error = Some(e),
|
||||
}
|
||||
if probe.error.is_none() {
|
||||
self.shared.probes.lock().insert(spec.id, probe.clone());
|
||||
self.shared.probes.lock().insert(active_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<()> {
|
||||
@@ -1695,6 +1765,28 @@ 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();
|
||||
@@ -1797,8 +1889,11 @@ impl Task {
|
||||
}
|
||||
match (next, result) {
|
||||
(Some(queued), _) => prompt = queued.prompt,
|
||||
(None, Ok(_)) => {
|
||||
(None, Ok(stop)) => {
|
||||
self.set_status(AgentStatus::Ready, None);
|
||||
if stop != "cancelled" {
|
||||
self.emit_attention(AgentAttentionReason::Finished);
|
||||
}
|
||||
return self.release_when_idle();
|
||||
}
|
||||
(None, Err(failure)) => return self.fail(failure),
|
||||
@@ -1869,6 +1964,7 @@ 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.
|
||||
@@ -1940,7 +2036,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 live = self.ensure_session().await.map_err(Failure::from)?;
|
||||
let mut 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());
|
||||
@@ -1962,9 +2058,34 @@ impl Task {
|
||||
None => prompt.clone(),
|
||||
}
|
||||
};
|
||||
let content = self.content(&live, &prompt).await;
|
||||
let result: Result<Value, RpcError> =
|
||||
let mut content = self.content(&live, &prompt).await;
|
||||
let mut 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)),
|
||||
@@ -2044,11 +2165,43 @@ impl Task {
|
||||
let s = self.state.lock();
|
||||
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone())
|
||||
};
|
||||
let spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
|
||||
let launch_cwd = cwd.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 = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?;
|
||||
self.stderr.lock().clear();
|
||||
self.config_sent.lock().clear();
|
||||
let weak = Arc::downgrade(self);
|
||||
@@ -2063,17 +2216,24 @@ 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 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 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 init = peer.initialize(&client_info()).await.map_err(|e| self.describe(e))?;
|
||||
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 sign_in_message = spec.sign_in_message(&init.auth_methods);
|
||||
let can_load = init.load_session();
|
||||
let (capabilities, embedded) = capabilities_of(&init);
|
||||
let mcp_servers = self.shared.mcp_servers_for_session(&provider_id, &init);
|
||||
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(cwd).to_string_lossy().into_owned();
|
||||
let cwd_s = dunce::canonicalize(cwd).unwrap_or_else(|_| cwd.to_path_buf()).to_string_lossy().into_owned();
|
||||
|
||||
let mut tried_auth = false;
|
||||
let mut session = None;
|
||||
@@ -2093,11 +2253,20 @@ impl Task {
|
||||
Some(s) => s,
|
||||
None => {
|
||||
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();
|
||||
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();
|
||||
(id, v)
|
||||
}
|
||||
};
|
||||
@@ -2120,13 +2289,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();
|
||||
(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,
|
||||
@@ -2172,7 +2341,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());
|
||||
@@ -2185,10 +2354,18 @@ impl Task {
|
||||
}
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
let live =
|
||||
Live { sign_in_message, peer, session: session_id, capabilities, embedded, resumable: can_load, init };
|
||||
*self.live.lock() = Some(live.clone());
|
||||
Ok(live)
|
||||
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,
|
||||
})
|
||||
}
|
||||
|
||||
/// Sends the user's choices that the session offers only now: an option advertised
|
||||
@@ -2230,6 +2407,7 @@ 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()
|
||||
@@ -2500,6 +2678,7 @@ 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
|
||||
@@ -2583,6 +2762,7 @@ 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);
|
||||
@@ -3174,3 +3354,55 @@ 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;
|
||||
}
|
||||
}
|
||||
@@ -5,6 +5,15 @@ 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 {
|
||||
@@ -123,6 +132,40 @@ 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")]
|
||||
@@ -138,6 +181,10 @@ 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.
|
||||
@@ -666,6 +713,12 @@ 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};
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,841 @@
|
||||
//! 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())
|
||||
}
|
||||
@@ -0,0 +1,540 @@
|
||||
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)
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,583 @@
|
||||
//! 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,6 +13,7 @@
|
||||
|
||||
pub(crate) mod claude;
|
||||
pub(crate) mod codex;
|
||||
pub(crate) mod copilot;
|
||||
|
||||
use ide_jsonrpc::{Framing, Handler, Peer};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
@@ -20,6 +20,8 @@ pub(crate) enum Driver {
|
||||
Codex,
|
||||
/// `claude` in stream-json mode.
|
||||
Claude,
|
||||
/// `copilot --headless --no-auto-update --stdio`.
|
||||
Copilot,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
@@ -55,7 +57,13 @@ 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::Acp, &["copilot", "--acp"], "Run `copilot` 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.",
|
||||
),
|
||||
("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."),
|
||||
@@ -242,10 +250,13 @@ 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
|
||||
/// and `npx -y` adapters). CLI built-ins (`copilot`, `gemini`, …) can be installed and
|
||||
/// updated from the ACP Registry into `<config>/agents/<id>.toml`.
|
||||
/// 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`.
|
||||
pub(crate) fn is_builtin(id: &str) -> bool {
|
||||
BUILTIN.iter().any(|&(bid, _, driver, cmd, _)| bid == id && (driver != Driver::Acp || cmd.first() == Some(&"npx")))
|
||||
id != "copilot"
|
||||
&& 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.
|
||||
@@ -618,6 +629,10 @@ 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) => {
|
||||
@@ -643,6 +658,14 @@ 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;
|
||||
}
|
||||
|
||||
@@ -3619,3 +3619,374 @@ 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,
|
||||
})
|
||||
.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,
|
||||
})
|
||||
.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,
|
||||
})
|
||||
.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,
|
||||
})
|
||||
.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,
|
||||
})
|
||||
.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,
|
||||
})
|
||||
.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 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,
|
||||
})
|
||||
.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,
|
||||
})
|
||||
.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();
|
||||
}
|
||||
@@ -415,7 +415,7 @@ pub(crate) enum Action {
|
||||
|
||||
impl Action {
|
||||
pub(crate) fn display(&self, root: &Path) -> String {
|
||||
let rel = |p: &Path| p.strip_prefix(root).unwrap_or(p).to_string_lossy().into_owned();
|
||||
let rel = |p: &Path| p.strip_prefix(root).unwrap_or(p).to_string_lossy().replace('\\', "/");
|
||||
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)),
|
||||
@@ -646,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!(entries[0].ends_with("lib/*"));
|
||||
assert!(entries[1].ends_with("WEB-INF/lib/*"));
|
||||
assert!(Path::new(entries[0]).ends_with("lib/*"));
|
||||
assert!(Path::new(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!(test_cp.starts_with(&root.join("out/production/shop").to_string_lossy().into_owned()));
|
||||
assert_eq!(Path::new(test_cp.split(sep).next().unwrap()), root.join("out/production/shop"));
|
||||
assert!(test_cp.contains("junit.jar"));
|
||||
}
|
||||
|
||||
@@ -693,7 +693,9 @@ 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" && w[1].ends_with("build/classes/production/p")));
|
||||
assert!(
|
||||
javac.args.windows(2).any(|w| w[0] == "-d" && Path::new(&w[1]).ends_with("build/classes/production/p"))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -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] };
|
||||
let model = crate::BuildModel { maven: None, gradle: vec![model], sbt: Vec::new() };
|
||||
assert_eq!(crate::dependency_coordinates(root, &model)[0].artifact_id, "included");
|
||||
}
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
//! Build tool models for the Maven and Gradle tool windows, and Build › Build
|
||||
//! Build tool models for the Maven, Gradle and sbt 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,6 +13,7 @@ pub mod kotlin_bridge;
|
||||
pub mod maven;
|
||||
pub mod pom_edit;
|
||||
mod process;
|
||||
pub mod sbt;
|
||||
mod sync;
|
||||
pub mod web;
|
||||
mod xml;
|
||||
@@ -20,6 +21,7 @@ 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,
|
||||
};
|
||||
@@ -42,6 +44,9 @@ 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 {
|
||||
@@ -96,7 +101,7 @@ pub fn load_linked(
|
||||
g
|
||||
})
|
||||
.collect();
|
||||
BuildModel { maven, gradle }
|
||||
BuildModel { maven, gradle, sbt: sbt::load(root) }
|
||||
}
|
||||
|
||||
/// Gradle project folders outside `root` as of the last sync (`includeFlat` siblings):
|
||||
@@ -329,7 +334,7 @@ mod tests {
|
||||
..Default::default()
|
||||
};
|
||||
let gradle = gradle::load(root).into_iter().collect();
|
||||
let model = BuildModel { maven: Some(maven), gradle };
|
||||
let model = BuildModel { maven: Some(maven), gradle, sbt: Vec::new() };
|
||||
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))
|
||||
@@ -348,7 +353,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() };
|
||||
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect(), sbt: Vec::new() };
|
||||
let names: Vec<String> = dependency_coordinates(root, &model)
|
||||
.into_iter()
|
||||
.map(|c| format!("{}:{}:{}", c.group_id, c.artifact_id, c.version))
|
||||
@@ -367,7 +372,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() };
|
||||
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect(), sbt: Vec::new() };
|
||||
let versions: Vec<_> = dependency_coordinates(root, &model).into_iter().map(|c| c.version).collect();
|
||||
assert_eq!(versions, ["1.2", "2.3"]);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,301 @@
|
||||
//! 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,7 +14,8 @@ 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` and the Windows shell files.
|
||||
/// IDEA's default list, plus `.jj`, rope's `.ropeproject` (pylsp-rope creates it in the
|
||||
/// project root) and the Windows shell files.
|
||||
pub const DEFAULT_IGNORED_NAMES: &[&str] = &[
|
||||
"*.pyc",
|
||||
"*.pyo",
|
||||
@@ -25,6 +26,7 @@ pub const DEFAULT_IGNORED_NAMES: &[&str] = &[
|
||||
".git",
|
||||
".hg",
|
||||
".jj",
|
||||
".ropeproject",
|
||||
".svn",
|
||||
"CVS",
|
||||
"__pycache__",
|
||||
|
||||
@@ -71,6 +71,8 @@ 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>>,
|
||||
@@ -508,6 +510,7 @@ impl Default for Settings {
|
||||
agent_security: AgentSecuritySettings::default(),
|
||||
scopes: Vec::new(),
|
||||
file_colors: FileColorSettings::default(),
|
||||
database: DatabaseSettings::default(),
|
||||
plugins: BTreeMap::new(),
|
||||
}
|
||||
}
|
||||
@@ -647,13 +650,20 @@ 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, groups: BTreeMap::new() }
|
||||
Self { balloons: true, sound: false, system_notifications: true, groups: BTreeMap::new() }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1337,6 +1347,9 @@ 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,6 +241,30 @@ 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,6 +120,12 @@ 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,6 +12,7 @@ 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,6 +19,7 @@ mod jvm_memory;
|
||||
pub mod kotlin;
|
||||
pub mod kotlin_lsp;
|
||||
mod session;
|
||||
pub mod unity;
|
||||
|
||||
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
|
||||
use connection::{Connection, DapError};
|
||||
@@ -1121,6 +1122,16 @@ 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
|
||||
@@ -1202,6 +1213,10 @@ 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(())
|
||||
}
|
||||
|
||||
@@ -1229,11 +1244,18 @@ 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 {
|
||||
if !graceful && (!own_terminate || killed) {
|
||||
let _ = s
|
||||
.conn
|
||||
.request_timeout(
|
||||
@@ -1244,7 +1266,7 @@ impl DebugManager {
|
||||
.await;
|
||||
}
|
||||
}
|
||||
if own_terminate && !graceful {
|
||||
if own_terminate && !graceful && !killed {
|
||||
// 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;
|
||||
@@ -1263,7 +1285,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" {
|
||||
if terminate && s.request == "launch" && !killed {
|
||||
// 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;
|
||||
use std::time::{Duration, Instant};
|
||||
use tokio::io::{AsyncRead, AsyncReadExt};
|
||||
use tokio::process::Child;
|
||||
use tokio::sync::{mpsc, watch};
|
||||
@@ -116,6 +116,7 @@ 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
|
||||
@@ -270,6 +271,7 @@ 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()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -716,6 +718,15 @@ 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);
|
||||
}
|
||||
@@ -724,7 +735,9 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
|
||||
match event {
|
||||
"initialized" => {
|
||||
s.initialized.send_replace(true);
|
||||
s.emit(DebugEvent::Initialized);
|
||||
if s.adapter != "unity" {
|
||||
s.emit(DebugEvent::Initialized);
|
||||
}
|
||||
}
|
||||
"stopped" => {
|
||||
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
|
||||
|
||||
@@ -158,6 +158,7 @@ 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.
|
||||
@@ -198,6 +199,7 @@ impl Default for Script {
|
||||
close_during_startup: false,
|
||||
gdb15_starts_at_launch: false,
|
||||
launch_after_configuration: false,
|
||||
empty_thread_responses: 0,
|
||||
accept: &[],
|
||||
custom: None,
|
||||
}
|
||||
@@ -244,6 +246,8 @@ 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;
|
||||
@@ -268,13 +272,14 @@ 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": true,
|
||||
"supportsConfigurationDoneRequest": !unity,
|
||||
"supportsCompletionsRequest": true,
|
||||
"supportsTerminateRequest": script.supports_terminate,
|
||||
"supportsSetVariable": true,
|
||||
@@ -293,8 +298,15 @@ 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;
|
||||
@@ -448,7 +460,14 @@ 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" => ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]})),
|
||||
"threads" => {
|
||||
thread_requests += 1;
|
||||
if thread_requests <= script.empty_thread_responses {
|
||||
ok!(msg, json!({"threads": []}));
|
||||
} else {
|
||||
ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]}));
|
||||
}
|
||||
}
|
||||
"stackTrace" => ok!(
|
||||
msg,
|
||||
json!({"stackFrames": [
|
||||
@@ -508,6 +527,14 @@ 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;
|
||||
@@ -878,6 +905,32 @@ 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());
|
||||
@@ -2274,6 +2327,44 @@ 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() {
|
||||
|
||||
@@ -0,0 +1,187 @@
|
||||
//! 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"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,187 @@
|
||||
//! 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,6 +279,18 @@ 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"))
|
||||
}
|
||||
@@ -1079,8 +1091,7 @@ impl DbManager {
|
||||
let driver = pool.driver();
|
||||
let mut out = SchemaObjects::default();
|
||||
if let Some(q) = sql::routines(driver, schema) {
|
||||
out.routines = pool
|
||||
.rows(&q, MAX_META_ROWS)
|
||||
out.routines = catalog_rows(&pool, &q)
|
||||
.await?
|
||||
.into_iter()
|
||||
.filter_map(|r| {
|
||||
|
||||
@@ -219,6 +219,9 @@ 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 {
|
||||
@@ -236,8 +239,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 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 \
|
||||
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] \
|
||||
WHERE n.nspname = {s} AND t.relname = {t} ORDER BY i.relname, k.ord"
|
||||
),
|
||||
DbDriver::Mysql => format!(
|
||||
@@ -284,12 +287,15 @@ 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 a.attidentity <> '' 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 \
|
||||
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') \
|
||||
@@ -363,9 +369,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 \
|
||||
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 \
|
||||
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 NOT IN ('pg_catalog', 'information_schema') \
|
||||
ORDER BY 1, 2, 3, k.ord LIMIT 20000"
|
||||
}
|
||||
@@ -408,7 +414,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 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"
|
||||
"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"
|
||||
),
|
||||
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"
|
||||
@@ -671,6 +677,16 @@ 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);
|
||||
@@ -1172,4 +1188,32 @@ 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,3 +133,98 @@ 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,7 +320,8 @@ 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.
|
||||
/// the background. Consumers always use Local, even when migration fails. On every
|
||||
/// system, tool virtual environments moved from elsewhere are dropped (#3581).
|
||||
pub fn migrate(data: &Path, local: &Path) {
|
||||
if cfg!(target_os = "windows") && data != local {
|
||||
migrate_entries(data, local);
|
||||
@@ -328,6 +329,7 @@ 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,6 +190,7 @@ impl Host {
|
||||
open_locks: Default::default(),
|
||||
};
|
||||
host.apply_proxy();
|
||||
host.apply_added_jdks();
|
||||
ops::agent::move_user_mcp_values(&host);
|
||||
host
|
||||
}
|
||||
@@ -531,6 +532,14 @@ 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::*;
|
||||
|
||||
@@ -128,9 +128,11 @@ pub fn run_command() -> Tool {
|
||||
&format!(
|
||||
"Runs a shell command line in a new or reused tab of OpenIDEA's Run tool window, with the shell of \
|
||||
Settings › Tools › Terminal. The user is asked first (unless the IDE runs tools without \
|
||||
confirmation). Waits up to `timeout` milliseconds (default {RUN_TIMEOUT_MS}) for the command to finish; a command \
|
||||
still running then keeps running, and `wait_for_run`, `read_run_output`, `get_run_status`, `send_run_input` and \
|
||||
`stop_run` follow it up by name. Returns the tab's status (`state`: starting, running, stopping, succeeded, failed, \
|
||||
confirmation). Waits up to `timeout` milliseconds (default {RUN_TIMEOUT_MS}) for the command to finish, or until its \
|
||||
output matches `pattern`; a command still running then keeps running, and `wait_for_run`, `read_run_output`, \
|
||||
`get_run_status`, `send_run_input` and `stop_run` follow it up by name. A server, watcher or app never finishes: to \
|
||||
start one, pass `pattern` for the line it prints once ready (e.g. `Listening on|Started .* in|ready in`) rather than \
|
||||
a long `timeout`, so the call returns as soon as it is up. Returns the tab's status (`state`: starting, running, stopping, succeeded, failed, \
|
||||
crashed, stoppedByAgent, stoppedByUser or startFailed; `exitCode`; `crash` with the signal or exception of a crashed \
|
||||
process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
|
||||
),
|
||||
@@ -152,6 +154,7 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
|
||||
};
|
||||
let env = call.args.get("envs").filter(|v| !v.is_null()).map(|_| call.str_map("envs")).transpose()?;
|
||||
let deadline = deadline(&call, RUN_TIMEOUT_MS)?;
|
||||
let ready = pattern(&call)?;
|
||||
let host = call.host();
|
||||
let runs = &host.mcp_agent_runs;
|
||||
if let Some(run) = runs.get(call.root(), &name).filter(|r| r.running()) {
|
||||
@@ -185,7 +188,7 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
|
||||
return Err(IdeError::invalid(format!("`{name}` did not start: {error}")));
|
||||
}
|
||||
let from = run.process_offset();
|
||||
let end = run.wait(deadline, None, from, &call.cancel).await?;
|
||||
let end = run.wait(deadline, ready.as_ref(), from, &call.cancel).await?;
|
||||
let mut extra = output_view(&call, &run, from)?;
|
||||
extra.insert("waitEnded".into(), end.as_str().into());
|
||||
result(&run, extra)
|
||||
@@ -209,6 +212,12 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
|
||||
ParamType::Integer,
|
||||
"Milliseconds to wait for the command to finish before returning (0 returns once it started); the command \
|
||||
keeps running after it",
|
||||
))
|
||||
.param(Param::optional(
|
||||
"pattern",
|
||||
ParamType::String,
|
||||
"Regular expression that ends the wait when the command's output matches it: the ready line of a server or \
|
||||
watcher. `waitEnded` is then `matched`",
|
||||
))
|
||||
.param(Param::optional("maxLinesCount", ParamType::Integer, MAX_LINES))
|
||||
.param(Param::optional("truncateMode", ParamType::String, TRUNCATE_MODE))
|
||||
|
||||
@@ -748,9 +748,15 @@ 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 outside it.
|
||||
// The project folder and the content roots its walk does not cover: those outside it and
|
||||
// those inside it that it skips as ignored.
|
||||
let roots: Vec<PathBuf> = std::iter::once(root.clone())
|
||||
.chain(call.project().content_roots().into_iter().filter(|r| relative_to_root(&root, r).is_none()))
|
||||
.chain(
|
||||
call.project()
|
||||
.content_roots()
|
||||
.into_iter()
|
||||
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r)),
|
||||
)
|
||||
.collect();
|
||||
let host = call.host();
|
||||
let walk = Walk {
|
||||
|
||||
@@ -0,0 +1,115 @@
|
||||
//! 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"));
|
||||
}
|
||||
}
|
||||
@@ -650,28 +650,52 @@ fn structure_plan(
|
||||
kind: BuildKind,
|
||||
cache: &Path,
|
||||
) -> IdeResult<Option<compile::BuildPlan>> {
|
||||
let (roots, jdk) = structure_inputs(root, settings, detected);
|
||||
compile::structure_plan(
|
||||
root,
|
||||
&settings.project_structure,
|
||||
&roots,
|
||||
jdk.as_ref(),
|
||||
&settings.languages.java.language_level,
|
||||
kind,
|
||||
cache,
|
||||
)
|
||||
let (ps, roots, jdk) = structure_inputs(root, settings, detected);
|
||||
compile::structure_plan(root, &ps, &roots, jdk.as_ref(), &settings.languages.java.language_level, kind, cache)
|
||||
}
|
||||
|
||||
/// The roots and JDK a build of a project without a build tool uses.
|
||||
/// The Project Structure, roots and JDK a build of a project without a build tool uses.
|
||||
/// An Eclipse project's `.classpath` libraries and its web content folder count as if they
|
||||
/// were configured, and a web project with no artifacts gets IDEA's `<name>:war exploded`.
|
||||
pub(crate) fn structure_inputs(
|
||||
root: &Path,
|
||||
settings: &Settings,
|
||||
detected: &[ide_workspace::roots::SourceFolder],
|
||||
) -> (compile::StructureRoots, Option<compile::StructureJdk>) {
|
||||
use ide_workspace::roots::{ProjectRoots, RootKind};
|
||||
let roots = ProjectRoots::compute(detected.to_vec(), &settings.project_structure);
|
||||
) -> (ide_core::settings::ProjectStructureSettings, compile::StructureRoots, Option<compile::StructureJdk>) {
|
||||
use ide_core::settings::{ArtifactConfig, ArtifactKind, FacetConfig, ProjectLibrary};
|
||||
use ide_workspace::roots::{ProjectRoots, RootKind, eclipse};
|
||||
let mut ps = settings.project_structure.clone();
|
||||
let mut included = Vec::new();
|
||||
if let Some(cp) = eclipse::classpath(root).filter(|cp| !cp.libraries.is_empty()) {
|
||||
let name = "Eclipse classpath".to_owned();
|
||||
if !ps.libraries.iter().any(|l| l.name == name) {
|
||||
ps.libraries.push(ProjectLibrary { name: name.clone(), classes: cp.libraries, ..Default::default() });
|
||||
}
|
||||
included.push(name);
|
||||
}
|
||||
if !ps.facets.iter().any(|f| f.kind == "web")
|
||||
&& let Some(web) = eclipse::web_root(root)
|
||||
{
|
||||
ps.facets.push(FacetConfig {
|
||||
kind: "web".into(),
|
||||
module: ".".into(),
|
||||
descriptor: format!("{web}/WEB-INF/web.xml"),
|
||||
web_root: web,
|
||||
});
|
||||
if ps.artifacts.is_empty() {
|
||||
let name = root.file_name().map_or_else(|| "app".into(), |n| n.to_string_lossy().into_owned());
|
||||
ps.artifacts.push(ArtifactConfig {
|
||||
name: format!("{name}:war exploded"),
|
||||
kind: ArtifactKind::WarExploded,
|
||||
module: ".".into(),
|
||||
include_libraries: included,
|
||||
..Default::default()
|
||||
});
|
||||
}
|
||||
}
|
||||
let roots = ProjectRoots::compute(detected.to_vec(), &ps);
|
||||
let of = |kind: RootKind| roots.roots.iter().filter(|r| r.kind == kind).map(|r| root.join(&r.path)).collect();
|
||||
let module = settings.project_structure.module_settings(root, root);
|
||||
let module = ps.module_settings(root, root);
|
||||
let level = module
|
||||
.map(|m| m.language_level.as_str())
|
||||
.filter(|l| !l.trim().is_empty())
|
||||
@@ -690,7 +714,7 @@ pub(crate) fn structure_inputs(
|
||||
test_resources: of(RootKind::TestResources),
|
||||
excluded: of(RootKind::Excluded),
|
||||
};
|
||||
(roots, jdk)
|
||||
(ps, roots, jdk)
|
||||
}
|
||||
|
||||
fn cmake_plan(root: &Path, kind: BuildKind, configs: &[ide_run::RunConfig], id: &str) -> IdeResult<compile::BuildPlan> {
|
||||
|
||||
@@ -88,6 +88,10 @@ 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,6 +12,25 @@ 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"
|
||||
@@ -100,12 +119,26 @@ 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> {
|
||||
@@ -460,6 +493,17 @@ 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(
|
||||
@@ -664,6 +708,7 @@ 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
|
||||
});
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
|
||||
pub mod agent;
|
||||
pub mod analysis;
|
||||
pub mod bdd;
|
||||
pub mod build;
|
||||
pub mod bytes;
|
||||
pub mod coverage;
|
||||
|
||||
@@ -232,6 +232,9 @@ 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();
|
||||
}
|
||||
|
||||
@@ -205,8 +205,8 @@ pub async fn run_tomcat_installations(
|
||||
/// Id prefix of a Project Structure WAR artifact (a project without a build tool).
|
||||
const PROJECT_ARTIFACT: &str = "project:";
|
||||
|
||||
fn project_web_artifacts(settings: &ide_core::settings::Settings) -> Vec<ide_build::web::WebArtifact> {
|
||||
ide_build::compile::structure_web_artifacts(&settings.project_structure)
|
||||
fn project_web_artifacts(ps: &ide_core::settings::ProjectStructureSettings) -> Vec<ide_build::web::WebArtifact> {
|
||||
ide_build::compile::structure_web_artifacts(ps)
|
||||
.into_iter()
|
||||
.map(|a| ide_build::web::WebArtifact {
|
||||
id: format!("{PROJECT_ARTIFACT}{}", a.name),
|
||||
@@ -228,20 +228,19 @@ fn build_project_war(
|
||||
cache: &std::path::Path,
|
||||
) -> IdeResult<()> {
|
||||
use ide_build::compile;
|
||||
let artifact = settings
|
||||
.project_structure
|
||||
let (ps, roots, jdk) = crate::ops::build::structure_inputs(root, settings, detected);
|
||||
let artifact = ps
|
||||
.artifacts
|
||||
.iter()
|
||||
.find(|a| a.name == name)
|
||||
.ok_or_else(|| IdeError::invalid(format!("No artifact named {name} in Project Structure › Artifacts")))?;
|
||||
let (roots, jdk) = crate::ops::build::structure_inputs(root, settings, detected);
|
||||
let war = base.join("artifact").join(format!(
|
||||
"{}.war",
|
||||
name.split(':').next().unwrap_or(name).replace(|c: char| !c.is_alphanumeric() && c != '-', "_")
|
||||
));
|
||||
let plan = compile::structure_war_plan(
|
||||
root,
|
||||
&settings.project_structure,
|
||||
&ps,
|
||||
&roots,
|
||||
jdk.as_ref(),
|
||||
&settings.languages.java.language_level,
|
||||
@@ -278,7 +277,9 @@ pub async fn run_tomcat_artifacts(host: &Host, window: &str) -> IdeResult<Vec<id
|
||||
let mut artifacts = ide_build::web::artifacts(&project.root, &model);
|
||||
// Without a build tool, the Project Structure's WAR artifacts are built by the IDE.
|
||||
if model.maven.is_none() && model.gradle.is_empty() {
|
||||
artifacts.extend(project_web_artifacts(&settings));
|
||||
let detected = project.detected_roots.read().clone();
|
||||
let (ps, _, _) = crate::ops::build::structure_inputs(&project.root, &settings, &detected);
|
||||
artifacts.extend(project_web_artifacts(&ps));
|
||||
}
|
||||
artifacts
|
||||
})
|
||||
|
||||
@@ -37,6 +37,9 @@ 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.
|
||||
@@ -372,9 +375,20 @@ 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,8 +95,12 @@ pub(crate) fn search_project(
|
||||
cancel,
|
||||
&|mut file| {
|
||||
if dir != root {
|
||||
let name = dir.file_name().unwrap_or_default().to_string_lossy();
|
||||
file.rel_path = format!("{name}/{}", file.rel_path);
|
||||
// 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);
|
||||
}
|
||||
emit(file);
|
||||
},
|
||||
|
||||
@@ -677,9 +677,14 @@ impl Shared {
|
||||
}
|
||||
let previous =
|
||||
self.setting_snapshots.lock().insert((client.map(str::to_owned), pkg.id().into()), current.clone());
|
||||
previous
|
||||
.map(|old| current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect())
|
||||
.unwrap_or_default()
|
||||
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(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn status_snapshot(&self, client: &str) -> Vec<super::PluginStatusItem> {
|
||||
@@ -2826,7 +2831,7 @@ impl HostApi for PluginApi {
|
||||
}
|
||||
|
||||
fn post_view_message(&self, view: &str, message: String) -> Result<(), HostError> {
|
||||
let declared = [super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
|
||||
let declared = super::ui_points::WEB_POINTS
|
||||
.iter()
|
||||
.any(|point| self.shared.ui.items(point, Some(self.id())).iter().any(|i| i.key == view));
|
||||
if !declared {
|
||||
|
||||
@@ -1489,9 +1489,8 @@ impl PluginHost {
|
||||
}
|
||||
|
||||
fn declared_view(&self, id: &str, view: &str) -> IdeResult<()> {
|
||||
let declared = [ui_points::VIEWS, ui_points::CUSTOM_EDITORS]
|
||||
.iter()
|
||||
.any(|point| self.ui.items(point, Some(id)).iter().any(|i| i.key == view));
|
||||
let declared =
|
||||
ui_points::WEB_POINTS.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,6 +89,7 @@ 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,6 +36,12 @@
|
||||
//! 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"]
|
||||
@@ -73,6 +79,9 @@ 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";
|
||||
@@ -745,6 +754,41 @@ 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 {
|
||||
@@ -1196,6 +1240,46 @@ 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::VIEWS, super::ui_points::CUSTOM_EDITORS]
|
||||
super::ui_points::WEB_POINTS
|
||||
.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::VIEWS, super::ui_points::CUSTOM_EDITORS]
|
||||
let entry = super::ui_points::WEB_POINTS
|
||||
.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(extra_roots.clone());
|
||||
lsp.set_content_roots(language_server_roots(&root, 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(roots.clone());
|
||||
self.lsp.set_content_roots(language_server_roots(&self.root, roots.clone()));
|
||||
self.lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
|
||||
&self.root,
|
||||
&self.settings.effective().languages.java.maven.linked_projects,
|
||||
@@ -1350,15 +1350,20 @@ pub(crate) fn workspace_member_roots(root: &Path) -> Vec<PathBuf> {
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// 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).
|
||||
/// 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).
|
||||
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)).collect::<Vec<_>>();
|
||||
let mut roots = workspace
|
||||
.projects
|
||||
.into_iter()
|
||||
.filter(|p| !p.starts_with(root) || ide_index::walk_skips(root, p))
|
||||
.collect::<Vec<_>>();
|
||||
for path in extra_content_roots(settings, root, build_cache) {
|
||||
if !roots.contains(&path) {
|
||||
roots.push(path);
|
||||
@@ -1369,6 +1374,22 @@ 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 —
|
||||
@@ -2163,4 +2184,25 @@ 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]);
|
||||
}
|
||||
}
|
||||
@@ -594,6 +594,31 @@ fn agent_process(h: &Harness, name: &str) -> ide_core::RunId {
|
||||
h.host.processes.list().into_iter().filter(|r| r.config_id == id && r.running).map(|r| r.id).max().unwrap()
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn run_command_returns_once_a_server_prints_its_ready_line() {
|
||||
let h = Harness::new();
|
||||
h.trust().await;
|
||||
h.host.mcp_requests.set_ready("main", true);
|
||||
h.host
|
||||
.global_settings
|
||||
.set(ide_workspace::SettingsScope::Global, "mcpServer.runWithoutConfirmation", json!(true))
|
||||
.unwrap();
|
||||
let _started = run_tool_window(&h);
|
||||
// A server started with its ready line returns once it prints it, long before the timeout.
|
||||
let started_at = std::time::Instant::now();
|
||||
let up = h
|
||||
.json(
|
||||
"run_command",
|
||||
json!({"name": "web", "command": "sleep 1; echo Listening on 8080; sleep 30", "pattern": "Listening on", "timeout": 60000}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!((up["waitEnded"].as_str(), up["state"].as_str()), (Some("matched"), Some("running")), "{up}");
|
||||
assert!(up["output"].as_str().unwrap().contains("Listening on 8080"), "{up}");
|
||||
assert!(started_at.elapsed() < std::time::Duration::from_secs(20), "returned after {:?}", started_at.elapsed());
|
||||
h.json("stop_run", json!({"name": "web", "force": true, "timeout": 10000})).await;
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
|
||||
|
||||
@@ -6271,10 +6271,15 @@ 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(), 3, "{received}");
|
||||
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[0]["kind"], "settings-changed");
|
||||
assert_eq!(events[0]["data"], "[\"enabled\"]");
|
||||
assert_eq!(events[2]["kind"], "input-mode-changed");
|
||||
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]["editor"][0], path);
|
||||
assert_eq!(events[2]["editor"][1][0], serde_json::json!([0, 0, 0, 0]));
|
||||
}
|
||||
@@ -7016,3 +7021,22 @@ 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,6 +105,70 @@ 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();
|
||||
|
||||
@@ -52,6 +52,29 @@ 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() {
|
||||
@@ -115,12 +138,18 @@ 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());
|
||||
let nested = (extra_roots.include_root && (path.starts_with(root) || root.starts_with(&path)))
|
||||
// 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)))
|
||||
|| extra.iter().any(|e| path.starts_with(&e.path) || e.path.starts_with(&path));
|
||||
if nested || !path.is_dir() {
|
||||
continue;
|
||||
}
|
||||
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
|
||||
// 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(),
|
||||
};
|
||||
extra.push(ExtraRoot { gitignore: root_ignores(&path), name, path });
|
||||
}
|
||||
Self {
|
||||
@@ -176,13 +205,11 @@ 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)> {
|
||||
if self.include_root && path.starts_with(&self.root) {
|
||||
return Some((&self.root, None, &self.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));
|
||||
}
|
||||
self.extra
|
||||
.iter()
|
||||
.find(|e| path.starts_with(&e.path))
|
||||
.map(|e| (e.path.as_path(), Some(e.name.as_str()), &e.gitignore))
|
||||
(self.include_root && path.starts_with(&self.root)).then_some((self.root.as_path(), None, &self.gitignore))
|
||||
}
|
||||
|
||||
/// Whether `path` is (at or) below one of the roots.
|
||||
@@ -207,7 +234,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 {
|
||||
if !self.include_root || self.extra.iter().any(|e| path.starts_with(&e.path)) {
|
||||
return None;
|
||||
}
|
||||
let rel = rel_string(path.strip_prefix(&self.root).ok()?);
|
||||
@@ -537,4 +564,35 @@ 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,6 +21,7 @@ mod matching;
|
||||
mod store;
|
||||
mod worker;
|
||||
|
||||
pub use filter::walk_skips;
|
||||
pub use worker::MAX_SYMBOL_FILE;
|
||||
use worker::{Job, MAX_RECENT, Shared};
|
||||
|
||||
|
||||
@@ -33,6 +33,7 @@ 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")),
|
||||
@@ -626,6 +627,7 @@ mod tests {
|
||||
"Vue",
|
||||
"Angular Template",
|
||||
"Angular TypeScript",
|
||||
"Thymeleaf",
|
||||
"ERB",
|
||||
"JSP",
|
||||
"Astro",
|
||||
@@ -678,7 +680,7 @@ mod tests {
|
||||
let got: Vec<(&str, bool)> = cfg
|
||||
.language_servers
|
||||
.iter()
|
||||
.filter(|s| !s.require_root_marker)
|
||||
.filter(|s| !s.require_root_marker && s.features.is_empty())
|
||||
.map(|s| (s.name.as_str(), s.fallback))
|
||||
.collect();
|
||||
let expected: Vec<(&str, bool)> = servers.iter().enumerate().map(|(i, name)| (*name, i > 0)).collect();
|
||||
@@ -778,13 +780,26 @@ 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"]);
|
||||
assert_eq!(names, ["basedpyright", "pyright", "ty", "pyrefly", "ruff", "pylsp"]);
|
||||
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);
|
||||
@@ -826,6 +841,23 @@ 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();
|
||||
@@ -1057,6 +1089,7 @@ 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,11 +6,15 @@
|
||||
|
||||
use crate::LspManager;
|
||||
use crate::server::Server;
|
||||
use ide_core::{DocId, Pos, Range};
|
||||
use ide_core::{CancellationToken, 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.
|
||||
@@ -18,6 +22,43 @@ 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")
|
||||
@@ -66,6 +107,15 @@ 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;
|
||||
@@ -78,10 +128,9 @@ 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 listed = tokio::task::spawn_blocking(move || list_deprecations(&dir, &search, &modules)).await;
|
||||
let Ok(Some(deprecated)) = listed else { return };
|
||||
let Some(deprecated) = list_deprecations(&dir, &search, &modules, cancel).await else { return };
|
||||
// The document changed meanwhile: its own save runs again.
|
||||
if self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
|
||||
if cancel.is_cancelled() || self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
|
||||
return;
|
||||
}
|
||||
let items = required
|
||||
@@ -157,22 +206,100 @@ struct ListedModule {
|
||||
}
|
||||
|
||||
/// `(module, message)` of each deprecated module in `modules`; `None` when `go` failed.
|
||||
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);
|
||||
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() {
|
||||
return None;
|
||||
}
|
||||
Some(parse_deprecations(&output.stdout))
|
||||
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
|
||||
}
|
||||
|
||||
fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
|
||||
@@ -187,6 +314,231 @@ 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 } }
|
||||
}
|
||||
|
||||
@@ -240,6 +240,7 @@ 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.
|
||||
@@ -516,6 +517,7 @@ 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()),
|
||||
@@ -1393,6 +1395,7 @@ 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 };
|
||||
@@ -3713,6 +3716,7 @@ 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();
|
||||
}
|
||||
@@ -4057,6 +4061,7 @@ 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;
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
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
|
||||
@@ -0,0 +1,196 @@
|
||||
<!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,6 +56,16 @@ 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);
|
||||
@@ -1362,6 +1372,14 @@ 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,3 +1206,21 @@ 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,7 +745,8 @@ pub fn native_tsdk(root: &Path, s: &Settings) -> Option<PathBuf> {
|
||||
}
|
||||
}
|
||||
|
||||
const PYTHON_SERVERS: [&str; 7] = ["basedpyright", "pyright", "ty", "pyrefly", "pylsp", "jedi-language-server", "ruff"];
|
||||
const PYTHON_SERVERS: [&str; 8] =
|
||||
["basedpyright", "pyright", "ty", "pyrefly", "pylsp", "jedi-language-server", "ruff", "djlsp"];
|
||||
|
||||
pub(crate) fn merge(base: &mut Value, layer: Value) {
|
||||
match (base, layer) {
|
||||
@@ -979,6 +980,16 @@ 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) {
|
||||
@@ -1002,6 +1013,13 @@ 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,6 +885,8 @@ 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,6 +138,26 @@ 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());
|
||||
@@ -190,6 +210,7 @@ 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)
|
||||
@@ -1364,6 +1385,26 @@ 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();
|
||||
|
||||
@@ -190,6 +190,18 @@ 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,6 +338,15 @@ 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)]
|
||||
{
|
||||
@@ -347,7 +356,8 @@ pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResul
|
||||
}
|
||||
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 = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
|
||||
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();
|
||||
fs::write(&link, format!("#!/bin/sh\nexec {runner}'{quoted}' \"$@\"\n"))?;
|
||||
make_executable(&link)?;
|
||||
make_executable(target)?;
|
||||
@@ -356,7 +366,8 @@ pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResul
|
||||
#[cfg(not(unix))]
|
||||
{
|
||||
let link = bin_dir.join(format!("{command}.cmd"));
|
||||
let runner = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
|
||||
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();
|
||||
fs::write(&link, format!("@echo off\r\n{runner}\"{}\" %*\r\n", cmd_path(bin_dir, target)))?;
|
||||
Ok(link)
|
||||
}
|
||||
@@ -510,6 +521,35 @@ 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,6 +19,7 @@ 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;
|
||||
@@ -47,6 +48,8 @@ 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 {
|
||||
@@ -92,6 +95,10 @@ 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.
|
||||
@@ -331,6 +338,7 @@ struct Usage {
|
||||
args: Vec<String>,
|
||||
initialization_options: Option<String>,
|
||||
alternatives: Vec<String>,
|
||||
companion: bool,
|
||||
}
|
||||
|
||||
fn usages(langs: &[LanguageConfig]) -> BTreeMap<String, Usage> {
|
||||
@@ -364,6 +372,11 @@ 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;
|
||||
@@ -749,6 +762,7 @@ 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));
|
||||
};
|
||||
@@ -775,6 +789,7 @@ 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)))
|
||||
}
|
||||
@@ -1256,6 +1271,42 @@ 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(
|
||||
@@ -1269,8 +1320,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.python_command(self.python().expect("checked"));
|
||||
c.args(["-m", "pip", "install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--target"])
|
||||
let mut c = self.pip_command(self.python().expect("checked"), emit);
|
||||
c.args(["install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--target"])
|
||||
.arg(&lib)
|
||||
.args(["--only-binary=:all:", "--platform", "any", "--implementation", "py"])
|
||||
.arg(package);
|
||||
@@ -1296,6 +1347,14 @@ 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),
|
||||
@@ -1400,7 +1459,9 @@ impl Tools {
|
||||
let pkg = staging.join("pkg");
|
||||
let kind = archive::ArchiveKind::from_name(&dl.name);
|
||||
let main = spec.commands[0];
|
||||
let exe_name = self.platform.exe(main);
|
||||
// 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) };
|
||||
match kind {
|
||||
archive::ArchiveKind::Gz | archive::ArchiveKind::Raw => {
|
||||
archive::extract(&archive, kind, &pkg.join("bin"), &exe_name, cancel)?
|
||||
@@ -1442,7 +1503,13 @@ impl Tools {
|
||||
} else {
|
||||
archive::make_executable(&target)?;
|
||||
if self.exe_in(&bin, main).as_deref() != Some(target.as_path()) {
|
||||
archive::link_executable(&bin, main, &target)?;
|
||||
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)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
self.write_manifest(spec.name, &Manifest { version: Some(dl.version.clone()), source: Some(dl.url.clone()) })
|
||||
|
||||
@@ -0,0 +1,124 @@
|
||||
//! 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,6 +20,8 @@ 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.
|
||||
@@ -80,6 +82,7 @@ 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",
|
||||
}
|
||||
}
|
||||
@@ -131,6 +134,29 @@ 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",
|
||||
@@ -263,6 +289,17 @@ 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)",
|
||||
@@ -285,6 +322,17 @@ 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",
|
||||
@@ -429,6 +477,26 @@ 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",
|
||||
@@ -1164,6 +1232,8 @@ 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,6 +49,24 @@ 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] {
|
||||
@@ -297,9 +315,10 @@ 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("sqls", &CancellationToken::new()) {
|
||||
let slot = match install_slot("join-test-slot", &CancellationToken::new()) {
|
||||
Ok(slot) => slot,
|
||||
Err(_) => panic!("no install is running"),
|
||||
};
|
||||
@@ -310,7 +329,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("sqls", &slot);
|
||||
release_install_slot("join-test-slot", &slot);
|
||||
slot.finish(Err(IdeError::new(ErrorKind::Io, "compile failed")));
|
||||
})
|
||||
};
|
||||
@@ -330,8 +349,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("sqls", &CancellationToken::new()) {
|
||||
Ok(fresh) => release_install_slot("sqls", &fresh),
|
||||
match install_slot("join-test-slot", &CancellationToken::new()) {
|
||||
Ok(fresh) => release_install_slot("join-test-slot", &fresh),
|
||||
Err(_) => panic!("the finished install still holds its slot"),
|
||||
}
|
||||
}
|
||||
@@ -339,7 +358,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("marksman", &CancellationToken::new()) {
|
||||
let slot = match install_slot("finished-test-slot", &CancellationToken::new()) {
|
||||
Ok(slot) => slot,
|
||||
Err(_) => panic!("no install is running"),
|
||||
};
|
||||
@@ -362,8 +381,9 @@ fn install_joined_after_it_finished_returns_the_result() {
|
||||
default_args: vec![],
|
||||
default_initialization_options: None,
|
||||
alternatives: vec![],
|
||||
companion: false,
|
||||
};
|
||||
release_install_slot("marksman", &slot);
|
||||
release_install_slot("finished-test-slot", &slot);
|
||||
slot.finish(Ok(ok));
|
||||
let info = join_install(&slot, &CancellationToken::new(), &|_| {}).unwrap();
|
||||
assert_eq!(info.version.as_deref(), Some("1.0"));
|
||||
@@ -441,6 +461,51 @@ 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]
|
||||
@@ -877,9 +942,14 @@ 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");
|
||||
@@ -917,6 +987,51 @@ 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,7 +1159,8 @@ 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.
|
||||
/// changes are kept), untracked files and directories are deleted. A submodule goes back
|
||||
/// to the commit the index records, with its tracked files restored.
|
||||
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,7 +12,9 @@ use std::path::Path;
|
||||
use std::sync::{Arc, Mutex, OnceLock, Weak};
|
||||
use std::time::SystemTime;
|
||||
|
||||
pub(crate) const COMMITS: TableDefinition<&str, &[u8]> = TableDefinition::new("summaries-v2");
|
||||
// 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");
|
||||
const MESSAGES: TableDefinition<&str, &str> = TableDefinition::new("messages-v1");
|
||||
const MAX_MEMORY_COMMITS: usize = 4096;
|
||||
const MAX_MEMORY_MESSAGES: usize = 1024;
|
||||
@@ -268,6 +270,7 @@ 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)
|
||||
});
|
||||
@@ -309,8 +312,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 = 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 summary_text = subject(raw.as_bstr());
|
||||
let message_truncated = raw.trim() != summary_text.as_bytes();
|
||||
let record = Arc::new(Commit {
|
||||
id: key.clone(),
|
||||
short_id: key[..key.len().min(8)].to_string(),
|
||||
@@ -327,7 +330,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: raw.trim() != summary,
|
||||
message_truncated,
|
||||
history_path: None,
|
||||
log_position: None,
|
||||
log_total: None,
|
||||
@@ -425,6 +428,23 @@ 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::*;
|
||||
@@ -487,4 +507,39 @@ 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,16 +25,19 @@ 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 = run(r.root(), &["rev-parse", "-q", "--verify", "refs/stash"], None).map(|o| o.stdout_str()).ok();
|
||||
let before = stash_top(r);
|
||||
run(r.root(), &["stash", "push", "-q", "-m", message], None)?;
|
||||
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())?;
|
||||
// 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)?;
|
||||
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<()> {
|
||||
|
||||
@@ -391,18 +391,24 @@ pub(crate) fn discard(r: &Repo, paths: &[PathBuf]) -> IdeResult<()> {
|
||||
let rel = r.rel_paths(paths)?;
|
||||
// `git restore --worktree` refuses unmerged paths: roll those back to HEAD first.
|
||||
discard_unmerged(r, &rel)?;
|
||||
let (mut tracked, mut untracked) = (Vec::new(), Vec::new());
|
||||
let (mut tracked, mut untracked, mut submodules) = (Vec::new(), Vec::new(), Vec::new());
|
||||
{
|
||||
let repo = r.gix()?;
|
||||
let index = repo.index_or_empty().map_err(gx)?;
|
||||
for p in rel {
|
||||
let exact = index.entry_index_by_path(BStr::new(p.as_bytes())).is_ok();
|
||||
let exact = index.entry_index_by_path(BStr::new(p.as_bytes())).ok().map(|i| &index.entries()[i]);
|
||||
let dir_prefix = if p == "." { String::new() } else { format!("{}/", p.trim_end_matches('/')) };
|
||||
let has_tracked_children = index.prefixed_entries(BStr::new(dir_prefix.as_bytes())).is_some();
|
||||
if exact {
|
||||
tracked.push(p);
|
||||
let children = index.prefixed_entries(BStr::new(dir_prefix.as_bytes()));
|
||||
if let Some(entry) = exact {
|
||||
if entry.mode.is_submodule() {
|
||||
submodules.push(p);
|
||||
} else {
|
||||
tracked.push(p);
|
||||
}
|
||||
} else if r.abs_path(&p).is_dir() {
|
||||
if has_tracked_children {
|
||||
if let Some(children) = children {
|
||||
submodules
|
||||
.extend(children.iter().filter(|e| e.mode.is_submodule()).map(|e| e.path(&index).to_string()));
|
||||
tracked.push(p.clone());
|
||||
}
|
||||
untracked.push(p);
|
||||
@@ -412,6 +418,11 @@ pub(crate) fn discard(r: &Repo, paths: &[PathBuf]) -> IdeResult<()> {
|
||||
}
|
||||
}
|
||||
run_paths(r, &["restore", "--worktree"], &tracked)?;
|
||||
// A plain restore leaves a submodule alone. This one checks out the commit the index
|
||||
// records there and restores its tracked files, keeping its untracked ones.
|
||||
if crate::execution_allowed() {
|
||||
run_paths(r, &["restore", "--recurse-submodules", "--worktree"], &submodules)?;
|
||||
}
|
||||
if !untracked.is_empty() {
|
||||
// `git clean` keeps ignored files and refuses paths outside the worktree.
|
||||
run_paths(r, &["clean", "-f", "-d", "-q"], &untracked)?;
|
||||
|
||||
@@ -69,7 +69,8 @@ impl Fixture {
|
||||
fn push_from_other(&self, bare: &Path, rel: &str, content: &str) {
|
||||
let other = self.tmp.path().join(format!("other-{}", rel.replace('/', "_")));
|
||||
if !other.exists() {
|
||||
git_in(self.tmp.path(), &["clone", "-q", bare.to_str().unwrap(), other.to_str().unwrap()]);
|
||||
let (bare, other_dir) = (bare.to_str().unwrap(), other.to_str().unwrap());
|
||||
git_in(self.tmp.path(), &["clone", "-q", "-c", "core.autocrlf=false", bare, other_dir]);
|
||||
configure(&other);
|
||||
}
|
||||
git_in(&other, &["pull", "-q", "--rebase"]);
|
||||
@@ -636,6 +637,73 @@ fn update_with_rebase_keeps_a_file_added_then_deleted_added_to_the_index() {
|
||||
assert!(fx.git(&["status", "--porcelain", "--", "ad.txt"]).starts_with('A'), "still added");
|
||||
}
|
||||
|
||||
/// Submodules `dirty` and `moved` (each with commits "one" and "two", at "two") committed in
|
||||
/// the clone of [`Fixture::with_origin`] and pushed; then `dirty` gets an uncommitted edit of a
|
||||
/// tracked file plus an untracked file, and `moved` is checked out at "one". Returns the commit
|
||||
/// the superproject records for `moved`.
|
||||
fn with_changed_submodules(fx: &Fixture) -> String {
|
||||
for name in ["dirty", "moved"] {
|
||||
let lib = fx.tmp.path().join(format!("lib-{name}"));
|
||||
std::fs::create_dir(&lib).unwrap();
|
||||
git_in(&lib, &["init", "-q"]);
|
||||
configure(&lib);
|
||||
std::fs::write(lib.join("f.txt"), "one\n").unwrap();
|
||||
git_in(&lib, &["add", "-A"]);
|
||||
git_in(&lib, &["commit", "-q", "-m", "one"]);
|
||||
std::fs::write(lib.join("f.txt"), "two\n").unwrap();
|
||||
git_in(&lib, &["commit", "-q", "-am", "two"]);
|
||||
let url = lib.to_str().unwrap();
|
||||
fx.git(&["-c", "protocol.file.allow=always", "-c", "core.autocrlf=false", "submodule", "add", "-q", url, name]);
|
||||
configure(&fx.path(name));
|
||||
}
|
||||
fx.commit_all("submodules");
|
||||
fx.git(&["push", "-q", "origin", "main"]);
|
||||
let recorded = git_in(&fx.path("moved"), &["rev-parse", "HEAD"]);
|
||||
fx.write("dirty/f.txt", "edited\n");
|
||||
fx.write("dirty/untracked.txt", "u\n");
|
||||
git_in(&fx.path("moved"), &["checkout", "-q", "HEAD~1"]);
|
||||
recorded
|
||||
}
|
||||
|
||||
/// git lists submodules at another commit or with changes inside among the superproject's
|
||||
/// changes, but its stash leaves them in place, so Update Project has nothing to put aside (#3632).
|
||||
#[test]
|
||||
fn update_with_changed_submodules_and_no_other_local_changes() {
|
||||
for (rebase, earlier_stash) in [(false, false), (false, true), (true, false), (true, true)] {
|
||||
let (fx, bare) = Fixture::with_origin();
|
||||
let recorded = with_changed_submodules(&fx);
|
||||
if earlier_stash {
|
||||
fx.write("a.txt", "stashed\n");
|
||||
fx.git(&["stash", "push", "-q", "-m", "earlier"]);
|
||||
}
|
||||
fx.push_from_other(&bare, "remote.txt", "r\n");
|
||||
let repo = fx.repo();
|
||||
let (cancel, out) = quiet();
|
||||
repo.pull(rebase, &cancel, &out).unwrap_or_else(|e| panic!("rebase={rebase} stash={earlier_stash}: {e}"));
|
||||
assert!(fx.exists("remote.txt"));
|
||||
assert_eq!(fx.read("dirty/f.txt"), "edited\n");
|
||||
assert_ne!(git_in(&fx.path("moved"), &["rev-parse", "HEAD"]), recorded);
|
||||
let stashes = fx.git(&["stash", "list"]);
|
||||
assert_eq!(stashes.lines().count(), usize::from(earlier_stash), "{stashes}");
|
||||
assert!(!fx.dir.join(".git/openidea-saved-changes").exists());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rollback_changed_submodules_restores_the_recorded_commit_and_tracked_files() {
|
||||
for whole_root in [false, true] {
|
||||
let (fx, _bare) = Fixture::with_origin();
|
||||
let recorded = with_changed_submodules(&fx);
|
||||
let repo = fx.repo();
|
||||
let paths = if whole_root { vec![fx.dir.clone()] } else { vec![fx.path("dirty"), fx.path("moved")] };
|
||||
repo.discard(&paths).unwrap();
|
||||
assert_eq!(fx.read("dirty/f.txt"), "two\n", "whole_root={whole_root}");
|
||||
assert_eq!(git_in(&fx.path("moved"), &["rev-parse", "HEAD"]), recorded);
|
||||
assert_eq!(fx.read("dirty/untracked.txt"), "u\n", "untracked files of a submodule are kept");
|
||||
assert_eq!(fx.git(&["status", "--porcelain", "--ignore-submodules=untracked"]), "");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_to_the_remote_branch_drops_local_commits_and_keeps_local_changes() {
|
||||
let (fx, bare) = Fixture::with_origin();
|
||||
|
||||
@@ -33,6 +33,7 @@ pub(crate) fn virtual_env_marker(dir: &Path) -> Option<&'static str> {
|
||||
/// Build files whose changes can change the detected roots.
|
||||
pub(crate) const BUILD_FILES: &[&str] = &[
|
||||
"pom.xml",
|
||||
".classpath",
|
||||
"build.gradle",
|
||||
"build.gradle.kts",
|
||||
"settings.gradle",
|
||||
@@ -139,9 +140,6 @@ pub fn detect(root: &Path) -> Vec<SourceFolder> {
|
||||
}
|
||||
let found: Vec<String> = out[before..].iter().map(|r| r.path.clone()).collect();
|
||||
for name in dirs {
|
||||
if name.starts_with('.') || SKIP_DIRS.contains(&name.as_str()) {
|
||||
continue;
|
||||
}
|
||||
let child = join(&rel, &name);
|
||||
// Roots are not searched for nested modules (`src/main/java` can be huge).
|
||||
if found.iter().any(|f| *f == child || f.is_empty() && name == "src") {
|
||||
@@ -154,6 +152,11 @@ pub fn detect(root: &Path) -> Vec<SourceFolder> {
|
||||
}
|
||||
continue;
|
||||
}
|
||||
// Skipping discovery is not an exclusion: marked hidden/conventional
|
||||
// environments still need an explicit root for index and watcher filtering.
|
||||
if name.starts_with('.') || SKIP_DIRS.contains(&name.as_str()) {
|
||||
continue;
|
||||
}
|
||||
queue.push_back((child, depth + 1));
|
||||
}
|
||||
}
|
||||
@@ -238,6 +241,20 @@ fn module_roots(root: &Path, rel: &str, files: &[String], out: &mut Vec<SourceFo
|
||||
}
|
||||
}
|
||||
|
||||
// An Eclipse project without Maven or Gradle: its `.classpath` is the source model.
|
||||
if has(".classpath")
|
||||
&& !has("pom.xml")
|
||||
&& !GRADLE_FILES.iter().any(|f| has(f))
|
||||
&& let Some(cp) = super::eclipse::classpath(&dir)
|
||||
{
|
||||
for (sub, test) in &cp.sources {
|
||||
add(sub, if *test { RootKind::Test } else { RootKind::Source }, ".classpath");
|
||||
}
|
||||
if let Some(output) = &cp.output {
|
||||
add(output, RootKind::Excluded, ".classpath");
|
||||
}
|
||||
}
|
||||
|
||||
// Before `package.json`: a Laravel app's `tests/` is the PHP test root.
|
||||
if has("composer.json")
|
||||
&& let Ok(text) = std::fs::read_to_string(dir.join("composer.json"))
|
||||
@@ -557,6 +574,96 @@ mod tests {
|
||||
assert!(affects_roots(Path::new("code10/pyvenv.cfg")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn marked_environments_are_detected_before_name_based_walk_skips() {
|
||||
let dir = tree(&[
|
||||
".venv/pyvenv.cfg",
|
||||
".venv/Lib/site-packages/pkg/setup.py",
|
||||
".conda/conda-meta/history",
|
||||
"venv/pyvenv.cfg",
|
||||
"nested/.custom/pyvenv.cfg",
|
||||
"nested/.custom/lib/pkg/pyproject.toml",
|
||||
"build/business.go",
|
||||
"bin/business.go",
|
||||
"env/business.go",
|
||||
"dist/business.go",
|
||||
".ordinary/setup.py",
|
||||
]);
|
||||
assert_eq!(
|
||||
summary(&detect(dir.path())),
|
||||
vec![
|
||||
"[email protected]/conda-meta",
|
||||
"[email protected]/pyvenv.cfg",
|
||||
"nested/.custom=Excluded@nested/.custom/pyvenv.cfg",
|
||||
"venv=Excluded@venv/pyvenv.cfg",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn marked_environment_detection_preserves_source_roots_and_user_overrides() {
|
||||
let dir = tree(&["Cargo.toml", "src/pyvenv.cfg", ".venv/pyvenv.cfg", ".conda/conda-meta/history"]);
|
||||
let detected = detect(dir.path());
|
||||
assert!(detected.iter().any(|r| r.path == ".venv" && r.kind == RootKind::Excluded));
|
||||
assert!(detected.iter().any(|r| r.path == "src" && r.kind == RootKind::Source));
|
||||
let settings = ide_core::settings::ProjectStructureSettings {
|
||||
source_roots: vec![".venv".into()],
|
||||
unmarked: vec![".conda".into()],
|
||||
..Default::default()
|
||||
};
|
||||
let effective = super::super::ProjectRoots::compute(detected, &settings);
|
||||
assert!(effective.excluded_globs().is_empty());
|
||||
assert_eq!(effective.root_for(".venv/app.py").unwrap().kind, RootKind::Source);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn environment_markers_require_the_expected_file_type_and_respect_walk_boundaries() {
|
||||
let dir = tree(&[
|
||||
"pyvenv.cfg",
|
||||
"app.py",
|
||||
".not_venv/pyvenv.cfg/",
|
||||
".not_conda/conda-meta",
|
||||
".hidden/nested/pyvenv.cfg",
|
||||
"a/b/c/d/e/f/g/pyvenv.cfg",
|
||||
"at/b/c/d/e/f/pyvenv.cfg",
|
||||
]);
|
||||
// An environment opened as the project remains browsable. Hidden parents and
|
||||
// the existing depth budget are not traversed to discover more environments.
|
||||
assert_eq!(summary(&detect(dir.path())), vec!["at/b/c/d/e/f=Excluded@at/b/c/d/e/f/pyvenv.cfg"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn detected_environment_roots_prune_vfs_walk_without_hiding_business_directories() {
|
||||
let dir = tree(&[
|
||||
".venv/pyvenv.cfg",
|
||||
".venv/Lib/site-packages/pkg/setup.py",
|
||||
"internal/build/build.go",
|
||||
"env/business.go",
|
||||
"bin/business.go",
|
||||
"dist/business.go",
|
||||
"service/go.mod",
|
||||
]);
|
||||
for i in 0..128 {
|
||||
fs::write(dir.path().join(format!(".venv/Lib/site-packages/pkg/dep{i}.py")), "").unwrap();
|
||||
}
|
||||
let walk = |excludes: &[String]| {
|
||||
let files = std::sync::Mutex::new(Vec::new());
|
||||
ide_vfs::walk_files(dir.path(), excludes, |path| {
|
||||
files.lock().unwrap().push(path.strip_prefix(dir.path()).unwrap().to_owned());
|
||||
});
|
||||
let mut files = files.into_inner().unwrap();
|
||||
files.sort();
|
||||
files
|
||||
};
|
||||
let before = walk(&[]);
|
||||
let roots = super::super::ProjectRoots::compute(detect(dir.path()), &Default::default());
|
||||
let after = walk(&roots.excluded_globs());
|
||||
assert_eq!(before.len(), 135);
|
||||
assert_eq!(after.len(), 5);
|
||||
assert_eq!(after, before.into_iter().filter(|p| !p.starts_with(".venv")).collect::<Vec<_>>());
|
||||
assert_eq!(roots.root_for("service/go.mod").unwrap().kind, RootKind::Source);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn first_ecosystem_wins_for_a_shared_folder() {
|
||||
// A Gradle build with a frontend: `build` stays Gradle's, `src` is not a Node root.
|
||||
|
||||
@@ -0,0 +1,193 @@
|
||||
//! Eclipse projects without Maven or Gradle: `.classpath` names the source folders (tests
|
||||
//! by their `test` attribute), the output folder and the library jars; a Dynamic Web
|
||||
//! Project's `.settings/org.eclipse.wst.common.component` names the web content folder.
|
||||
use std::path::Path;
|
||||
|
||||
/// What `.classpath` declares, with project-relative `/`-separated paths.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq)]
|
||||
pub struct EclipseClasspath {
|
||||
/// Source folders and whether they hold tests.
|
||||
pub sources: Vec<(String, bool)>,
|
||||
pub output: Option<String>,
|
||||
/// Library jars or class folders (`kind="lib"`), project-relative or absolute.
|
||||
pub libraries: Vec<String>,
|
||||
}
|
||||
|
||||
/// The value of `name="…"` in a tag's text.
|
||||
fn attribute(tag: &str, name: &str) -> Option<String> {
|
||||
let mut rest = tag;
|
||||
while let Some(at) = rest.find(name) {
|
||||
let before = rest[..at].chars().last();
|
||||
let after = &rest[at + name.len()..];
|
||||
rest = after;
|
||||
if before.is_some_and(|c| !c.is_whitespace()) {
|
||||
continue;
|
||||
}
|
||||
let Some(after) = after.trim_start().strip_prefix('=') else { continue };
|
||||
let after = after.trim_start();
|
||||
let quote = after.chars().next().filter(|c| *c == '"' || *c == '\'')?;
|
||||
let value = &after[1..];
|
||||
let end = value.find(quote)?;
|
||||
return Some(unescape(&value[..end]));
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn unescape(value: &str) -> String {
|
||||
value.replace(""", "\"").replace("'", "'").replace("<", "<").replace(">", ">").replace("&", "&")
|
||||
}
|
||||
|
||||
/// Each element `<name …>…</name>` or `<name …/>` as (opening tag, inner text).
|
||||
fn elements<'a>(text: &'a str, name: &str) -> Vec<(&'a str, &'a str)> {
|
||||
let open = format!("<{name}");
|
||||
let close = format!("</{name}>");
|
||||
let mut out = Vec::new();
|
||||
let mut rest = text;
|
||||
while let Some(at) = rest.find(&open) {
|
||||
let from = &rest[at..];
|
||||
// `<classpathentry` must not match `<classpathentryX`.
|
||||
if !from[open.len()..].starts_with(|c: char| c.is_whitespace() || c == '/' || c == '>') {
|
||||
rest = &from[open.len()..];
|
||||
continue;
|
||||
}
|
||||
let Some(end) = from.find('>') else { break };
|
||||
let tag = &from[..=end];
|
||||
if tag.ends_with("/>") {
|
||||
out.push((tag, ""));
|
||||
rest = &from[end + 1..];
|
||||
} else {
|
||||
let body = &from[end + 1..];
|
||||
let stop = body.find(&close).unwrap_or(body.len());
|
||||
out.push((tag, &body[..stop]));
|
||||
rest = &body[stop..];
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn clean(path: &str) -> String {
|
||||
let p = path.trim().replace('\\', "/");
|
||||
let p = p.trim_start_matches("./").trim_end_matches('/');
|
||||
p.to_owned()
|
||||
}
|
||||
|
||||
pub fn parse_classpath(text: &str) -> EclipseClasspath {
|
||||
let mut out = EclipseClasspath::default();
|
||||
for (tag, body) in elements(text, "classpathentry") {
|
||||
let (Some(kind), Some(path)) = (attribute(tag, "kind"), attribute(tag, "path")) else { continue };
|
||||
let path = clean(&path);
|
||||
match kind.as_str() {
|
||||
// `/OtherProject` is a project reference, not a folder of this one.
|
||||
"src" if !path.starts_with('/') && !path.is_empty() => {
|
||||
let test = elements(body, "attribute").iter().any(|(a, _)| {
|
||||
attribute(a, "name").as_deref() == Some("test") && attribute(a, "value").as_deref() == Some("true")
|
||||
});
|
||||
out.sources.push((path, test));
|
||||
}
|
||||
"output" if !path.is_empty() => out.output = Some(path),
|
||||
"lib" if !path.is_empty() => out.libraries.push(path),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The project's `.classpath`, unless a Maven or Gradle build owns its model.
|
||||
pub fn classpath(dir: &Path) -> Option<EclipseClasspath> {
|
||||
if ["pom.xml", "build.gradle", "build.gradle.kts"].iter().any(|f| dir.join(f).is_file()) {
|
||||
return None;
|
||||
}
|
||||
std::fs::read_to_string(dir.join(".classpath")).ok().map(|t| parse_classpath(&t))
|
||||
}
|
||||
|
||||
/// The web content folder of a web project: the `wb-resource` deployed at `/`, else a
|
||||
/// conventional `WebContent` / `WebRoot` / `web` / `src/main/webapp` holding `WEB-INF/web.xml`.
|
||||
pub fn web_root(dir: &Path) -> Option<String> {
|
||||
if let Ok(text) = std::fs::read_to_string(dir.join(".settings/org.eclipse.wst.common.component")) {
|
||||
for (tag, _) in elements(&text, "wb-resource") {
|
||||
if attribute(tag, "deploy-path").as_deref() == Some("/")
|
||||
&& let Some(source) = attribute(tag, "source-path")
|
||||
{
|
||||
let source = clean(source.trim_start_matches('/'));
|
||||
if dir.join(&source).is_dir() {
|
||||
return Some(source);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
["WebContent", "WebRoot", "web", "src/main/webapp"]
|
||||
.into_iter()
|
||||
.find(|d| dir.join(d).join("WEB-INF/web.xml").is_file())
|
||||
.map(str::to_owned)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn reads_sources_tests_output_and_libraries() {
|
||||
let cp = parse_classpath(
|
||||
r#"<?xml version="1.0" encoding="UTF-8"?>
|
||||
<classpath>
|
||||
<classpathentry kind="src" path="src"/>
|
||||
<classpathentry kind="src" output="bin/test" path="test">
|
||||
<attributes>
|
||||
<attribute name="test" value="true"/>
|
||||
</attributes>
|
||||
</classpathentry>
|
||||
<classpathentry kind="src" path="/OtherProject"/>
|
||||
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
|
||||
<classpathentry kind="lib" path="WebContent/WEB-INF/lib/commons-lang.jar"/>
|
||||
<classpathentry kind='lib' path='lib\mail.jar' sourcepath="lib/mail-src.zip"/>
|
||||
<classpathentry kind="output" path="build/classes"/>
|
||||
</classpath>"#,
|
||||
);
|
||||
assert_eq!(cp.sources, [("src".to_owned(), false), ("test".to_owned(), true)]);
|
||||
assert_eq!(cp.output.as_deref(), Some("build/classes"));
|
||||
assert_eq!(cp.libraries, ["WebContent/WEB-INF/lib/commons-lang.jar", "lib/mail.jar"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn finds_the_web_content_folder() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
std::fs::create_dir_all(dir.path().join("site/WEB-INF")).unwrap();
|
||||
std::fs::create_dir_all(dir.path().join(".settings")).unwrap();
|
||||
std::fs::write(
|
||||
dir.path().join(".settings/org.eclipse.wst.common.component"),
|
||||
r#"<project-modules><wb-module deploy-name="shop">
|
||||
<wb-resource deploy-path="/WEB-INF/classes" source-path="/src"/>
|
||||
<wb-resource deploy-path="/" source-path="/site" tag="defaultRootSource"/>
|
||||
</wb-module></project-modules>"#,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(web_root(dir.path()).as_deref(), Some("site"));
|
||||
let plain = tempfile::tempdir().unwrap();
|
||||
std::fs::create_dir_all(plain.path().join("WebRoot/WEB-INF")).unwrap();
|
||||
assert_eq!(web_root(plain.path()), None);
|
||||
std::fs::write(plain.path().join("WebRoot/WEB-INF/web.xml"), "<web-app/>").unwrap();
|
||||
assert_eq!(web_root(plain.path()).as_deref(), Some("WebRoot"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn detects_the_roots_of_an_eclipse_project() {
|
||||
use super::super::{RootKind, detect};
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
for d in ["src", "test", "bin"] {
|
||||
std::fs::create_dir_all(dir.path().join(d)).unwrap();
|
||||
}
|
||||
std::fs::write(
|
||||
dir.path().join(".classpath"),
|
||||
r#"<classpath><classpathentry kind="src" path="src"/><classpathentry kind="src" path="test"><attributes><attribute name="test" value="true"/></attributes></classpathentry><classpathentry kind="output" path="bin"/></classpath>"#,
|
||||
)
|
||||
.unwrap();
|
||||
let roots: Vec<(String, RootKind)> = detect(dir.path()).into_iter().map(|r| (r.path, r.kind)).collect();
|
||||
assert_eq!(
|
||||
roots,
|
||||
[("bin".into(), RootKind::Excluded), ("src".into(), RootKind::Source), ("test".into(), RootKind::Test)]
|
||||
);
|
||||
// A Maven build owns the model even with a stale `.classpath` next to it.
|
||||
std::fs::write(dir.path().join("pom.xml"), "<project/>").unwrap();
|
||||
assert!(detect(dir.path()).iter().all(|r| r.detected_from.as_deref() != Some(".classpath")));
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@
|
||||
//! project-relative and `/`-separated; `""` is the project root itself.
|
||||
|
||||
mod detect;
|
||||
pub mod eclipse;
|
||||
pub(crate) use detect::{BUILD_FILES, virtual_env_marker};
|
||||
mod gradle;
|
||||
mod java;
|
||||
|
||||
@@ -30,12 +30,14 @@ pub enum SettingsScope {
|
||||
/// Settings a project's own file can't hold: the IDE's MCP server, imported color schemes, and
|
||||
/// what agents may do without asking (commands run without asking, the modes new tasks start in,
|
||||
/// whether new tasks ask for approvals).
|
||||
const USER_ONLY: [&[&str]; 5] = [
|
||||
const USER_ONLY: [&[&str]; 6] = [
|
||||
&["mcpServer"],
|
||||
&["editor", "customSchemes"],
|
||||
&["agentSecurity", "allowedCommands"],
|
||||
&["agents", "defaults"],
|
||||
&["agents", "newTaskApprovals"],
|
||||
// OS notification centre: machine-local; projects must not enable/disable.
|
||||
&["notifications", "systemNotifications"],
|
||||
];
|
||||
|
||||
/// The [`USER_ONLY`] setting that writing `value` at `key` would set, as a dotted key.
|
||||
@@ -439,13 +441,26 @@ impl SettingsStore {
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct JetBrainsSettings {
|
||||
pub entries: Vec<String>,
|
||||
/// Entry name → text, for `colors/*.icls` and the `options/*.xml` files OpenIDEA reads.
|
||||
/// Entry name → text, for the files OpenIDEA reads: `colors/*.icls`, `keymaps/*.xml`,
|
||||
/// `codestyles/*.xml` and some of `options/`.
|
||||
pub files: BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
const JETBRAINS_MARKER: &str = "IntelliJ IDEA Global Settings";
|
||||
const JETBRAINS_OPTIONS: [&str; 4] =
|
||||
["options/editor-font.xml", "options/colors.scheme.xml", "options/editor.xml", "options/ide.general.xml"];
|
||||
const JETBRAINS_OPTIONS: [&str; 9] = [
|
||||
"options/editor-font.xml",
|
||||
"options/terminal-font.xml",
|
||||
"options/colors.scheme.xml",
|
||||
"options/code.style.schemes.xml",
|
||||
"options/editor.xml",
|
||||
"options/ide.general.xml",
|
||||
// The active keymap is stored per operating system.
|
||||
"options/mac/keymap.xml",
|
||||
"options/windows/keymap.xml",
|
||||
"options/linux/keymap.xml",
|
||||
];
|
||||
/// Folders whose files are all read: (folder, extension).
|
||||
const JETBRAINS_READ_DIRS: [(&str, &str); 3] = [("colors/", ".icls"), ("keymaps/", ".xml"), ("codestyles/", ".xml")];
|
||||
const JETBRAINS_MAX_TEXT: u64 = 4 << 20;
|
||||
|
||||
/// The settings of a JetBrains IDE: an exported `settings.zip`, or the IDE's own settings folder
|
||||
@@ -456,11 +471,23 @@ pub fn read_jetbrains_settings(path: &Path) -> IdeResult<JetBrainsSettings> {
|
||||
|
||||
fn is_mapped_jetbrains_file(name: &str) -> bool {
|
||||
JETBRAINS_OPTIONS.contains(&name)
|
||||
|| name.strip_prefix("colors/").is_some_and(|n| !n.contains('/') && n.ends_with(".icls"))
|
||||
|| JETBRAINS_READ_DIRS
|
||||
.iter()
|
||||
.any(|(dir, ext)| name.strip_prefix(dir).is_some_and(|n| !n.contains('/') && n.ends_with(ext)))
|
||||
}
|
||||
|
||||
/// Folders of the settings folder whose files are listed (their names say what the user customised).
|
||||
const JETBRAINS_LISTED_DIRS: [&str; 6] = ["options", "colors", "keymaps", "codestyles", "templates", "inspection"];
|
||||
const JETBRAINS_LISTED_DIRS: [&str; 9] = [
|
||||
"options",
|
||||
"options/mac",
|
||||
"options/windows",
|
||||
"options/linux",
|
||||
"colors",
|
||||
"keymaps",
|
||||
"codestyles",
|
||||
"templates",
|
||||
"inspection",
|
||||
];
|
||||
|
||||
fn read_jetbrains_folder(dir: &Path) -> IdeResult<JetBrainsSettings> {
|
||||
use std::io::Read;
|
||||
@@ -934,11 +961,25 @@ mod tests {
|
||||
("options/editor-font.xml", "<application/>"),
|
||||
("options/vcs.xml", "<application/>"),
|
||||
("keymaps/macOS.xml", "<keymap/>"),
|
||||
("keymaps/nested/ignored.xml", "<keymap/>"),
|
||||
("codestyles/Default.xml", "<code_scheme/>"),
|
||||
("options/mac/keymap.xml", "<application/>"),
|
||||
("options/terminal-font.xml", "<application/>"),
|
||||
],
|
||||
);
|
||||
let read = read_jetbrains_settings(&ok).unwrap();
|
||||
assert_eq!(read.entries.len(), 5);
|
||||
assert_eq!(read.files.keys().collect::<Vec<_>>(), ["colors/_@user_Darcula.icls", "options/editor-font.xml"]);
|
||||
assert_eq!(read.entries.len(), 9);
|
||||
assert_eq!(
|
||||
read.files.keys().collect::<Vec<_>>(),
|
||||
[
|
||||
"codestyles/Default.xml",
|
||||
"colors/_@user_Darcula.icls",
|
||||
"keymaps/macOS.xml",
|
||||
"options/editor-font.xml",
|
||||
"options/mac/keymap.xml",
|
||||
"options/terminal-font.xml"
|
||||
]
|
||||
);
|
||||
assert!(read_jetbrains_settings(&write("other.zip", &[("options/editor.xml", "")])).is_err());
|
||||
std::fs::write(tmp.path().join("plain.zip"), "not a zip").unwrap();
|
||||
assert!(read_jetbrains_settings(&tmp.path().join("plain.zip")).is_err());
|
||||
@@ -957,18 +998,31 @@ mod tests {
|
||||
put("colors/nested/ignored.icls", "<scheme/>");
|
||||
put("options/editor-font.xml", "<application/>");
|
||||
put("options/vcs.xml", "<application/>");
|
||||
put("options/mac/keymap.xml", "<application/>");
|
||||
put("keymaps/macOS.xml", "<keymap/>");
|
||||
put("codestyles/Default.xml", "<code_scheme/>");
|
||||
put("plugins/Tools/lib/tools.jar", "jar");
|
||||
|
||||
let read = read_jetbrains_settings(&config).unwrap();
|
||||
assert_eq!(read.files.keys().collect::<Vec<_>>(), ["colors/_@user_Darcula.icls", "options/editor-font.xml"]);
|
||||
assert_eq!(
|
||||
read.files.keys().collect::<Vec<_>>(),
|
||||
[
|
||||
"codestyles/Default.xml",
|
||||
"colors/_@user_Darcula.icls",
|
||||
"keymaps/macOS.xml",
|
||||
"options/editor-font.xml",
|
||||
"options/mac/keymap.xml"
|
||||
]
|
||||
);
|
||||
assert_eq!(
|
||||
read.entries,
|
||||
[
|
||||
"options/editor-font.xml",
|
||||
"options/vcs.xml",
|
||||
"options/mac/keymap.xml",
|
||||
"colors/_@user_Darcula.icls",
|
||||
"keymaps/macOS.xml",
|
||||
"codestyles/Default.xml",
|
||||
"installed.txt"
|
||||
]
|
||||
);
|
||||
@@ -1219,4 +1273,22 @@ mod tests {
|
||||
std::fs::write(project.join(".openidea/settings.toml"), "[agents]\nnewTaskApprovals = \"bypass\"\n").unwrap();
|
||||
assert_eq!(settings.reload().agents.new_task_approvals, NewTaskApprovals::Ask);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn system_notifications_are_a_user_setting() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let config = tmp.path().join("config");
|
||||
let project = tmp.path().join("project");
|
||||
std::fs::create_dir_all(project.join(".openidea")).unwrap();
|
||||
std::fs::write(project.join(".openidea/settings.toml"), "[notifications]\nsystemNotifications = false\n")
|
||||
.unwrap();
|
||||
let settings = SettingsStore::load(&config, Some(&project));
|
||||
assert!(settings.effective().notifications.system_notifications);
|
||||
assert!(settings.set(SettingsScope::Project, "notifications.systemNotifications", json!(false)).is_err());
|
||||
let s = settings.set(SettingsScope::Global, "notifications.systemNotifications", json!(false)).unwrap();
|
||||
assert!(!s.notifications.system_notifications);
|
||||
std::fs::write(project.join(".openidea/settings.toml"), "[notifications]\nsystemNotifications = true\n")
|
||||
.unwrap();
|
||||
assert!(!settings.reload().notifications.system_notifications);
|
||||
}
|
||||
}
|
||||
@@ -43,7 +43,7 @@ User-visible text is written in English at the call site and goes through the te
|
||||
|
||||
## WebKit compatibility
|
||||
|
||||
On macOS and Linux the app runs in WebKit, and the supported floor is Safari 15.4, the engine of macOS 12 (the app's minimum). `pnpm build` runs `scripts/check-webkit.ts` on the bundle, and `src/platform/webkitCompatibility.test.ts` checks application regexes. Avoid:
|
||||
On macOS and Linux the app runs in WebKit, and the supported floor is Safari 15.4, the engine of macOS 12 (the app's minimum). On macOS 11 and on macOS 12 before 12.3, `src-tauri/src/macos_webview.rs` loads the newer WebKit staged by a Safari update, provided that update is installed. `pnpm build` runs `scripts/check-webkit.ts` on the bundle, and `src/platform/webkitCompatibility.test.ts` checks application regexes. Avoid:
|
||||
|
||||
- regex lookbehind (`(?<=…)`, `(?<!…)`), which needs Safari 16.4, and the regex `v` flag;
|
||||
- import attributes;
|
||||
|
||||
@@ -44,6 +44,8 @@ You don't need a JDK to build: the Java extension bundles in `java/` are checked
|
||||
|
||||
`pnpm dev:app` is the same as `pnpm tauri dev`, plus the global Tauri API (`window.__TAURI__`, from `src-tauri/tauri.dev.conf.json`), which is useful when you drive the app from scripts.
|
||||
|
||||
On macOS, `.cargo/config.toml` defaults `MACOSX_DEPLOYMENT_TARGET` to 11.0 (export your own value to override), so debug builds launch on older systems too. When the system WebKit predates Safari 15.4, `src-tauri/src/macos_webview.rs` re-execs once into the newer WebKit staged by a Safari update; set `OPENIDEA_DISABLE_STAGED_WEBKIT=1` to keep the system engine while debugging.
|
||||
|
||||
Other everyday commands:
|
||||
|
||||
| Command | What it does |
|
||||
|
||||
@@ -9,7 +9,7 @@ In the file names below, `<version>` is the release version, for example `0.1.40
|
||||
|
||||
## macOS
|
||||
|
||||
macOS 12 Monterey or later.
|
||||
macOS 12 Monterey or later. macOS 11 Big Sur also works: install the latest Safari update in Software Update first, and OpenIDEA will load the newer WebKit Apple stages alongside it (the system engine predates Safari 15.4). On macOS 12, install that update too if its system WebKit is older than Safari 15.4; otherwise the built-in engine is used as is.
|
||||
|
||||
| Mac | File |
|
||||
| ------------- | -------------------------------- |
|
||||
|
||||
@@ -114,6 +114,7 @@ Notes on what they do:
|
||||
|
||||
As JetBrains IDEs do, the command runs on pipes, not a terminal: programs print plain lines instead of progress bars and redraws. The agent gets that output cleaned of escape sequences and cut to 2000 lines (`maxLinesCount`); beyond that the end stays, or the start or both ends with `truncateMode`. The tab's raw output log stays complete.
|
||||
|
||||
- **Servers return once they are up.** The call waits 10 seconds by default for the command to finish. A server, watcher or app never finishes: the agent passes `pattern` with its ready line (`Listening on`, `Started … in`) and gets the answer as soon as the line appears, while the command keeps running.
|
||||
- **One tab per name.** A name whose command finished runs the next command in the same tab. A name whose command is still running is refused, with that command and its last output: the agent has to stop it with `stop_run` first or pick another name. Nothing is stopped behind your back.
|
||||
- **Following a command up.** `wait_for_run` waits for the command to end or for a pattern in its output (a server's "listening" line), `read_run_output` reads the output from any point, `get_run_status` tells whether it is running, succeeded, failed, crashed or was stopped by the agent or by you, and `send_run_input` writes text and Enter to its input; Ctrl+C stops it and Ctrl+D ends its input.
|
||||
- **You can step in.** What you type into the tab's input line, a rerun, a Stop and closing the tab are reported to the agent with their time. A wait ends at once, and the agent is advised to stop what it is doing, tell you it received the intervention and wait for your confirmation.
|
||||
|
||||
@@ -107,7 +107,7 @@ The table lists every built-in language definition. Server and debugger names in
|
||||
| D | `d` | `.d`, `.di` | Yes | — | serve-d | — |
|
||||
| Dart | `dart` | `.dart` | Yes | Yes | dart | dart |
|
||||
| Diff | `diff` | `.diff`, `.patch`, `.rej` | Yes | — | — | — |
|
||||
| Django Template | `django-html` | `.djhtml`, `templates/*.html`, `*.txt` | Yes | Yes | **vscode-html-language-server** | — |
|
||||
| Django Template | `django-html` | `.djhtml`, `templates/*.html`, `*.txt` | Yes | Yes | **vscode-html-language-server**, **djlsp** | — |
|
||||
| Dockerfile | `dockerfile` | `.dockerfile`, `.containerfile` | Yes | — | **dockerfile-language-server** | — |
|
||||
| Elixir | `elixir` | `.ex`, `.exs` | Yes | Yes | **elixir-ls** | **elixir-ls-debugger** |
|
||||
| ERB | `erb` | `.erb`, `.html.erb`, `.rhtml`, `.js.erb`, `.text.erb`, … | Yes | — | — | — |
|
||||
@@ -200,6 +200,7 @@ Run configurations are detected from the build files in your project. The table
|
||||
| Ruby | `Gemfile`, `Rakefile`, `*.gemspec`, `config.ru` | Rails server, Rake tasks, RSpec, Minitest |
|
||||
| C / C++ | `CMakeLists.txt` | CMake targets |
|
||||
| C# | `.sln`, `.slnx`, `.csproj` | .NET Project, `dotnet test` |
|
||||
| Scala | `build.sbt` | `sbt run`, `sbt test`; every project's tasks in the **sbt** tool window |
|
||||
| GDScript | `project.godot` | Godot |
|
||||
| Any | `justfile`, `Makefile` | just recipes, Make targets |
|
||||
|
||||
|
||||
@@ -129,6 +129,7 @@ See [Debugging](/en/guide/debugging).
|
||||
|
||||
- **Spring Boot run configurations** are created from `@SpringBootApplication` classes, and they are listed in the **Services** tool window by default.
|
||||
- **Configuration navigation**: Go to Definition on a key in `application.yml` or `.properties` opens the Java members bound to it (`@ConfigurationProperties`, `@Value`, `Environment.getProperty`). It also works the other way, from `${…}` placeholders in Java, YAML, properties or Spring XML. Keys described by `spring-configuration-metadata.json` in dependencies resolve to their source classes. **Find Usages** on a key lists configuration declarations and Java usages together.
|
||||
- **Thymeleaf templates**: `.html` files in a project with `src/main/resources/templates` highlight `th:*` and `data-th-*` values as Thymeleaf expressions and complete the attribute names after `th:`. Go to Declaration on a fragment expression (`~{fragments/nav :: menu}`, or the bare form in `th:replace` / `th:insert`) opens the template or its `th:fragment`; on a message key (`#{home.title}`) it lists the key in each `messages*.properties` of the bundles set by `spring.messages.basename`.
|
||||
- **Spring Web endpoints**: request mappings in Java and Kotlin controllers get a gutter icon, plus **Generate Request in HTTP Client** and **Generate Requests for Controller** actions that write requests to a scratch `.http` file. Search Everywhere matches request paths in its **All** tab. See [HTTP Client](/en/guide/http-client).
|
||||
- **Facets** in **Project Structure** (`⌘;` / `Ctrl+Alt+Shift+S`) record the frameworks a module uses (Web, Spring, JPA). A Web facet also adds its `WEB-INF/lib/*.jar` to the jdtls classpath.
|
||||
|
||||
|
||||
@@ -140,6 +140,8 @@ Django is the only framework with dedicated support: the `manage.py runserver` a
|
||||
|
||||
The HTML and text files in a `templates` folder of a Django project (one with a `manage.py` above it) open as **Django Template** files: the template tags, variables, filters and comments are highlighted on top of the HTML, and block tags (`{% block %}`, `{% if %}`, `{% for %}`, `{% with %}` and the others of Django and its contrib libraries) fold, indent their content and highlight their end tag. Typing `{%`, `{{` or `{#` closes the pair, finishing a block tag adds its end tag, and `{% end` completes the end tags of the open blocks. **Comment with Line Comment** puts each line in its own `{# … #}`, and **Comment with Block Comment** over several lines uses `{% comment %}`. The HTML language server and Emmet work in the markup between the tags.
|
||||
|
||||
With **Django Template LSP** (`djlsp`, installed from **Settings › Languages & Frameworks › Language Servers**), the template tags, filters, template names (`{% extends %}`, `{% include %}`), static files and URL names of the project complete, show their documentation on hover, and **Go to Declaration** opens the template or the tag's Python source. It reads them by running Django with the project interpreter, so Django has to be installed there.
|
||||
|
||||
An HTML file elsewhere with Django tags shows a banner that switches it to Django Template or keeps it as HTML; either choice is the file's **Override File Type**.
|
||||
|
||||
## Limitations
|
||||
|
||||
@@ -114,6 +114,7 @@ Each contribution point is a table (`[contributes.settings]`) or an array of tab
|
||||
| `views` | `id`, `title`, `icon?`, `location`, `web?`, `group?`, `when?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
|
||||
| `customEditors` | `id`, `title`, `patterns`, `priority`, `layout?`, `web?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
|
||||
| `markerIcons` | `id`, `icon`, `iconDark?`, `markers?`, `tooltip?` (API 1.3): gutter marker icons | no | [Language features](/en/plugins/guides/language-features) |
|
||||
| `editorPanels` | `id`, `web`, `width`, `when?` (API 1.9; needs `editor.read`) | no | [README: Editor panels](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#editor-panels) |
|
||||
| `fileIcons` | `id`, `patterns`, `icon`, `iconDark?` | no | [Icon themes](/en/plugins/guides/icon-themes) |
|
||||
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables` | no | [File actions](/en/plugins/guides/file-actions) |
|
||||
| `snippets` | `language`, `path` (API 1.4) | no | [Language features](/en/plugins/guides/language-features) |
|
||||
|
||||
@@ -152,12 +152,13 @@ Sub-tables such as `[editor.general]`, `[editor.appearance]`, `[editor.completio
|
||||
|
||||
### `[notifications]`
|
||||
|
||||
| Key | Default | Description |
|
||||
| --------------------------- | ----------- | ------------------------------------------------------------ |
|
||||
| `balloons` | `true` | **Display balloon notifications**. |
|
||||
| `sound` | `false` | **Play sound**. |
|
||||
| `groups.<group-id>.display` | `"balloon"` | Popup type per group: `balloon`, `sticky` or `none`. |
|
||||
| `groups.<group-id>.log` | `true` | Also list the notification in the Notifications tool window. |
|
||||
| Key | Default | Description |
|
||||
| --------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
|
||||
| `balloons` | `true` | **Display balloon notifications**. |
|
||||
| `sound` | `false` | **Play sound**. |
|
||||
| `systemNotifications` | `true` | **Enable system notifications**. When a balloon is shown and no OpenIDEA window is focused, the same title and text also go to the OS notification centre. On by default; client/local only. Click focuses the window that raised the toast; balloon actions stay in the IDE. **Windows:** a click is reported only while the toast is on screen, not after it moves to Action Center. Desktop `permission_state` always reports Granted without an OS prompt — that is not proof Do Not Disturb or system notification settings allow delivery. |
|
||||
| `groups.<group-id>.display` | `"balloon"` | Popup type per group: `balloon`, `sticky` or `none`. |
|
||||
| `groups.<group-id>.log` | `true` | Also list the notification in the Notifications tool window. |
|
||||
|
||||
### `[terminal]`
|
||||
|
||||
|
||||
@@ -43,7 +43,7 @@ description: "前端 UI 代码的规则:设计 token、CSS Modules、图标、
|
||||
|
||||
## WebKit 兼容性
|
||||
|
||||
在 macOS 和 Linux 上应用运行于 WebKit,最低支持 Safari 15.4,即 macOS 12 的引擎(应用的最低系统版本)。`pnpm build` 会对产物运行 `scripts/check-webkit.ts`,`src/platform/webkitCompatibility.test.ts` 会检查应用中的正则。请避免:
|
||||
在 macOS 和 Linux 上应用运行于 WebKit,最低支持 Safari 15.4,即 macOS 12 的引擎(应用的最低系统版本)。在 macOS 11 以及 12.3 之前的 macOS 12 上,`src-tauri/src/macos_webview.rs` 会加载 Safari 更新暂存的新版 WebKit,前提是已安装该更新。`pnpm build` 会对产物运行 `scripts/check-webkit.ts`,`src/platform/webkitCompatibility.test.ts` 会检查应用中的正则。请避免:
|
||||
|
||||
- 正则后行断言(`(?<=…)`、`(?<!…)`,需要 Safari 16.4)和正则 `v` 标志;
|
||||
- import attributes;
|
||||
|
||||
@@ -44,6 +44,8 @@ sudo apt-get install -y libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librs
|
||||
|
||||
`pnpm dev:app` 与 `pnpm tauri dev` 相同,只是额外开启全局 Tauri API(`window.__TAURI__`,来自 `src-tauri/tauri.dev.conf.json`),用脚本驱动应用时比较方便。
|
||||
|
||||
在 macOS 上,`.cargo/config.toml` 默认把 `MACOSX_DEPLOYMENT_TARGET` 设为 11.0(自己导出该变量即可覆盖),让 debug 构建也能在旧系统启动。当系统 WebKit 低于 Safari 15.4 时,`src-tauri/src/macos_webview.rs` 会重新 exec 到 Safari 更新暂存的新版 WebKit;调试时可设 `OPENIDEA_DISABLE_STAGED_WEBKIT=1` 继续用系统引擎。
|
||||
|
||||
其他常用命令:
|
||||
|
||||
| 命令 | 作用 |
|
||||
|
||||
@@ -9,7 +9,7 @@ description: "在 macOS、Windows 或 Linux 上下载并安装 OpenIDEA,以及
|
||||
|
||||
## macOS
|
||||
|
||||
需要 macOS 12 Monterey 或更高版本。
|
||||
需要 macOS 12 Monterey 或更高版本。macOS 11 Big Sur 也可运行:请先通过「软件更新」安装最新的 Safari 更新,OpenIDEA 会加载 Apple 随该更新暂存的新版 WebKit(系统自带的引擎低于 Safari 15.4)。macOS 12 若尚未更新到 Safari 15.4 及以上,同样需要先安装该更新;之后直接使用系统引擎。
|
||||
|
||||
| Mac | 文件 |
|
||||
| ---------- | -------------------------------- |
|
||||
|
||||
@@ -113,6 +113,7 @@ stdio 配置大致如下(路径以你机器上的为准):
|
||||
|
||||
和 JetBrains 的 IDE 一样,命令通过管道运行,而不是在终端里运行:程序输出的是普通文本行,不会有进度条和屏幕重绘。智能体拿到的输出会去掉控制字符,并截断到 2000 行(`maxLinesCount`);超出部分默认保留结尾,也可以用 `truncateMode` 改为保留开头或两头。标签页的原始输出日志保持完整。
|
||||
|
||||
- **服务启动好就返回。** 调用默认最多等 10 秒让命令结束。服务器、监视进程或应用不会结束:智能体传入 `pattern`(它就绪时输出的那一行,如 `Listening on`、`Started … in`),这一行一出现就返回,命令继续运行。
|
||||
- **一个名称对应一个标签。** 名称对应的命令已结束时,下一条命令在同一标签中运行。命令仍在运行时会被拒绝,并返回该命令和它最后的输出:智能体必须先用 `stop_run` 停止它,或者换一个名称。任何进程都不会被悄悄停掉。
|
||||
- **跟进命令。** `wait_for_run` 等待命令结束,或等待输出中出现指定文本(例如服务器的“正在监听”一行);`read_run_output` 从任意位置读取输出;`get_run_status` 报告命令是在运行、成功、失败、崩溃,还是被智能体或你停止;`send_run_input` 向命令的输入写入文本和 Enter,Ctrl+C 会停止命令,Ctrl+D 结束它的输入。
|
||||
- **你可以随时干预。** 你在标签输入行中输入的内容、重新运行、停止和关闭标签,都会连同时间一起告诉智能体。正在进行的等待会立即返回,并建议智能体停下手头的工作,回复你已收到干预,等你确认后再继续。
|
||||
|
||||
@@ -102,7 +102,7 @@ IDE 安装工具从不需要 `sudo`。工具装在本地数据目录下 IDE 自
|
||||
| D | `d` | `.d`, `.di` | 是 | — | serve-d | — |
|
||||
| Dart | `dart` | `.dart` | 是 | 是 | dart | dart |
|
||||
| Diff | `diff` | `.diff`, `.patch`, `.rej` | 是 | — | — | — |
|
||||
| Django Template | `django-html` | `.djhtml`, `templates/*.html`, `*.txt` | 是 | 是 | **vscode-html-language-server** | — |
|
||||
| Django Template | `django-html` | `.djhtml`, `templates/*.html`, `*.txt` | 是 | 是 | **vscode-html-language-server**, **djlsp** | — |
|
||||
| Dockerfile | `dockerfile` | `.dockerfile`, `.containerfile` | 是 | — | **dockerfile-language-server** | — |
|
||||
| Elixir | `elixir` | `.ex`, `.exs` | 是 | 是 | **elixir-ls** | **elixir-ls-debugger** |
|
||||
| ERB | `erb` | `.erb`, `.html.erb`, `.rhtml`, `.js.erb`, `.text.erb`, … | 是 | — | — | — |
|
||||
@@ -195,6 +195,7 @@ IDE 安装工具从不需要 `sudo`。工具装在本地数据目录下 IDE 自
|
||||
| Ruby | `Gemfile`、`Rakefile`、`*.gemspec`、`config.ru` | Rails server、Rake 任务、RSpec、Minitest |
|
||||
| C / C++ | `CMakeLists.txt` | CMake 目标 |
|
||||
| C# | `.sln`、`.slnx`、`.csproj` | .NET Project、`dotnet test` |
|
||||
| Scala | `build.sbt` | `sbt run`、`sbt test`;各项目的任务在 **sbt** 工具窗口中 |
|
||||
| GDScript | `project.godot` | Godot |
|
||||
| 任意 | `justfile`、`Makefile` | just 配方、Make 目标 |
|
||||
|
||||
|
||||
Loaded 100 of 291 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача