дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-20 16:39:31 +02:00
Порівняти коміти
115
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
4aef69e73f | ||
|
|
121e1fa535 | ||
|
|
5859cf9f5b | ||
|
|
21b187f2d5 | ||
|
|
121d7edc15 | ||
|
|
b9256a7260 | ||
|
|
47b4cb55ba | ||
|
|
da1bcd67cd | ||
|
|
67a4797cf4 | ||
|
|
39523bc419 | ||
|
|
639c76d54c | ||
|
|
d5f29ea256 | ||
|
|
f9455549a7 | ||
|
|
dd14e8b040 | ||
|
|
efce16d45d | ||
|
|
977ce62bf0 | ||
|
|
479123dcf3 | ||
|
|
09301ca12d | ||
|
|
485c1ac40b | ||
|
|
4eca76c286 | ||
|
|
6d756ec472 | ||
|
|
8b427bcedd | ||
|
|
966963c8b6 | ||
|
|
ead8dc507b | ||
|
|
f5db9714d6 | ||
|
|
f90eca0777 | ||
|
|
485a7edc4e | ||
|
|
786de5f5e8 | ||
|
|
ac08cd85b2 | ||
|
|
0c8d45154f | ||
|
|
7eb186ae8a | ||
|
|
31bb1cb797 | ||
|
|
1ba6a6247c | ||
|
|
fa74f6e8e4 | ||
|
|
5c321f02e4 | ||
|
|
00871ab971 | ||
|
|
5aba5e0629 | ||
|
|
eec447872c | ||
|
|
98418d727b | ||
|
|
2265497b18 | ||
|
|
7f33640895 | ||
|
|
a57e12dbc5 | ||
|
|
b3f8cec272 | ||
|
|
e44e389571 | ||
|
|
0cf0e93d92 | ||
|
|
c7ad3459c4 | ||
|
|
af281341b1 | ||
|
|
313a5f3a14 | ||
|
|
18cd2ef63b | ||
|
|
4fc55f7520 | ||
|
|
795413c366 | ||
|
|
dd3c9c7b0a | ||
|
|
361ca01cc0 | ||
|
|
1b9c330613 | ||
|
|
2d7bb56a8d | ||
|
|
2c8a029939 | ||
|
|
6e2c19846c | ||
|
|
6c2ae13387 | ||
|
|
34cb4ad5e0 | ||
|
|
d080ca28f8 | ||
|
|
22a5e4c9e6 | ||
|
|
e93ac42489 | ||
|
|
ae604b7933 | ||
|
|
bd27eb5474 | ||
|
|
15fcf4f2c1 | ||
|
|
65415a03bd | ||
|
|
58585e1064 | ||
|
|
0f355c286d | ||
|
|
a0a51a63cb | ||
|
|
b44393a989 | ||
|
|
eda632866a | ||
|
|
3eaaa71ae1 | ||
|
|
77503e5fee | ||
|
|
8edab7b8e6 | ||
|
|
f8474fc2a2 | ||
|
|
0558c1127c | ||
|
|
e335e8bcf6 | ||
|
|
7e2e2e6cc9 | ||
|
|
de73495ab0 | ||
|
|
6c848b9a43 | ||
|
|
4812adba97 | ||
|
|
af938d0726 | ||
|
|
8562fadde2 | ||
|
|
a50813eb56 | ||
|
|
282f1fd482 | ||
|
|
2129efd196 | ||
|
|
a4de18796b | ||
|
|
cbf09b8962 | ||
|
|
f9077a1f93 | ||
|
|
68d2370c8f | ||
|
|
d735a7b7ce | ||
|
|
4ac0cbd908 | ||
|
|
142552741a | ||
|
|
685b458ad0 | ||
|
|
846794450a | ||
|
|
5e78713188 | ||
|
|
33c802c048 | ||
|
|
1e75b7717b | ||
|
|
28a464d3b7 | ||
|
|
0b9048ce02 | ||
|
|
4567540b95 | ||
|
|
3a0288111d | ||
|
|
a83fc0f3d1 | ||
|
|
1a12c88f0c | ||
|
|
6400206a94 | ||
|
|
49d8e1bc71 | ||
|
|
8a56c204f4 | ||
|
|
5bf4d4bb15 | ||
|
|
84dcd99f7b | ||
|
|
ea8351d9f6 | ||
|
|
aab6d9ffdc | ||
|
|
72f286d619 | ||
|
|
ecb0631b89 | ||
|
|
f26d3e2612 | ||
|
|
e36cd37e56 |
No files matched your search
Створено
+108
-106
@@ -1203,27 +1203,27 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-assembler-x64"
|
||||
version = "0.136.5"
|
||||
version = "0.136.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "249a61efca6a54425e027f5704a6f68a0232b4df527e05a3ef947d89dbdcb078"
|
||||
checksum = "aecefa88696b62f833cc0c997d19c93246b0268e2aaf23e0e8692e527f6de088"
|
||||
dependencies = [
|
||||
"cranelift-assembler-x64-meta",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-assembler-x64-meta"
|
||||
version = "0.136.5"
|
||||
version = "0.136.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d5336a46e05db2d515440b1ce8a9363e7bc04b608c0f66cc98dddc5492a66fbf"
|
||||
checksum = "1391a2546f5edf06a0ff5e9430d73c2713fd536aefec53200dc21846d1467f53"
|
||||
dependencies = [
|
||||
"cranelift-srcgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-bforest"
|
||||
version = "0.136.5"
|
||||
version = "0.136.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "01b3675b13214270fddbd257d5fbf4109be8b02d92fc636fe96e2829514a7235"
|
||||
checksum = "9528915fbc2c950702329e08c6d72aaff8ece9b7ecdbd225742825c09a445227"
|
||||
dependencies = [
|
||||
"cranelift-entity",
|
||||
"wasmtime-internal-core",
|
||||
@@ -1231,9 +1231,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-bitset"
|
||||
version = "0.136.5"
|
||||
version = "0.136.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d7c1d67aa02b6e174bd2b165c113e94af9498fcc20e2892d0f4d5ab8c9618d09"
|
||||
checksum = "9dd69a6db85c1bcff989809e0e0b3b06506425f32b545c46aeafda5fe7775d6a"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"serde_derive",
|
||||
@@ -1242,9 +1242,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-codegen"
|
||||
version = "0.136.5"
|
||||
version = "0.136.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "26fe6f3ec5344c32602c414e986dcbe699fa501a3e3e7b02f887d9d12b14ae42"
|
||||
checksum = "24c2db6c26cd96393cf785c4b51b900738963cc7422aa0045416a7641ae2f6cd"
|
||||
dependencies = [
|
||||
"bumpalo",
|
||||
"cranelift-assembler-x64",
|
||||
@@ -1273,9 +1273,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-codegen-meta"
|
||||
version = "0.136.5"
|
||||
version = "0.136.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "96c5e6323d458486d95781defdb5016a1176fc911d8bc8e64b696adbda6e9044"
|
||||
checksum = "e284270142e7f1dcb73a992a62a8b3716b4062a65a52d8f2732c6ebf6f7f342f"
|
||||
dependencies = [
|
||||
"cranelift-assembler-x64-meta",
|
||||
"cranelift-codegen-shared",
|
||||
@@ -1286,24 +1286,24 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-codegen-shared"
|
||||
version = "0.136.5"
|
||||
version = "0.136.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f1260aa93b0bd48e8e55c1c7fd9ff6a260f1a1bc46e1f0151a5055b124e5b15d"
|
||||
checksum = "6595667b7d505cf85d5bdd014e6f57ad6128183238f8e372319d9384782472f5"
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-control"
|
||||
version = "0.136.5"
|
||||
version = "0.136.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "50c179632a09850f81f1a1e9116cb09330c734a86689f3ee4c3f4ec81543acbd"
|
||||
checksum = "f26ffdbfcd24c3833d730849e6d132af34a400a2b89b44446015c01eecbea21d"
|
||||
dependencies = [
|
||||
"arbitrary",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-entity"
|
||||
version = "0.136.5"
|
||||
version = "0.136.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d8c071188cb1c3b1803e23ae415a8d5f58d741d3a4b26a79b83dd61921112eac"
|
||||
checksum = "9ffb08ccd8a77fb31cdbbda2afa2333d8f85299b1bc0d1c194259ba66d160d74"
|
||||
dependencies = [
|
||||
"cranelift-bitset",
|
||||
"serde",
|
||||
@@ -1313,9 +1313,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-frontend"
|
||||
version = "0.136.5"
|
||||
version = "0.136.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e2b85ba0a55d7685117b275fe6f36c819d438862e4223d28f0b97902460ff0ac"
|
||||
checksum = "b447e4f2bb44b1188185a77f478e5a91b7723a40b3b58c3e2d5b26df2ed5a665"
|
||||
dependencies = [
|
||||
"cranelift-codegen",
|
||||
"hashbrown 0.17.1",
|
||||
@@ -1326,15 +1326,15 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-isle"
|
||||
version = "0.136.5"
|
||||
version = "0.136.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "20ed364edcaed769da7b2709d540f8f7d0ff257749ba193f475e22dba6a0178b"
|
||||
checksum = "2f0989e943f3a9d41989595826bba544df9fda64bcddd4df0c06fb2e26af3cb3"
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-native"
|
||||
version = "0.136.5"
|
||||
version = "0.136.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "418d98c3dce08f0d13526692bbd1888bff4c5f45207f5093d168b5a224fbc88c"
|
||||
checksum = "5fa10df59e776c42dae5b6ba5216ba5321707a2136abd2219e615c54b234fc1b"
|
||||
dependencies = [
|
||||
"cranelift-codegen",
|
||||
"libc",
|
||||
@@ -1343,9 +1343,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-srcgen"
|
||||
version = "0.136.5"
|
||||
version = "0.136.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4f016b9994e39cad68107f33fa5b8dcee8fb7e38332bde3f97690e5e8abe1b10"
|
||||
checksum = "36508559c8839a8b6ee091f9deaa9cfe620a82f1abb5e358a0a0c65290583622"
|
||||
|
||||
[[package]]
|
||||
name = "crc"
|
||||
@@ -4144,7 +4144,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
|
||||
|
||||
[[package]]
|
||||
name = "ide-agent"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4169,7 +4169,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-analysis"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ast-grep-core",
|
||||
"ide-core",
|
||||
@@ -4183,7 +4183,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-android"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"serde",
|
||||
@@ -4194,7 +4194,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-build"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"chardetng",
|
||||
@@ -4212,7 +4212,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-cli"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"serde",
|
||||
@@ -4226,7 +4226,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-clipboard"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"gtk",
|
||||
"objc2 0.6.5",
|
||||
@@ -4237,7 +4237,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-command"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"heck 0.5.0",
|
||||
"proc-macro2",
|
||||
@@ -4248,7 +4248,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-core"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4265,7 +4265,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-coverage"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-run",
|
||||
@@ -4279,7 +4279,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-dap"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"futures",
|
||||
@@ -4308,7 +4308,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-db"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"bb8",
|
||||
@@ -4346,7 +4346,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-docker"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"serde",
|
||||
@@ -4359,7 +4359,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-extension"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -4380,7 +4380,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-flutter"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ide-android",
|
||||
"ide-core",
|
||||
@@ -4391,7 +4391,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-fonts"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"objc2-core-foundation",
|
||||
"objc2-core-text",
|
||||
@@ -4403,7 +4403,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-github"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-vcs",
|
||||
@@ -4416,7 +4416,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-heap"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"ide-core",
|
||||
@@ -4434,7 +4434,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-host"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -4509,7 +4509,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-http"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-vfs",
|
||||
@@ -4528,7 +4528,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-index"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"criterion",
|
||||
@@ -4550,7 +4550,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jdwp"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ide-jvm-inspect",
|
||||
"proptest",
|
||||
@@ -4562,7 +4562,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jsonrpc"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"encoding_rs",
|
||||
"futures",
|
||||
@@ -4579,7 +4579,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jvm-attach"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"tempfile",
|
||||
@@ -4588,7 +4588,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jvm-inspect"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"futures",
|
||||
"serde",
|
||||
@@ -4599,7 +4599,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-language"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"criterion",
|
||||
@@ -4658,8 +4658,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-lsp"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
"futures",
|
||||
@@ -4686,7 +4687,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-mcp"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"bytes",
|
||||
"dunce",
|
||||
@@ -4705,7 +4706,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-notebook"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"futures",
|
||||
"ide-core",
|
||||
@@ -4728,7 +4729,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-plugin"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4751,7 +4752,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-profiler"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-jvm-attach",
|
||||
@@ -4765,7 +4766,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-remote"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"futures",
|
||||
@@ -4785,7 +4786,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-run"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4809,7 +4810,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-scaffold"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-tools",
|
||||
@@ -4825,7 +4826,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-sdk"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"flate2",
|
||||
@@ -4848,7 +4849,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-search"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"encoding_rs",
|
||||
@@ -4869,7 +4870,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-spell"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"parking_lot",
|
||||
@@ -4882,7 +4883,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-ssh"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"flate2",
|
||||
@@ -4907,7 +4908,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-streams"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-language",
|
||||
@@ -4920,7 +4921,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-syntax"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-language",
|
||||
@@ -4935,7 +4936,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-terminal"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"libc",
|
||||
@@ -4943,12 +4944,13 @@ dependencies = [
|
||||
"portable-pty",
|
||||
"serde",
|
||||
"specta",
|
||||
"tokio",
|
||||
"tracing",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-text"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"ide-core",
|
||||
@@ -4961,7 +4963,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-tools"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"flate2",
|
||||
"hex",
|
||||
@@ -4982,7 +4984,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-vcs"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -5003,7 +5005,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-vfs"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"chardetng",
|
||||
"dunce",
|
||||
@@ -5029,7 +5031,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-web"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"ide-core",
|
||||
@@ -5045,7 +5047,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-workspace"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -6674,7 +6676,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "openidea"
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -7403,9 +7405,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pulley-interpreter"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1d74df9e20cba0f6dd07f01c3140535a6b23e40aecccfcacfb921621b41d0acb"
|
||||
checksum = "335e459f9c7809af04768799880504d014d07e8e2fc6ae682fe2a105d8ced33f"
|
||||
dependencies = [
|
||||
"cranelift-bitset",
|
||||
"log",
|
||||
@@ -7415,9 +7417,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pulley-macros"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8415513bfa407c06de6f11dbe9437f2352e075a5520ff491a131166d3d90aed1"
|
||||
checksum = "dd492ac929a6ca0357362d9fa0a09e31290feac5914550ccfb539b21f89c4b9e"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
@@ -9759,7 +9761,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
|
||||
dependencies = [
|
||||
"fastrand",
|
||||
"getrandom 0.4.3",
|
||||
"getrandom 0.3.4",
|
||||
"once_cell",
|
||||
"rustix",
|
||||
"windows-sys 0.61.2",
|
||||
@@ -11096,9 +11098,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d45bf3b13781b9febb0eef42e1e145146c92ef891f345fd918e0e0fa1568c992"
|
||||
checksum = "f32390bdc8d7cdb6259a1b855178bfed88226b4004b209fd48fb30e0deb01cd3"
|
||||
dependencies = [
|
||||
"addr2line",
|
||||
"async-trait",
|
||||
@@ -11138,9 +11140,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime-environ"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "833f00f3dc6128159284c5b71e211f24c97d45e052230a14f767fd830a6fb8b0"
|
||||
checksum = "9c10f8ef1c9ee5e0f125c775fe56a4d07b8525db30a96e6358c61d93bd11dee4"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"cpp_demangle",
|
||||
@@ -11169,9 +11171,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime-internal-component-macro"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0d69c34412409072d2e8ec399101524c330e334ff313f77415e6984cc9c6a172"
|
||||
checksum = "620c53182ebd26c9fff5b90dd53cf8ec3103c381403fd32f8d395da31a9e4a46"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"proc-macro2",
|
||||
@@ -11184,15 +11186,15 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime-internal-component-util"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b168d39f2d6b896d89fe096afa4ccdd7a8e927b01469b590af84f02fca3126a1"
|
||||
checksum = "011e31ca343d9ba0ec623153cd94131b6f03973ef1a0ab791161f642e4a16a93"
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime-internal-core"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7ad86a65d12c6a9202584ceb658c9a20cf5b25c32eed61c9be5e5f863f88f0d9"
|
||||
checksum = "ab15e50a060b746493e6e95ef3ce4e6e7ebfdd7cc336a7dff0f0277e01b447ef"
|
||||
dependencies = [
|
||||
"hashbrown 0.17.1",
|
||||
"libm",
|
||||
@@ -11201,9 +11203,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime-internal-cranelift"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a71f0fd1dd40e4e18d4a20cdba29ff8e0eb2c0f21b12c2eb5869e0fea789dd05"
|
||||
checksum = "dc3d27440a83fba26dd2784a997e13d9acb3606a75fb127c324929b52221c5c5"
|
||||
dependencies = [
|
||||
"cranelift-codegen",
|
||||
"cranelift-control",
|
||||
@@ -11227,9 +11229,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime-internal-fiber"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fa4dfa39e58735b24ce3d28bfc8c2b3041603cc8a941bb268395351beff90172"
|
||||
checksum = "6e54b28d0d453ca8932e4504065ae66a78f01fcb22b1a2ee287128d732fa9d6f"
|
||||
dependencies = [
|
||||
"cc",
|
||||
"libc",
|
||||
@@ -11241,9 +11243,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime-internal-jit-debug"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f2eb98d4486c7b0163447d77dea06f3cc87e5e5ba5fc93613f8ec42e27ea181d"
|
||||
checksum = "9293e75a3048b900f7b7c524702abca16d8a2332f970324eefc519f454cd5d69"
|
||||
dependencies = [
|
||||
"cc",
|
||||
"wasmtime-internal-versioned-export-macros",
|
||||
@@ -11251,9 +11253,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime-internal-jit-icache-coherence"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "852cae234735d79db6c58fe0d04b32f4078ad01fdb3fd6d488ac366132ba9785"
|
||||
checksum = "b852e568831b913d410541bb37edc45a5002e472208fbdbaf844ed801dd4255f"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"wasmtime-internal-core",
|
||||
@@ -11262,9 +11264,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime-internal-unwinder"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b9289378c82b9db7e7cf933d6bb441ad968536ac48f3f38c55b7cf9d3e8d87e1"
|
||||
checksum = "a1f7349c9834a542275ad757340079e6453fccb429efce581454d23f85af92c0"
|
||||
dependencies = [
|
||||
"cranelift-codegen",
|
||||
"log",
|
||||
@@ -11274,9 +11276,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime-internal-versioned-export-macros"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cc5c60c732d99dbcc5d670b71ba6ccf2b015cd16fc828990eaad2c4b8805ebdb"
|
||||
checksum = "30b3e0768a450d9dea3e16b83f2498f0b08db0e32bad695e35564eef017be3f1"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
@@ -11285,9 +11287,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime-internal-wit-bindgen"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c77e4fcc7cd22772578458c5e233df47190ebc9b8b65788797d99a02787c9000"
|
||||
checksum = "b9d085c540b95d0ffebf98c266e6f152e1acf96a9f676f224a74307b9d422c15"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"bitflags 2.13.2",
|
||||
@@ -11299,9 +11301,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime-wasi"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "705b90d1fa1084cc73df656868948da77711b97f6b895d145a4949f86bcea674"
|
||||
checksum = "17f8ce6b9e77539b5f52d440346f876a84c513ec1b07162845282f8652f7f7f9"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"bitflags 2.13.2",
|
||||
@@ -11323,9 +11325,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasmtime-wasi-io"
|
||||
version = "49.0.5"
|
||||
version = "49.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f3d2b6a255be488639f450b380e7e0923789f946de3463696cd30f2fe8a65cc3"
|
||||
checksum = "da9f90eb7ce6edbead27dba3a58843398875defa73b8dce4bbc29d0ce3dc9b40"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"bytes",
|
||||
|
||||
+1
-1
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
|
||||
exclude = ["sdk", "plugins"]
|
||||
|
||||
[workspace.package]
|
||||
version = "0.1.48"
|
||||
version = "0.1.49"
|
||||
edition = "2024"
|
||||
rust-version = "1.96"
|
||||
license = "Apache-2.0"
|
||||
|
||||
@@ -60,6 +60,44 @@ Their original copyright headers and Apache-2.0 licensing are retained.
|
||||
|
||||
At render time `src/ui/icons.tsx` may recolour monochrome icons to `currentColor`.
|
||||
|
||||
## Flutter plugin icons
|
||||
|
||||
These icons of [flutter-intellij](https://github.com/flutter/flutter-intellij) (commit `d02813ad5890`) are used
|
||||
under the BSD 3-Clause License:
|
||||
|
||||
- `src/ui/expui/flutter/*.svg`: the DevTools tool window icons, copied unmodified from
|
||||
`resources/icons/expui/`.
|
||||
- `src/ui/expui/flutter/[email protected]` and `[email protected]`: the Flutter outline's widget
|
||||
icons, `resources/icons/custom/[email protected]` and `[email protected]`, renamed, content unmodified.
|
||||
|
||||
```text
|
||||
Copyright 2016 The Chromium Authors. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without modification,
|
||||
are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following
|
||||
disclaimer in the documentation and/or other materials provided
|
||||
with the distribution.
|
||||
* Neither the name of Google Inc. nor the names of its
|
||||
contributors may be used to endorse or promote products derived
|
||||
from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
```
|
||||
|
||||
## JetBrains IntelliJ Platform VCS log graph algorithms
|
||||
|
||||
`crates/ide-vcs/src/bek.rs` and `src/features/vcs/graph.ts` adapt the Bek ordering,
|
||||
|
||||
@@ -256,6 +256,38 @@ impl AgentCatalogs {
|
||||
.cloned()
|
||||
}
|
||||
|
||||
pub(super) async fn load_levels(
|
||||
self: &Arc<Self>,
|
||||
shared: &Arc<Shared>,
|
||||
provider: &str,
|
||||
model: &str,
|
||||
) -> Result<Vec<AgentConfigOption>, String> {
|
||||
if let Some(levels) = self.levels(shared, provider, model) {
|
||||
return Ok(levels);
|
||||
}
|
||||
let unavailable = || "The agent did not report settings for the selected model".to_owned();
|
||||
let spec = shared.spec(provider).ok_or_else(unavailable)?;
|
||||
let (_, flight) = self.request(shared, spec, false, Some(model));
|
||||
if let Some(mut ready) = flight {
|
||||
while !*ready.borrow_and_update() {
|
||||
if ready.changed().await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
self.levels(shared, provider, model).ok_or_else(|| {
|
||||
let state = self.state.lock();
|
||||
state
|
||||
.entries
|
||||
.get(&Self::key(shared, provider))
|
||||
.and_then(|entry| {
|
||||
entry.model_failures.get(model).map(|failure| &failure.error).or(entry.error.as_ref())
|
||||
})
|
||||
.cloned()
|
||||
.unwrap_or_else(unavailable)
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
|
||||
let key = Self::key(shared, provider);
|
||||
let mut state = self.state.lock();
|
||||
|
||||
@@ -323,6 +323,36 @@ async fn discovered_model_can_be_selected_while_the_session_is_not_running() {
|
||||
switch_chat_model(ChatSwitch::Idle).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_effort_is_discovered_persisted_and_applied_before_the_first_reply() {
|
||||
switch_chat_model(ChatSwitch::Uncached).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_with_no_effort_can_be_selected() {
|
||||
switch_chat_model(ChatSwitch::NoEffort).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_settings_failure_leaves_the_chat_unchanged() {
|
||||
switch_chat_model(ChatSwitch::DiscoveryFails).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_withdrawn_effort_prevents_sending() {
|
||||
switch_chat_model(ChatSwitch::EffortUnavailable).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_rejected_effort_prevents_sending() {
|
||||
switch_chat_model(ChatSwitch::EffortRejected).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_lookup_does_not_overwrite_a_newer_selection() {
|
||||
switch_chat_model(ChatSwitch::Superseded).await;
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
enum ChatSwitch {
|
||||
Live,
|
||||
@@ -330,6 +360,12 @@ enum ChatSwitch {
|
||||
ResumeFails,
|
||||
Unavailable,
|
||||
Idle,
|
||||
Uncached,
|
||||
NoEffort,
|
||||
DiscoveryFails,
|
||||
EffortUnavailable,
|
||||
EffortRejected,
|
||||
Superseded,
|
||||
}
|
||||
|
||||
async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
@@ -376,7 +412,21 @@ async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
}
|
||||
let before_entries = serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap();
|
||||
let before_config = manager.task(&task.id).unwrap().state.lock().task.config.clone();
|
||||
if matches!(scenario, ChatSwitch::Idle) {
|
||||
let offline = matches!(scenario, ChatSwitch::Idle | ChatSwitch::Uncached | ChatSwitch::Superseded);
|
||||
let missing_settings = matches!(
|
||||
scenario,
|
||||
ChatSwitch::Uncached | ChatSwitch::NoEffort | ChatSwitch::DiscoveryFails | ChatSwitch::Superseded
|
||||
);
|
||||
let no_effort = matches!(scenario, ChatSwitch::NoEffort);
|
||||
let effort_error = match scenario {
|
||||
ChatSwitch::EffortUnavailable => Some("no longer offers effort value thorough"),
|
||||
ChatSwitch::EffortRejected => Some("effort rejected by the agent"),
|
||||
_ => None,
|
||||
};
|
||||
let choose_effort = matches!(scenario, ChatSwitch::Uncached) || effort_error.is_some();
|
||||
let (catalog_models, catalog_effort): (&[&str], &[&str]) =
|
||||
if missing_settings { (&["old", "new"], &["low", "high"]) } else { (&["new", "old"], &["quick", "thorough"]) };
|
||||
if offline {
|
||||
manager.shutdown();
|
||||
manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
}
|
||||
@@ -385,41 +435,122 @@ async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
let next = harness.next().await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (1, "session/new"));
|
||||
next.reply.send(Ok(response(&["new", "old"], &["catalog-only"]))).unwrap();
|
||||
assert_eq!(model_values(&completed(&mut events).await), ["new", "old"]);
|
||||
next.reply.send(Ok(response(catalog_models, catalog_effort))).unwrap();
|
||||
let catalog = completed(&mut events).await;
|
||||
assert_eq!(model_values(&catalog), catalog_models);
|
||||
if missing_settings {
|
||||
assert!(!catalog.thought_levels.contains_key("new"));
|
||||
}
|
||||
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
|
||||
|
||||
let live = matches!(scenario, ChatSwitch::Live);
|
||||
let offline = matches!(scenario, ChatSwitch::Idle);
|
||||
let resumed_launch = if missing_settings { 3 } else { 2 };
|
||||
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
|
||||
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
|
||||
let switching = manager.set_config(&task.id, "model", "new".into());
|
||||
tokio::pin!(switching);
|
||||
if !offline {
|
||||
let next = next_chat_request(&mut harness, switching.as_mut()).await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
|
||||
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
if live {
|
||||
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
} else {
|
||||
next.reply.send(Err("not in this process's model list".into())).unwrap();
|
||||
{
|
||||
let switching = manager.set_config(&task.id, "model", "new".into());
|
||||
tokio::pin!(switching);
|
||||
if !offline {
|
||||
let next = next_chat_request(&mut harness, switching.as_mut()).await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
|
||||
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
if live {
|
||||
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
} else {
|
||||
next.reply.send(Err("not in this process's model list".into())).unwrap();
|
||||
}
|
||||
}
|
||||
if missing_settings {
|
||||
let discovery = next_chat_request(&mut harness, switching.as_mut()).await;
|
||||
assert_eq!((discovery.launch, discovery.method.as_str()), (2, "session/new"));
|
||||
discovery.reply.send(Ok(response(catalog_models, catalog_effort))).unwrap();
|
||||
let set = next_chat_request(&mut harness, switching.as_mut()).await;
|
||||
assert_eq!(set.params, json!({"sessionId": "discovery-only", "configId": "model", "value": "new"}));
|
||||
assert_eq!(set.method, "session/set_config_option");
|
||||
assert!(
|
||||
manager
|
||||
.prompt(&task.id, AgentPrompt { text: "too early".into(), ..Default::default() }, false)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
if matches!(scenario, ChatSwitch::DiscoveryFails) {
|
||||
set.reply.send(Err("Sign in required".into())).unwrap();
|
||||
let error = switching.await.unwrap_err().to_string();
|
||||
assert!(error.contains("Sign in required"), "{error}");
|
||||
assert_eq!(manager.subscribe(Arc::new(|_| {})).remove(0).config, before_config);
|
||||
assert!(harness.pending.try_recv().is_err());
|
||||
manager.shutdown();
|
||||
return;
|
||||
}
|
||||
if matches!(scenario, ChatSwitch::Superseded) {
|
||||
manager.set_config(&task.id, "model", "old".into()).await.unwrap();
|
||||
set.reply.send(Ok(response(&["new", "old"], &["quick", "thorough"]))).unwrap();
|
||||
switching.await.unwrap();
|
||||
let task = manager.subscribe(Arc::new(|_| {})).remove(0);
|
||||
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
|
||||
assert_eq!(task.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("low"));
|
||||
assert!(harness.pending.try_recv().is_err());
|
||||
manager.shutdown();
|
||||
return;
|
||||
}
|
||||
let levels: &[&str] = if no_effort { &[] } else { &["quick", "thorough"] };
|
||||
set.reply.send(Ok(response(&["new", "old"], levels))).unwrap();
|
||||
}
|
||||
tokio::select! {
|
||||
result = &mut switching => result.unwrap(),
|
||||
request = harness.next() => panic!("selection must not reopen the chat or send: {request:?}"),
|
||||
}
|
||||
}
|
||||
// A fallback selection settles without waiting for a new process.
|
||||
tokio::select! {
|
||||
result = &mut switching => result.unwrap(),
|
||||
request = harness.next() => panic!("selection must not open another session: {request:?}"),
|
||||
}
|
||||
assert_eq!(serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap(), before_entries);
|
||||
if matches!(scenario, ChatSwitch::Uncached) {
|
||||
let update = tokio::time::timeout(Duration::from_secs(5), async {
|
||||
loop {
|
||||
if let AgentEvent::Task { task: update } = events.recv().await.unwrap()
|
||||
&& update.id == task.id
|
||||
{
|
||||
break update;
|
||||
}
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let effort = update.config.iter().find(|o| o.id == "effort").unwrap();
|
||||
assert_eq!(effort.values.iter().map(|v| v.value.as_str()).collect::<Vec<_>>(), ["quick", "thorough"]);
|
||||
}
|
||||
let snapshot = |manager: &AgentManager| manager.subscribe(Arc::new(|_| {})).remove(0);
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("new"));
|
||||
assert_eq!(current.model.as_deref(), Some(if live { "new" } else { "old" }));
|
||||
let effort =
|
||||
|task: &crate::AgentTask| task.config.iter().find(|o| o.id == "effort").and_then(|o| o.current.clone());
|
||||
assert_eq!(
|
||||
effort(¤t).as_deref(),
|
||||
if live {
|
||||
Some("session-only")
|
||||
} else if no_effort {
|
||||
None
|
||||
} else {
|
||||
Some("quick")
|
||||
},
|
||||
"the new model's effort must be available before sending"
|
||||
);
|
||||
if choose_effort {
|
||||
assert!(manager.set_config(&task.id, "effort", "high".into()).await.is_err());
|
||||
manager.set_config(&task.id, "effort", "thorough".into()).await.unwrap();
|
||||
assert_eq!(effort(&snapshot(&manager)).as_deref(), Some("thorough"));
|
||||
if matches!(scenario, ChatSwitch::Uncached) {
|
||||
manager.shutdown();
|
||||
manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let restored = snapshot(&manager);
|
||||
assert_eq!(restored.id, task.id);
|
||||
assert_eq!(effort(&restored).as_deref(), Some("thorough"));
|
||||
}
|
||||
}
|
||||
|
||||
manager.prompt(&task.id, AgentPrompt { text: "next".into(), ..Default::default() }, false).await.unwrap();
|
||||
if !live {
|
||||
let load = harness.next().await;
|
||||
assert_eq!((load.launch, load.method.as_str()), (2, "session/load"));
|
||||
assert_eq!((load.launch, load.method.as_str()), (resumed_launch, "session/load"));
|
||||
assert_eq!(load.params["sessionId"], "saved-chat");
|
||||
load.notifications
|
||||
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
|
||||
@@ -447,6 +578,7 @@ async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
let task = snapshot(&manager);
|
||||
assert_eq!(task.model.as_deref(), Some("old"));
|
||||
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
|
||||
assert_eq!(effort(&task).as_deref(), Some("low"));
|
||||
let expected = if load_fails { "cannot resume saved-chat" } else { "does not offer model new" };
|
||||
assert!(task.error.as_deref().unwrap().contains(expected), "{:?}", task.error);
|
||||
assert!(harness.pending.try_recv().is_err(), "must not send on the previous model or create a session");
|
||||
@@ -472,24 +604,60 @@ async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
return;
|
||||
}
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_config_option"));
|
||||
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_config_option"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
set.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
let levels: &[&str] = match scenario {
|
||||
ChatSwitch::NoEffort => &[],
|
||||
ChatSwitch::EffortUnavailable => &["session-only", "quick"],
|
||||
_ if choose_effort => &["session-only", "thorough"],
|
||||
_ => &["session-only"],
|
||||
};
|
||||
set.reply.send(Ok(response(&["new", "old"], levels))).unwrap();
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_mode"));
|
||||
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_mode"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
if choose_effort && !matches!(scenario, ChatSwitch::EffortUnavailable) {
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_config_option"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "effort", "value": "thorough"}));
|
||||
let reply = if effort_error.is_some() {
|
||||
Err("effort rejected by the agent".into())
|
||||
} else {
|
||||
Ok(response(&["new", "old"], &["thorough", "session-only"]))
|
||||
};
|
||||
set.reply.send(reply).unwrap();
|
||||
}
|
||||
if let Some(expected) = effort_error {
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.model.as_deref(), Some("old"));
|
||||
assert_eq!(effort(¤t).as_deref(), Some("low"));
|
||||
assert!(current.error.as_deref().unwrap().contains(expected), "{:?}", current.error);
|
||||
assert!(harness.pending.try_recv().is_err(), "must not send using a fallback effort");
|
||||
manager.shutdown();
|
||||
return;
|
||||
}
|
||||
}
|
||||
let next = harness.next().await;
|
||||
assert_eq!(
|
||||
(next.launch, next.method.as_str(), &next.params["sessionId"]),
|
||||
(if live { 0 } else { 2 }, "session/prompt", &json!("saved-chat"))
|
||||
(if live { 0 } else { resumed_launch }, "session/prompt", &json!("saved-chat"))
|
||||
);
|
||||
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.model.as_deref(), Some("new"));
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("session-only"));
|
||||
assert_eq!(
|
||||
effort(¤t).as_deref(),
|
||||
if choose_effort {
|
||||
Some("thorough")
|
||||
} else if no_effort {
|
||||
None
|
||||
} else {
|
||||
Some("session-only")
|
||||
}
|
||||
);
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
|
||||
manager.shutdown();
|
||||
}
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
|
||||
use crate::model::{
|
||||
AgentCommand, AgentCommandSource, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit,
|
||||
AgentModelPricing, AgentUsage,
|
||||
AgentModelPricing, AgentTokens, AgentUsage,
|
||||
};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
@@ -272,6 +272,18 @@ pub(crate) fn usage_of(update: &Value) -> Option<AgentUsage> {
|
||||
Some(AgentUsage { used: tokens("used")?, size: tokens("size").filter(|s| *s > 0)?, cost })
|
||||
}
|
||||
|
||||
/// The `usage` of a `session/prompt` result: `{ inputTokens, cachedReadTokens, outputTokens }`.
|
||||
pub(crate) fn tokens_of(result: &Value) -> Option<AgentTokens> {
|
||||
let usage = result.get("usage")?;
|
||||
let tokens = |key: &str| usage.get(key).and_then(Value::as_u64).map_or(0, |n| u32::try_from(n).unwrap_or(u32::MAX));
|
||||
let tokens = AgentTokens {
|
||||
input: tokens("inputTokens"),
|
||||
cached: tokens("cachedReadTokens"),
|
||||
output: tokens("outputTokens"),
|
||||
};
|
||||
(tokens != AgentTokens::default()).then_some(tokens)
|
||||
}
|
||||
|
||||
/// The usage-limit windows a [`crate::LIMITS_UPDATE`] carries; malformed entries are skipped.
|
||||
pub(crate) fn limits_of(update: &Value) -> Vec<AgentLimit> {
|
||||
let limits = update.get("limits").and_then(Value::as_array).into_iter().flatten();
|
||||
@@ -368,6 +380,15 @@ mod tests {
|
||||
c.iter().map(|o| (o.id.as_str(), o.current.as_deref())).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_hermes_prompt_result_reports_the_turns_tokens() {
|
||||
let result = json!({"stopReason": "end_turn", "usage": {"cachedReadTokens": 51306, "inputTokens": 77284,
|
||||
"outputTokens": 509, "thoughtTokens": 0, "totalTokens": 77793}});
|
||||
assert_eq!(tokens_of(&result), Some(AgentTokens { input: 77284, cached: 51306, output: 509 }));
|
||||
assert_eq!(tokens_of(&json!({"stopReason": "end_turn"})), None);
|
||||
assert_eq!(tokens_of(&json!({"usage": {}})), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn config_options_win_over_the_older_fields() {
|
||||
let r = json!({
|
||||
|
||||
@@ -0,0 +1,111 @@
|
||||
//! Hermes Agent profiles on disk: `default` is the Hermes home itself, the others are
|
||||
//! `<home>/profiles/<name>` directories holding one of Hermes' identity files.
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use serde::Serialize;
|
||||
use specta::Type;
|
||||
|
||||
const PROFILE_FILES: &[&str] = &["config.yaml", ".env", "SOUL.md", "profile.yaml", "auth.json", "state.db"];
|
||||
|
||||
/// Hermes' home directory (`~/.hermes`; `%LOCALAPPDATA%\hermes` on Windows).
|
||||
pub fn root(home: Option<&Path>) -> Option<PathBuf> {
|
||||
#[cfg(windows)]
|
||||
if let Some(local) = std::env::var_os("LOCALAPPDATA") {
|
||||
return Some(PathBuf::from(local).join("hermes"));
|
||||
}
|
||||
home.map(|h| h.join(".hermes"))
|
||||
}
|
||||
|
||||
/// The profile names under `root`: `default` first, then the others by name; none without `root`.
|
||||
pub fn profiles(root: &Path) -> Vec<String> {
|
||||
if !root.is_dir() {
|
||||
return Vec::new();
|
||||
}
|
||||
let mut named: Vec<String> = std::fs::read_dir(root.join("profiles"))
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.flatten()
|
||||
.filter(|e| PROFILE_FILES.iter().any(|f| e.path().join(f).exists()))
|
||||
.filter_map(|e| e.file_name().to_str().map(str::to_owned))
|
||||
.filter(|name| name != "default")
|
||||
.collect();
|
||||
named.sort();
|
||||
std::iter::once("default".to_owned()).chain(named).collect()
|
||||
}
|
||||
|
||||
/// A profile and the name Hermes shows for it (`hermes profile list`).
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Type)]
|
||||
pub struct HermesProfile {
|
||||
/// What `hermes -p` takes; `default` is the Hermes home itself.
|
||||
pub name: String,
|
||||
/// `display_name` from the profile's `profile.yaml`, else the name.
|
||||
pub label: String,
|
||||
}
|
||||
|
||||
/// [`profiles`] with the names Hermes shows for them.
|
||||
pub fn labeled_profiles(root: &Path) -> Vec<HermesProfile> {
|
||||
profiles(root)
|
||||
.into_iter()
|
||||
.map(|name| {
|
||||
let home = if name == "default" { root.to_path_buf() } else { root.join("profiles").join(&name) };
|
||||
let label = display_name(&home).unwrap_or_else(|| name.clone());
|
||||
HermesProfile { name, label }
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The top-level `display_name:` of `<home>/profile.yaml`, the only key read (no YAML parser).
|
||||
fn display_name(home: &Path) -> Option<String> {
|
||||
let text = std::fs::read_to_string(home.join("profile.yaml")).ok()?;
|
||||
let value = text.lines().find_map(|l| l.strip_prefix("display_name:"))?;
|
||||
let value = value.trim().trim_matches(['"', '\'']).trim();
|
||||
(!value.is_empty()).then(|| value.to_owned())
|
||||
}
|
||||
|
||||
/// The home of the profile an agent id stands for: `hermes` and `hermes-default` are the
|
||||
/// default profile, `hermes-<slug>` the profile whose name slugifies to `<slug>`.
|
||||
pub fn profile_home(root: &Path, provider: &str) -> Option<PathBuf> {
|
||||
let slug = match provider {
|
||||
"hermes" | "hermes-default" => return Some(root.to_path_buf()),
|
||||
_ => provider.strip_prefix("hermes-")?,
|
||||
};
|
||||
profiles(root).into_iter().find(|p| crate::provider::slugify_id(p) == slug).map(|p| root.join("profiles").join(p))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn lists_default_and_profiles_with_an_identity_file() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
assert!(profiles(&dir.path().join("missing")).is_empty());
|
||||
let root = dir.path().join(".hermes");
|
||||
std::fs::create_dir_all(root.join("profiles/empty")).unwrap();
|
||||
assert_eq!(profiles(&root), ["default"]);
|
||||
for (name, file) in [("work", "config.yaml"), ("Dom 2", "SOUL.md"), ("db", "state.db")] {
|
||||
std::fs::create_dir_all(root.join("profiles").join(name)).unwrap();
|
||||
std::fs::write(root.join("profiles").join(name).join(file), "").unwrap();
|
||||
}
|
||||
std::fs::write(root.join("profiles/stray.yaml"), "").unwrap();
|
||||
assert_eq!(profiles(&root), ["default", "Dom 2", "db", "work"]);
|
||||
assert_eq!(profile_home(&root, "hermes"), Some(root.clone()));
|
||||
assert_eq!(profile_home(&root, "hermes-dom-2"), Some(root.join("profiles/Dom 2")));
|
||||
assert_eq!(profile_home(&root, "hermes-empty"), None);
|
||||
assert_eq!(profile_home(&root, "claude"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn labels_profiles_with_their_display_name() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path().join(".hermes");
|
||||
std::fs::create_dir_all(root.join("profiles/work")).unwrap();
|
||||
std::fs::write(root.join("profile.yaml"), "description: mine\ndisplay_name: \"qb\"\n").unwrap();
|
||||
std::fs::write(root.join("profiles/work/profile.yaml"), "ui_meta:\n display_name: nested\n").unwrap();
|
||||
let label = |name: &str, label: &str| HermesProfile { name: name.into(), label: label.into() };
|
||||
assert_eq!(labeled_profiles(&root), [label("default", "qb"), label("work", "work")]);
|
||||
std::fs::remove_file(root.join("profile.yaml")).unwrap();
|
||||
assert_eq!(labeled_profiles(&root)[0], label("default", "default"));
|
||||
}
|
||||
}
|
||||
+350
-120
@@ -14,6 +14,7 @@ mod config;
|
||||
mod conversation;
|
||||
mod elicitation;
|
||||
mod external;
|
||||
pub mod hermes;
|
||||
pub mod mcp;
|
||||
mod model;
|
||||
mod native;
|
||||
@@ -357,9 +358,11 @@ struct TaskFile {
|
||||
/// Settings the user chose, re-applied to every new or reloaded session.
|
||||
#[serde(default)]
|
||||
wanted: Vec<AgentConfigChoice>,
|
||||
/// Option id of a discovered model in `wanted` that still needs a same-session reload.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
/// Pending model option id in task files saved before pending settings were stored separately.
|
||||
#[serde(default, skip_serializing)]
|
||||
pending_model: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pending_switch: Option<PendingModel>,
|
||||
/// In the project's own checkout: files already changed when the task started.
|
||||
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
||||
before: BTreeMap<String, worktree::Stamp>,
|
||||
@@ -384,6 +387,26 @@ struct TaskFile {
|
||||
title_renamed: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
struct PendingModel {
|
||||
model: AgentConfigChoice,
|
||||
candidate: Option<AgentConfigValue>,
|
||||
options: Vec<AgentConfigOption>,
|
||||
choices: Vec<AgentConfigChoice>,
|
||||
}
|
||||
|
||||
impl PendingModel {
|
||||
fn apply(&self, wanted: &mut Vec<AgentConfigChoice>, confirmed: &[AgentConfigOption]) {
|
||||
wanted.retain(|choice| {
|
||||
choice.id != self.model.id
|
||||
&& !self.options.iter().any(|o| o.id == choice.id)
|
||||
&& !confirmed.iter().any(|o| o.id == choice.id && config::is_per_model_option(o))
|
||||
});
|
||||
wanted.push(self.model.clone());
|
||||
wanted.extend(self.choices.iter().cloned());
|
||||
}
|
||||
}
|
||||
|
||||
/// The changed files of a checkout, stamped.
|
||||
type Snapshot = BTreeMap<String, worktree::Stamp>;
|
||||
|
||||
@@ -392,8 +415,9 @@ struct TaskState {
|
||||
session_id: Option<String>,
|
||||
conversation: Conversation,
|
||||
wanted: Vec<AgentConfigChoice>,
|
||||
pending_model: Option<String>,
|
||||
pending_model: Option<PendingModel>,
|
||||
model_choice: u64,
|
||||
discovering_model: Option<u64>,
|
||||
before: Arc<BTreeMap<String, worktree::Stamp>>,
|
||||
saved: Option<String>,
|
||||
/// See `TaskFile::touched`.
|
||||
@@ -415,23 +439,43 @@ struct TaskState {
|
||||
}
|
||||
|
||||
impl TaskState {
|
||||
fn pending_model(&self) -> Option<&AgentConfigChoice> {
|
||||
let id = self.pending_model.as_deref()?;
|
||||
self.wanted.iter().find(|c| c.id == id)
|
||||
}
|
||||
|
||||
fn snapshot(&self) -> AgentTask {
|
||||
let mut task = self.task.clone();
|
||||
if let Some(choice) = self.pending_model()
|
||||
&& let Some(model) = task.config.iter_mut().find(|o| o.id == choice.id)
|
||||
if let Some(pending) = &self.pending_model
|
||||
&& let Some(model) = task.config.iter_mut().find(|o| o.id == pending.model.id)
|
||||
{
|
||||
model.current = Some(choice.value.clone());
|
||||
model.current = Some(pending.model.value.clone());
|
||||
if let Some(candidate) = &pending.candidate
|
||||
&& !model.values.iter().any(|v| v.value == candidate.value)
|
||||
{
|
||||
model.values.push(candidate.clone());
|
||||
}
|
||||
task.config.retain(|o| !config::is_per_model_option(o));
|
||||
task.config.extend(pending.options.iter().cloned().map(|mut option| {
|
||||
if let Some(choice) = pending.choices.iter().find(|choice| choice.id == option.id) {
|
||||
option.current = Some(choice.value.clone());
|
||||
}
|
||||
option
|
||||
}));
|
||||
}
|
||||
task
|
||||
}
|
||||
}
|
||||
|
||||
struct DiscoveringModel<'a> {
|
||||
state: &'a Mutex<TaskState>,
|
||||
generation: u64,
|
||||
}
|
||||
|
||||
impl Drop for DiscoveringModel<'_> {
|
||||
fn drop(&mut self) {
|
||||
let mut s = self.state.lock();
|
||||
if s.discovering_model == Some(self.generation) {
|
||||
s.discovering_model = None;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A running agent and its session.
|
||||
#[derive(Clone)]
|
||||
struct Live {
|
||||
@@ -666,7 +710,8 @@ impl AgentManager {
|
||||
|
||||
/// The slash commands to complete for `provider`, in `task`'s directory or (without one)
|
||||
/// in the project: what the agent offered last time there, unadvertised builtins,
|
||||
/// and, for Claude Code, skills and custom commands on disk it has not listed.
|
||||
/// and, for Claude Code, skills and custom commands on disk it has not listed (for Hermes,
|
||||
/// its profile's skills).
|
||||
pub async fn commands(&self, provider: &str, task: Option<&str>) -> IdeResult<Vec<AgentCommand>> {
|
||||
let (provider, offered, cwd) = match task {
|
||||
Some(id) => {
|
||||
@@ -700,10 +745,18 @@ impl AgentManager {
|
||||
offered.push(command);
|
||||
}
|
||||
}
|
||||
let home = self.shared.paths.home_dir.clone();
|
||||
if provider == "hermes" || provider.starts_with("hermes-") {
|
||||
let found = blocking(move || {
|
||||
let profile = hermes::root(home.as_deref()).and_then(|root| hermes::profile_home(&root, &provider));
|
||||
Ok(profile.map(|p| skills::hermes(&p)).unwrap_or_default())
|
||||
})
|
||||
.await?;
|
||||
return Ok(skills::merge(offered, found));
|
||||
}
|
||||
if provider != "claude" && provider != "claude-acp" {
|
||||
return Ok(offered);
|
||||
}
|
||||
let home = self.shared.paths.home_dir.clone();
|
||||
let found = blocking(move || Ok(skills::discover(&cwd, home.as_deref()))).await?;
|
||||
Ok(skills::merge(offered, found))
|
||||
}
|
||||
@@ -789,6 +842,7 @@ impl AgentManager {
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
stats: Box::default(),
|
||||
};
|
||||
let file = TaskFile {
|
||||
task: task.clone(),
|
||||
@@ -796,6 +850,7 @@ impl AgentManager {
|
||||
entries: Vec::new(),
|
||||
wanted: Vec::new(),
|
||||
pending_model: None,
|
||||
pending_switch: None,
|
||||
before: BTreeMap::new(),
|
||||
saved: None,
|
||||
touched: Some(BTreeSet::new()),
|
||||
@@ -811,7 +866,8 @@ impl AgentManager {
|
||||
Ok(task)
|
||||
}
|
||||
|
||||
/// Creates the task (and its worktree) and sends `req.prompt` as its first message.
|
||||
/// Creates the task (and its worktree) and sends `req.prompt` as its first message, unless
|
||||
/// `req.idle`.
|
||||
pub async fn create(&self, req: NewAgentTask) -> IdeResult<AgentTask> {
|
||||
let spec = self
|
||||
.shared
|
||||
@@ -886,7 +942,7 @@ impl AgentManager {
|
||||
title,
|
||||
provider: spec.id.clone(),
|
||||
model: model_of(&config),
|
||||
status: AgentStatus::Starting,
|
||||
status: if req.idle { AgentStatus::Ready } else { AgentStatus::Starting },
|
||||
isolation: req.isolation,
|
||||
cwd: IpcPath(cwd),
|
||||
branch,
|
||||
@@ -904,6 +960,7 @@ impl AgentManager {
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: req.mcp_overrides,
|
||||
stats: Box::default(),
|
||||
};
|
||||
let file = TaskFile {
|
||||
task: task.clone(),
|
||||
@@ -911,6 +968,7 @@ impl AgentManager {
|
||||
entries: Vec::new(),
|
||||
wanted: req.config,
|
||||
pending_model: None,
|
||||
pending_switch: None,
|
||||
before,
|
||||
saved,
|
||||
touched: (req.isolation == Isolation::Local).then(BTreeSet::new),
|
||||
@@ -920,11 +978,13 @@ impl AgentManager {
|
||||
title_renamed: false,
|
||||
};
|
||||
let handle = Task::restore(file, self.shared.clone());
|
||||
handle.state.lock().busy = true;
|
||||
handle.state.lock().busy = !req.idle;
|
||||
self.tasks.write().insert(task.id.clone(), handle.clone());
|
||||
handle.emit_task();
|
||||
handle.persist();
|
||||
self.shared.runtime.spawn(async move { handle.run(prompt).await });
|
||||
if !req.idle {
|
||||
self.shared.runtime.spawn(async move { handle.run(prompt).await });
|
||||
}
|
||||
Ok(task)
|
||||
}
|
||||
|
||||
@@ -946,6 +1006,9 @@ impl AgentManager {
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
if s.discovering_model.is_some() {
|
||||
return Err(IdeError::unavailable("Model settings are still loading"));
|
||||
}
|
||||
if s.busy {
|
||||
let item = AgentQueued { id: uuid::Uuid::new_v4().simple().to_string(), prompt };
|
||||
if now {
|
||||
@@ -1065,6 +1128,24 @@ impl AgentManager {
|
||||
let task = self.task(id)?;
|
||||
let (target, change) = {
|
||||
let mut s = task.state.lock();
|
||||
let busy = s.busy;
|
||||
let archived = s.task.status == AgentStatus::Archived;
|
||||
if let Some(pending) = &mut s.pending_model
|
||||
&& let Some(target) = pending.options.iter().find(|o| o.id == option)
|
||||
{
|
||||
if archived || busy {
|
||||
return Err(IdeError::invalid("The pending model settings cannot be changed now"));
|
||||
}
|
||||
if !target.values.iter().any(|v| v.value == value) {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
}
|
||||
pending.choices.retain(|c| c.id != option);
|
||||
pending.choices.push(AgentConfigChoice { id: option.to_owned(), value });
|
||||
drop(s);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
return Ok(());
|
||||
}
|
||||
let target = s
|
||||
.task
|
||||
.config
|
||||
@@ -1072,6 +1153,9 @@ impl AgentManager {
|
||||
.find(|o| o.id == option)
|
||||
.ok_or_else(|| IdeError::not_found("no such setting"))?
|
||||
.clone();
|
||||
if s.pending_model.is_some() && config::is_per_model_option(&target) {
|
||||
return Err(IdeError::invalid("This setting is not available on the selected model"));
|
||||
}
|
||||
if !target.values.iter().any(|v| v.value == value) {
|
||||
if target.category.as_deref() != Some("model") {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
@@ -1080,8 +1164,12 @@ impl AgentManager {
|
||||
} else {
|
||||
let switching_model = target.category.as_deref() == Some("model");
|
||||
if switching_model {
|
||||
if s.pending_model.is_some() && s.busy {
|
||||
return Err(IdeError::invalid("The pending model settings cannot be changed now"));
|
||||
}
|
||||
s.model_choice += 1;
|
||||
s.pending_model = None;
|
||||
s.discovering_model = None;
|
||||
}
|
||||
let previous_levels = (switching_model && target.current.as_deref() != Some(value.as_str()))
|
||||
.then(|| s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>());
|
||||
@@ -1113,33 +1201,19 @@ impl AgentManager {
|
||||
&& (previous.as_deref() != Some(value.as_str()) || !model_options)
|
||||
{
|
||||
let provider = task.state.lock().task.provider.clone();
|
||||
let mut levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
|
||||
let mut error = None;
|
||||
if levels.is_none()
|
||||
&& let Some(spec) = self.shared.spec(&provider)
|
||||
{
|
||||
let (catalog, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, Some(&value));
|
||||
error = catalog.error;
|
||||
if let Some(mut ready) = flight {
|
||||
while !*ready.borrow_and_update() {
|
||||
if ready.changed().await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
|
||||
}
|
||||
let levels = self.shared.paths.catalogs.load_levels(&self.shared, &provider, &value).await;
|
||||
// Another selection may have superseded this discovery while it was waiting.
|
||||
if task.state.lock().model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
let Some(levels) = levels else {
|
||||
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
return Err(IdeError::unavailable(
|
||||
error.unwrap_or_else(|| "The agent did not report settings for the selected model".into()),
|
||||
));
|
||||
let levels = match levels {
|
||||
Ok(levels) => levels,
|
||||
Err(error) => {
|
||||
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
return Err(IdeError::unavailable(error));
|
||||
}
|
||||
};
|
||||
let mut s = task.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
@@ -1254,6 +1328,7 @@ impl AgentManager {
|
||||
resets_ms: None,
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
stats: Box::default(),
|
||||
..s.task.clone()
|
||||
};
|
||||
TaskFile {
|
||||
@@ -1262,6 +1337,7 @@ impl AgentManager {
|
||||
entries,
|
||||
wanted: s.wanted.clone(),
|
||||
pending_model: None,
|
||||
pending_switch: None,
|
||||
before: (*s.before).clone(),
|
||||
saved: s.saved.clone(),
|
||||
touched: s.touched.as_deref().cloned(),
|
||||
@@ -1307,6 +1383,8 @@ impl AgentManager {
|
||||
};
|
||||
s.session_id = None;
|
||||
s.pending_model = None;
|
||||
s.model_choice += 1;
|
||||
s.discovering_model = None;
|
||||
s.conversation = Conversation::default();
|
||||
// The fresh session reports its own usage; nothing carries over.
|
||||
s.task.usage = None;
|
||||
@@ -1905,6 +1983,24 @@ impl Task {
|
||||
let mut task = file.task;
|
||||
config::add_client_options(&task.provider, &mut task.config);
|
||||
let conversation = Conversation::restore(file.entries, file.subagents);
|
||||
let mut wanted = file.wanted;
|
||||
let pending_model = file.pending_switch.or_else(|| {
|
||||
let id = file.pending_model?;
|
||||
let index = wanted.iter().position(|choice| choice.id == id)?;
|
||||
let model = wanted.remove(index);
|
||||
if let Some(value) = task.model.clone() {
|
||||
wanted.push(AgentConfigChoice { id, value });
|
||||
}
|
||||
let catalog = shared.paths.catalogs.cached(&shared, &task.provider);
|
||||
let candidate = catalog
|
||||
.config
|
||||
.iter()
|
||||
.find(|o| o.category.as_deref() == Some("model"))
|
||||
.and_then(|o| o.values.iter().find(|v| v.value == model.value))
|
||||
.cloned();
|
||||
let options = catalog.thought_levels.get(&model.value).cloned().unwrap_or_default();
|
||||
Some(PendingModel { model, candidate, options, choices: Vec::new() })
|
||||
});
|
||||
Arc::new(Self {
|
||||
id: task.id.clone(),
|
||||
shared,
|
||||
@@ -1912,9 +2008,10 @@ impl Task {
|
||||
task,
|
||||
session_id: file.session_id,
|
||||
conversation,
|
||||
wanted: file.wanted,
|
||||
pending_model: file.pending_model,
|
||||
wanted,
|
||||
pending_model,
|
||||
model_choice: 0,
|
||||
discovering_model: None,
|
||||
before: Arc::new(file.before),
|
||||
saved: file.saved,
|
||||
touched: file.touched.map(Arc::new),
|
||||
@@ -2108,7 +2205,8 @@ impl Task {
|
||||
session_id: s.session_id.clone(),
|
||||
entries: s.conversation.main.entries.clone(),
|
||||
wanted: s.wanted.clone(),
|
||||
pending_model: s.pending_model.clone(),
|
||||
pending_model: None,
|
||||
pending_switch: s.pending_model.clone(),
|
||||
before: (*s.before).clone(),
|
||||
saved: s.saved.clone(),
|
||||
touched: s.touched.as_deref().cloned(),
|
||||
@@ -2261,13 +2359,18 @@ impl Task {
|
||||
let candidate = self.shared.paths.catalogs.fresh_model(&self.shared, &spec, &value).ok_or_else(|| {
|
||||
IdeError::invalid(format!("{} has no value {value} in the current model catalog", target.name))
|
||||
})?;
|
||||
let model_choice = {
|
||||
let selection = {
|
||||
let mut s = self.state.lock();
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
s.model_choice += 1;
|
||||
s.model_choice
|
||||
s.discovering_model = Some(s.model_choice);
|
||||
DiscoveringModel { state: &self.state, generation: s.model_choice }
|
||||
};
|
||||
let model_choice = selection.generation;
|
||||
// A prompt starting during the switch must not grab the peer we're about to recycle.
|
||||
let _connecting = self.connecting.lock().await;
|
||||
let connecting = self.connecting.lock().await;
|
||||
{
|
||||
let s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
@@ -2290,16 +2393,16 @@ impl Task {
|
||||
Ok(None)
|
||||
};
|
||||
|
||||
let accepted = {
|
||||
let mut s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
let pending = match result {
|
||||
Ok(Some(reply)) => {
|
||||
let refused = match result {
|
||||
Ok(Some(reply)) => {
|
||||
let (config, model) = {
|
||||
let mut s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
if let Some(options) = reply.get("configOptions") {
|
||||
config::merge_update(&mut s.task.config, options);
|
||||
} else if s.task.model.as_deref() != Some(value.as_str()) {
|
||||
@@ -2318,36 +2421,66 @@ impl Task {
|
||||
model.current = Some(value.clone());
|
||||
s.task.model = Some(value.clone());
|
||||
sync_usage_context_size(&mut s.task);
|
||||
false
|
||||
}
|
||||
refused => {
|
||||
if s.session_id.is_none()
|
||||
|| live.as_ref().is_some_and(|l| !l.resumable)
|
||||
|| self.start_fresh.load(Ordering::Acquire)
|
||||
{
|
||||
return Err(IdeError::unavailable(
|
||||
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
|
||||
));
|
||||
}
|
||||
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
|
||||
return Err(IdeError::invalid("wait until the agent is done"));
|
||||
}
|
||||
true
|
||||
}
|
||||
};
|
||||
s.wanted.retain(|c| c.id != target.id);
|
||||
s.pending_model = pending.then(|| target.id.clone());
|
||||
s.wanted.push(AgentConfigChoice { id: target.id, value });
|
||||
(!pending).then(|| {
|
||||
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
|
||||
(s.task.config.clone(), model)
|
||||
})
|
||||
s.pending_model = None;
|
||||
s.wanted.retain(|c| c.id != target.id);
|
||||
s.wanted.push(AgentConfigChoice { id: target.id, value });
|
||||
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
|
||||
(s.task.config.clone(), model)
|
||||
};
|
||||
self.shared.remember(&provider, Some(&config), None, model.as_deref());
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
return Ok(());
|
||||
}
|
||||
refused => refused,
|
||||
};
|
||||
if let Some((config, model)) = accepted {
|
||||
self.shared.remember(&provider, Some(&config), None, model.as_deref());
|
||||
} else {
|
||||
self.recycle_resumable_session();
|
||||
{
|
||||
let s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if s.session_id.is_none()
|
||||
|| live.as_ref().is_some_and(|l| !l.resumable)
|
||||
|| self.start_fresh.load(Ordering::Acquire)
|
||||
{
|
||||
return Err(IdeError::unavailable(
|
||||
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
|
||||
));
|
||||
}
|
||||
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
|
||||
return Err(IdeError::invalid("wait until the agent is done"));
|
||||
}
|
||||
}
|
||||
// Catalog discovery never owns the chat session. Let a newer model choice supersede it.
|
||||
drop(connecting);
|
||||
let options = self.shared.paths.catalogs.load_levels(&self.shared, &provider, &value).await;
|
||||
let _connecting = self.connecting.lock().await;
|
||||
{
|
||||
let mut s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
|
||||
return Err(IdeError::invalid("wait until the agent is done"));
|
||||
}
|
||||
let options = options.map_err(IdeError::unavailable)?;
|
||||
let choices = s
|
||||
.pending_model
|
||||
.take()
|
||||
.filter(|pending| pending.model.value == value)
|
||||
.map(|pending| pending.choices)
|
||||
.unwrap_or_default();
|
||||
s.pending_model = Some(PendingModel {
|
||||
model: AgentConfigChoice { id: target.id, value },
|
||||
candidate: Some(candidate),
|
||||
options,
|
||||
choices,
|
||||
});
|
||||
}
|
||||
self.recycle_resumable_session();
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
Ok(())
|
||||
@@ -2533,7 +2666,13 @@ impl Task {
|
||||
.await;
|
||||
}
|
||||
match result {
|
||||
Ok(v) => Ok(v.get("stopReason").and_then(Value::as_str).unwrap_or("end_turn").to_owned()),
|
||||
Ok(v) => {
|
||||
if let Some(tokens) = config::tokens_of(&v) {
|
||||
self.state.lock().task.stats.tokens = Some(tokens);
|
||||
self.emit_task();
|
||||
}
|
||||
Ok(v.get("stopReason").and_then(Value::as_str).unwrap_or("end_turn").to_owned())
|
||||
}
|
||||
Err(e) => Err(self.failure(e)),
|
||||
}
|
||||
}
|
||||
@@ -2609,10 +2748,9 @@ impl Task {
|
||||
}
|
||||
let (provider_id, cwd, saved, pending) = {
|
||||
let s = self.state.lock();
|
||||
let pending = s.pending_model().map(|choice| (choice.clone(), s.task.model.clone()));
|
||||
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), pending)
|
||||
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), s.pending_model.clone())
|
||||
};
|
||||
let pending_model = pending.as_ref().map(|(choice, _)| choice);
|
||||
let pending_model = pending.as_ref();
|
||||
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);
|
||||
@@ -2638,22 +2776,12 @@ impl Task {
|
||||
let live = match opened {
|
||||
Ok(live) => live,
|
||||
Err(err) => {
|
||||
if let Some((choice, previous)) = pending {
|
||||
let mut s = self.state.lock();
|
||||
if s.pending_model() == Some(&choice) {
|
||||
s.pending_model = None;
|
||||
s.wanted.retain(|c| c.id != choice.id);
|
||||
if let Some(model) = s.task.config.iter_mut().find(|o| o.id == choice.id) {
|
||||
model.current.clone_from(&previous);
|
||||
}
|
||||
s.task.model.clone_from(&previous);
|
||||
if let Some(value) = previous {
|
||||
s.wanted.push(AgentConfigChoice { id: choice.id, value });
|
||||
}
|
||||
drop(s);
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
}
|
||||
let mut s = self.state.lock();
|
||||
if pending.is_some() && s.pending_model == pending {
|
||||
s.pending_model = None;
|
||||
drop(s);
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
}
|
||||
return Err(err.message);
|
||||
}
|
||||
@@ -2668,7 +2796,7 @@ impl Task {
|
||||
spec: provider::ProviderSpec,
|
||||
cwd: &Path,
|
||||
saved: Option<String>,
|
||||
pending_model: Option<&AgentConfigChoice>,
|
||||
pending_model: Option<&PendingModel>,
|
||||
) -> Result<Live, SessionOpenError> {
|
||||
let launch_cwd = cwd.to_path_buf();
|
||||
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
@@ -2694,14 +2822,15 @@ 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 client = Client::new(self, saved.as_deref().filter(|_| pending_model.is_some()));
|
||||
let handler = acp::Dialect::wrap(client.clone());
|
||||
let raw_peer =
|
||||
(self.shared.connector)(&spec, cwd, client.clone(), on_stderr).map_err(|e| SessionOpenError {
|
||||
(self.shared.connector)(&spec, cwd, handler.clone(), on_stderr).map_err(|e| SessionOpenError {
|
||||
message: format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command),
|
||||
allow_acp_fallback: !native::copilot::is_missing_binary_error(&e),
|
||||
})?;
|
||||
let mut stop_on_err = KillOnDrop(Some(raw_peer.clone()));
|
||||
let peer = acp::Conn::new(raw_peer, client);
|
||||
let peer = acp::Conn::new(raw_peer, handler);
|
||||
|
||||
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));
|
||||
@@ -2800,7 +2929,13 @@ impl Task {
|
||||
|
||||
// The session's settings, then the user's choices on top.
|
||||
// A session that reports none keeps the last known ones, but what is set is unknown.
|
||||
let reported = config::options_of(&result);
|
||||
let mut reported = config::options_of(&result);
|
||||
if let Some(update) = client.take_opening_config()
|
||||
&& let Some(config) = update.get("configOptions")
|
||||
&& reported.iter().all(|o| o.category.as_deref() != Some("model"))
|
||||
{
|
||||
config::merge_update(&mut reported, config);
|
||||
}
|
||||
let known = !reported.is_empty();
|
||||
if known {
|
||||
self.shared.remember(provider_id, Some(&reported), None, model_of(&reported).as_deref());
|
||||
@@ -2808,19 +2943,33 @@ impl Task {
|
||||
let (mut options, mut wanted) = {
|
||||
let s = self.state.lock();
|
||||
let options = if known { reported } else { s.task.config.clone() };
|
||||
let wanted = s.wanted.clone();
|
||||
let mut wanted = s.wanted.clone();
|
||||
if let Some(pending) = pending_model {
|
||||
pending.apply(&mut wanted, &s.task.config);
|
||||
}
|
||||
(options, wanted)
|
||||
};
|
||||
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,
|
||||
Some(o) if config::is_per_model_option(o) => 2,
|
||||
_ => 1,
|
||||
wanted.sort_by_key(|c| {
|
||||
if let Some(pending) = pending_model {
|
||||
if c == &pending.model {
|
||||
return 0;
|
||||
}
|
||||
if pending.choices.contains(c) {
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
match options.iter().find(|o| o.id == c.id) {
|
||||
Some(o) if o.category.as_deref() == Some("model") => 0,
|
||||
Some(o) if config::is_per_model_option(o) => 2,
|
||||
_ => 1,
|
||||
}
|
||||
});
|
||||
let mut model_options = known;
|
||||
for choice in &wanted {
|
||||
let pending = pending_model == Some(choice);
|
||||
let pending = pending_model.is_some_and(|p| &p.model == choice);
|
||||
let explicit = pending_model.is_some_and(|p| p.choices.contains(choice));
|
||||
if pending
|
||||
&& !options.iter().any(|o| {
|
||||
o.id == choice.id
|
||||
@@ -2833,6 +2982,19 @@ impl Task {
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
if explicit
|
||||
&& (!model_options
|
||||
|| !options.iter().any(|o| {
|
||||
o.id == choice.id
|
||||
&& config::is_per_model_option(o)
|
||||
&& o.values.iter().any(|v| v.value == choice.value)
|
||||
}))
|
||||
{
|
||||
return Err(SessionOpenError {
|
||||
message: format!("The selected model no longer offers {} value {}.", choice.id, choice.value),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
// An option the session doesn't offer yet is set once it does (`apply_late_choices`).
|
||||
let Some(o) = options.iter().find(|o| o.id == choice.id).cloned() else { continue };
|
||||
if o.id == config::CURSOR_APPROVAL {
|
||||
@@ -2844,7 +3006,7 @@ impl Task {
|
||||
if config::is_per_model_option(&o) && !model_options {
|
||||
continue;
|
||||
}
|
||||
let already = known && o.current.as_deref() == Some(choice.value.as_str());
|
||||
let already = (known || explicit) && o.current.as_deref() == Some(choice.value.as_str());
|
||||
if already || !o.values.iter().any(|v| v.value == choice.value) {
|
||||
continue;
|
||||
}
|
||||
@@ -2853,14 +3015,30 @@ impl Task {
|
||||
params["sessionId"] = json!(session_id);
|
||||
match peer.request::<_, Value>(method, params, None).await {
|
||||
Ok(reply) => {
|
||||
if pending && !config::accepts_model(&reply, &o.id, &choice.value) {
|
||||
let observed = client.take_opening_config();
|
||||
let report =
|
||||
if reply.get("configOptions").is_some() { &reply } else { observed.as_ref().unwrap_or(&reply) };
|
||||
if pending && !config::accepts_model(report, &o.id, &choice.value) {
|
||||
return Err(SessionOpenError {
|
||||
message: format!("The reloaded session did not switch to model {}.", choice.value),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
if let Some(fresh) = reply.get("configOptions") {
|
||||
if let Some(fresh) = report.get("configOptions") {
|
||||
config::merge_update(&mut options, fresh);
|
||||
if explicit
|
||||
&& !options.iter().any(|option| {
|
||||
option.id == choice.id && option.current.as_deref() == Some(choice.value.as_str())
|
||||
})
|
||||
{
|
||||
return Err(SessionOpenError {
|
||||
message: format!(
|
||||
"The selected model did not accept {} value {}.",
|
||||
choice.id, choice.value
|
||||
),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
model_options = true;
|
||||
} else if o.category.as_deref() == Some("model") {
|
||||
if o.current.as_deref() != Some(choice.value.as_str()) {
|
||||
@@ -2872,7 +3050,7 @@ impl Task {
|
||||
o.current = Some(choice.value.clone());
|
||||
}
|
||||
}
|
||||
Err(e) if pending => {
|
||||
Err(e) if pending || explicit => {
|
||||
return Err(SessionOpenError { message: self.describe(e), allow_acp_fallback: false });
|
||||
}
|
||||
Err(e) => tracing::warn!("agent task {}: setting {} to {} failed: {e}", self.id, o.id, choice.value),
|
||||
@@ -2882,6 +3060,16 @@ impl Task {
|
||||
self.shared.remember(provider_id, Some(&options), None, model.as_deref());
|
||||
{
|
||||
let mut s = self.state.lock();
|
||||
if let Some(pending) = pending_model {
|
||||
if s.pending_model.as_ref() != Some(pending) {
|
||||
return Err(SessionOpenError {
|
||||
message: "The pending model settings changed while reopening the session.".into(),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
let TaskState { task, wanted, .. } = &mut *s;
|
||||
pending.apply(wanted, &task.config);
|
||||
}
|
||||
s.task.model = model_of(&options).or(s.task.model.take());
|
||||
s.task.config = options;
|
||||
s.pending_model = None;
|
||||
@@ -2891,6 +3079,7 @@ impl Task {
|
||||
// The (re)started process runs nothing yet: whatever it reports next is all of it.
|
||||
s.background_tasks = Vec::new();
|
||||
s.task.background.clear();
|
||||
*client.opening_config.lock() = None;
|
||||
}
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
@@ -3017,6 +3206,17 @@ impl Task {
|
||||
return;
|
||||
}
|
||||
if kind == "session_info_update" {
|
||||
let depth = update.pointer("/_meta/hermes/sessionProvenance/compressionDepth").and_then(Value::as_u64);
|
||||
if let Some(depth) = depth.and_then(|d| u32::try_from(d).ok()) {
|
||||
let changed = {
|
||||
let mut s = self.state.lock();
|
||||
std::mem::replace(&mut s.task.stats.compressions, depth) != depth
|
||||
};
|
||||
if changed {
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
}
|
||||
}
|
||||
// The agent's own title for the session replaces the first line of the prompt,
|
||||
// unless the user named the task.
|
||||
let title = update.get("title").and_then(Value::as_str).map(str::trim).filter(|t| !t.is_empty());
|
||||
@@ -3358,6 +3558,28 @@ impl Task {
|
||||
/// Answers the agent's requests on behalf of one task.
|
||||
struct Client {
|
||||
task: Weak<Task>,
|
||||
opening_config: Mutex<Option<OpeningConfig>>,
|
||||
}
|
||||
|
||||
/// Config replays belong to the candidate connection until its model and settings are confirmed.
|
||||
struct OpeningConfig {
|
||||
session: String,
|
||||
options: Option<Value>,
|
||||
}
|
||||
|
||||
impl Client {
|
||||
fn new(task: &Arc<Task>, opening_session: Option<&str>) -> Arc<Self> {
|
||||
Arc::new(Self {
|
||||
task: Arc::downgrade(task),
|
||||
opening_config: Mutex::new(
|
||||
opening_session.map(|id| OpeningConfig { session: id.to_owned(), options: None }),
|
||||
),
|
||||
})
|
||||
}
|
||||
|
||||
fn take_opening_config(&self) -> Option<Value> {
|
||||
self.opening_config.lock().as_mut()?.options.take()
|
||||
}
|
||||
}
|
||||
|
||||
impl Handler for Client {
|
||||
@@ -3374,6 +3596,14 @@ impl Handler for Client {
|
||||
if method == "session/update"
|
||||
&& let (Some(task), Some(update)) = (self.task.upgrade(), params.get("update"))
|
||||
{
|
||||
if update.get("sessionUpdate").and_then(Value::as_str) == Some("config_option_update")
|
||||
&& let Some(opening) = self.opening_config.lock().as_mut()
|
||||
{
|
||||
if params.get("sessionId").and_then(Value::as_str) == Some(opening.session.as_str()) {
|
||||
opening.options = Some(update.clone());
|
||||
}
|
||||
return;
|
||||
}
|
||||
task.on_update(params.get("sessionId").and_then(Value::as_str), update);
|
||||
}
|
||||
}
|
||||
@@ -3838,7 +4068,7 @@ fn entry_event(
|
||||
entry: &AgentEntry,
|
||||
) -> AgentEvent {
|
||||
let text = match entry {
|
||||
AgentEntry::Agent { text } | AgentEntry::Thought { text } => Some(text),
|
||||
AgentEntry::Agent { text } | AgentEntry::Thought { text, .. } => Some(text),
|
||||
_ => None,
|
||||
};
|
||||
let Some(text) = text else {
|
||||
|
||||
@@ -108,6 +108,29 @@ pub struct AgentTask {
|
||||
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`), including `"openidea"`.
|
||||
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
||||
pub mcp_overrides: BTreeMap<String, bool>,
|
||||
/// Token counts of the last turn and context compressions, when the agent reports them.
|
||||
// Boxed so that `AgentEvent::Task` stays within clippy's `large_enum_variant` bound on Windows.
|
||||
#[serde(default)]
|
||||
pub stats: Box<AgentSessionStats>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentSessionStats {
|
||||
/// The last turn's tokens (`session/prompt` result `usage`).
|
||||
#[serde(default)]
|
||||
pub tokens: Option<AgentTokens>,
|
||||
/// How many times the agent compressed the conversation (Hermes `compressionDepth`).
|
||||
#[serde(default)]
|
||||
pub compressions: u32,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentTokens {
|
||||
pub input: u32,
|
||||
pub cached: u32,
|
||||
pub output: u32,
|
||||
}
|
||||
|
||||
/// A task the agent runs in the background while the conversation goes on.
|
||||
@@ -479,6 +502,9 @@ pub enum AgentEntry {
|
||||
},
|
||||
Thought {
|
||||
text: String,
|
||||
/// When the reasoning started (ms since the epoch); `None` in tasks saved before.
|
||||
#[serde(default)]
|
||||
started_ms: Option<f64>,
|
||||
},
|
||||
Tool {
|
||||
id: String,
|
||||
@@ -490,6 +516,11 @@ pub enum AgentEntry {
|
||||
/// Text the tool reported (command output…), truncated.
|
||||
output: Option<String>,
|
||||
diffs: Vec<AgentToolDiff>,
|
||||
/// When the call started and ended (ms since the epoch); `None` in tasks saved before.
|
||||
#[serde(default)]
|
||||
started_ms: Option<f64>,
|
||||
#[serde(default)]
|
||||
ended_ms: Option<f64>,
|
||||
},
|
||||
Plan {
|
||||
items: Vec<AgentPlanItem>,
|
||||
@@ -633,6 +664,10 @@ pub struct NewAgentTask {
|
||||
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
|
||||
#[serde(default)]
|
||||
pub mcp_overrides: BTreeMap<String, bool>,
|
||||
/// Creates the task without sending `prompt` (it only names the task): the composer's
|
||||
/// `!` command runs in it first.
|
||||
#[serde(default)]
|
||||
pub idle: bool,
|
||||
}
|
||||
|
||||
/// A file the task changed: against [`AgentTask::base_commit`], or against `HEAD` in the
|
||||
|
||||
@@ -82,6 +82,7 @@ const BUILTIN: &[(&str, &str, Driver, &[&str], &str)] = &[
|
||||
("kiro", "Kiro", Driver::Acp, &["kiro-cli", "acp"], "Run `kiro-cli login` in a terminal."),
|
||||
("vibe", "Mistral Vibe", Driver::Acp, &["vibe-acp"], "Run `vibe` in a terminal and sign in."),
|
||||
("omp", "OMP", Driver::Acp, &["omp", "acp"], "Run `omp` in a terminal and sign in."),
|
||||
("hermes", "Hermes Agent", Driver::Acp, &["hermes", "acp"], "Run `hermes model` in a terminal."),
|
||||
];
|
||||
|
||||
fn builtins() -> Vec<ProviderSpec> {
|
||||
@@ -503,7 +504,7 @@ fn validated_custom_id(id: &str) -> IdeResult<String> {
|
||||
}
|
||||
|
||||
/// Turns an `acp.json` server name into a file-stem id (`"My Agent!"` → `"my-agent"`).
|
||||
fn slugify_id(name: &str) -> String {
|
||||
pub(crate) fn slugify_id(name: &str) -> String {
|
||||
let mut id = String::with_capacity(name.len());
|
||||
for c in name.chars() {
|
||||
if c.is_ascii_alphanumeric() {
|
||||
@@ -716,6 +717,15 @@ mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn hermes_is_built_in_over_acp() {
|
||||
let spec = builtin_spec("hermes").unwrap();
|
||||
assert_eq!(spec.driver, Driver::Acp);
|
||||
let info = describe(&spec);
|
||||
assert_eq!((info.name.as_str(), info.command.as_str()), ("Hermes Agent", "hermes acp"));
|
||||
assert_eq!(info.login_hint.as_deref(), Some("Run `hermes model` in a terminal."));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn qoder_global_and_cn_editions_are_both_built_in() {
|
||||
let info = |id: &str| describe(&load(None, None).into_iter().find(|s| s.id == id).unwrap());
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
//! Claude Code's slash commands on disk, for completion before (or without) a session:
|
||||
//! skills (`.claude/skills/<dir>/SKILL.md`) and custom commands (`.claude/commands/**/*.md`)
|
||||
//! of the working directory and every directory above it, then the user's `~/.claude`.
|
||||
//! of the working directory and every directory above it, then the user's `~/.claude`; and
|
||||
//! the skills of a Hermes profile (`<profile>/skills`).
|
||||
|
||||
use crate::{AgentCommand, AgentCommandSource};
|
||||
use std::collections::HashSet;
|
||||
@@ -34,6 +35,19 @@ pub(crate) fn discover(cwd: &Path, home: Option<&Path>) -> Vec<AgentCommand> {
|
||||
out
|
||||
}
|
||||
|
||||
/// The skills of a Hermes profile: `<profile>/skills/<skill>` and `<profile>/skills/<category>/<skill>`;
|
||||
/// the first of a name wins.
|
||||
pub(crate) fn hermes(profile: &Path) -> Vec<AgentCommand> {
|
||||
let root = profile.join("skills");
|
||||
let mut found = skills(&root);
|
||||
for category in sorted(&root).into_iter().filter(|p| !p.join("SKILL.md").exists()) {
|
||||
found.extend(skills(&category));
|
||||
}
|
||||
let mut seen = HashSet::new();
|
||||
found.retain(|c| seen.insert(c.name.clone()));
|
||||
found
|
||||
}
|
||||
|
||||
/// `first` (the agent's own list) plus the commands of `more` it lacks.
|
||||
pub(crate) fn merge(first: Vec<AgentCommand>, more: Vec<AgentCommand>) -> Vec<AgentCommand> {
|
||||
let mut out = first;
|
||||
@@ -256,6 +270,24 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hermes_skills_flat_and_in_categories() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let profile = tmp.path();
|
||||
assert!(hermes(profile).is_empty());
|
||||
for dir in ["skills/plan", "skills/dev/review", "skills/dev/plan", "skills/empty"] {
|
||||
std::fs::create_dir_all(profile.join(dir)).unwrap();
|
||||
}
|
||||
for dir in ["skills/plan", "skills/dev/review", "skills/dev/plan"] {
|
||||
std::fs::write(profile.join(dir).join("SKILL.md"), "---\ndescription: d\n---\n").unwrap();
|
||||
}
|
||||
let names: Vec<_> = hermes(profile).into_iter().map(|c| (c.name, c.source)).collect();
|
||||
assert_eq!(
|
||||
names,
|
||||
[("plan".to_owned(), AgentCommandSource::Skill), ("review".to_owned(), AgentCommandSource::Skill)]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nothing_without_claude_dirs() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -909,6 +909,27 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
|
||||
mgr3.shutdown();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn hermes_profiles_complete_their_own_skills() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let skill = |dir: &str, name: &str| {
|
||||
let dir = tmp.path().join(dir).join(name);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
std::fs::write(dir.join("SKILL.md"), format!("---\nname: {name}\ndescription: d\n---\n")).unwrap();
|
||||
};
|
||||
skill(".hermes/skills", "plan");
|
||||
skill(".hermes/profiles/dom/skills/home", "lights");
|
||||
std::fs::write(tmp.path().join(".hermes/profiles/dom/config.yaml"), "").unwrap();
|
||||
let mgr = manager_at(tmp.path(), &tmp.path().join("models.json"), Arc::new(FakeAgent::default()));
|
||||
let names = |c: Vec<AgentCommand>| c.into_iter().map(|c| c.name).collect::<Vec<_>>();
|
||||
assert!(names(mgr.commands("hermes", None).await.unwrap()).contains(&"plan".to_owned()));
|
||||
let dom = names(mgr.commands("hermes-dom", None).await.unwrap());
|
||||
assert!(dom.contains(&"lights".to_owned()) && !dom.contains(&"plan".to_owned()));
|
||||
assert!(!names(mgr.commands("claude", None).await.unwrap()).contains(&"plan".to_owned()));
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -1420,6 +1441,32 @@ async fn shell_commands_show_in_the_conversation_and_go_with_the_next_message()
|
||||
assert_eq!(sent.pointer("/0/text").and_then(Value::as_str), Some("again"));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn an_idle_task_starts_no_turn_until_its_first_message() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("! echo first"),
|
||||
provider: "claude".into(),
|
||||
isolation: Isolation::Local,
|
||||
idle: true,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!((task.status, task.title.as_str()), (AgentStatus::Ready, "! echo first"));
|
||||
|
||||
mgr.run_shell(&task.id, "echo first", ide_core::CancellationToken::new()).await.unwrap();
|
||||
assert!(agent.prompts.lock().is_empty(), "an idle task starts no turn");
|
||||
mgr.prompt(&task.id, text("again"), false).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let sent = agent.prompts.lock().last().cloned().unwrap();
|
||||
assert!(sent.pointer("/0/text").and_then(Value::as_str).is_some_and(|t| t.contains("echo first")));
|
||||
assert_eq!(sent.pointer("/1/text").and_then(Value::as_str), Some("again"));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn send_now_interrupts_the_turn_when_steering_is_refused() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -1851,6 +1898,32 @@ async fn real_claude_task_in_a_worktree() {
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn hermes_session_info_names_the_task_and_counts_compressions() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
// "again" ends the turn at once; the default prompt waits for a permission answer.
|
||||
.create(NewAgentTask { prompt: text("again"), provider: "claude".into(), ..Default::default() })
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
let info = |title: &str, depth: u32| {
|
||||
json!({"sessionUpdate": "session_info_update", "title": title, "updatedAt": "2026-11-18T18:35:32.068362+00:00",
|
||||
"_meta": {"hermes": {"sessionProvenance": {"sessionKind": "root", "parentHermesSessionId": null,
|
||||
"compressionDepth": depth}}}})
|
||||
};
|
||||
handle.on_update(None, &info("Make a 3-step plan and carry it out: 1) list the…", 0));
|
||||
handle.on_update(None, &info("List files and edit notes.txt", 0));
|
||||
let t = handle.state.lock().task.clone();
|
||||
assert_eq!(t.title, "List files and edit notes.txt", "the agent's latest title wins");
|
||||
assert_eq!(t.stats.compressions, 0);
|
||||
handle.on_update(None, &info("List files and edit notes.txt", 2));
|
||||
assert_eq!(handle.state.lock().task.stats.compressions, 2);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn renamed_titles_survive_updates_forks_and_restart() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -1909,7 +1982,7 @@ async fn startup_warnings_survive_replay_and_restart_without_failing_the_task()
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
handle.replaying.store(true, Ordering::Release);
|
||||
handle.turn_started.store(false, Ordering::Release);
|
||||
let client = Client { task: Arc::downgrade(&handle) };
|
||||
let client = Client::new(&handle, None);
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({"message": "Project MCP config is disabled until trusted."}));
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({"message": " "}));
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({}));
|
||||
@@ -3505,11 +3578,13 @@ fn streamed_text_is_sent_as_appends() {
|
||||
);
|
||||
let replaced = entry_event("t", &mut streamed, None, 3, &agent("Other"));
|
||||
assert!(matches!(replaced, AgentEvent::Entry { .. }), "text that doesn't extend the sent text is sent whole");
|
||||
let thought = entry_event("t", &mut streamed, None, 4, &AgentEntry::Thought { text: "hmm…".into() });
|
||||
let thought = AgentEntry::Thought { text: "hmm…".into(), started_ms: None };
|
||||
let thought = entry_event("t", &mut streamed, None, 4, &thought);
|
||||
assert!(matches!(thought, AgentEvent::Entry { index: 4, .. }), "a new message starts whole");
|
||||
let tool = AgentEntry::Error { message: "x".into() };
|
||||
entry_event("t", &mut streamed, None, 4, &tool);
|
||||
let again = entry_event("t", &mut streamed, None, 4, &AgentEntry::Thought { text: "hmm… ok".into() });
|
||||
let again = AgentEntry::Thought { text: "hmm… ok".into(), started_ms: None };
|
||||
let again = entry_event("t", &mut streamed, None, 4, &again);
|
||||
assert!(matches!(again, AgentEvent::Entry { .. }), "an entry replaced by another kind forgets its text");
|
||||
|
||||
let long = "é".repeat(5000);
|
||||
@@ -4377,6 +4452,7 @@ async fn per_session_mcp_overrides_filter_session_and_reload_when_idle() {
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
mcp_overrides: BTreeMap::from([("slack".into(), false)]),
|
||||
idle: false,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -4504,6 +4580,7 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
idle: false,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -4528,6 +4605,7 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
idle: false,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
@@ -85,6 +85,8 @@ impl Timeline {
|
||||
locations: locations(update.get("locations")),
|
||||
output: None,
|
||||
diffs: Vec::new(),
|
||||
started_ms: Some(crate::now_ms()),
|
||||
ended_ms: None,
|
||||
};
|
||||
let index = match self.tools.get(&id) {
|
||||
Some(&i) => {
|
||||
@@ -134,17 +136,22 @@ impl Timeline {
|
||||
fn append_text(&mut self, thought: bool, text: &str) -> usize {
|
||||
match self.entries.last_mut() {
|
||||
Some(AgentEntry::Agent { text: t }) if !thought => t.push_str(text),
|
||||
Some(AgentEntry::Thought { text: t }) if thought => t.push_str(text),
|
||||
Some(AgentEntry::Thought { text: t, .. }) if thought => t.push_str(text),
|
||||
_ => {
|
||||
let text = text.to_owned();
|
||||
return self.push(if thought { AgentEntry::Thought { text } } else { AgentEntry::Agent { text } });
|
||||
return self.push(if thought {
|
||||
AgentEntry::Thought { text, started_ms: Some(crate::now_ms()) }
|
||||
} else {
|
||||
AgentEntry::Agent { text }
|
||||
});
|
||||
}
|
||||
}
|
||||
self.entries.len() - 1
|
||||
}
|
||||
|
||||
fn merge_tool(&mut self, index: usize, update: &Value) {
|
||||
let AgentEntry::Tool { title, kind, status, locations: locs, output, diffs, .. } = &mut self.entries[index]
|
||||
let AgentEntry::Tool { title, kind, status, locations: locs, output, diffs, ended_ms, .. } =
|
||||
&mut self.entries[index]
|
||||
else {
|
||||
return;
|
||||
};
|
||||
@@ -156,6 +163,9 @@ impl Timeline {
|
||||
}
|
||||
if let Some(s) = tool_status(update.get("status")) {
|
||||
*status = s;
|
||||
if matches!(s, AgentToolStatus::Completed | AgentToolStatus::Failed) && ended_ms.is_none() {
|
||||
*ended_ms = Some(crate::now_ms());
|
||||
}
|
||||
}
|
||||
if update.get("locations").is_some_and(Value::is_array) {
|
||||
*locs = locations(update.get("locations"));
|
||||
@@ -183,6 +193,11 @@ impl Timeline {
|
||||
}
|
||||
}
|
||||
if !text.is_empty() {
|
||||
// The command a call announced (`$ cmd`) stays above the result that replaces it.
|
||||
let command = output.as_deref().and_then(|o| o.lines().next()).filter(|l| l.starts_with("$ "));
|
||||
if let Some(command) = command.filter(|c| !text.starts_with(c)) {
|
||||
text = format!("{command}\n{text}");
|
||||
}
|
||||
*output = Some(tail(text));
|
||||
}
|
||||
if !new_diffs.is_empty() {
|
||||
@@ -432,11 +447,14 @@ mod tests {
|
||||
assert_eq!(t.apply(&chunk("lo")).changed, vec![0]);
|
||||
t.apply(&json!({"sessionUpdate": "agent_thought_chunk", "content": {"type": "text", "text": "hmm"}}));
|
||||
t.apply(&chunk("again"));
|
||||
// The thought's start is the clock's: it is there, and the rest compares exactly.
|
||||
let AgentEntry::Thought { started_ms, .. } = &mut t.entries[1] else { panic!("{:?}", t.entries) };
|
||||
assert!(started_ms.take().is_some());
|
||||
assert_eq!(
|
||||
t.entries,
|
||||
vec![
|
||||
AgentEntry::Agent { text: "Hello".into() },
|
||||
AgentEntry::Thought { text: "hmm".into() },
|
||||
AgentEntry::Thought { text: "hmm".into(), started_ms: None },
|
||||
AgentEntry::Agent { text: "again".into() },
|
||||
]
|
||||
);
|
||||
@@ -528,6 +546,25 @@ mod tests {
|
||||
assert!(matches!(t.entries[2], AgentEntry::User { done_ms: None, .. }));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_hermes_terminal_call_keeps_its_command_and_times() {
|
||||
let text = |t: &str| serde_json::json!([{"type": "content", "content": {"type": "text", "text": t}}]);
|
||||
let mut t = Timeline::default();
|
||||
t.apply(&serde_json::json!({"sessionUpdate": "tool_call", "toolCallId": "tc-0b98b5e30a28",
|
||||
"kind": "execute", "title": "terminal: echo ok + 2 commands", "locations": [],
|
||||
"content": text("$ echo ok >> notes.txt && wc -l notes.txt")}));
|
||||
let AgentEntry::Tool { started_ms, ended_ms, .. } = &t.entries[0] else { panic!() };
|
||||
assert!(started_ms.is_some() && ended_ms.is_none());
|
||||
t.apply(&serde_json::json!({"sessionUpdate": "tool_call_update", "toolCallId": "tc-0b98b5e30a28",
|
||||
"kind": "execute", "status": "completed",
|
||||
"content": text("terminal result\n- **output:** 3 notes.txt\n- **exit_code:** 0")}));
|
||||
let AgentEntry::Tool { output, status, ended_ms, .. } = &t.entries[0] else { panic!() };
|
||||
assert_eq!(*status, AgentToolStatus::Completed);
|
||||
assert!(ended_ms.is_some());
|
||||
let expected = "$ echo ok >> notes.txt && wc -l notes.txt\nterminal result\n- **output:** 3 notes.txt\n";
|
||||
assert_eq!(output.as_deref(), Some(format!("{expected}- **exit_code:** 0").as_str()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn long_output_keeps_its_tail() {
|
||||
let s = tail("é".repeat(MAX_OUTPUT));
|
||||
|
||||
@@ -236,10 +236,9 @@ fn classpath(
|
||||
}
|
||||
args.extend(["dependency:build-classpath", output_arg.as_str(), scope_arg.as_str(), "-q"]);
|
||||
let top_dir = subdir(root, &target.top.dir);
|
||||
let status = ProcCommand::new(&target.top.command)
|
||||
.args(&args)
|
||||
.envs(&target.top.env)
|
||||
.current_dir(&top_dir)
|
||||
let mut command = ProcCommand::new(&target.top.command);
|
||||
command.args(&args).envs(&target.top.env).current_dir(&top_dir);
|
||||
let status = ide_core::process::prepare(&mut command)
|
||||
.output()
|
||||
.map_err(|e| IdeError::internal(format!("cannot resolve the compile classpath: {e}")))?;
|
||||
if !status.status.success() {
|
||||
|
||||
@@ -25,7 +25,8 @@ pub use gradle_deps::{GradleDependency, GradleReport, gradle_dependencies, gradl
|
||||
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,
|
||||
SyncOptions, SyncProgress, maven_offline, maven_profiles, save_maven_offline, save_maven_profiles, sync_gradle,
|
||||
sync_gradle_model, sync_maven,
|
||||
};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
@@ -163,7 +163,13 @@ fn run_with_env_capture(
|
||||
let encoding =
|
||||
ide_core::output_encoding::fix(program, args, env, |k| std::env::var(k).ok(), "UTF-8", cfg!(windows));
|
||||
let program = program_path(program, env, cwd);
|
||||
let mut command = Command::new(&program);
|
||||
let mut command = if ide_core::process::needs_sh(&program) {
|
||||
let mut sh = Command::new("/bin/sh");
|
||||
sh.arg(&program);
|
||||
sh
|
||||
} else {
|
||||
Command::new(&program)
|
||||
};
|
||||
command.args(args).current_dir(cwd).envs(env).envs(encoding.env.iter().map(|(k, v)| (k, v))).stdin(Stdio::null());
|
||||
command.stdout(Stdio::piped()).stderr(Stdio::piped());
|
||||
// Its own group: `mvnw` / `gradlew` start the JVM as a child, and cancelling kills both.
|
||||
|
||||
@@ -86,15 +86,20 @@ const MAVEN_CACHE_VERSION: u32 = 1;
|
||||
|
||||
/// `dependency:tree` of a plugin version whose `-Dverbose` lists the occurrences Maven
|
||||
/// omitted (conflicts, duplicates): verbose output was dropped in 3.0 and is back since 3.2.
|
||||
/// Offline, the project's own plugin version is used instead, since this one may not be cached.
|
||||
/// Offline, it is used only when an earlier sync downloaded it; otherwise the project's own
|
||||
/// plugin version is, which may be cached instead.
|
||||
const DEPENDENCY_TREE: &str = "org.apache.maven.plugins:maven-dependency-plugin:3.8.1:tree";
|
||||
const DEPENDENCY_TREE_JAR: &str =
|
||||
"org/apache/maven/plugins/maven-dependency-plugin/3.8.1/maven-dependency-plugin-3.8.1.jar";
|
||||
|
||||
/// The goals that read the effective POM into `effective` and the verbose dependency trees.
|
||||
fn maven_sync_goals(effective: &Path, offline: bool) -> Vec<String> {
|
||||
/// The goals that read the effective POM into `effective` and the verbose dependency trees;
|
||||
/// `repo` is the local repository the build resolves from.
|
||||
fn maven_sync_goals(effective: &Path, offline: bool, repo: Option<&Path>) -> Vec<String> {
|
||||
let pinned = !offline || repo.is_some_and(|repo| repo.join(DEPENDENCY_TREE_JAR).is_file());
|
||||
vec![
|
||||
"help:effective-pom".into(),
|
||||
format!("-Doutput={}", effective.to_string_lossy()),
|
||||
if offline { "dependency:tree".into() } else { DEPENDENCY_TREE.into() },
|
||||
if pinned { DEPENDENCY_TREE.into() } else { "dependency:tree".into() },
|
||||
"-Dverbose".into(),
|
||||
]
|
||||
}
|
||||
@@ -118,6 +123,7 @@ fn sync_maven_options(options: &[String]) -> Vec<String> {
|
||||
}
|
||||
const GRADLE_CACHE: &str = "gradle.json";
|
||||
const MAVEN_PROFILES: &str = "maven-profiles.json";
|
||||
const MAVEN_OFFLINE: &str = "maven-offline.json";
|
||||
|
||||
/// The Maven profiles (`-P` entries, `!id` deactivates) the project was last synced
|
||||
/// with: what the IDE resolves it with besides `mvn` (the Java language server, Build Project).
|
||||
@@ -127,12 +133,31 @@ pub fn maven_profiles(cache_dir: &Path) -> Vec<String> {
|
||||
|
||||
/// Records the profiles of a sync for [`maven_profiles`]; `true` when they changed.
|
||||
pub fn save_maven_profiles(cache_dir: &Path, profiles: &[String]) -> IdeResult<bool> {
|
||||
if maven_profiles(cache_dir) == profiles {
|
||||
save_if_changed(cache_dir, MAVEN_PROFILES, &profiles.to_vec())
|
||||
}
|
||||
|
||||
/// Whether the project was last synced offline (`-o`): the Java language server then
|
||||
/// resolves it offline too.
|
||||
pub fn maven_offline(cache_dir: &Path) -> bool {
|
||||
read_cache(cache_dir, MAVEN_OFFLINE).unwrap_or(false)
|
||||
}
|
||||
|
||||
/// Records the offline mode of a sync for [`maven_offline`]; `true` when it changed.
|
||||
pub fn save_maven_offline(cache_dir: &Path, offline: bool) -> IdeResult<bool> {
|
||||
save_if_changed(cache_dir, MAVEN_OFFLINE, &offline)
|
||||
}
|
||||
|
||||
fn save_if_changed<T: Serialize + DeserializeOwned + PartialEq + Default>(
|
||||
dir: &Path,
|
||||
name: &str,
|
||||
value: &T,
|
||||
) -> IdeResult<bool> {
|
||||
if read_cache::<T>(dir, name).unwrap_or_default() == *value {
|
||||
return Ok(false);
|
||||
}
|
||||
std::fs::create_dir_all(cache_dir)?;
|
||||
let json = serde_json::to_vec(profiles).map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
std::fs::write(cache_dir.join(MAVEN_PROFILES), json)?;
|
||||
std::fs::create_dir_all(dir)?;
|
||||
let json = serde_json::to_vec(value).map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
std::fs::write(dir.join(name), json)?;
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
@@ -382,7 +407,8 @@ pub fn sync_maven(
|
||||
if !options.profiles.is_empty() {
|
||||
args.push(format!("-P{}", options.profiles.join(",")));
|
||||
}
|
||||
args.extend(maven_sync_goals(&effective, options.offline));
|
||||
let repo = local_repo.clone().or_else(maven::default_local_repo);
|
||||
args.extend(maven_sync_goals(&effective, options.offline, repo.as_deref()));
|
||||
progress(SyncProgress { message: format!("Reading {}", top.display_name), fraction: None });
|
||||
let command = options.maven_command.as_deref().unwrap_or(&top.command);
|
||||
let out = run(command, &args, &root.join(&top.dir), &options.env, cancel, |line| {
|
||||
@@ -532,14 +558,18 @@ mod tests {
|
||||
assert!(loaded.gradle[0].sync_error.as_deref().unwrap().contains("cannot start"));
|
||||
assert!(loaded.gradle[1].sync_error.is_none());
|
||||
assert_eq!(loaded.gradle[1].projects[0].tasks[0].name, "healthy");
|
||||
let bad_wrapper = root.join("a/gradlew");
|
||||
std::fs::write(&bad_wrapper, "#!/bin/sh\nexit 0\n").unwrap();
|
||||
std::fs::set_permissions(&bad_wrapper, std::fs::Permissions::from_mode(0o644)).unwrap();
|
||||
models[0].command = bad_wrapper.to_string_lossy().into_owned();
|
||||
// A wrapper without the execute bit (committed from Windows, unpacked from a zip)
|
||||
// runs through `sh`, and its mode is left alone.
|
||||
let plain_wrapper = root.join("a/gradlew");
|
||||
std::fs::write(&plain_wrapper, "#!/bin/sh\nprintf '%s\\n' 'Build tasks' '-----------' 'plain - ok'\n").unwrap();
|
||||
std::fs::set_permissions(&plain_wrapper, std::fs::Permissions::from_mode(0o644)).unwrap();
|
||||
models[0].command = plain_wrapper.to_string_lossy().into_owned();
|
||||
run(&models[0]).unwrap();
|
||||
let loaded = crate::load_linked(root, &cache, None, &Default::default(), &settings);
|
||||
assert!(loaded.gradle[0].sync_error.as_deref().unwrap().contains("cannot start"));
|
||||
assert!(loaded.gradle[0].sync_error.is_none());
|
||||
assert_eq!(loaded.gradle[0].projects[0].tasks[0].name, "plain");
|
||||
assert!(loaded.gradle[1].sync_error.is_none());
|
||||
assert_eq!(std::fs::metadata(&plain_wrapper).unwrap().permissions().mode() & 0o777, 0o644);
|
||||
let blocked_cache = root.join("blocked-cache");
|
||||
std::fs::write(&blocked_cache, "a file cannot contain sync caches").unwrap();
|
||||
assert!(
|
||||
@@ -908,12 +938,31 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sync_reads_verbose_trees_with_a_pinned_plugin_unless_offline() {
|
||||
let online = maven_sync_goals(Path::new("e.xml"), false);
|
||||
fn the_offline_mode_of_the_last_sync_is_kept_for_the_language_server() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let cache = tmp.path().join("cache");
|
||||
assert!(!maven_offline(&cache), "never synced: online");
|
||||
assert!(save_maven_offline(&cache, true).unwrap());
|
||||
assert!(maven_offline(&cache));
|
||||
assert!(!save_maven_offline(&cache, true).unwrap(), "unchanged");
|
||||
assert!(save_maven_offline(&cache, false).unwrap());
|
||||
assert!(!maven_offline(&cache));
|
||||
assert!(!save_maven_offline(&tmp.path().join("other"), false).unwrap(), "online is the default");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sync_reads_verbose_trees_with_a_pinned_plugin_unless_offline_without_it() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let online = maven_sync_goals(Path::new("e.xml"), false, None);
|
||||
assert_eq!(online, ["help:effective-pom", "-Doutput=e.xml", DEPENDENCY_TREE, "-Dverbose"]);
|
||||
let offline = maven_sync_goals(Path::new("e.xml"), true);
|
||||
let offline = maven_sync_goals(Path::new("e.xml"), true, Some(tmp.path()));
|
||||
assert_eq!(offline[2], "dependency:tree");
|
||||
assert!(offline.contains(&"-Dverbose".to_owned()));
|
||||
// Downloaded by an online sync: offline keeps using it, the project's version may be missing.
|
||||
let jar = tmp.path().join(DEPENDENCY_TREE_JAR);
|
||||
std::fs::create_dir_all(jar.parent().unwrap()).unwrap();
|
||||
std::fs::write(&jar, "").unwrap();
|
||||
assert_eq!(maven_sync_goals(Path::new("e.xml"), true, Some(tmp.path()))[2], DEPENDENCY_TREE);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -965,6 +1014,28 @@ mod tests {
|
||||
assert!(sync_maven_options(&[]).is_empty());
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn maven_sync_runs_a_wrapper_without_the_execute_bit() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().join("p");
|
||||
std::fs::create_dir_all(&root).unwrap();
|
||||
std::fs::write(root.join("pom.xml"), "<project><groupId>g</groupId><artifactId>a</artifactId></project>")
|
||||
.unwrap();
|
||||
let mvnw = root.join("mvnw");
|
||||
std::fs::write(&mvnw, "#!/bin/sh\nprintf '%s\\n' \"$@\" > mvnw-args\n").unwrap();
|
||||
std::fs::set_permissions(&mvnw, std::fs::Permissions::from_mode(0o644)).unwrap();
|
||||
let cache = tmp.path().join("cache");
|
||||
sync_maven(&root, &cache, &SyncOptions::default(), &CancellationToken::new(), &|_| {}).unwrap();
|
||||
let args = std::fs::read_to_string(root.join("mvnw-args")).unwrap();
|
||||
assert!(args.contains("help:effective-pom"), "args: {args}");
|
||||
let loaded = crate::load_linked(&root, &cache, None, &Default::default(), &Default::default());
|
||||
let maven = loaded.maven.unwrap();
|
||||
assert!(maven.synced_at.is_some() && maven.sync_error.is_none(), "{:?}", maven.sync_error);
|
||||
assert_eq!(std::fs::metadata(&mvnw).unwrap().permissions().mode() & 0o777, 0o644);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn maven_sync_runs_the_daemon_command_serially() {
|
||||
|
||||
@@ -36,6 +36,8 @@ pub enum IdeEvent {
|
||||
},
|
||||
/// Project window membership or selection changed.
|
||||
WindowGroupsChanged,
|
||||
/// A project was loaded or unloaded for the MCP server without a window of its own.
|
||||
McpBackgroundProjectsChanged,
|
||||
/// A window entered or left full screen, itself or as a member of a full-screen window group.
|
||||
WindowFullscreenChanged,
|
||||
/// This remote window's connection to its host ended on its own (network loss, the host or
|
||||
@@ -87,6 +89,8 @@ pub enum IdeEvent {
|
||||
DocDirty {
|
||||
doc: DocId,
|
||||
dirty: bool,
|
||||
/// Text version when this transition occurred, including when it was saved.
|
||||
version: u32,
|
||||
},
|
||||
/// A complete workspace edit can be undone as one operation.
|
||||
WorkspaceEditApplied {
|
||||
@@ -312,6 +316,8 @@ pub enum LspRefreshKind {
|
||||
InlayHints,
|
||||
SemanticTokens,
|
||||
CodeLens,
|
||||
/// The Dart server published a document's Flutter outline.
|
||||
FlutterOutline,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
@@ -370,6 +376,18 @@ pub enum DebugEvent {
|
||||
/// `flutter debug_adapter`'s `flutter.appStarted` event (launch and attach): the session is
|
||||
/// a Flutter app that can take a hot reload now. The plain Dart adapter never sends it.
|
||||
FlutterAppStarted,
|
||||
/// The VM Service of a Flutter session's app, which DevTools connects to.
|
||||
FlutterVmService {
|
||||
uri: String,
|
||||
/// The Flutter device the app runs on.
|
||||
device: Option<String>,
|
||||
},
|
||||
/// Flutter's inspector selected a widget: its source, 0-based.
|
||||
FlutterNavigate {
|
||||
path: crate::IpcPath,
|
||||
line: u32,
|
||||
column: u32,
|
||||
},
|
||||
/// The session's capabilities changed after it started: fetch them again.
|
||||
Capabilities,
|
||||
/// The adapter's `invalidated` event: what it shows for `areas` (`all`, `stacks`, `threads`,
|
||||
|
||||
@@ -807,6 +807,27 @@ pub fn find_executable_in(
|
||||
.find_map(|dir| names.iter().map(|n| dir.join(n)).find(|p| p.is_file()))
|
||||
}
|
||||
|
||||
/// Whether `program` is a script to start as `/bin/sh <program>`: on Unix, a `#!` script
|
||||
/// without the execute bit — a `mvnw` / `gradlew` committed from Windows or unpacked from a
|
||||
/// zip — which `exec` refuses with `EACCES`. The file's mode is left alone, as other IDEs do.
|
||||
pub fn needs_sh(program: &std::path::Path) -> bool {
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use std::io::Read;
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let mut magic = [0u8; 2];
|
||||
program.is_absolute()
|
||||
&& std::fs::metadata(program).is_ok_and(|m| m.is_file() && m.permissions().mode() & 0o111 == 0)
|
||||
&& std::fs::File::open(program).and_then(|mut f| f.read_exact(&mut magic)).is_ok()
|
||||
&& &magic == b"#!"
|
||||
}
|
||||
#[cfg(not(unix))]
|
||||
{
|
||||
let _ = program;
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
/// [`find_executable_in`] for this platform (`PATHEXT` from the environment).
|
||||
pub fn find_executable(name: &str, search: &OsStr) -> Option<std::path::PathBuf> {
|
||||
let pathext = host_var_os("PATHEXT");
|
||||
|
||||
@@ -34,6 +34,8 @@ pub struct Settings {
|
||||
pub project_structure: ProjectStructureSettings,
|
||||
/// Version Control (Git, Commit, Confirmation, Issue Navigation).
|
||||
pub vcs: VcsSettings,
|
||||
/// Build, Execution, Deployment › Compiler (Build tool window).
|
||||
pub build: BuildSettings,
|
||||
/// Build, Execution, Deployment › Console.
|
||||
pub console: ConsoleSettings,
|
||||
pub debugger: DebuggerSettings,
|
||||
@@ -317,6 +319,20 @@ pub enum NewTaskApprovals {
|
||||
Ask,
|
||||
}
|
||||
|
||||
/// Which folders without an open window the MCP server still serves tools for.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum McpBackgroundProjects {
|
||||
/// Only projects open in a window.
|
||||
#[default]
|
||||
Off,
|
||||
/// Also folders the user trusts: trusted projects, recent projects and the repositories inside
|
||||
/// trusted locations.
|
||||
Trusted,
|
||||
/// Only the folders in [`McpServerSettings::background_project_paths`] (and below them).
|
||||
Listed,
|
||||
}
|
||||
|
||||
/// Agents › MCP Server: agents use the IDE's built-in tools.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
@@ -341,6 +357,21 @@ pub struct McpServerSettings {
|
||||
/// Keep the bearer token across runs (in the app data, readable by this user only) rather than
|
||||
/// make a new one each run.
|
||||
pub fixed_token: bool,
|
||||
/// Serve tools for folders that have no open window (see [`McpBackgroundProjects`]); the
|
||||
/// project loads when an agent first asks for it.
|
||||
#[serde(deserialize_with = "or_default")]
|
||||
#[specta(type = McpBackgroundProjects)]
|
||||
pub background_projects: McpBackgroundProjects,
|
||||
/// The folders [`McpBackgroundProjects::Listed`] serves, and the ones `Trusted` serves even
|
||||
/// when untrusted.
|
||||
#[serde(deserialize_with = "or_default")]
|
||||
#[specta(type = Vec<String>)]
|
||||
pub background_project_paths: Vec<String>,
|
||||
/// Minutes a background project may go without a tool call before it is unloaded, at most
|
||||
/// 1440; 0 keeps it until the IDE quits.
|
||||
pub background_idle_minutes: u32,
|
||||
/// Background projects loaded at once, 1 to 32; the least recently used one makes room.
|
||||
pub background_project_limit: u32,
|
||||
}
|
||||
|
||||
/// The default of [`McpServerSettings::port`].
|
||||
@@ -359,6 +390,10 @@ impl Default for McpServerSettings {
|
||||
fixed_port: true,
|
||||
port: DEFAULT_MCP_PORT,
|
||||
fixed_token: false,
|
||||
background_projects: McpBackgroundProjects::Off,
|
||||
background_project_paths: Vec::new(),
|
||||
background_idle_minutes: 30,
|
||||
background_project_limit: 8,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -508,6 +543,7 @@ impl Default for Settings {
|
||||
languages: LanguagesSettings::default(),
|
||||
project_structure: ProjectStructureSettings::default(),
|
||||
vcs: VcsSettings::default(),
|
||||
build: BuildSettings::default(),
|
||||
console: ConsoleSettings::default(),
|
||||
debugger: DebuggerSettings::default(),
|
||||
run: RunSettings::default(),
|
||||
@@ -1194,11 +1230,31 @@ pub struct ArduinoSettings {
|
||||
}
|
||||
|
||||
/// Languages & Frameworks › Markdown. Like IDEA's, it is application-level only.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct MarkdownSettings {
|
||||
/// Preview (and notebook Markdown cell) font size in px; unset follows the editor font size.
|
||||
pub preview_font_size: Option<u32>,
|
||||
/// "Detect commands that can be run right from Markdown files": gutter run icons on
|
||||
/// shell code blocks and on command lines in code blocks.
|
||||
pub run_commands: bool,
|
||||
/// Where those commands run; unset asks when the project and the file's folder differ.
|
||||
pub command_directory: Option<MarkdownCommandDirectory>,
|
||||
}
|
||||
|
||||
impl Default for MarkdownSettings {
|
||||
fn default() -> Self {
|
||||
Self { preview_font_size: None, run_commands: true, command_directory: None }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
pub enum MarkdownCommandDirectory {
|
||||
/// The project's root folder.
|
||||
Project,
|
||||
/// The Markdown file's parent folder.
|
||||
File,
|
||||
}
|
||||
|
||||
impl LanguagesSettings {
|
||||
@@ -1535,6 +1591,9 @@ pub struct MavenSettings {
|
||||
/// project (jdtls `java.maven.downloadSources`). Off: sources are fetched on demand
|
||||
/// from a library class's Download Sources banner.
|
||||
pub download_sources: bool,
|
||||
/// Always update snapshots (`-U`): Maven checks remote repositories for newer SNAPSHOT
|
||||
/// dependencies on every sync, build and run, and jdtls on import (`java.maven.updateSnapshots`).
|
||||
pub update_snapshots: bool,
|
||||
}
|
||||
|
||||
impl MavenSettings {
|
||||
@@ -2114,6 +2173,63 @@ mod tests {
|
||||
let restored: Settings = serde_json::from_value(value).unwrap();
|
||||
assert_eq!(restored, settings);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn background_projects_default_to_off_with_no_paths_30_idle_minutes_and_a_limit_of_8() {
|
||||
for settings in [Settings::default(), serde_json::from_str(r#"{"mcpServer":{"enabled":true}}"#).unwrap()] {
|
||||
let mcp = settings.mcp_server;
|
||||
assert_eq!(mcp.background_projects, McpBackgroundProjects::Off);
|
||||
assert!(mcp.background_project_paths.is_empty());
|
||||
assert_eq!((mcp.background_idle_minutes, mcp.background_project_limit), (30, 8));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_bad_background_mode_or_path_list_reads_as_its_default_and_keeps_the_rest() {
|
||||
for (key, bad) in
|
||||
[("backgroundProjects", serde_json::json!("bogus")), ("backgroundProjectPaths", serde_json::json!(5))]
|
||||
{
|
||||
let mut json = serde_json::json!({
|
||||
"appearance": { "theme": "solarized-dark" },
|
||||
"mcpServer": {
|
||||
"enabled": true,
|
||||
"port": 7000,
|
||||
"backgroundProjects": "listed",
|
||||
"backgroundProjectPaths": ["/projects/inventory"],
|
||||
"backgroundIdleMinutes": 10,
|
||||
"backgroundProjectLimit": 3,
|
||||
},
|
||||
});
|
||||
json["mcpServer"][key] = bad;
|
||||
let settings: Settings = serde_json::from_value(json).unwrap_or_else(|e| panic!("{key}: {e}"));
|
||||
let mcp = settings.mcp_server;
|
||||
let (mode, paths) = if key == "backgroundProjects" {
|
||||
(McpBackgroundProjects::Off, vec!["/projects/inventory".to_owned()])
|
||||
} else {
|
||||
(McpBackgroundProjects::Listed, Vec::new())
|
||||
};
|
||||
assert_eq!((mcp.background_projects, mcp.background_project_paths), (mode, paths), "{key}");
|
||||
assert_eq!((mcp.enabled, mcp.port), (true, 7000), "{key}");
|
||||
assert_eq!((mcp.background_idle_minutes, mcp.background_project_limit), (10, 3), "{key}");
|
||||
assert_eq!(settings.appearance.theme, "solarized-dark", "{key}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn background_project_settings_round_trip() {
|
||||
for mode in [McpBackgroundProjects::Off, McpBackgroundProjects::Trusted, McpBackgroundProjects::Listed] {
|
||||
let mut settings = Settings::default();
|
||||
settings.mcp_server.background_projects = mode;
|
||||
settings.mcp_server.background_project_paths =
|
||||
vec!["/projects/inventory".into(), "/projects/billing".into()];
|
||||
settings.mcp_server.background_idle_minutes = 0;
|
||||
settings.mcp_server.background_project_limit = 32;
|
||||
let json = serde_json::to_string(&settings).unwrap();
|
||||
assert!(json.contains(r#""backgroundProjects":""#), "{json}");
|
||||
let restored: Settings = serde_json::from_str(&json).unwrap();
|
||||
assert_eq!(restored.mcp_server, settings.mcp_server);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -239,6 +239,8 @@ pub enum SymbolKind {
|
||||
Event,
|
||||
Operator,
|
||||
Key,
|
||||
/// A Flutter widget built in the code (Flutter outline only).
|
||||
Widget,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
|
||||
@@ -170,6 +170,12 @@ pub struct CommitSettings {
|
||||
pub double_click_opens_diff: Option<bool>,
|
||||
/// Team conventions for Generate Commit Message with Agent, added to its prompt.
|
||||
pub agent_instructions: String,
|
||||
/// The coding agent Generate Commit Message with Agent uses; empty follows the latest task's agent.
|
||||
pub agent: String,
|
||||
/// That agent's model for commit messages; empty keeps the model the agent would use.
|
||||
pub agent_model: String,
|
||||
/// That model's thinking level for commit messages; empty keeps the agent's.
|
||||
pub agent_effort: String,
|
||||
}
|
||||
|
||||
impl Default for CommitSettings {
|
||||
@@ -192,6 +198,9 @@ impl Default for CommitSettings {
|
||||
disabled_plugin_checks: Vec::new(),
|
||||
double_click_opens_diff: None,
|
||||
agent_instructions: String::new(),
|
||||
agent: String::new(),
|
||||
agent_model: String::new(),
|
||||
agent_effort: String::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -308,6 +317,23 @@ pub struct SqlResolutionScope {
|
||||
pub schema: String,
|
||||
}
|
||||
|
||||
/// Build, Execution, Deployment › Compiler (Build tool window behaviour).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct BuildSettings {
|
||||
/// When to open the Build tool window: `always` | `onError` | `never`.
|
||||
pub open_tool_window: String,
|
||||
/// When to focus the Build tool window: `always` | `onError` | `never`.
|
||||
pub focus_tool_window: String,
|
||||
}
|
||||
|
||||
impl Default for BuildSettings {
|
||||
fn default() -> Self {
|
||||
// Builds open the tool window without taking focus.
|
||||
Self { open_tool_window: "always".into(), focus_tool_window: "never".into() }
|
||||
}
|
||||
}
|
||||
|
||||
/// Build, Execution, Deployment › Console.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
@@ -448,6 +474,9 @@ pub struct TerminalSettings {
|
||||
/// Shell command line; empty = the login shell.
|
||||
pub shell_path: String,
|
||||
pub tab_name: String,
|
||||
/// Title a program sets (OSC 0/2) as the tab's name: `running` (while a command runs),
|
||||
/// `always`, or `off`.
|
||||
pub app_title_as_tab_name: String,
|
||||
pub audible_bell: bool,
|
||||
pub close_on_exit: bool,
|
||||
pub mouse_reporting: bool,
|
||||
@@ -483,6 +512,7 @@ impl Default for TerminalSettings {
|
||||
env: BTreeMap::new(),
|
||||
shell_path: String::new(),
|
||||
tab_name: "Local".into(),
|
||||
app_title_as_tab_name: "running".into(),
|
||||
audible_bell: true,
|
||||
close_on_exit: true,
|
||||
mouse_reporting: true,
|
||||
|
||||
@@ -68,10 +68,16 @@ pub enum Incoming {
|
||||
Closed,
|
||||
}
|
||||
|
||||
/// Bounded outgoing queue: an adapter that stops reading its input holds back `send`
|
||||
/// instead of the IDE accumulating unbounded messages. The incoming queue stays unbounded:
|
||||
/// the event loop awaits requests while handling events (`stopped` restores breakpoints), so
|
||||
/// a reader parked on a full queue would never read the response that loop waits for.
|
||||
const OUT_CAPACITY: usize = 256;
|
||||
|
||||
type Pending = HashMap<i64, (String, oneshot::Sender<Result<Value, DapError>>)>;
|
||||
|
||||
struct Inner {
|
||||
out: mpsc::UnboundedSender<Vec<u8>>,
|
||||
out: mpsc::Sender<Vec<u8>>,
|
||||
pending: Mutex<Pending>,
|
||||
seq: AtomicI64,
|
||||
closed: AtomicBool,
|
||||
@@ -114,7 +120,7 @@ impl Connection {
|
||||
R: AsyncRead + Unpin + Send + 'static,
|
||||
W: AsyncWrite + Unpin + Send + 'static,
|
||||
{
|
||||
let (out_tx, mut out_rx) = mpsc::unbounded_channel::<Vec<u8>>();
|
||||
let (out_tx, mut out_rx) = mpsc::channel::<Vec<u8>>(OUT_CAPACITY);
|
||||
let (in_tx, in_rx) = mpsc::unbounded_channel();
|
||||
let inner = Arc::new(Inner {
|
||||
out: out_tx,
|
||||
@@ -183,17 +189,17 @@ impl Connection {
|
||||
self.inner.closed.load(Ordering::Acquire)
|
||||
}
|
||||
|
||||
fn send(&self, value: &Value) -> Result<(), DapError> {
|
||||
async fn send(&self, value: &Value) -> Result<(), DapError> {
|
||||
if self.is_closed() {
|
||||
return Err(DapError::Closed);
|
||||
}
|
||||
let body = serde_json::to_vec(value).map_err(|e| DapError::Protocol(e.to_string()))?;
|
||||
tracing::trace!(target: "ide_dap::wire", "--> {}", String::from_utf8_lossy(&body));
|
||||
self.inner.out.send(body).map_err(|_| DapError::Closed)
|
||||
self.inner.out.send(body).await.map_err(|_| DapError::Closed)
|
||||
}
|
||||
|
||||
/// Sends a request and returns a receiver for its response body, without waiting.
|
||||
pub fn send_request(
|
||||
pub async fn send_request(
|
||||
&self,
|
||||
command: &str,
|
||||
arguments: Value,
|
||||
@@ -205,7 +211,7 @@ impl Connection {
|
||||
if !arguments.is_null() {
|
||||
msg["arguments"] = arguments;
|
||||
}
|
||||
if let Err(e) = self.send(&msg) {
|
||||
if let Err(e) = self.send(&msg).await {
|
||||
self.inner.pending.lock().remove(&seq);
|
||||
return Err(e);
|
||||
}
|
||||
@@ -214,7 +220,7 @@ impl Connection {
|
||||
|
||||
/// Sends a request and waits for the response body (`null` when absent).
|
||||
pub async fn request(&self, command: &str, arguments: Value) -> Result<Value, DapError> {
|
||||
let rx = self.send_request(command, arguments)?;
|
||||
let rx = self.send_request(command, arguments).await?;
|
||||
rx.await.unwrap_or(Err(DapError::Closed))
|
||||
}
|
||||
|
||||
@@ -226,7 +232,12 @@ impl Connection {
|
||||
}
|
||||
|
||||
/// Answers a reverse request.
|
||||
pub fn respond(&self, request_seq: i64, command: &str, result: Result<Value, String>) -> Result<(), DapError> {
|
||||
pub async fn respond(
|
||||
&self,
|
||||
request_seq: i64,
|
||||
command: &str,
|
||||
result: Result<Value, String>,
|
||||
) -> Result<(), DapError> {
|
||||
let seq = self.inner.seq.fetch_add(1, Ordering::Relaxed);
|
||||
let mut msg = json!({
|
||||
"seq": seq,
|
||||
@@ -240,7 +251,7 @@ impl Connection {
|
||||
Ok(_) => {}
|
||||
Err(message) => msg["message"] = Value::String(message),
|
||||
}
|
||||
self.send(&msg)
|
||||
self.send(&msg).await
|
||||
}
|
||||
}
|
||||
|
||||
@@ -319,6 +330,62 @@ fn error_message(msg: &Value) -> String {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_handler_awaiting_a_request_still_gets_its_response_behind_an_event_burst() {
|
||||
// The event loop handles `stopped` by sending `setBreakpoints` and awaiting the reply
|
||||
// while the adapter keeps printing: the reply arrives behind thousands of events.
|
||||
let (client_in, mut adapter_out) = tokio::io::duplex(64 * 1024);
|
||||
let (client_out, adapter_in) = tokio::io::duplex(64 * 1024);
|
||||
let (conn, mut incoming) = Connection::start(client_in, client_out);
|
||||
let adapter = tokio::spawn(async move {
|
||||
let event =
|
||||
|seq: i64, event: &str| json!({"seq": seq, "type": "event", "event": event, "body": {"output": "x"}});
|
||||
framing::write_message(&mut adapter_out, event(0, "stopped").to_string().as_bytes()).await.unwrap();
|
||||
for i in 1..=5000 {
|
||||
framing::write_message(&mut adapter_out, event(i, "output").to_string().as_bytes()).await.unwrap();
|
||||
}
|
||||
let mut requests = BufReader::new(adapter_in);
|
||||
let request = framing::read_message(&mut requests).await.unwrap().unwrap();
|
||||
let request: Value = serde_json::from_slice(&request).unwrap();
|
||||
let response = json!({"seq": 5001, "type": "response", "request_seq": request["seq"], "success": true, "command": request["command"], "body": {"breakpoints": []}});
|
||||
framing::write_message(&mut adapter_out, response.to_string().as_bytes()).await.unwrap();
|
||||
adapter_out
|
||||
});
|
||||
let Some(Incoming::Event { event, .. }) = incoming.recv().await else { panic!("no event") };
|
||||
assert_eq!(event, "stopped");
|
||||
let reply = tokio::time::timeout(Duration::from_secs(10), conn.request("setBreakpoints", json!({})))
|
||||
.await
|
||||
.expect("the reader stalled behind the events")
|
||||
.unwrap();
|
||||
assert_eq!(reply, json!({"breakpoints": []}));
|
||||
let _ = adapter.await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn outgoing_commands_are_backpressured_when_the_adapter_is_slow() {
|
||||
let (writer, _unread_peer) = tokio::io::duplex(32 * 1024);
|
||||
let (reader, _idle_peer) = tokio::io::duplex(32 * 1024);
|
||||
// Nobody reads the writer's pipe, so it fills and the writer task stalls.
|
||||
let (conn, _incoming) = Connection::start(reader, writer);
|
||||
let producer_conn = conn.clone();
|
||||
let sent = Arc::new(std::sync::atomic::AtomicUsize::new(0));
|
||||
let count = sent.clone();
|
||||
let producer = tokio::spawn(async move {
|
||||
for i in 0..2000 {
|
||||
let body = json!({"seq": i, "type": "event", "event": "output", "body": {"output": "x"}});
|
||||
if producer_conn.send(&body).await.is_err() {
|
||||
break;
|
||||
}
|
||||
count.fetch_add(1, Ordering::Relaxed);
|
||||
}
|
||||
});
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
assert!(sent.load(Ordering::Relaxed) < 2000);
|
||||
// The bounded queue held `send` back; closing cancels the writer task.
|
||||
conn.close();
|
||||
producer.abort();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_output_events_with_non_utf8_text() {
|
||||
// "中文" in GBK inside an output event, as netcoredbg sends it on a Chinese Windows.
|
||||
|
||||
@@ -420,6 +420,22 @@ fn add_flutter_device(arguments: &mut Value, device: Value) {
|
||||
}
|
||||
}
|
||||
|
||||
/// The source a `navigate` tool event points at (1-based there). A `package:` location comes
|
||||
/// with the file the adapter resolved it to.
|
||||
fn flutter_navigation(body: &Value) -> Option<ide_core::event::DebugEvent> {
|
||||
if body.get("kind")?.as_str()? != "navigate" {
|
||||
return None;
|
||||
}
|
||||
let data = body.get("data")?;
|
||||
let uri = data.get("resolvedFileUri").or_else(|| data.get("fileUri"))?.as_str()?;
|
||||
let position = |key| data.get(key)?.as_u64().map(|n| n.saturating_sub(1) as u32);
|
||||
Some(ide_core::event::DebugEvent::FlutterNavigate {
|
||||
path: kotlin_lsp::source_path(uri)?.into(),
|
||||
line: position("line")?,
|
||||
column: position("column").unwrap_or(0),
|
||||
})
|
||||
}
|
||||
|
||||
fn no_session(s: DebugSessionId) -> IdeError {
|
||||
IdeError::not_found(format!("no debug session {}", s.0))
|
||||
}
|
||||
@@ -1128,7 +1144,7 @@ impl DebugManager {
|
||||
let mut launch = if launch_in_config {
|
||||
None
|
||||
} else {
|
||||
let reply = s.conn.send_request(request, arguments.clone())?;
|
||||
let reply = s.conn.send_request(request, arguments.clone()).await?;
|
||||
Some(Box::pin(async move { reply.await.unwrap_or(Err(DapError::Closed)) }))
|
||||
};
|
||||
let mut initialized = s.initialized.subscribe();
|
||||
@@ -1206,7 +1222,7 @@ impl DebugManager {
|
||||
}
|
||||
if s.supports("supportsConfigurationDoneRequest") {
|
||||
if s.adapter == kotlin::ADAPTER {
|
||||
drop(s.conn.send_request("configurationDone", json!({}))?);
|
||||
drop(s.conn.send_request("configurationDone", json!({})).await?);
|
||||
} else {
|
||||
s.conn.request_timeout("configurationDone", Value::Null, REQUEST_TIMEOUT).await?;
|
||||
}
|
||||
@@ -1220,7 +1236,7 @@ impl DebugManager {
|
||||
}
|
||||
None => {
|
||||
// GDB 15: the breakpoints are in, so its `run` cannot miss them.
|
||||
let reply = s.conn.send_request(request, arguments)?;
|
||||
let reply = s.conn.send_request(request, arguments).await?;
|
||||
reply.await.unwrap_or(Err(DapError::Closed))?;
|
||||
}
|
||||
}
|
||||
@@ -1230,7 +1246,7 @@ impl DebugManager {
|
||||
// never answered), and the page is already loading: its document and first scripts
|
||||
// are not in the list.
|
||||
if js_debug::is_page(s) {
|
||||
let answer = s.conn.send_request("enableNetworking", js_debug::networking_arguments())?;
|
||||
let answer = s.conn.send_request("enableNetworking", js_debug::networking_arguments()).await?;
|
||||
let session = s.clone();
|
||||
// Not waited for here: the page runs on. A refusal is told to the Network view,
|
||||
// which would otherwise wait for requests that never come.
|
||||
|
||||
@@ -99,6 +99,9 @@ pub(crate) struct Session {
|
||||
pub js_overrides: tokio::sync::Mutex<Option<tokio::sync::watch::Sender<Vec<crate::JsResponseRule>>>>,
|
||||
/// The file js-debug records the page's CPU profile into, while one is being recorded.
|
||||
pub js_profile: parking_lot::Mutex<Option<std::path::PathBuf>>,
|
||||
/// The device of the app `flutter debug_adapter` announced, once it did: the Dart adapter
|
||||
/// sends the same `dart.*` events.
|
||||
pub flutter_app: std::sync::OnceLock<Option<String>>,
|
||||
pub jvm_inspector: parking_lot::Mutex<Option<Arc<dyn ide_jvm_inspect::JvmInspector>>>,
|
||||
/// One inspector request per session at a time.
|
||||
pub inspect_lock: tokio::sync::Mutex<()>,
|
||||
@@ -274,6 +277,7 @@ impl Session {
|
||||
launch_type: std::sync::OnceLock::new(),
|
||||
js_overrides: tokio::sync::Mutex::new(None),
|
||||
js_profile: parking_lot::Mutex::new(None),
|
||||
flutter_app: std::sync::OnceLock::new(),
|
||||
jvm_inspector: parking_lot::Mutex::new(None),
|
||||
inspect_lock: tokio::sync::Mutex::default(),
|
||||
ended: ide_core::CancellationToken::new(),
|
||||
@@ -504,6 +508,9 @@ impl Session {
|
||||
|
||||
/// How long Stop waits for a launched program to exit before reporting the session ended.
|
||||
pub(crate) const DEBUGGEE_EXIT_WAIT: Duration = Duration::from_secs(10);
|
||||
/// How long a stop waits for a killed program to be gone (Windows ends processes asynchronously).
|
||||
#[cfg(windows)]
|
||||
const DEBUGGEE_KILL_WAIT: Duration = Duration::from_secs(5);
|
||||
|
||||
pub(crate) async fn remember_debuggee(s: &Arc<Session>) {
|
||||
#[cfg(windows)]
|
||||
@@ -643,14 +650,24 @@ pub(crate) async fn wait_for_debuggee(s: &Arc<Session>, terminate: bool) {
|
||||
}
|
||||
#[cfg(windows)]
|
||||
{
|
||||
use std::time::Instant;
|
||||
remember_debuggee(s).await;
|
||||
let deadline = std::time::Instant::now() + DEBUGGEE_EXIT_WAIT;
|
||||
let deadline = Instant::now() + DEBUGGEE_EXIT_WAIT;
|
||||
let mut killed: Option<Instant> = None;
|
||||
// The captured tree is the oracle when it was captured; otherwise the job (every
|
||||
// process the launch started) is, so a failed capture can no longer end the wait
|
||||
// while the program still holds its port.
|
||||
while launch_running(s) {
|
||||
if s.stop_force.swap(false, Ordering::AcqRel) || std::time::Instant::now() >= deadline {
|
||||
let now = Instant::now();
|
||||
if s.stop_force.swap(false, Ordering::AcqRel) || (killed.is_none() && now >= deadline) {
|
||||
signal_debuggee(s, true).await;
|
||||
killed.get_or_insert(now);
|
||||
}
|
||||
// Termination is asynchronous, and a process TerminateProcess can't end (stuck in
|
||||
// the kernel) would hold the stop forever: give up on it, as on Unix.
|
||||
if killed.is_some_and(|at| now.duration_since(at) >= DEBUGGEE_KILL_WAIT) {
|
||||
tracing::warn!(session = s.id.0, pid, "stop: the debugged program did not exit after it was killed");
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
}
|
||||
@@ -885,6 +902,20 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
|
||||
"profileStarted" => {
|
||||
*s.js_profile.lock() = str_("file").map(std::path::PathBuf::from);
|
||||
}
|
||||
// Sent before `dart.debuggerUris`, for `launch` and `attach` alike.
|
||||
"flutter.appStart" => {
|
||||
let _ = s.flutter_app.set(str_("deviceId"));
|
||||
}
|
||||
"dart.debuggerUris" => {
|
||||
if let (Some(device), Some(uri)) = (s.flutter_app.get(), str_("vmServiceUri")) {
|
||||
s.emit(DebugEvent::FlutterVmService { uri, device: device.clone() });
|
||||
}
|
||||
}
|
||||
"dart.toolEvent" if s.flutter_app.get().is_some() => {
|
||||
if let Some(event) = crate::flutter_navigation(&body) {
|
||||
s.emit(event);
|
||||
}
|
||||
}
|
||||
_ => tracing::trace!("dap: ignored event {event}"),
|
||||
}
|
||||
}
|
||||
@@ -893,7 +924,11 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
|
||||
match command {
|
||||
"runInTerminal" => {
|
||||
let result = run_in_terminal(s, &args);
|
||||
let _ = s.conn.respond(seq, command, result);
|
||||
let conn = s.conn.clone();
|
||||
let command = command.to_owned();
|
||||
tokio::spawn(async move {
|
||||
let _ = conn.respond(seq, &command, result).await;
|
||||
});
|
||||
}
|
||||
"startDebugging" => {
|
||||
let mgr = mgr.clone();
|
||||
@@ -902,11 +937,15 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
|
||||
let request = args.get("request").and_then(Value::as_str).unwrap_or("launch").to_owned();
|
||||
let configuration = args.get("configuration").cloned().unwrap_or_else(|| json!({}));
|
||||
let result = mgr.start_child(&s, request, configuration).await;
|
||||
let _ = s.conn.respond(seq, "startDebugging", result.map(|_| Value::Null).map_err(|e| e.message));
|
||||
let _ = s.conn.respond(seq, "startDebugging", result.map(|_| Value::Null).map_err(|e| e.message)).await;
|
||||
});
|
||||
}
|
||||
_ => {
|
||||
let _ = s.conn.respond(seq, command, Err(format!("unsupported reverse request {command}")));
|
||||
let conn = s.conn.clone();
|
||||
let command = command.to_owned();
|
||||
tokio::spawn(async move {
|
||||
let _ = conn.respond(seq, &command, Err(format!("unsupported reverse request {command}"))).await;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -572,6 +572,20 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
json!({"type": "event", "event": "hotcodereplace", "body": {"changeType": 3, "message": "Build completed"}})
|
||||
);
|
||||
}
|
||||
"hotRestart" => {
|
||||
ok!(msg, Value::Null);
|
||||
let uris = json!({"vmServiceUri": "ws://127.0.0.1:1/t=/ws"});
|
||||
let navigate =
|
||||
|file: &str| json!({"kind": "navigate", "data": {"fileUri": file, "line": 3, "column": 5}});
|
||||
// Not Flutter's yet: a plain Dart session sends these too.
|
||||
send!(json!({"type": "event", "event": "dart.debuggerUris", "body": uris}));
|
||||
send!(json!({"type": "event", "event": "dart.toolEvent", "body": navigate("file:///early.dart")}));
|
||||
send!(json!({"type": "event", "event": "flutter.appStart", "body": {"deviceId": "d1"}}));
|
||||
send!(json!({"type": "event", "event": "dart.debuggerUris", "body": uris}));
|
||||
send!(json!({"type": "event", "event": "dart.toolEvent", "body": {"kind": "other", "data": {}}}));
|
||||
send!(json!({"type": "event", "event": "dart.toolEvent", "body": navigate("package:a/a.dart")}));
|
||||
send!(json!({"type": "event", "event": "dart.toolEvent", "body": navigate("file:///a%20b/main.dart")}));
|
||||
}
|
||||
"terminate" => {
|
||||
ok!(msg, Value::Null);
|
||||
send!(json!({"type": "event", "event": "terminated"}));
|
||||
@@ -1906,6 +1920,27 @@ async fn hot_reload_sends_its_reason_and_reports_the_flutter_app() {
|
||||
h.wait_event(|e| matches!(e, DebugEvent::FlutterAppStarted)).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn flutter_events_need_a_flutter_app() {
|
||||
let h = harness(Script::default());
|
||||
let id = h.start(config()).await.unwrap();
|
||||
h.manager.hot_restart(id).await.unwrap();
|
||||
let navigate = h.wait_event(|e| matches!(e, DebugEvent::FlutterNavigate { .. })).await;
|
||||
let DebugEvent::FlutterNavigate { path, line, column } = navigate else { unreachable!() };
|
||||
assert_eq!((path.as_ref(), line, column), (Path::new("/a b/main.dart"), 2, 4));
|
||||
let events = h.events.lock();
|
||||
let count = |want: fn(&DebugEvent) -> bool| {
|
||||
events.iter().filter(|e| matches!(e, IdeEvent::Debug { event, .. } if want(event))).count()
|
||||
};
|
||||
assert_eq!(
|
||||
count(
|
||||
|e| matches!(e, DebugEvent::FlutterVmService { uri, device } if uri == "ws://127.0.0.1:1/t=/ws" && device.as_deref() == Some("d1"))
|
||||
),
|
||||
1
|
||||
);
|
||||
assert_eq!(count(|e| matches!(e, DebugEvent::FlutterNavigate { .. })), 1);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn hot_swap_only_for_java_debug() {
|
||||
let h = harness(Script::default());
|
||||
|
||||
@@ -248,6 +248,17 @@ fn legacy_eof(e: &sqlx::Error) -> bool {
|
||||
matches!(e, sqlx::Error::Protocol(msg) if msg.starts_with("OK_Packet too short"))
|
||||
}
|
||||
|
||||
/// A TLS handshake that failed, e.g. with a server limited to TLS 1.0/1.1. SSL mode Prefer means
|
||||
/// TLS when it works, else a plain connection, as libpq's `sslmode=prefer` and MySQL clients'
|
||||
/// PREFERRED do; sqlx only goes plain when the server offers no TLS, so such errors are retried.
|
||||
fn tls_failed(e: &sqlx::Error) -> bool {
|
||||
match e {
|
||||
sqlx::Error::Tls(_) => true,
|
||||
sqlx::Error::Io(io) => io.get_ref().is_some_and(|inner| inner.is::<rustls::Error>()),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn db_err(e: sqlx::Error) -> IdeError {
|
||||
match &e {
|
||||
sqlx::Error::Database(d) => {
|
||||
@@ -832,9 +843,17 @@ impl Pool {
|
||||
if let Some(n) = setup.statement_cache {
|
||||
opts = opts.statement_cache_capacity(n);
|
||||
}
|
||||
let manager = PgManager { options: opts, init: init.clone(), timeout };
|
||||
let mut manager = PgManager { options: opts, init: init.clone(), timeout };
|
||||
// Open once directly so authentication failures retain their database error.
|
||||
let first = manager.connect().await.map_err(db_err)?;
|
||||
let first = match manager.connect().await {
|
||||
Err(e) if source.ssl == DbSslMode::Prefer && tls_failed(&e) => {
|
||||
tracing::info!("TLS handshake failed, connecting without TLS (SSL mode Prefer): {e}");
|
||||
manager.options = manager.options.clone().ssl_mode(PgSslMode::Disable);
|
||||
manager.connect().await
|
||||
}
|
||||
first => first,
|
||||
}
|
||||
.map_err(db_err)?;
|
||||
let pool = Bb8Pool::builder().max_size(MAX).connection_timeout(timeout).build_unchecked(manager);
|
||||
let _ = pool.add(first);
|
||||
Ok(Pool::Postgres(ServerPool { inner: pool, closed: AtomicBool::new(false) }))
|
||||
@@ -883,14 +902,19 @@ impl Pool {
|
||||
}
|
||||
let mut manager = MysqlManager { options: opts, init: init.clone(), timeout };
|
||||
// Open once directly so authentication failures retain their database error.
|
||||
let first = match manager.connect().await {
|
||||
Err(e) if legacy_eof(&e) => {
|
||||
manager.options = manager.options.clone().deprecate_eof(false);
|
||||
manager.connect().await
|
||||
let mut first = manager.connect().await;
|
||||
if source.ssl == DbSslMode::Prefer && first.as_ref().is_err_and(tls_failed) {
|
||||
if let Err(e) = &first {
|
||||
tracing::info!("TLS handshake failed, connecting without TLS (SSL mode Prefer): {e}");
|
||||
}
|
||||
first => first,
|
||||
manager.options = manager.options.clone().ssl_mode(MySqlSslMode::Disabled);
|
||||
first = manager.connect().await;
|
||||
}
|
||||
.map_err(db_err)?;
|
||||
if first.as_ref().is_err_and(legacy_eof) {
|
||||
manager.options = manager.options.clone().deprecate_eof(false);
|
||||
first = manager.connect().await;
|
||||
}
|
||||
let first = first.map_err(db_err)?;
|
||||
let pool = Bb8Pool::builder().max_size(MAX).connection_timeout(timeout).build_unchecked(manager);
|
||||
let _ = pool.add(first);
|
||||
Ok(Pool::Mysql(ServerPool { inner: pool, closed: AtomicBool::new(false) }))
|
||||
@@ -1406,6 +1430,19 @@ mod tests {
|
||||
use super::*;
|
||||
use crate::source::{DbOptions, DbProperty};
|
||||
|
||||
#[test]
|
||||
fn prefer_retries_without_tls_only_after_a_failed_handshake() {
|
||||
use std::io;
|
||||
// What a server limited to old TLS versions gives: rustls's alert inside the I/O error.
|
||||
let alert = rustls::Error::AlertReceived(rustls::AlertDescription::HandshakeFailure);
|
||||
assert!(tls_failed(&sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, alert))));
|
||||
assert!(tls_failed(&sqlx::Error::Tls("bad config".into())));
|
||||
// Unreachable servers, protocol errors and wrong passwords keep their error.
|
||||
assert!(!tls_failed(&sqlx::Error::Io(io::ErrorKind::ConnectionRefused.into())));
|
||||
assert!(!tls_failed(&sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, "eof"))));
|
||||
assert!(!tls_failed(&sqlx::Error::Protocol("OK_Packet too short".into())));
|
||||
}
|
||||
|
||||
fn sqlserver_debug(ssl: DbSslMode) -> String {
|
||||
let mut config = tiberius::Config::new();
|
||||
apply_sqlserver_ssl(&mut config, ssl);
|
||||
|
||||
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
|
||||
|
||||
pub const MANIFEST_FILE: &str = "plugin.toml";
|
||||
/// The plugin API (engine) version this host implements.
|
||||
pub const ENGINE_VERSION: &str = "1.13.0";
|
||||
pub const ENGINE_VERSION: &str = "1.14.0";
|
||||
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
|
||||
pub const LEGACY_API: &str = "0.1";
|
||||
/// Marketplace categories, in the order they are shown.
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "ide-flutter"
|
||||
description = "Flutter devices, kept current by the `flutter daemon` protocol"
|
||||
description = "Flutter devices from the `flutter daemon` protocol, and the project's DevTools server"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
@@ -0,0 +1,299 @@
|
||||
//! One `dart devtools` server per project window, started when first asked for. In `--machine`
|
||||
//! mode it reports its port as a `server.started` line on stdout. A server that fails or exits
|
||||
//! is not restarted on its own: the next request starts a new one.
|
||||
|
||||
use crate::{KILL_GRACE, OUTPUT_TAIL, keep_output, read_lines, spawn_watched};
|
||||
use ide_core::process::{kill_tree, terminate_tree};
|
||||
use ide_core::tool_path::{find_command, search_path_in};
|
||||
use parking_lot::{Condvar, Mutex};
|
||||
use serde_json::Value;
|
||||
use std::collections::VecDeque;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Child;
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const START_TIMEOUT: Duration = Duration::from_secs(60);
|
||||
/// The address embedded pages are allowed to come from, so never `localhost`.
|
||||
const HOST: &str = "127.0.0.1";
|
||||
const ARGS: [&str; 7] = ["devtools", "--machine", "--allow-embedding", "--host", HOST, "--port", "0"];
|
||||
|
||||
fn started_port(line: &str) -> Option<u16> {
|
||||
let message: Value = serde_json::from_str(line.trim()).ok()?;
|
||||
if message.get("event")?.as_str()? != "server.started" {
|
||||
return None;
|
||||
}
|
||||
u16::try_from(message.get("params")?.get("port")?.as_u64()?).ok()
|
||||
}
|
||||
|
||||
/// The `dart` of the SDK `flutter` belongs to, so that DevTools matches the debugged app.
|
||||
fn dart_executable(root: &Path) -> Option<PathBuf> {
|
||||
let path = search_path_in(root);
|
||||
find_command("flutter", &path, root)
|
||||
.and_then(|flutter| {
|
||||
// On the search path `flutter` is often a link into the SDK.
|
||||
let flutter = if cfg!(unix) { std::fs::canonicalize(&flutter).unwrap_or(flutter) } else { flutter };
|
||||
let dart = flutter.with_file_name(if cfg!(windows) { "dart.bat" } else { "dart" });
|
||||
dart.is_file().then_some(dart)
|
||||
})
|
||||
.or_else(|| find_command("dart", &path, root))
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
enum Status {
|
||||
#[default]
|
||||
Stopped,
|
||||
Starting,
|
||||
Ready(String),
|
||||
Failed(String),
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct State {
|
||||
/// Bumped by every start and stop: a reader of an older process no longer has a say.
|
||||
generation: u64,
|
||||
child: Option<Child>,
|
||||
status: Status,
|
||||
}
|
||||
|
||||
impl State {
|
||||
fn shut_down(&mut self) {
|
||||
self.generation += 1;
|
||||
if let Some(mut child) = self.child.take() {
|
||||
std::thread::spawn(move || terminate_tree(&mut child, KILL_GRACE));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct Shared {
|
||||
root: PathBuf,
|
||||
/// Replaces the lookup on the search path (tests).
|
||||
executable: Option<PathBuf>,
|
||||
timeout: Duration,
|
||||
state: Mutex<State>,
|
||||
changed: Condvar,
|
||||
}
|
||||
|
||||
impl Shared {
|
||||
/// Applies `status` unless this process was replaced or stopped; false if it was.
|
||||
fn set(&self, generation: u64, status: Status) -> bool {
|
||||
let mut state = self.state.lock();
|
||||
if state.generation != generation {
|
||||
return false;
|
||||
}
|
||||
state.status = status;
|
||||
self.changed.notify_all();
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
pub struct DevToolsServer(Arc<Shared>);
|
||||
|
||||
impl DevToolsServer {
|
||||
pub fn new(root: PathBuf) -> Self {
|
||||
Self::with_executable(root, None, START_TIMEOUT)
|
||||
}
|
||||
|
||||
fn with_executable(root: PathBuf, executable: Option<PathBuf>, timeout: Duration) -> Self {
|
||||
Self(Arc::new(Shared { root, executable, timeout, state: Mutex::default(), changed: Condvar::new() }))
|
||||
}
|
||||
|
||||
/// The server's address, starting it if none runs. Blocks until it is known.
|
||||
pub fn url(&self) -> Result<String, String> {
|
||||
let shared = &self.0;
|
||||
let deadline = Instant::now() + shared.timeout;
|
||||
let mut state = shared.state.lock();
|
||||
if matches!(state.status, Status::Stopped | Status::Failed(_)) {
|
||||
state.generation += 1;
|
||||
state.status = Status::Starting;
|
||||
let (shared, generation) = (shared.clone(), state.generation);
|
||||
std::thread::spawn(move || run(&shared, generation));
|
||||
}
|
||||
loop {
|
||||
match &state.status {
|
||||
Status::Ready(url) => return Ok(url.clone()),
|
||||
Status::Failed(message) => return Err(message.clone()),
|
||||
Status::Stopped => return Err("Flutter DevTools was stopped".into()),
|
||||
Status::Starting => {}
|
||||
}
|
||||
if shared.changed.wait_until(&mut state, deadline).timed_out() {
|
||||
state.shut_down();
|
||||
let message = "Flutter DevTools did not start in time".to_owned();
|
||||
state.status = Status::Failed(message.clone());
|
||||
shared.changed.notify_all();
|
||||
return Err(message);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Ends the server (project closed, or no longer trusted).
|
||||
pub fn stop(&self) {
|
||||
let mut state = self.0.state.lock();
|
||||
state.shut_down();
|
||||
state.status = Status::Stopped;
|
||||
self.0.changed.notify_all();
|
||||
}
|
||||
|
||||
/// Ends the server before returning, for a process about to exit.
|
||||
pub fn kill(&self) {
|
||||
let mut state = self.0.state.lock();
|
||||
state.generation += 1;
|
||||
state.status = Status::Stopped;
|
||||
if let Some(mut child) = state.child.take() {
|
||||
kill_tree(&mut child);
|
||||
}
|
||||
self.0.changed.notify_all();
|
||||
}
|
||||
}
|
||||
|
||||
/// One server's whole life, on its own thread.
|
||||
fn run(shared: &Arc<Shared>, generation: u64) {
|
||||
let fail = |message: String| {
|
||||
shared.set(generation, Status::Failed(message));
|
||||
};
|
||||
let Some(executable) = shared.executable.clone().or_else(|| dart_executable(&shared.root)) else {
|
||||
return fail("Dart SDK not found: install Flutter or add it to PATH".into());
|
||||
};
|
||||
let mut child = match spawn_watched(&executable, &ARGS, &shared.root) {
|
||||
Ok(child) => child,
|
||||
Err(e) => return fail(format!("could not run {}: {e}", executable.display())),
|
||||
};
|
||||
let (Some(stdout), Some(stderr)) = (child.stdout.take(), child.stderr.take()) else {
|
||||
terminate_tree(&mut child, Duration::ZERO);
|
||||
return fail("no output pipe".into());
|
||||
};
|
||||
{
|
||||
let mut state = shared.state.lock();
|
||||
if state.generation != generation {
|
||||
drop(state);
|
||||
terminate_tree(&mut child, KILL_GRACE);
|
||||
return;
|
||||
}
|
||||
state.child = Some(child);
|
||||
}
|
||||
let tail = Arc::new(Mutex::new(VecDeque::with_capacity(OUTPUT_TAIL)));
|
||||
let errors = {
|
||||
let tail = tail.clone();
|
||||
std::thread::spawn(move || {
|
||||
read_lines(stderr, |line| {
|
||||
keep_output(&tail, line);
|
||||
true
|
||||
});
|
||||
})
|
||||
};
|
||||
read_lines(stdout, |line| match started_port(line) {
|
||||
Some(port) => shared.set(generation, Status::Ready(format!("http://{HOST}:{port}"))),
|
||||
None => {
|
||||
keep_output(&tail, line);
|
||||
true
|
||||
}
|
||||
});
|
||||
let _ = errors.join();
|
||||
|
||||
let mut state = shared.state.lock();
|
||||
if state.generation != generation {
|
||||
return;
|
||||
}
|
||||
let child = state.child.take();
|
||||
state.status = if matches!(state.status, Status::Ready(_)) {
|
||||
Status::Stopped
|
||||
} else {
|
||||
let message = Vec::from(std::mem::take(&mut *tail.lock())).join("\n");
|
||||
Status::Failed(if message.is_empty() { "dart devtools exited".into() } else { message })
|
||||
};
|
||||
shared.changed.notify_all();
|
||||
drop(state);
|
||||
if let Some(mut child) = child {
|
||||
std::thread::spawn(move || terminate_tree(&mut child, Duration::ZERO));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn only_server_started_gives_a_port() {
|
||||
let line =
|
||||
r#"{"event":"server.started","method":"server.started","params":{"host":"127.0.0.1","port":9100,"pid":1}}"#;
|
||||
assert_eq!(started_port(line), Some(9100));
|
||||
assert_eq!(started_port(r#"{"event":"server.dtdStarted","params":{"uri":"ws://x"}}"#), None);
|
||||
assert_eq!(started_port("Serving DevTools"), None);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
mod process {
|
||||
use super::*;
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
const STARTED: &str = r#"echo '{"event":"server.started","params":{"port":4242}}'"#;
|
||||
|
||||
fn server(dir: &Path, script: &str, timeout: Duration) -> DevToolsServer {
|
||||
let path = dir.join("dart");
|
||||
std::fs::write(&path, format!("#!/bin/sh\necho run >> runs\n{script}")).unwrap();
|
||||
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
DevToolsServer::with_executable(dir.to_owned(), Some(path), timeout)
|
||||
}
|
||||
|
||||
fn runs(dir: &Path) -> usize {
|
||||
std::fs::read_to_string(dir.join("runs")).map_or(0, |s| s.lines().count())
|
||||
}
|
||||
|
||||
fn wait_for(what: &str, done: impl Fn() -> bool) {
|
||||
let deadline = Instant::now() + Duration::from_secs(10);
|
||||
while !done() {
|
||||
assert!(Instant::now() < deadline, "timed out waiting for {what}");
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_running_server_is_shared_and_stop_ends_it() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let script = format!("echo \"$*\" > args\necho $$ > pid\n{STARTED}\nexec sleep 30");
|
||||
let devtools = server(dir.path(), &script, Duration::from_secs(10));
|
||||
assert_eq!(devtools.url().unwrap(), "http://127.0.0.1:4242");
|
||||
assert_eq!(devtools.url().unwrap(), "http://127.0.0.1:4242");
|
||||
assert_eq!(runs(dir.path()), 1);
|
||||
let args = std::fs::read_to_string(dir.path().join("args")).unwrap();
|
||||
assert_eq!(args.trim(), ARGS.join(" "));
|
||||
|
||||
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap();
|
||||
devtools.stop();
|
||||
let alive = || {
|
||||
let mut probe = std::process::Command::new("kill");
|
||||
probe.args(["-0", pid.trim()]).stderr(std::process::Stdio::null()).status().unwrap().success()
|
||||
};
|
||||
wait_for("the server to end", || !alive());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_failure_is_reported_and_only_a_new_request_retries() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let devtools = server(dir.path(), "echo boom >&2\nexit 3", Duration::from_secs(10));
|
||||
assert_eq!(devtools.url().unwrap_err(), "boom");
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
assert_eq!(runs(dir.path()), 1);
|
||||
assert_eq!(devtools.url().unwrap_err(), "boom");
|
||||
assert_eq!(runs(dir.path()), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_server_that_exits_is_not_restarted_until_asked() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let devtools = server(dir.path(), STARTED, Duration::from_secs(10));
|
||||
devtools.url().unwrap();
|
||||
wait_for("the exit to be noticed", || matches!(devtools.0.state.lock().status, Status::Stopped));
|
||||
assert_eq!(runs(dir.path()), 1);
|
||||
devtools.url().unwrap();
|
||||
assert_eq!(runs(dir.path()), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_server_that_never_reports_times_out() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let devtools = server(dir.path(), "exec sleep 30", Duration::from_millis(200));
|
||||
assert_eq!(devtools.url().unwrap_err(), "Flutter DevTools did not start in time");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -8,6 +8,10 @@
|
||||
//! a watcher in its process group ends the group once the IDE is gone, even after a crash. A
|
||||
//! daemon that fails stays failed until the user restarts it.
|
||||
|
||||
mod devtools;
|
||||
|
||||
pub use devtools::DevToolsServer;
|
||||
|
||||
use ide_android::AndroidDevice;
|
||||
use ide_core::event::{FlutterDaemonStatus, FlutterDevice, FlutterDeviceList};
|
||||
use ide_core::process::{kill_tree, own_group, prepare, terminate_tree};
|
||||
@@ -227,26 +231,28 @@ fn refresh_adb(shared: &Arc<Shared>, generation: u64) {
|
||||
});
|
||||
}
|
||||
|
||||
/// `flutter daemon`, ended with its whole process group when process `parent` is gone.
|
||||
/// A tool that does not end with its stdin, ended with its whole process group when process
|
||||
/// `parent` is gone.
|
||||
#[cfg(unix)]
|
||||
fn daemon_command(executable: &Path, parent: u32) -> Command {
|
||||
fn watched_command(executable: &Path, args: &[&str], parent: u32) -> Command {
|
||||
const WATCHED: &str = r#"(while kill -0 "$1" 2>/dev/null; do sleep 5; done; kill -KILL 0) </dev/null >/dev/null 2>&1 &
|
||||
exec "$2" daemon"#;
|
||||
shift
|
||||
exec "$@""#;
|
||||
let mut cmd = Command::new("/bin/sh");
|
||||
cmd.args(["-c", WATCHED, "sh"]).arg(parent.to_string()).arg(executable);
|
||||
cmd.args(["-c", WATCHED, "sh"]).arg(parent.to_string()).arg(executable).args(args);
|
||||
cmd
|
||||
}
|
||||
|
||||
// No watcher on Windows, so a crashed IDE leaves the daemon; a Job Object would cover it.
|
||||
// No watcher on Windows, so a crashed IDE leaves the tool; a Job Object would cover it.
|
||||
#[cfg(not(unix))]
|
||||
fn daemon_command(executable: &Path, _parent: u32) -> Command {
|
||||
fn watched_command(executable: &Path, args: &[&str], _parent: u32) -> Command {
|
||||
let mut cmd = Command::new(executable);
|
||||
cmd.arg("daemon");
|
||||
cmd.args(args);
|
||||
cmd
|
||||
}
|
||||
|
||||
fn spawn_daemon(executable: &Path, root: &Path) -> std::io::Result<Child> {
|
||||
let mut cmd = daemon_command(executable, std::process::id());
|
||||
fn spawn_watched(executable: &Path, args: &[&str], root: &Path) -> std::io::Result<Child> {
|
||||
let mut cmd = watched_command(executable, args, std::process::id());
|
||||
cmd.current_dir(root).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped());
|
||||
prepare(own_group(&mut cmd));
|
||||
cmd.spawn()
|
||||
@@ -299,7 +305,7 @@ fn run(shared: &Arc<Shared>, generation: u64) {
|
||||
let Some(executable) = executable else {
|
||||
return finish(shared, generation, FlutterDaemonStatus::NotInstalled);
|
||||
};
|
||||
let mut child = match spawn_daemon(&executable, &shared.root) {
|
||||
let mut child = match spawn_watched(&executable, &["daemon"], &shared.root) {
|
||||
Ok(child) => child,
|
||||
Err(e) => {
|
||||
let message = format!("could not run {}: {e}", executable.display());
|
||||
@@ -530,7 +536,7 @@ cat > /dev/null
|
||||
std::fs::write(&flutter, "#!/bin/sh\necho $$ > pid\nexec sleep 60\n").unwrap();
|
||||
std::fs::set_permissions(&flutter, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
let mut ide = Command::new("sleep").arg("60").spawn().unwrap();
|
||||
let mut cmd = daemon_command(&flutter, ide.id());
|
||||
let mut cmd = watched_command(&flutter, &["daemon"], ide.id());
|
||||
cmd.current_dir(dir.path()).stdin(Stdio::piped());
|
||||
let mut daemon = own_group(&mut cmd).spawn().unwrap();
|
||||
wait_for("the daemon", || dir.path().join("pid").is_file());
|
||||
|
||||
@@ -98,6 +98,7 @@ async fn run(base: PathBuf) -> i32 {
|
||||
}));
|
||||
// A stable path for `--mcp-stdio` client configurations across server upgrades.
|
||||
host.mcp.set_stdio_link(base.join("bin").join("openidea-server"));
|
||||
host.mcp_background.serve_none();
|
||||
host.mcp.apply(&host);
|
||||
// The desktop's code plugins run here, next to the project (`plugin_sync_packages`).
|
||||
let plugins = match RemotePlugins::start(&plugins_data, &host, peer.clone()) {
|
||||
|
||||
@@ -119,6 +119,29 @@ fn php_cs_fixer_edits(
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// Some language servers (Vue's, for one) answer Reformat Code with one edit replacing the
|
||||
/// whole file; applied as is, it moves the caret and the view to the top of the file. The same
|
||||
/// result as one edit per changed region keeps them where they were.
|
||||
fn minimal_edits(text: &str, edits: Vec<TextEdit>) -> Vec<TextEdit> {
|
||||
if !edits.iter().any(|e| e.range.end.line > e.range.start.line) {
|
||||
return edits;
|
||||
}
|
||||
let original = ide_text::Document::new(text);
|
||||
let mut formatted = original.clone();
|
||||
if formatted.apply_edits(&edits).is_err() {
|
||||
return edits;
|
||||
}
|
||||
original
|
||||
.diff(&formatted.text())
|
||||
.changes
|
||||
.into_iter()
|
||||
.map(|c| TextEdit {
|
||||
range: Range::new(original.offset_to_pos(c.from), original.offset_to_pos(c.to)),
|
||||
new_text: c.insert,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub async fn format(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -292,7 +315,11 @@ async fn provider_edits(
|
||||
if options.on_save && !settings.editor.format_on_save {
|
||||
return Ok(None);
|
||||
}
|
||||
return project.lsp.format(doc, range, options).await.map(Some);
|
||||
let edits = project.lsp.format(doc, range, options).await?;
|
||||
let text = snap.text;
|
||||
return tokio::task::spawn_blocking(move || Some(minimal_edits(&text, edits)))
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()));
|
||||
};
|
||||
let tool_settings = settings.languages.formatter(selected);
|
||||
if options.on_save && !tool_settings.run_on_save {
|
||||
@@ -523,6 +550,25 @@ mod tests {
|
||||
|
||||
const ALIGN: PhpAlignment = PhpAlignment { key_value_pairs: true, assignments: true };
|
||||
|
||||
#[test]
|
||||
fn a_whole_file_edit_becomes_one_edit_per_changed_region() {
|
||||
let text = "a\n b\nc\nd\n e\n";
|
||||
let formatted = "a\nb\nc\nd\ne\n";
|
||||
let whole = vec![TextEdit { range: Range::new(Pos::new(0, 0), Pos::new(5, 0)), new_text: formatted.into() }];
|
||||
let edits = minimal_edits(text, whole);
|
||||
assert_eq!(
|
||||
edits,
|
||||
[
|
||||
TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 2)), new_text: String::new() },
|
||||
TextEdit { range: Range::new(Pos::new(4, 0), Pos::new(4, 2)), new_text: String::new() },
|
||||
]
|
||||
);
|
||||
assert_eq!(after(text, &edits), formatted);
|
||||
// Single-line edits are already minimal and pass through.
|
||||
let small = vec![TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 2)), new_text: String::new() }];
|
||||
assert_eq!(minimal_edits(text, small.clone()), small);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn php_alignment_is_off_unless_the_php_code_style_turns_it_on() {
|
||||
let php = LanguageId::new("php");
|
||||
|
||||
@@ -69,6 +69,8 @@ pub struct Host {
|
||||
pub mcp_requests: mcp::Requests,
|
||||
/// Commands agents run in the Run tool window (`run_command`).
|
||||
pub mcp_agent_runs: mcp::AgentRuns,
|
||||
/// Projects the MCP server serves without a window.
|
||||
pub mcp_background: mcp::BackgroundProjects,
|
||||
pub(crate) agent_catalogs: Arc<ide_agent::AgentCatalogs>,
|
||||
pub trust: trust::TrustStore,
|
||||
pub(crate) mcp_approvals: Arc<trust::McpServerApprovals>,
|
||||
@@ -125,10 +127,16 @@ pub struct Host {
|
||||
const EXIT_SHUTDOWN_WAIT: std::time::Duration = std::time::Duration::from_secs(10);
|
||||
|
||||
impl Host {
|
||||
/// Windows whose current project has this root.
|
||||
/// Windows whose current project has this root. A project served without a window
|
||||
/// has none.
|
||||
pub(crate) fn windows_for_root(&self, root: &std::path::Path) -> Vec<String> {
|
||||
let mut windows: Vec<_> =
|
||||
self.projects.read().iter().filter(|(_, p)| p.root == root).map(|(w, _)| w.clone()).collect();
|
||||
let mut windows: Vec<_> = self
|
||||
.projects
|
||||
.read()
|
||||
.iter()
|
||||
.filter(|(w, p)| p.root == root && !mcp::BackgroundProjects::is_key(w))
|
||||
.map(|(w, _)| w.clone())
|
||||
.collect();
|
||||
windows.sort();
|
||||
windows
|
||||
}
|
||||
@@ -159,6 +167,7 @@ impl Host {
|
||||
mcp_reports: Default::default(),
|
||||
mcp_requests: Default::default(),
|
||||
mcp_agent_runs: Default::default(),
|
||||
mcp_background: Default::default(),
|
||||
agent_catalogs: Arc::default(),
|
||||
trust: trust::TrustStore::load(&config_dir, &data_dir),
|
||||
mcp_approvals: Arc::new(trust::McpServerApprovals::load(&data_dir)),
|
||||
@@ -322,9 +331,18 @@ impl Host {
|
||||
}
|
||||
project.files_events_active.store(false, std::sync::atomic::Ordering::Release);
|
||||
project.plugin_diagnostics.close();
|
||||
// A project served without a window shares its files with a window whose root lies
|
||||
// around or below its own: their diagnostics stay.
|
||||
let background = mcp::BackgroundProjects::is_key(window);
|
||||
let shared = background
|
||||
&& self.projects.read().values().any(|other| {
|
||||
!other.light && (other.root.starts_with(&project.root) || project.root.starts_with(&other.root))
|
||||
});
|
||||
// The producers will re-report when a project reopens; until then the snapshot
|
||||
// must not answer for files whose project is gone.
|
||||
self.diagnostics.forget_root(&project.root);
|
||||
if !shared {
|
||||
self.diagnostics.forget_root(&project.root);
|
||||
}
|
||||
if let Some(plugins) = plugins::editor_plugin_host() {
|
||||
plugins.invalidate_client_navigation(&project.root, Some(window), None);
|
||||
plugins.set_active_file(window, None);
|
||||
@@ -344,6 +362,7 @@ impl Host {
|
||||
project.documents.clear_workspace_edit_history();
|
||||
project.agents.shutdown();
|
||||
project.flutter.stop();
|
||||
project.devtools.stop();
|
||||
project.notebooks.stop_admission();
|
||||
// What the closing window started goes with it — the builds and searches it
|
||||
// asked for, its runs, its shells and its debug sessions — and its language
|
||||
@@ -354,7 +373,8 @@ impl Host {
|
||||
vec![project.notebooks.clone()],
|
||||
project.kotlin_bridge.iter().cloned().collect(),
|
||||
Some(project.lsp.clone()),
|
||||
Some((self.debugger.clone(), window.to_owned(), project.root.clone())),
|
||||
// Debug sessions under the root belong to windows: a project served without one starts none.
|
||||
Some((self.debugger.clone(), window.to_owned(), (!background).then(|| project.root.clone()))),
|
||||
Some(project),
|
||||
))
|
||||
}
|
||||
@@ -367,7 +387,7 @@ impl Host {
|
||||
notebooks: Vec<Arc<notebook::NotebookService>>,
|
||||
bridges: Vec<Arc<kotlin_bridge::KotlinBridge>>,
|
||||
lsp: Option<Arc<ide_lsp::LspManager>>,
|
||||
debug: Option<(Arc<ide_dap::DebugManager>, String, std::path::PathBuf)>,
|
||||
debug: Option<(Arc<ide_dap::DebugManager>, String, Option<std::path::PathBuf>)>,
|
||||
retired: Option<Arc<Project>>,
|
||||
) -> std::thread::JoinHandle<()> {
|
||||
for bridge in &bridges {
|
||||
@@ -394,7 +414,9 @@ impl Host {
|
||||
}
|
||||
if let Some((debug, key, root)) = debug {
|
||||
debug.stop_key(&key).await;
|
||||
debug.stop_under(&root).await;
|
||||
if let Some(root) = root {
|
||||
debug.stop_under(&root).await;
|
||||
}
|
||||
}
|
||||
});
|
||||
if let Some(retired) = retired {
|
||||
@@ -413,17 +435,22 @@ impl Host {
|
||||
}
|
||||
|
||||
fn wait_blocking(&self, shutdown: std::thread::JoinHandle<()>) {
|
||||
let wait = move || {
|
||||
Self::in_place(move || {
|
||||
if let Err(error) = shutdown.join() {
|
||||
tracing::error!("project shutdown thread failed: {error:?}");
|
||||
}
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
/// Runs blocking work on this thread. On a worker of a multi-thread runtime the
|
||||
/// runtime is told first, so the worker's other tasks move to another thread.
|
||||
pub(crate) fn in_place<T>(work: impl FnOnce() -> T) -> T {
|
||||
if tokio::runtime::Handle::try_current()
|
||||
.is_ok_and(|handle| handle.runtime_flavor() == tokio::runtime::RuntimeFlavor::MultiThread)
|
||||
{
|
||||
tokio::task::block_in_place(wait);
|
||||
tokio::task::block_in_place(work)
|
||||
} else {
|
||||
wait();
|
||||
work()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -464,6 +491,7 @@ impl Host {
|
||||
self.terminals.kill_all();
|
||||
for project in self.projects() {
|
||||
project.flutter.kill();
|
||||
project.devtools.kill();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -487,6 +515,7 @@ impl Host {
|
||||
for project in &projects {
|
||||
project.files_events_active.store(false, std::sync::atomic::Ordering::Release);
|
||||
project.flutter.kill();
|
||||
project.devtools.kill();
|
||||
}
|
||||
for project in &projects {
|
||||
project.plugin_diagnostics.close();
|
||||
|
||||
@@ -0,0 +1,498 @@
|
||||
//! Projects the MCP server serves without a window ("background projects"): opened by a
|
||||
//! client's first tool call under the key `mcp:<root>` in the host's projects, held by the
|
||||
//! calls and runs in flight, unloaded when idle or when the limit needs room, and closed
|
||||
//! when a window opens the same root or the settings and trust decisions stop serving it.
|
||||
|
||||
mod policy;
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
use crate::{Host, Project};
|
||||
use ide_core::settings::McpBackgroundProjects;
|
||||
use ide_core::{IdeError, IdeResult, IpcPath};
|
||||
use parking_lot::{Mutex, RwLock};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::HashMap;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
/// Starts the key of every background project; window labels never contain `:`.
|
||||
const KEY_PREFIX: &str = "mcp:";
|
||||
/// `mcpServer.backgroundIdleMinutes` counts up to a day.
|
||||
const MAX_IDLE_MINUTES: u32 = 24 * 60;
|
||||
/// `mcpServer.backgroundProjectLimit` stays within these bounds.
|
||||
const MIN_PROJECTS: u32 = 1;
|
||||
const MAX_PROJECTS: u32 = 32;
|
||||
/// How often idle projects are looked for.
|
||||
const SWEEP_EVERY: Duration = Duration::from_secs(30);
|
||||
|
||||
/// A project served without a window, as the IDE lists it.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct McpBackgroundProject {
|
||||
pub root: IpcPath,
|
||||
/// Seconds since its last tool call began or ended.
|
||||
pub idle_seconds: u32,
|
||||
/// Seconds until it is unloaded for being idle. Absent while something keeps it open
|
||||
/// and when idle projects are never unloaded.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
#[specta(optional)]
|
||||
pub unloads_in_seconds: Option<u32>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
#[specta(optional)]
|
||||
pub kept_open_by: Option<McpBackgroundHold>,
|
||||
}
|
||||
|
||||
/// What keeps an idle background project loaded.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase")]
|
||||
pub enum McpBackgroundHold {
|
||||
/// A tool call is in flight.
|
||||
Request,
|
||||
/// A run it started is alive; `name` is the first one's.
|
||||
Run { name: String },
|
||||
}
|
||||
|
||||
type Observer = Arc<dyn Fn() + Send + Sync>;
|
||||
|
||||
/// The background projects of one [`Host`].
|
||||
#[derive(Default)]
|
||||
pub struct BackgroundProjects {
|
||||
/// Serializes opens and unloads, and is held across the open itself. Taken before
|
||||
/// `state`, never with it held.
|
||||
gate: Mutex<()>,
|
||||
state: Mutex<State>,
|
||||
observer: RwLock<Option<Observer>>,
|
||||
/// Set by [`BackgroundProjects::serve_none`].
|
||||
serves_none: AtomicBool,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct State {
|
||||
entries: HashMap<PathBuf, Arc<Entry>>,
|
||||
/// Windows that are opening a root right now, counted per root.
|
||||
claims: HashMap<PathBuf, usize>,
|
||||
/// The root a background open under way is opening; the gate allows one at a time.
|
||||
opening: Option<PathBuf>,
|
||||
}
|
||||
|
||||
/// Marks the root of the open under way in [`State::opening`] until that open is over.
|
||||
struct Opening<'a>(&'a BackgroundProjects);
|
||||
|
||||
impl Drop for Opening<'_> {
|
||||
fn drop(&mut self) {
|
||||
self.0.state.lock().opening = None;
|
||||
}
|
||||
}
|
||||
|
||||
struct Entry {
|
||||
/// Tool calls running in the project.
|
||||
in_flight: AtomicUsize,
|
||||
/// When a call last reached the project or left it.
|
||||
last_used: Mutex<Instant>,
|
||||
}
|
||||
|
||||
/// Keeps a background project loaded while a tool call runs in it.
|
||||
pub(crate) struct ActivityGuard(Arc<Entry>);
|
||||
|
||||
/// What answers a tool call: the window label or background key, the project, and the
|
||||
/// call's guard when the project is served in the background.
|
||||
pub(crate) type Served = (String, Arc<Project>, Option<ActivityGuard>);
|
||||
|
||||
impl Drop for ActivityGuard {
|
||||
fn drop(&mut self) {
|
||||
// The time first: a sweep that sees no call in flight then sees a fresh time.
|
||||
*self.0.last_used.lock() = Instant::now();
|
||||
self.0.in_flight.fetch_sub(1, Ordering::AcqRel);
|
||||
}
|
||||
}
|
||||
|
||||
/// A window is opening the root: no background project of it is opened meanwhile.
|
||||
pub(crate) struct Claim<'a> {
|
||||
owner: &'a BackgroundProjects,
|
||||
root: PathBuf,
|
||||
}
|
||||
|
||||
impl Drop for Claim<'_> {
|
||||
fn drop(&mut self) {
|
||||
let mut state = self.owner.state.lock();
|
||||
if let Some(count) = state.claims.get_mut(&self.root) {
|
||||
*count -= 1;
|
||||
if *count == 0 {
|
||||
state.claims.remove(&self.root);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// When [`BackgroundProjects::remove`] unloads a project.
|
||||
#[derive(Clone, Copy)]
|
||||
enum Only {
|
||||
Always,
|
||||
/// No call or run holds it.
|
||||
Unheld,
|
||||
/// Nothing holds it and it has been idle for the configured time at this moment.
|
||||
Idle(Instant),
|
||||
}
|
||||
|
||||
/// The inputs of [`policy::resolve`] at one moment.
|
||||
struct Policy {
|
||||
mode: McpBackgroundProjects,
|
||||
listed: Vec<PathBuf>,
|
||||
decisions: crate::trust::TrustDecisions,
|
||||
recents: Vec<PathBuf>,
|
||||
home: Option<PathBuf>,
|
||||
}
|
||||
|
||||
impl Policy {
|
||||
/// `None` when the MCP server or its background projects are off, and when the trust
|
||||
/// decisions cannot be read.
|
||||
fn current(host: &Host) -> Option<Self> {
|
||||
let settings = host.global_settings.effective().mcp_server;
|
||||
// Without the server no client is served, a request it accepted before it stopped included.
|
||||
if !settings.enabled || host.mcp_background.serves_none.load(Ordering::Relaxed) {
|
||||
return None;
|
||||
}
|
||||
let mode = settings.background_projects;
|
||||
let by_trust = match mode {
|
||||
McpBackgroundProjects::Off => return None,
|
||||
McpBackgroundProjects::Trusted => true,
|
||||
McpBackgroundProjects::Listed => false,
|
||||
};
|
||||
let recents = if by_trust { ide_workspace::RecentProjects::load(&host.config_dir).paths() } else { Vec::new() };
|
||||
Some(Self {
|
||||
mode,
|
||||
listed: settings.background_project_paths.iter().map(PathBuf::from).collect(),
|
||||
decisions: host.trust.decisions().ok()?,
|
||||
recents,
|
||||
home: dirs::home_dir(),
|
||||
})
|
||||
}
|
||||
|
||||
fn resolve(&self, path: &Path) -> Option<PathBuf> {
|
||||
policy::resolve(self.mode, &self.listed, &self.decisions, &self.recents, self.home.as_deref(), path)
|
||||
}
|
||||
}
|
||||
|
||||
/// The root of the project that serves `path` in the background under the current
|
||||
/// settings and trust decisions. Opens nothing.
|
||||
pub(crate) fn serving_root(host: &Host, path: &Path) -> Option<PathBuf> {
|
||||
Policy::current(host)?.resolve(path)
|
||||
}
|
||||
|
||||
/// How long a project may stay idle; `None` when `minutes` is 0 (never unloaded).
|
||||
fn idle_limit(minutes: u32) -> Option<Duration> {
|
||||
(minutes > 0).then(|| Duration::from_secs(u64::from(minutes.min(MAX_IDLE_MINUTES)) * 60))
|
||||
}
|
||||
|
||||
fn project_limit(limit: u32) -> usize {
|
||||
limit.clamp(MIN_PROJECTS, MAX_PROJECTS) as usize
|
||||
}
|
||||
|
||||
fn whole_seconds(time: Duration) -> u32 {
|
||||
u32::try_from(time.as_secs()).unwrap_or(u32::MAX)
|
||||
}
|
||||
|
||||
/// What keeps the project at `root` loaded, a call before a run.
|
||||
fn hold(host: &Host, root: &Path, entry: &Entry) -> Option<McpBackgroundHold> {
|
||||
if entry.in_flight.load(Ordering::Acquire) > 0 {
|
||||
return Some(McpBackgroundHold::Request);
|
||||
}
|
||||
host.processes.running_in(root).into_iter().next().map(|run| McpBackgroundHold::Run { name: run.name })
|
||||
}
|
||||
|
||||
impl BackgroundProjects {
|
||||
/// The key of the background project at `root` in the host's projects.
|
||||
pub fn key(root: &Path) -> String {
|
||||
format!("{KEY_PREFIX}{}", root.display())
|
||||
}
|
||||
|
||||
/// Serves no project in the background, whatever the settings say: the remote server,
|
||||
/// which exists for its window's project and holds no trust decisions of its own.
|
||||
pub fn serve_none(&self) {
|
||||
self.serves_none.store(true, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
/// Whether `window` is the key of a background project and not a window's label.
|
||||
pub fn is_key(window: &str) -> bool {
|
||||
window.starts_with(KEY_PREFIX)
|
||||
}
|
||||
|
||||
/// The loaded background project at `root`. Leaves its idle time alone.
|
||||
pub(crate) fn project(&self, host: &Host, root: &Path) -> Option<Arc<Project>> {
|
||||
self.state.lock().entries.contains_key(root).then(|| host.project(&Self::key(root)).ok()).flatten()
|
||||
}
|
||||
|
||||
/// The project that answers a tool call for `root`, opened now unless it is loaded: its
|
||||
/// key, the project and the guard of the call, which counts as in flight from here on,
|
||||
/// so nothing unloads the project before the call runs. A window that opened the root
|
||||
/// meanwhile answers instead, with its label and no guard. Refused while a window is
|
||||
/// opening the root, when the settings and trust decisions do not serve it, and when
|
||||
/// the limit is reached with every loaded project held.
|
||||
pub(crate) fn open(&self, host: &Host, root: &Path) -> IdeResult<Served> {
|
||||
let key = Self::key(root);
|
||||
// Without the gate, which the open of another root may hold for seconds.
|
||||
if let Some((project, call)) = self.reach(host, root, &key) {
|
||||
return Ok((key, project, Some(call)));
|
||||
}
|
||||
let mut changed = false;
|
||||
let opened = {
|
||||
let _gate = self.gate.lock();
|
||||
self.open_gated(host, root, &key, &mut changed)
|
||||
};
|
||||
if changed {
|
||||
self.notify();
|
||||
}
|
||||
opened
|
||||
}
|
||||
|
||||
/// The loaded project at `root`, with a call entered in it.
|
||||
fn reach(&self, host: &Host, root: &Path, key: &str) -> Option<(Arc<Project>, ActivityGuard)> {
|
||||
let call = {
|
||||
// Under `state`, so an unload either sees the call or has removed the entry.
|
||||
let state = self.state.lock();
|
||||
let entry = state.entries.get(root)?.clone();
|
||||
entry.in_flight.fetch_add(1, Ordering::AcqRel);
|
||||
*entry.last_used.lock() = Instant::now();
|
||||
ActivityGuard(entry)
|
||||
};
|
||||
// A project closed behind its entry drops the guard here; the gated open replaces both.
|
||||
host.project(key).ok().map(|project| (project, call))
|
||||
}
|
||||
|
||||
fn open_gated(&self, host: &Host, root: &Path, key: &str, changed: &mut bool) -> IdeResult<Served> {
|
||||
// Another call opened it while this one waited for the gate.
|
||||
if let Some((project, call)) = self.reach(host, root, key) {
|
||||
return Ok((key.to_owned(), project, Some(call)));
|
||||
}
|
||||
if let Some((window, project)) = host.window_project(root) {
|
||||
return Ok((window, project, None));
|
||||
}
|
||||
let _opening = {
|
||||
let mut state = self.state.lock();
|
||||
if state.claims.contains_key(root) {
|
||||
return Err(IdeError::unavailable(format!("{} is opening in a window; retry", root.display())));
|
||||
}
|
||||
// An entry whose project was closed behind its back would count against the limit.
|
||||
*changed |= state.entries.remove(root).is_some();
|
||||
// In the same step as the look at the claims: a window that claims the root from
|
||||
// here on sees this open and waits for it.
|
||||
state.opening = Some(root.to_path_buf());
|
||||
Opening(self)
|
||||
};
|
||||
if serving_root(host, root).as_deref() != Some(root) {
|
||||
return Err(IdeError::unavailable(format!("{} is not served in the background", root.display())));
|
||||
}
|
||||
let limit = project_limit(host.global_settings.effective().mcp_server.background_project_limit);
|
||||
while self.state.lock().entries.len() >= limit {
|
||||
let Some(idle) = self.longest_idle(host) else {
|
||||
return Err(IdeError::unavailable(format!(
|
||||
"the limit of {limit} background projects is reached and all are busy"
|
||||
)));
|
||||
};
|
||||
// A call that entered it meanwhile keeps it; the loop then looks again.
|
||||
*changed |= self.remove(host, &idle, Only::Unheld);
|
||||
}
|
||||
let project = host.open_project(key, root)?;
|
||||
// Entered from the start: the next open cannot evict it before this call runs.
|
||||
let entry = Arc::new(Entry { in_flight: AtomicUsize::new(1), last_used: Mutex::new(Instant::now()) });
|
||||
self.state.lock().entries.insert(root.to_path_buf(), entry.clone());
|
||||
if let Some(plugins) = host.plugin_host() {
|
||||
plugins.reopen_client(key);
|
||||
}
|
||||
*changed = true;
|
||||
Ok((key.to_owned(), project, Some(ActivityGuard(entry))))
|
||||
}
|
||||
|
||||
/// Unloads the background project at `root` and stops what it started; its workers
|
||||
/// finish shutting down in the background. It waits for a background open that is under
|
||||
/// way, so call it from a blocking context. With `only_if_idle`, a project that a call
|
||||
/// or a run holds, or that is not idle for the configured time at that moment, stays.
|
||||
/// `false` when nothing was unloaded, an unknown root included.
|
||||
pub fn detach(&self, host: &Host, root: &Path, only_if_idle: Option<Instant>) -> bool {
|
||||
let removed = {
|
||||
let _gate = self.gate.lock();
|
||||
self.remove(host, root, only_if_idle.map_or(Only::Always, Only::Idle))
|
||||
};
|
||||
if removed {
|
||||
self.notify();
|
||||
}
|
||||
removed
|
||||
}
|
||||
|
||||
/// The single way a background project closes. The caller holds the gate.
|
||||
fn remove(&self, host: &Host, root: &Path, only: Only) -> bool {
|
||||
// Before `state`: the runs have a lock of their own.
|
||||
let running = !host.processes.running_in(root).is_empty();
|
||||
let may_idle = idle_limit(host.global_settings.effective().mcp_server.background_idle_minutes);
|
||||
{
|
||||
let mut state = self.state.lock();
|
||||
let Some(entry) = state.entries.get(root) else { return false };
|
||||
let held = running || entry.in_flight.load(Ordering::Acquire) > 0;
|
||||
let idle = |now: Instant| {
|
||||
may_idle.is_some_and(|limit| now.saturating_duration_since(*entry.last_used.lock()) >= limit)
|
||||
};
|
||||
let stays = match only {
|
||||
Only::Always => false,
|
||||
Only::Unheld => held,
|
||||
Only::Idle(now) => held || !idle(now),
|
||||
};
|
||||
if stays {
|
||||
return false;
|
||||
}
|
||||
state.entries.remove(root);
|
||||
}
|
||||
let key = Self::key(root);
|
||||
if let Some(plugins) = host.plugin_host() {
|
||||
plugins.forget_client(&key);
|
||||
}
|
||||
host.close_project_detached(&key);
|
||||
true
|
||||
}
|
||||
|
||||
/// The projects no call or run holds that have been idle for the configured time at `now`.
|
||||
pub(crate) fn sweep_candidates(&self, host: &Host, now: Instant) -> Vec<PathBuf> {
|
||||
let minutes = host.global_settings.effective().mcp_server.background_idle_minutes;
|
||||
let Some(limit) = idle_limit(minutes) else { return Vec::new() };
|
||||
let idle = |entry: &Entry| now.saturating_duration_since(*entry.last_used.lock()) >= limit;
|
||||
let entries = self.entries().into_iter();
|
||||
entries.filter(|(root, entry)| idle(entry) && hold(host, root, entry).is_none()).map(|(root, _)| root).collect()
|
||||
}
|
||||
|
||||
/// Unloads the projects that are idle at `now`; each is checked again as it is unloaded.
|
||||
pub(crate) fn sweep(&self, host: &Host, now: Instant) {
|
||||
for root in self.sweep_candidates(host, now) {
|
||||
self.detach(host, &root, Some(now));
|
||||
}
|
||||
}
|
||||
|
||||
/// A window is about to open `root`: unloads the root's background project and keeps
|
||||
/// another from opening until the claim drops. It waits for a background open only when
|
||||
/// the root is loaded or is the one being opened; a window on any other folder goes on
|
||||
/// at once.
|
||||
pub(crate) fn claim(&self, host: &Host, root: &Path) -> Claim<'_> {
|
||||
let contested = {
|
||||
let mut state = self.state.lock();
|
||||
// From here no background open of the root gets past its look at the claims.
|
||||
*state.claims.entry(root.to_path_buf()).or_default() += 1;
|
||||
state.entries.contains_key(root) || state.opening.as_deref() == Some(root)
|
||||
};
|
||||
let claim = Claim { owner: self, root: root.to_path_buf() };
|
||||
if contested {
|
||||
let removed = {
|
||||
let _gate = self.gate.lock();
|
||||
self.remove(host, root, Only::Always)
|
||||
};
|
||||
if removed {
|
||||
self.notify();
|
||||
}
|
||||
}
|
||||
claim
|
||||
}
|
||||
|
||||
/// Waits for a background open that is under way. After it, the project that open
|
||||
/// read its settings and trust for is registered, and an open that starts later reads
|
||||
/// what is stored now.
|
||||
pub(crate) fn wait_for_open(&self) {
|
||||
drop(self.gate.lock());
|
||||
}
|
||||
|
||||
/// The loaded background projects at `now`, sorted by root.
|
||||
pub fn snapshot(&self, host: &Host, now: Instant) -> Vec<McpBackgroundProject> {
|
||||
let may_idle = idle_limit(host.global_settings.effective().mcp_server.background_idle_minutes);
|
||||
let mut projects: Vec<_> = self
|
||||
.entries()
|
||||
.into_iter()
|
||||
.map(|(root, entry)| {
|
||||
let idle = now.saturating_duration_since(*entry.last_used.lock());
|
||||
let kept_open_by = hold(host, &root, &entry);
|
||||
let unloads_in = may_idle.filter(|_| kept_open_by.is_none()).map(|limit| limit.saturating_sub(idle));
|
||||
McpBackgroundProject {
|
||||
root: root.into(),
|
||||
idle_seconds: whole_seconds(idle),
|
||||
unloads_in_seconds: unloads_in.map(whole_seconds),
|
||||
kept_open_by,
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
projects.sort_by(|a, b| a.root.cmp(&b.root));
|
||||
projects
|
||||
}
|
||||
|
||||
fn entries(&self) -> Vec<(PathBuf, Arc<Entry>)> {
|
||||
self.state.lock().entries.iter().map(|(root, entry)| (root.clone(), entry.clone())).collect()
|
||||
}
|
||||
|
||||
/// The project nothing holds that was used the longest ago.
|
||||
fn longest_idle(&self, host: &Host) -> Option<PathBuf> {
|
||||
let unheld = self.entries().into_iter().filter(|(root, entry)| hold(host, root, entry).is_none());
|
||||
unheld.min_by_key(|(_, entry)| *entry.last_used.lock()).map(|(root, _)| root)
|
||||
}
|
||||
|
||||
/// Tells the observer that the loaded projects changed. Never called with a lock of
|
||||
/// this type held.
|
||||
fn notify(&self) {
|
||||
let observer = self.observer.read().clone();
|
||||
if let Some(observer) = observer {
|
||||
observer();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Host {
|
||||
/// The window, and its project, that has `root` open as a project (not in LightEdit).
|
||||
fn window_project(&self, root: &Path) -> Option<(String, Arc<Project>)> {
|
||||
let projects = self.projects.read();
|
||||
let windows = projects.iter().filter(|(w, p)| !BackgroundProjects::is_key(w) && !p.light && p.root == root);
|
||||
windows.min_by_key(|(w, _)| w.as_str()).map(|(w, p)| (w.clone(), p.clone()))
|
||||
}
|
||||
|
||||
/// Unloads the background projects the settings and trust decisions no longer serve:
|
||||
/// all of them when the MCP server is off, otherwise each whose root no longer serves
|
||||
/// itself. Call it after either changes, from a blocking context: it reads the recent
|
||||
/// projects and waits for a background open that is under way.
|
||||
pub fn apply_background_policy(&self) {
|
||||
// First: a project that is being opened under the old settings has no entry yet.
|
||||
self.mcp_background.wait_for_open();
|
||||
let roots: Vec<PathBuf> = self.mcp_background.entries().into_iter().map(|(root, _)| root).collect();
|
||||
if roots.is_empty() {
|
||||
return;
|
||||
}
|
||||
let policy = Policy::current(self);
|
||||
for root in roots {
|
||||
if policy.as_ref().and_then(|policy| policy.resolve(&root)).as_deref() != Some(&root) {
|
||||
self.mcp_background.detach(self, &root, None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Starts the timer that unloads idle background projects for as long as the host lives.
|
||||
pub fn start_background_sweeper(self: &Arc<Self>) {
|
||||
let host = Arc::downgrade(self);
|
||||
self.runtime.spawn(async move {
|
||||
let mut tick = tokio::time::interval(SWEEP_EVERY);
|
||||
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
|
||||
tick.tick().await;
|
||||
loop {
|
||||
tick.tick().await;
|
||||
let Some(host) = host.upgrade() else { break };
|
||||
// The timer's clock, so a sweep and its tick agree on the time.
|
||||
let now = tokio::time::Instant::now().into_std();
|
||||
// An unload waits for the gate, which an open in flight holds: off the async workers.
|
||||
let sweep = tokio::task::spawn_blocking(move || host.mcp_background.sweep(&host, now));
|
||||
if let Err(error) = sweep.await {
|
||||
tracing::warn!(%error, "sweeping idle background projects failed");
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Sets what is told when a background project is opened or unloaded. It runs on the
|
||||
/// thread that made the change, outside the locks of the background projects.
|
||||
pub fn set_background_projects_observer(&self, observer: Arc<dyn Fn() + Send + Sync>) {
|
||||
*self.mcp_background.observer.write() = Some(observer);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,229 @@
|
||||
//! Which folder serves a client's path as a background project: a pure function of the
|
||||
//! setting, the listed folders, the trust decisions, the recent projects and the project
|
||||
//! markers on disk.
|
||||
|
||||
use crate::trust::TrustDecisions;
|
||||
use ide_core::settings::McpBackgroundProjects;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
/// The root of the background project that serves `path`: the innermost of the `listed`
|
||||
/// folders containing it and, in `Trusted` mode, of the trusted projects, the trusted recent
|
||||
/// projects and the nearest trusted folder with a project marker. `None` when the mode is
|
||||
/// `Off`, when `path` is relative or missing, and when no folder qualifies. Listed and
|
||||
/// recent folders that are gone or not absolute paths are skipped.
|
||||
pub(crate) fn resolve(
|
||||
mode: McpBackgroundProjects,
|
||||
listed: &[PathBuf],
|
||||
decisions: &TrustDecisions,
|
||||
recents: &[PathBuf],
|
||||
home: Option<&Path>,
|
||||
path: &Path,
|
||||
) -> Option<PathBuf> {
|
||||
let by_trust = match mode {
|
||||
McpBackgroundProjects::Off => return None,
|
||||
McpBackgroundProjects::Trusted => true,
|
||||
McpBackgroundProjects::Listed => false,
|
||||
};
|
||||
if !path.is_absolute() {
|
||||
return None;
|
||||
}
|
||||
let path = dunce::canonicalize(path).ok()?;
|
||||
// A relative entry would be read against the working directory, which says nothing
|
||||
// about the user's folders (`/` for an app started from the Finder).
|
||||
let existing = |entry: &PathBuf| entry.is_absolute().then(|| dunce::canonicalize(entry).ok()).flatten();
|
||||
// A listed folder serves its subtree whether or not it is trusted: it opens restricted then.
|
||||
let mut candidates: Vec<PathBuf> = listed.iter().filter_map(existing).collect();
|
||||
if by_trust {
|
||||
candidates.extend(decisions.projects.iter().filter(|p| trusted_here(decisions, p)).cloned());
|
||||
// Remote projects are recorded as locations (`ssh://…`), not as folders of this machine.
|
||||
let local = recents.iter().filter(|p| !p.to_string_lossy().contains("://"));
|
||||
candidates.extend(local.filter_map(existing).filter(|p| trusted_here(decisions, p)));
|
||||
let home = home.map(|h| dunce::canonicalize(h).unwrap_or_else(|_| h.to_path_buf()));
|
||||
// A trusted location and the home folder hold projects; neither is one.
|
||||
candidates
|
||||
.extend(marker_root(&path).filter(|a| {
|
||||
trusted_here(decisions, a) && !decisions.locations.contains(a) && home.as_ref() != Some(a)
|
||||
}));
|
||||
}
|
||||
innermost(&candidates, &path).cloned()
|
||||
}
|
||||
|
||||
/// The entry with the most components among those of `entries` that contain `path`.
|
||||
fn innermost<'a>(entries: impl IntoIterator<Item = &'a PathBuf>, path: &Path) -> Option<&'a PathBuf> {
|
||||
entries.into_iter().filter(|entry| path.starts_with(entry)).max_by_key(|entry| entry.components().count())
|
||||
}
|
||||
|
||||
/// Whether the decisions trust a project at `root`: its innermost grant (the project itself
|
||||
/// or a trusted location around it) lies deeper than every restricted folder around it, so a
|
||||
/// restricted folder vetoes everything below it short of a grant made further down.
|
||||
fn trusted_here(decisions: &TrustDecisions, root: &Path) -> bool {
|
||||
let own = decisions.projects.iter().filter(|project| *project == root);
|
||||
let Some(grant) = innermost(own.chain(&decisions.locations), root) else { return false };
|
||||
innermost(&decisions.restricted, root).is_none_or(|veto| veto.components().count() < grant.components().count())
|
||||
}
|
||||
|
||||
/// The first ancestor of `path`, itself included, that looks like a project: it holds an
|
||||
/// `.openidea` folder, or a `.git` or `.jj` entry (a linked worktree's `.git` is a file).
|
||||
fn marker_root(path: &Path) -> Option<PathBuf> {
|
||||
let marked = |dir: &&Path| dir.join(".openidea").is_dir() || dir.join(".git").exists() || dir.join(".jj").exists();
|
||||
path.ancestors().find(marked).map(Path::to_path_buf)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use McpBackgroundProjects::{Listed, Off, Trusted};
|
||||
|
||||
type Folders = &'static [&'static str];
|
||||
/// What is asked, the mode, the listed folders, the trusted projects, the trusted
|
||||
/// locations, the restricted folders, the recent projects, the path and the root that
|
||||
/// serves it; folders are relative to the tree.
|
||||
type Case = (
|
||||
&'static str,
|
||||
McpBackgroundProjects,
|
||||
Folders,
|
||||
Folders,
|
||||
Folders,
|
||||
Folders,
|
||||
Folders,
|
||||
&'static str,
|
||||
Option<&'static str>,
|
||||
);
|
||||
|
||||
/// `code/` with projects of every marker kind, and `home/` standing in for the user's home.
|
||||
fn tree() -> (tempfile::TempDir, PathBuf) {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(tmp.path()).unwrap();
|
||||
for dir in [
|
||||
"code/app/.git",
|
||||
"code/app/src",
|
||||
"code/app/.wt/feature/src",
|
||||
"code/lib/.jj",
|
||||
"code/tool/.openidea",
|
||||
"code/tool/sub",
|
||||
"code/plain/src",
|
||||
"code/vendor/dep/.git",
|
||||
"home/.openidea",
|
||||
"home/notes",
|
||||
"home/work/.git",
|
||||
] {
|
||||
std::fs::create_dir_all(base.join(dir)).unwrap();
|
||||
}
|
||||
// A linked worktree's `.git` is a file.
|
||||
std::fs::write(base.join("code/app/.wt/feature/.git"), "gitdir: ../../.git/worktrees/feature\n").unwrap();
|
||||
// A file named like the settings folder is no marker.
|
||||
std::fs::write(base.join("code/plain/.openidea"), "").unwrap();
|
||||
(tmp, base)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_innermost_folder_the_policy_allows_serves_a_path() {
|
||||
let (_tmp, base) = tree();
|
||||
let paths = |names: &[&str]| names.iter().map(|n| base.join(n)).collect::<Vec<_>>();
|
||||
#[rustfmt::skip]
|
||||
let cases: &[Case] = &[
|
||||
("off serves nothing", Off, &["code/app"], &["code/app"], &["code"], &[], &["code/app"], "code/app/src", None),
|
||||
("a listed folder, trusted or not", Listed, &["code/app"], &[], &[], &[], &[], "code/app/src", Some("code/app")),
|
||||
("a listed folder itself", Listed, &["code/app"], &[], &[], &[], &[], "code/app", Some("code/app")),
|
||||
("listed mode ignores trust", Listed, &[], &["code/app"], &["code"], &[], &["code/app"], "code/app/src", None),
|
||||
("a sibling of a listed folder", Listed, &["code/app"], &[], &[], &[], &[], "code/lib", None),
|
||||
("a listed folder that is gone", Listed, &["code/gone", "code/app"], &[], &[], &[], &[], "code/app/src", Some("code/app")),
|
||||
("a trusted project", Trusted, &[], &["code/plain"], &[], &[], &[], "code/plain/src", Some("code/plain")),
|
||||
("a recent project in a trusted location", Trusted, &[], &[], &["code"], &[], &["code/plain"], "code/plain/src", Some("code/plain")),
|
||||
("a recent project nobody trusted", Trusted, &[], &[], &[], &[], &["code/plain"], "code/plain/src", None),
|
||||
("a recent project that was restricted", Trusted, &[], &[], &["code"], &["code/plain"], &["code/plain"], "code/plain/src", None),
|
||||
("a recent project that is gone", Trusted, &[], &[], &["code"], &[], &["code/gone"], "code/plain/src", None),
|
||||
("a .git folder", Trusted, &[], &[], &["code"], &[], &[], "code/app/src", Some("code/app")),
|
||||
("a .git file", Trusted, &[], &[], &["code"], &[], &[], "code/app/.wt/feature/src", Some("code/app/.wt/feature")),
|
||||
("a .jj folder, from the root itself", Trusted, &[], &[], &["code"], &[], &[], "code/lib", Some("code/lib")),
|
||||
("an .openidea folder", Trusted, &[], &[], &["code"], &[], &[], "code/tool/sub", Some("code/tool")),
|
||||
("an .openidea file is no marker", Trusted, &[], &[], &["code"], &[], &[], "code/plain/src", None),
|
||||
("a marker nobody trusted", Trusted, &[], &[], &[], &[], &[], "code/app/src", None),
|
||||
("the walk stops at the first marker", Trusted, &[], &[], &["code"], &["code/app/.wt/feature"], &[], "code/app/.wt/feature/src", None),
|
||||
("a worktree in a trusted location inside a trusted project", Trusted, &[], &["code/app"], &["code/app/.wt"], &[], &[], "code/app/.wt/feature/src", Some("code/app/.wt/feature")),
|
||||
("an untrusted worktree inside a trusted project", Trusted, &[], &["code/app"], &[], &[], &[], "code/app/.wt/feature/src", Some("code/app")),
|
||||
("a trusted child of a listed untrusted parent", Trusted, &["code"], &["code/plain"], &[], &[], &[], "code/plain/src", Some("code/plain")),
|
||||
("the listed parent for the rest of it", Trusted, &["code"], &["code/plain"], &[], &[], &[], "code/tool/sub", Some("code")),
|
||||
("a marker under a restricted folder", Trusted, &[], &[], &["code"], &["code/vendor"], &[], "code/vendor/dep", None),
|
||||
("a deeper grant under a restricted folder", Trusted, &[], &["code/vendor/dep"], &["code"], &["code/vendor"], &[], "code/vendor/dep", Some("code/vendor/dep")),
|
||||
("a restricted trusted location", Trusted, &[], &[], &["code"], &["code"], &[], "code/app/src", None),
|
||||
("a trusted location is no project", Trusted, &[], &[], &["code/app"], &[], &[], "code/app/src", None),
|
||||
("the home folder is no project", Trusted, &[], &[], &[""], &[], &[], "home/notes", None),
|
||||
("a repository in the home folder", Trusted, &[], &[], &[""], &[], &[], "home/work", Some("home/work")),
|
||||
("a missing path", Listed, &["code/app"], &[], &[], &[], &[], "code/app/missing", None),
|
||||
];
|
||||
for (what, mode, listed, projects, locations, restricted, recents, path, expected) in cases {
|
||||
let decisions = TrustDecisions {
|
||||
projects: paths(projects),
|
||||
locations: paths(locations),
|
||||
restricted: paths(restricted),
|
||||
};
|
||||
let home = base.join("home");
|
||||
let found = resolve(*mode, &paths(listed), &decisions, &paths(recents), Some(&home), &base.join(path));
|
||||
assert_eq!(found, expected.map(|root| base.join(root)), "{what}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_relative_path_is_served_by_nothing() {
|
||||
let (_tmp, base) = tree();
|
||||
let listed = [base.join("code/app"), PathBuf::from("code/app"), PathBuf::from(".")];
|
||||
let none = TrustDecisions::default();
|
||||
for path in ["code/app/src", ".", "src"] {
|
||||
assert_eq!(resolve(Listed, &listed, &none, &[], None, Path::new(path)), None, "{path}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_relative_list_or_recent_entry_serves_nothing() {
|
||||
// Read against the working directory, `.` would serve whatever folder the app was started from.
|
||||
let here = dunce::canonicalize(std::env::current_dir().unwrap()).unwrap();
|
||||
let around = TrustDecisions { locations: vec![here.parent().unwrap().to_path_buf()], ..Default::default() };
|
||||
let none = TrustDecisions::default();
|
||||
let (dot, absolute): (&[PathBuf], &[PathBuf]) = (&[PathBuf::from(".")], std::slice::from_ref(&here));
|
||||
for (what, mode, listed, decisions, recents, expected) in [
|
||||
("a listed `.`", Listed, dot, &none, &[][..], None),
|
||||
("a listed `.` with trusted projects served", Trusted, dot, &none, &[][..], None),
|
||||
("a recent `.`", Trusted, &[][..], &around, dot, None),
|
||||
("the same folder listed by its full path", Listed, absolute, &none, &[][..], Some(&here)),
|
||||
("the same folder recent by its full path", Trusted, &[][..], &around, absolute, Some(&here)),
|
||||
] {
|
||||
assert_eq!(resolve(mode, listed, decisions, recents, None, &here).as_ref(), expected, "{what}");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_folder_reached_through_a_link_is_the_folder_itself() {
|
||||
let (_tmp, base) = tree();
|
||||
std::os::unix::fs::symlink(base.join("code"), base.join("link")).unwrap();
|
||||
let none = TrustDecisions::default();
|
||||
// Listed by the link, asked for by the real path, and the other way round (`/tmp` and `/private/tmp`).
|
||||
for (listed, path) in [("link/app", "code/app/src"), ("code/app", "link/app/src"), ("link/app", "link/app")] {
|
||||
let found = resolve(Listed, &[base.join(listed)], &none, &[], None, &base.join(path));
|
||||
assert_eq!(found, Some(base.join("code/app")), "{listed} for {path}");
|
||||
}
|
||||
let trusted = TrustDecisions { locations: vec![base.join("code")], ..Default::default() };
|
||||
let recent = [base.join("link/plain")];
|
||||
assert_eq!(
|
||||
resolve(Trusted, &[], &trusted, &recent, None, &base.join("link/plain/src")),
|
||||
Some(base.join("code/plain"))
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_remote_recent_project_is_skipped_even_when_its_text_names_a_local_folder() {
|
||||
let (_tmp, base) = tree();
|
||||
// `<base>/ssh://box/app` reads as the local folder `<base>/ssh:/box/app`.
|
||||
std::fs::create_dir_all(base.join("ssh:/box/app/src")).unwrap();
|
||||
let recent = [PathBuf::from(format!("{}/ssh://box/app", base.display()))];
|
||||
let trusted = TrustDecisions { locations: vec![base.clone()], ..Default::default() };
|
||||
assert_eq!(resolve(Trusted, &[], &trusted, &recent, None, &base.join("ssh:/box/app/src")), None);
|
||||
let local = [base.join("ssh:/box/app")];
|
||||
assert_eq!(
|
||||
resolve(Trusted, &[], &trusted, &local, None, &base.join("ssh:/box/app/src")),
|
||||
Some(base.join("ssh:/box/app"))
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,792 @@
|
||||
use super::*;
|
||||
use crate::HostConfig;
|
||||
use ide_workspace::SettingsScope;
|
||||
use serde_json::json;
|
||||
|
||||
const MINUTE: Duration = Duration::from_secs(60);
|
||||
const SECOND: Duration = Duration::from_secs(1);
|
||||
|
||||
/// A host with the MCP server on that serves the folders `inventory`, `billing` and
|
||||
/// `orders` as listed background projects; no window is open.
|
||||
struct Fixture {
|
||||
host: Arc<Host>,
|
||||
base: PathBuf,
|
||||
syntax: Arc<std::sync::OnceLock<Arc<ide_language::Syntax>>>,
|
||||
_tmp: tempfile::TempDir,
|
||||
}
|
||||
|
||||
/// The grammars' warm-up, held unfinished as at start-up until this is dropped. Every open
|
||||
/// waits for it after it has read the settings and the trust decision, before it registers
|
||||
/// its project.
|
||||
struct WarmUp(#[expect(dead_code, reason = "dropping it ends the warm-up")] std::sync::mpsc::Sender<()>);
|
||||
|
||||
/// Returns once `done` holds; no later than half a minute from now.
|
||||
fn wait_until(what: &str, done: impl Fn() -> bool) {
|
||||
let deadline = Instant::now() + 30 * SECOND;
|
||||
while !done() {
|
||||
assert!(Instant::now() < deadline, "{what}");
|
||||
std::thread::yield_now();
|
||||
}
|
||||
}
|
||||
|
||||
/// Long enough to tell work that waits from work that has finished.
|
||||
const A_MOMENT: Duration = Duration::from_millis(300);
|
||||
|
||||
impl Fixture {
|
||||
fn new() -> Self {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(tmp.path()).unwrap();
|
||||
for name in ["inventory", "billing", "orders"] {
|
||||
std::fs::create_dir_all(base.join(name).join("parts")).unwrap();
|
||||
std::fs::write(base.join(name).join("notes.txt"), "stock\n").unwrap();
|
||||
}
|
||||
let syntax: Arc<std::sync::OnceLock<Arc<ide_language::Syntax>>> = Arc::default();
|
||||
let host = Arc::new(Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("local"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: syntax.clone(),
|
||||
sink_for: Box::new(|_| Arc::new(|_| {})),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
}));
|
||||
let fixture = Self { host, base, syntax, _tmp: tmp };
|
||||
fixture.set("enabled", json!(true));
|
||||
fixture.set("backgroundProjects", json!("listed"));
|
||||
fixture.list(&["inventory", "billing", "orders"]);
|
||||
fixture
|
||||
}
|
||||
|
||||
fn set(&self, key: &str, value: serde_json::Value) {
|
||||
self.host.global_settings.set(SettingsScope::Global, &format!("mcpServer.{key}"), value).unwrap();
|
||||
}
|
||||
|
||||
fn list(&self, names: &[&str]) {
|
||||
self.set("backgroundProjectPaths", json!(names.iter().map(|name| self.root(name)).collect::<Vec<_>>()));
|
||||
}
|
||||
|
||||
fn root(&self, name: &str) -> PathBuf {
|
||||
self.base.join(name)
|
||||
}
|
||||
|
||||
fn background(&self) -> &BackgroundProjects {
|
||||
&self.host.mcp_background
|
||||
}
|
||||
|
||||
fn open(&self, name: &str) -> Arc<Project> {
|
||||
self.background().open(&self.host, &self.root(name)).expect("the project is served").1
|
||||
}
|
||||
|
||||
/// A tool call that reached the project `name` and has not ended yet.
|
||||
fn call(&self, name: &str) -> ActivityGuard {
|
||||
let (_, _, call) = self.background().open(&self.host, &self.root(name)).expect("the project is served");
|
||||
call.expect("in the background")
|
||||
}
|
||||
|
||||
fn hold_warm_up(&self) -> WarmUp {
|
||||
let (started, holding) = std::sync::mpsc::channel();
|
||||
let (finish, finished) = std::sync::mpsc::channel::<()>();
|
||||
let syntax = self.syntax.clone();
|
||||
std::thread::spawn(move || {
|
||||
syntax.get_or_init(|| {
|
||||
// Both ends hang up when the test is over.
|
||||
let _ = started.send(());
|
||||
let _ = finished.recv();
|
||||
Arc::new(ide_language::Syntax::new())
|
||||
});
|
||||
});
|
||||
holding.recv_timeout(30 * SECOND).expect("the warm-up starts");
|
||||
WarmUp(finish)
|
||||
}
|
||||
|
||||
/// A client's first call for `name` on another thread, once its open is under way.
|
||||
fn open_in_flight(&self, name: &str) -> tokio::task::JoinHandle<Arc<Project>> {
|
||||
let (host, root) = (self.host.clone(), self.root(name));
|
||||
let open = tokio::task::spawn_blocking(move || host.mcp_background.open(&host, &root).expect("served").1);
|
||||
wait_until("the open is under way", || self.background().gate.is_locked());
|
||||
open
|
||||
}
|
||||
|
||||
/// Whether an open has read its settings and trust decision: Local History, which it
|
||||
/// creates next, is there.
|
||||
fn an_open_has_read_its_decisions(&self) -> bool {
|
||||
std::fs::read_dir(self.base.join("data/history")).is_ok_and(|mut entries| entries.next().is_some())
|
||||
}
|
||||
|
||||
fn refused(&self, name: &str) -> String {
|
||||
self.background().open(&self.host, &self.root(name)).err().expect("the open is refused").message
|
||||
}
|
||||
|
||||
fn snapshot(&self) -> Vec<McpBackgroundProject> {
|
||||
self.background().snapshot(&self.host, Instant::now())
|
||||
}
|
||||
|
||||
/// The folder names of the loaded projects, sorted.
|
||||
fn loaded(&self) -> Vec<String> {
|
||||
let name = |project: McpBackgroundProject| project.root.0.file_name().unwrap().to_string_lossy().into_owned();
|
||||
self.snapshot().into_iter().map(name).collect()
|
||||
}
|
||||
|
||||
fn held_by(&self, name: &str) -> Option<McpBackgroundHold> {
|
||||
let root = self.root(name);
|
||||
self.snapshot().into_iter().find(|project| project.root.0 == root).unwrap().kept_open_by
|
||||
}
|
||||
|
||||
fn used(&self, name: &str) -> Instant {
|
||||
*self.background().state.lock().entries[&self.root(name)].last_used.lock()
|
||||
}
|
||||
|
||||
fn claims(&self, name: &str) -> usize {
|
||||
self.background().state.lock().claims.get(&self.root(name)).copied().unwrap_or(0)
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Fixture {
|
||||
fn drop(&mut self) {
|
||||
// Waits for each shutdown, so nothing still works in the folder when it is deleted.
|
||||
for (root, _) in self.background().entries() {
|
||||
self.host.close_project(&BackgroundProjects::key(&root));
|
||||
}
|
||||
self.host.close_project("main");
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns once the clock reads later than `time`, so the next reading is strictly after it.
|
||||
fn tick_past(time: Instant) {
|
||||
while Instant::now() <= time {
|
||||
std::hint::spin_loop();
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn the_first_call_opens_a_project_under_its_key_and_the_next_one_reuses_it() {
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
let (key, project, _) = f.background().open(&f.host, &root).unwrap();
|
||||
assert_eq!(key, format!("mcp:{}", root.display()));
|
||||
assert!(BackgroundProjects::is_key(&key));
|
||||
assert!(!BackgroundProjects::is_key("main") && !BackgroundProjects::is_key("settings-main"));
|
||||
assert_eq!(project.root, root);
|
||||
assert!(Arc::ptr_eq(&f.host.project(&key).unwrap(), &project));
|
||||
assert!(!project.is_trusted(), "a listed folder nobody trusted opens in Restricted Mode");
|
||||
let (_, again, _) = f.background().open(&f.host, &root).unwrap();
|
||||
assert!(Arc::ptr_eq(&again, &project));
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_root_the_settings_do_not_serve_is_refused_and_nothing_opens() {
|
||||
let f = Fixture::new();
|
||||
f.list(&["billing"]);
|
||||
let root = f.root("inventory");
|
||||
assert_eq!(f.refused("inventory"), format!("{} is not served in the background", root.display()));
|
||||
// A folder inside a served root is not a root itself.
|
||||
assert!(f.refused("billing/parts").contains("is not served in the background"));
|
||||
f.set("backgroundProjects", json!("off"));
|
||||
assert!(f.refused("billing").contains("is not served in the background"));
|
||||
assert!(f.loaded().is_empty());
|
||||
assert!(f.host.projects().is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_call_in_flight_holds_the_project_and_its_end_restarts_the_idle_time() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
let root = f.root("inventory");
|
||||
let opened = f.used("inventory");
|
||||
tick_past(opened);
|
||||
let call = f.call("inventory");
|
||||
let entered = f.used("inventory");
|
||||
assert!(entered > opened, "entering counts as use");
|
||||
assert_eq!(f.held_by("inventory"), Some(McpBackgroundHold::Request));
|
||||
// Held: no idle time unloads it.
|
||||
let days_later = entered + 2 * 24 * 60 * MINUTE;
|
||||
assert!(f.background().sweep_candidates(&f.host, days_later).is_empty());
|
||||
assert!(!f.background().detach(&f.host, &root, Some(days_later)));
|
||||
tick_past(entered);
|
||||
drop(call);
|
||||
let left = f.used("inventory");
|
||||
assert!(left > entered, "the end of the call restarts the idle time");
|
||||
assert_eq!(f.held_by("inventory"), None);
|
||||
assert!(f.background().sweep_candidates(&f.host, left + 30 * MINUTE - SECOND).is_empty());
|
||||
assert_eq!(f.background().sweep_candidates(&f.host, left + 30 * MINUTE), [root]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_call_that_outlives_its_project_leaves_the_reopened_project_alone() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
let root = f.root("inventory");
|
||||
let outlived = f.call("inventory");
|
||||
assert!(f.background().detach(&f.host, &root, None), "an unload by hand does not wait for the call");
|
||||
f.open("inventory");
|
||||
let current = f.call("inventory");
|
||||
drop(outlived);
|
||||
assert_eq!(
|
||||
f.held_by("inventory"),
|
||||
Some(McpBackgroundHold::Request),
|
||||
"the call in the reopened project still counts"
|
||||
);
|
||||
drop(current);
|
||||
assert_eq!(f.held_by("inventory"), None);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn an_idle_project_is_unloaded_exactly_when_its_idle_time_is_up() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
let used = f.used("inventory");
|
||||
f.background().sweep(&f.host, used + 30 * MINUTE - SECOND);
|
||||
assert_eq!(f.loaded(), ["inventory"], "one second short");
|
||||
f.set("backgroundIdleMinutes", json!(0));
|
||||
f.background().sweep(&f.host, used + 365 * 24 * 60 * MINUTE);
|
||||
assert_eq!(f.loaded(), ["inventory"], "0 never unloads");
|
||||
// More than a day counts as a day.
|
||||
f.set("backgroundIdleMinutes", json!(5000));
|
||||
f.background().sweep(&f.host, used + 1440 * MINUTE - SECOND);
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
f.background().sweep(&f.host, used + 1440 * MINUTE);
|
||||
assert!(f.loaded().is_empty());
|
||||
assert!(f.host.project(&BackgroundProjects::key(&f.root("inventory"))).is_err());
|
||||
|
||||
f.set("backgroundIdleMinutes", json!(30));
|
||||
f.open("inventory");
|
||||
f.background().sweep(&f.host, f.used("inventory") + 30 * MINUTE);
|
||||
assert!(f.loaded().is_empty(), "exactly at the limit");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_call_that_arrives_between_the_sweep_and_the_unload_keeps_the_project() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
let root = f.root("inventory");
|
||||
let now = f.used("inventory") + 30 * MINUTE;
|
||||
assert_eq!(f.background().sweep_candidates(&f.host, now), std::slice::from_ref(&root));
|
||||
let call = f.call("inventory");
|
||||
assert!(!f.background().detach(&f.host, &root, Some(now)), "held by the call");
|
||||
drop(call);
|
||||
assert!(!f.background().detach(&f.host, &root, Some(now)), "used since the sweep looked");
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_live_run_holds_the_project_and_an_unload_by_hand_stops_it() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
let root = f.root("inventory");
|
||||
let (exits, exited) = std::sync::mpsc::channel();
|
||||
let exits = Mutex::new(exits);
|
||||
let sink: ide_core::SharedSink = Arc::new(move |event: ide_core::IdeEvent| {
|
||||
if let ide_core::IdeEvent::RunExited { run, .. } = event {
|
||||
// The receiver is gone once the test has seen the exit.
|
||||
let _ = exits.lock().send(run);
|
||||
}
|
||||
});
|
||||
let config = ide_run::RunConfig {
|
||||
id: "serve".into(),
|
||||
name: "serve stock".into(),
|
||||
kind: "shell".into(),
|
||||
command: "sleep 30".into(),
|
||||
args: Vec::new(),
|
||||
cwd: None,
|
||||
env: Default::default(),
|
||||
detected: false,
|
||||
is_test: false,
|
||||
debug_adapter: None,
|
||||
allow_parallel: false,
|
||||
extras: Default::default(),
|
||||
};
|
||||
let run = f.host.processes.start(&root, &config, &Default::default(), sink, Box::new(|_| {})).unwrap();
|
||||
assert_eq!(f.held_by("inventory"), Some(McpBackgroundHold::Run { name: "serve stock".into() }));
|
||||
assert_eq!(f.snapshot()[0].unloads_in_seconds, None);
|
||||
let days_later = f.used("inventory") + 2 * 24 * 60 * MINUTE;
|
||||
assert!(f.background().sweep_candidates(&f.host, days_later).is_empty());
|
||||
assert!(!f.background().detach(&f.host, &root, Some(days_later)));
|
||||
// The limit does not unload it either.
|
||||
f.set("backgroundProjectLimit", json!(1));
|
||||
assert_eq!(f.refused("billing"), "the limit of 1 background projects is reached and all are busy");
|
||||
|
||||
assert!(f.background().detach(&f.host, &root, None));
|
||||
assert_eq!(exited.recv_timeout(Duration::from_secs(30)).unwrap(), run.id);
|
||||
assert!(f.host.processes.running_in(&root).is_empty());
|
||||
assert!(!f.background().detach(&f.host, &root, None), "already unloaded");
|
||||
assert!(!f.background().detach(&f.host, &f.root("billing"), None), "never loaded");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn the_limit_unloads_the_project_used_longest_ago_and_refuses_when_all_are_held() {
|
||||
let f = Fixture::new();
|
||||
f.set("backgroundProjectLimit", json!(2));
|
||||
f.open("inventory");
|
||||
tick_past(f.used("inventory"));
|
||||
f.open("billing");
|
||||
// A call in `inventory` makes `billing` the one used longest ago.
|
||||
tick_past(f.used("billing"));
|
||||
drop(f.call("inventory"));
|
||||
f.open("orders");
|
||||
assert_eq!(f.loaded(), ["inventory", "orders"]);
|
||||
assert!(f.host.project(&BackgroundProjects::key(&f.root("billing"))).is_err());
|
||||
|
||||
let in_inventory = f.call("inventory");
|
||||
let in_orders = f.call("orders");
|
||||
assert_eq!(f.refused("billing"), "the limit of 2 background projects is reached and all are busy");
|
||||
assert_eq!(f.loaded(), ["inventory", "orders"]);
|
||||
// A loaded project answers at the limit.
|
||||
f.open("inventory");
|
||||
drop(in_orders);
|
||||
f.open("billing");
|
||||
assert_eq!(f.loaded(), ["billing", "inventory"]);
|
||||
// A lowered limit is reached by the next open.
|
||||
drop(in_inventory);
|
||||
f.set("backgroundProjectLimit", json!(0));
|
||||
f.open("orders");
|
||||
assert_eq!(f.loaded(), ["orders"], "0 serves one project");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_project_whose_call_has_not_started_running_is_not_evicted_for_another_client() {
|
||||
let f = Fixture::new();
|
||||
f.set("backgroundProjectLimit", json!(1));
|
||||
// The open hands the call over already counted: nothing unloads the project before it runs.
|
||||
let call = f.call("inventory");
|
||||
assert_eq!(f.refused("billing"), "the limit of 1 background projects is reached and all are busy");
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
assert_eq!(f.held_by("inventory"), Some(McpBackgroundHold::Request));
|
||||
drop(call);
|
||||
f.open("billing");
|
||||
assert_eq!(f.loaded(), ["billing"], "with the call over, the other client's project takes the place");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
|
||||
async fn a_trust_refresh_leaves_its_runtime_worker_to_other_tasks_while_it_unloads_projects() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
f.set("backgroundProjects", json!("off"));
|
||||
// The observer runs inside the policy step: holding it there holds the step.
|
||||
let (inside, entered) = std::sync::mpsc::channel();
|
||||
let (release, released) = std::sync::mpsc::channel::<()>();
|
||||
let released = Mutex::new(Some(released));
|
||||
f.host.set_background_projects_observer(Arc::new(move || {
|
||||
if let Some(released) = released.lock().take() {
|
||||
// Both ends hang up when the test is over.
|
||||
let _ = inside.send(());
|
||||
let _ = released.recv();
|
||||
}
|
||||
}));
|
||||
let host = f.host.clone();
|
||||
let refresh = tokio::spawn(async move { host.refresh_project_trust().await });
|
||||
// Waits on this thread, which is none of the runtime's: its timers stand while the worker is held.
|
||||
entered.recv_timeout(30 * SECOND).expect("the policy step unloads the project");
|
||||
// The runtime's only worker is inside the step; a task spawned now still runs.
|
||||
let (ran, other) = std::sync::mpsc::channel();
|
||||
tokio::spawn(async move {
|
||||
// The test may have given up waiting.
|
||||
let _ = ran.send(());
|
||||
});
|
||||
other.recv_timeout(10 * SECOND).expect("another task runs meanwhile");
|
||||
drop(release);
|
||||
refresh.await.unwrap().unwrap();
|
||||
assert!(f.loaded().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_limit_and_the_idle_time_stay_within_their_bounds() {
|
||||
for (setting, limit) in [(0, 1), (1, 1), (8, 8), (32, 32), (99, 32), (u32::MAX, 32)] {
|
||||
assert_eq!(project_limit(setting), limit, "{setting}");
|
||||
}
|
||||
let day = 24 * 60 * MINUTE;
|
||||
for (minutes, limit) in [
|
||||
(0, None),
|
||||
(1, Some(MINUTE)),
|
||||
(30, Some(30 * MINUTE)),
|
||||
(1440, Some(day)),
|
||||
(5000, Some(day)),
|
||||
(u32::MAX, Some(day)),
|
||||
] {
|
||||
assert_eq!(idle_limit(minutes), limit, "{minutes}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_window_that_opens_the_root_takes_it_over_and_gives_it_back_when_it_closes() {
|
||||
let f = Fixture::new();
|
||||
let background = f.open("inventory");
|
||||
f.open("billing");
|
||||
let root = f.root("inventory");
|
||||
let key = BackgroundProjects::key(&root);
|
||||
let window = f.host.open_project("main", &root).unwrap();
|
||||
assert!(!Arc::ptr_eq(&window, &background));
|
||||
assert!(f.host.project(&key).is_err());
|
||||
assert_eq!(f.loaded(), ["billing"], "the other project is left alone");
|
||||
assert_eq!(f.claims("inventory"), 0);
|
||||
// A call for the root reaches the window now.
|
||||
let (label, project, call) = f.background().open(&f.host, &root).unwrap();
|
||||
assert_eq!(label, "main");
|
||||
assert!(call.is_none(), "a window is not held by calls");
|
||||
assert!(Arc::ptr_eq(&project, &window));
|
||||
assert_eq!(f.loaded(), ["billing"]);
|
||||
|
||||
f.host.close_project("main");
|
||||
assert_eq!(f.background().open(&f.host, &root).unwrap().0, key);
|
||||
assert_eq!(f.loaded(), ["billing", "inventory"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_background_open_is_refused_until_every_window_opening_the_root_is_done() {
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
let first = f.background().claim(&f.host, &root);
|
||||
let second = f.background().claim(&f.host, &root);
|
||||
let refusal = format!("{} is opening in a window; retry", root.display());
|
||||
assert_eq!(f.refused("inventory"), refusal);
|
||||
drop(first);
|
||||
assert_eq!(f.refused("inventory"), refusal, "the second window is still opening it");
|
||||
f.open("billing");
|
||||
drop(second);
|
||||
assert_eq!(f.claims("inventory"), 0);
|
||||
f.open("inventory");
|
||||
assert_eq!(f.loaded(), ["billing", "inventory"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_window_open_that_fails_releases_the_root() {
|
||||
let f = Fixture::new();
|
||||
// Local History cannot be created, which fails the open after the window claimed the root.
|
||||
let history = f.base.join("data/history");
|
||||
std::fs::create_dir_all(history.parent().unwrap()).unwrap();
|
||||
std::fs::write(&history, "").unwrap();
|
||||
assert!(f.host.open_project("main", &f.root("inventory")).is_err());
|
||||
assert_eq!(f.claims("inventory"), 0);
|
||||
std::fs::remove_file(&history).unwrap();
|
||||
f.open("inventory");
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn revoked_trust_unloads_a_project_served_for_its_trust_and_restricts_a_listed_one() {
|
||||
let f = Fixture::new();
|
||||
f.set("backgroundProjects", json!("trusted"));
|
||||
f.list(&["billing"]);
|
||||
for name in ["inventory", "billing"] {
|
||||
f.host.trust.decide(&f.root(name), true, false).unwrap();
|
||||
}
|
||||
let inventory = f.open("inventory");
|
||||
let billing = f.open("billing");
|
||||
assert!(inventory.is_trusted() && billing.is_trusted());
|
||||
for name in ["inventory", "billing"] {
|
||||
f.host.set_project_trust(&f.root(name), false, false).await.unwrap();
|
||||
}
|
||||
assert_eq!(f.loaded(), ["billing"]);
|
||||
assert!(!billing.is_trusted(), "the listed project stays, in Restricted Mode");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_folder_taken_off_the_list_is_unloaded_and_the_others_stay() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
f.open("billing");
|
||||
f.list(&["billing", "orders"]);
|
||||
f.host.apply_background_policy();
|
||||
assert_eq!(f.loaded(), ["billing"]);
|
||||
f.host.apply_background_policy();
|
||||
assert_eq!(f.loaded(), ["billing"], "nothing more to unload");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn turning_background_projects_or_the_server_off_unloads_every_project() {
|
||||
for (key, value) in [("backgroundProjects", json!("off")), ("enabled", json!(false))] {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
f.open("billing");
|
||||
f.set(key, value);
|
||||
f.host.apply_background_policy();
|
||||
assert!(f.loaded().is_empty(), "{key}");
|
||||
assert!(f.host.projects().is_empty(), "{key}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn the_observer_hears_of_every_open_unload_and_eviction_outside_the_locks() {
|
||||
let f = Fixture::new();
|
||||
let heard = Arc::new(AtomicUsize::new(0));
|
||||
let locked = Arc::new(AtomicUsize::new(0));
|
||||
let (count, under_lock, host) = (heard.clone(), locked.clone(), Arc::downgrade(&f.host));
|
||||
f.host.set_background_projects_observer(Arc::new(move || {
|
||||
count.fetch_add(1, Ordering::AcqRel);
|
||||
let host = host.upgrade().unwrap();
|
||||
let background = &host.mcp_background;
|
||||
if background.gate.try_lock().is_none() || background.state.try_lock().is_none() {
|
||||
under_lock.fetch_add(1, Ordering::AcqRel);
|
||||
}
|
||||
}));
|
||||
let heard = || heard.load(Ordering::Acquire);
|
||||
let root = f.root("inventory");
|
||||
f.open("inventory");
|
||||
assert_eq!(heard(), 1, "an open");
|
||||
f.open("inventory");
|
||||
assert_eq!(heard(), 1, "a loaded project is reused silently");
|
||||
assert!(f.background().detach(&f.host, &root, None));
|
||||
assert_eq!(heard(), 2, "an unload");
|
||||
assert!(!f.background().detach(&f.host, &root, None));
|
||||
f.list(&["inventory", "billing"]);
|
||||
assert!(f.refused("orders").contains("not served"));
|
||||
assert_eq!(heard(), 2, "nothing changed");
|
||||
f.set("backgroundProjectLimit", json!(1));
|
||||
f.open("inventory");
|
||||
f.open("billing");
|
||||
assert_eq!(heard(), 4, "an open, then an eviction with its open");
|
||||
f.background().sweep(&f.host, f.used("billing") + 30 * MINUTE);
|
||||
assert_eq!(heard(), 5, "an idle unload");
|
||||
f.open("billing");
|
||||
f.host.open_project("main", &f.root("billing")).unwrap();
|
||||
assert_eq!(heard(), 7, "an open, then a window taking the root over");
|
||||
assert_eq!(locked.load(Ordering::Acquire), 0);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_background_project_is_not_a_window_of_its_root() {
|
||||
use crate::plugins::{HostWorkspace, PluginWorkspace};
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
f.host.open_project("main", &f.root("billing")).unwrap();
|
||||
let workspace = HostWorkspace(Arc::downgrade(&f.host));
|
||||
assert!(f.host.windows_for_root(&f.root("inventory")).is_empty());
|
||||
assert!(workspace.project_windows(&f.root("inventory")).is_empty(), "a plugin's notification finds no window");
|
||||
assert_eq!(f.host.windows_for_root(&f.root("billing")), ["main"]);
|
||||
assert_eq!(workspace.project_windows(&f.root("billing")), ["main"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn unloading_a_project_keeps_the_diagnostics_of_a_window_around_it() {
|
||||
let f = Fixture::new();
|
||||
f.list(&["inventory/parts", "billing"]);
|
||||
f.host.open_project("main", &f.root("inventory")).unwrap();
|
||||
f.open("inventory/parts");
|
||||
f.open("billing");
|
||||
let problem = ide_core::Diagnostic {
|
||||
range: ide_core::Range::point(ide_core::Pos::new(0, 0)),
|
||||
severity: ide_core::Severity::Warning,
|
||||
message: "low stock".into(),
|
||||
source: Some("lint".into()),
|
||||
code: None,
|
||||
unnecessary: false,
|
||||
deprecated: false,
|
||||
server: None,
|
||||
};
|
||||
let (nested, apart) = (f.root("inventory/parts/list.txt"), f.root("billing/notes.txt"));
|
||||
for file in [&nested, &apart] {
|
||||
f.host.diagnostics.replace(file, "lint", vec![problem.clone()]);
|
||||
}
|
||||
assert!(f.background().detach(&f.host, &f.root("inventory/parts"), None));
|
||||
assert!(f.background().detach(&f.host, &f.root("billing"), None));
|
||||
assert!(!f.host.diagnostics.file(&nested).is_empty(), "the window on `inventory` still shows them");
|
||||
assert!(f.host.diagnostics.file(&apart).is_empty(), "no project is left for these");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn the_snapshot_lists_projects_by_root_with_their_idle_time_and_what_holds_them() {
|
||||
let f = Fixture::new();
|
||||
f.open("orders");
|
||||
f.open("billing");
|
||||
let now = f.used("billing") + 10 * MINUTE;
|
||||
let snapshot = f.background().snapshot(&f.host, now);
|
||||
let roots: Vec<_> = snapshot.iter().map(|project| project.root.0.clone()).collect();
|
||||
assert_eq!(roots, [f.root("billing"), f.root("orders")]);
|
||||
let expected = McpBackgroundProject {
|
||||
root: f.root("billing").into(),
|
||||
idle_seconds: 600,
|
||||
unloads_in_seconds: Some(1200),
|
||||
kept_open_by: None,
|
||||
};
|
||||
assert_eq!(snapshot[0], expected);
|
||||
assert_eq!(
|
||||
serde_json::to_value(&snapshot[0]).unwrap(),
|
||||
json!({ "root": IpcPath::from(f.root("billing")), "idleSeconds": 600, "unloadsInSeconds": 1200 })
|
||||
);
|
||||
// Past its time and not swept yet: due now.
|
||||
assert_eq!(f.background().snapshot(&f.host, now + 60 * MINUTE)[0].unloads_in_seconds, Some(0));
|
||||
|
||||
let call = f.call("billing");
|
||||
let held = f.background().snapshot(&f.host, f.used("billing") + MINUTE).remove(0);
|
||||
assert_eq!((held.idle_seconds, held.unloads_in_seconds), (60, None));
|
||||
assert_eq!(serde_json::to_value(&held).unwrap()["keptOpenBy"], json!({ "kind": "request" }));
|
||||
drop(call);
|
||||
let run = McpBackgroundHold::Run { name: "serve stock".into() };
|
||||
assert_eq!(serde_json::to_value(run).unwrap(), json!({ "kind": "run", "name": "serve stock" }));
|
||||
|
||||
f.set("backgroundIdleMinutes", json!(0));
|
||||
assert!(f.snapshot().iter().all(|project| project.unloads_in_seconds.is_none()), "never unloaded");
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn the_timer_unloads_a_project_once_it_has_been_idle_for_the_configured_time() {
|
||||
let f = Fixture::new();
|
||||
f.set("backgroundIdleMinutes", json!(1));
|
||||
f.open("inventory");
|
||||
f.host.start_background_sweeper();
|
||||
// The clock is the runtime's and stands still unless the test moves it.
|
||||
tokio::time::sleep(45 * SECOND).await;
|
||||
assert_eq!(f.loaded(), ["inventory"], "swept once, half a minute idle");
|
||||
tokio::time::sleep(60 * SECOND).await;
|
||||
assert!(f.loaded().is_empty(), "swept again at a minute and a half");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn trust_revoked_while_a_project_opens_restricts_or_unloads_it_once_it_is_open() {
|
||||
use ide_mcp::ToolRegistry;
|
||||
for (mode, stays) in [("listed", true), ("trusted", false)] {
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
f.set("backgroundProjects", json!(mode));
|
||||
f.list(if stays { &["inventory"] } else { &[] });
|
||||
f.host.trust.decide(&root, true, false).unwrap();
|
||||
let warm_up = f.hold_warm_up();
|
||||
let open = f.open_in_flight("inventory");
|
||||
wait_until("the open reads the trust decision", || f.an_open_has_read_its_decisions());
|
||||
|
||||
let (host, folder) = (f.host.clone(), root.clone());
|
||||
let (done, refreshed) = std::sync::mpsc::channel();
|
||||
tokio::spawn(async move {
|
||||
// The test may have given up waiting.
|
||||
let _ = done.send(host.set_project_trust(&folder, false, false).await.is_ok());
|
||||
});
|
||||
let waited = refreshed.recv_timeout(A_MOMENT).is_err();
|
||||
drop(warm_up);
|
||||
let project = open.await.unwrap();
|
||||
if waited {
|
||||
assert!(refreshed.recv_timeout(30 * SECOND).unwrap(), "{mode}");
|
||||
}
|
||||
|
||||
assert!(!project.is_trusted(), "{mode}: opened with the trust it read, the project is restricted afterwards");
|
||||
if stays {
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
let tools = crate::mcp::Registry::new(f.host.clone()).tools(&root).unwrap();
|
||||
assert!(tools.iter().all(|tool| tool.read_only), "only the tools that read stay on offer");
|
||||
} else {
|
||||
assert!(f.loaded().is_empty(), "served for its trust, it is unloaded");
|
||||
assert!(f.host.project(&BackgroundProjects::key(&root)).is_err());
|
||||
}
|
||||
assert!(waited, "{mode}: the refresh waits for the open under way");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_policy_change_while_a_project_opens_unloads_it_once_it_is_open() {
|
||||
for change in ["the mode turned off", "the folder taken off the list", "the server turned off"] {
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
let warm_up = f.hold_warm_up();
|
||||
let open = f.open_in_flight("inventory");
|
||||
wait_until("the open reads the settings", || f.an_open_has_read_its_decisions());
|
||||
|
||||
match change {
|
||||
"the mode turned off" => f.set("backgroundProjects", json!("off")),
|
||||
"the folder taken off the list" => f.list(&["billing"]),
|
||||
_ => f.set("enabled", json!(false)),
|
||||
}
|
||||
let host = f.host.clone();
|
||||
let (done, applied) = std::sync::mpsc::channel();
|
||||
tokio::task::spawn_blocking(move || {
|
||||
host.apply_background_policy();
|
||||
// The test may have given up waiting.
|
||||
let _ = done.send(());
|
||||
});
|
||||
let waited = applied.recv_timeout(A_MOMENT).is_err();
|
||||
drop(warm_up);
|
||||
open.await.unwrap();
|
||||
if waited {
|
||||
applied.recv_timeout(30 * SECOND).expect(change);
|
||||
}
|
||||
|
||||
assert!(f.loaded().is_empty(), "{change}: the project that was opening is unloaded");
|
||||
assert!(f.host.project(&BackgroundProjects::key(&root)).is_err(), "{change}");
|
||||
assert!(waited, "{change}: the policy waits for the open under way");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_host_that_serves_none_refuses_every_folder_whatever_the_settings_say() {
|
||||
use ide_mcp::ToolRegistry;
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
f.host.mcp_background.serve_none();
|
||||
let registry = crate::mcp::Registry::new(f.host.clone());
|
||||
assert_eq!(registry.resolve(&root.join("parts")), None);
|
||||
assert_eq!(f.refused("inventory"), format!("{} is not served in the background", root.display()));
|
||||
assert!(f.loaded().is_empty());
|
||||
assert!(f.host.projects().is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_call_that_arrives_after_the_server_was_turned_off_opens_nothing() {
|
||||
use ide_mcp::ToolRegistry;
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
// A request the server had accepted before it stopped still reaches the open.
|
||||
f.set("enabled", json!(false));
|
||||
f.host.apply_background_policy();
|
||||
assert_eq!(f.refused("inventory"), format!("{} is not served in the background", root.display()));
|
||||
assert!(f.loaded().is_empty());
|
||||
assert!(f.host.projects().is_empty());
|
||||
let registry = crate::mcp::Registry::new(f.host.clone());
|
||||
assert_eq!(registry.resolve(&root.join("parts")), None, "no folder is served with the server off");
|
||||
assert!(registry.tools(&root).is_err());
|
||||
|
||||
f.set("enabled", json!(true));
|
||||
assert_eq!(registry.resolve(&root.join("parts")), Some(root));
|
||||
f.open("inventory");
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_window_opening_another_folder_does_not_wait_for_a_background_open() {
|
||||
let f = Fixture::new();
|
||||
let key = BackgroundProjects::key(&f.root("inventory"));
|
||||
// The background open stops at its own open lock, which it takes with the gate held.
|
||||
let lock = f.host.opening(&key);
|
||||
let held = lock.lock();
|
||||
let open = f.open_in_flight("inventory");
|
||||
|
||||
let (host, billing) = (f.host.clone(), f.root("billing"));
|
||||
let (done, opened) = std::sync::mpsc::channel();
|
||||
tokio::task::spawn_blocking(move || {
|
||||
// The test may have given up waiting.
|
||||
let _ = done.send(host.open_project("main", &billing).map(|project| project.root.clone()));
|
||||
});
|
||||
let window = opened.recv_timeout(10 * SECOND).expect("the window opens while the background open is held");
|
||||
assert_eq!(window.unwrap(), f.root("billing"));
|
||||
assert!(f.loaded().is_empty(), "the background open is still under way");
|
||||
|
||||
drop(held);
|
||||
open.await.unwrap();
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_window_opening_the_folder_that_is_being_opened_waits_for_it_and_takes_it_over() {
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
let key = BackgroundProjects::key(&root);
|
||||
let lock = f.host.opening(&key);
|
||||
let held = lock.lock();
|
||||
let open = f.open_in_flight("inventory");
|
||||
wait_until("the open marks its root", || f.background().state.lock().opening.as_deref() == Some(root.as_path()));
|
||||
|
||||
let (host, folder) = (f.host.clone(), root.clone());
|
||||
let (done, opened) = std::sync::mpsc::channel();
|
||||
tokio::task::spawn_blocking(move || {
|
||||
// The test may have given up waiting.
|
||||
let _ = done.send(host.open_project("main", &folder).map(|project| project.root.clone()));
|
||||
});
|
||||
let early = opened.recv_timeout(A_MOMENT).ok();
|
||||
assert!(early.is_none(), "the window waits for the background open of its own folder");
|
||||
drop(held);
|
||||
open.await.unwrap();
|
||||
assert_eq!(opened.recv_timeout(30 * SECOND).unwrap().unwrap(), root);
|
||||
assert!(f.host.project(&key).is_err(), "the window took the folder over");
|
||||
assert!(f.loaded().is_empty());
|
||||
assert_eq!(f.claims("inventory"), 0);
|
||||
}
|
||||
@@ -1,7 +1,7 @@
|
||||
use super::page::{OFFSET, Page};
|
||||
use super::search::{PathScope, paths_param};
|
||||
use super::tool::{Call, Output, Param, ParamType, Tool};
|
||||
use ide_core::{Diagnostic, IdeResult, Severity};
|
||||
use ide_core::{Diagnostic, IdeError, IdeResult, Severity};
|
||||
use serde_json::{Map, Value, json};
|
||||
|
||||
/// Problems `get_project_problems` lists by default.
|
||||
@@ -51,7 +51,28 @@ Lines and UTF-16 columns are 1-based.",
|
||||
]
|
||||
}
|
||||
|
||||
/// Editors and the Problems view are reported by a window: a project served in the
|
||||
/// background has none, and says so instead of answering as if nothing were open.
|
||||
fn reported_by_a_window(call: &Call) -> IdeResult<()> {
|
||||
if !super::BackgroundProjects::is_key(call.window()) {
|
||||
return Ok(());
|
||||
}
|
||||
let (tool, root) = (&call.tool, call.root().display());
|
||||
Err(IdeError::unavailable(format!(
|
||||
"{tool} needs the project open in a window: {root} is served in the background."
|
||||
)))
|
||||
}
|
||||
|
||||
/// [`reported_by_a_window`] for the Problems view, which `check_files` stands in for.
|
||||
fn problems_reported_by_a_window(call: &Call) -> IdeResult<()> {
|
||||
reported_by_a_window(call).map_err(|mut error| {
|
||||
error.message.push_str(" Use check_files for diagnostics.");
|
||||
error
|
||||
})
|
||||
}
|
||||
|
||||
async fn open_editors(call: Call) -> IdeResult<Output> {
|
||||
reported_by_a_window(&call)?;
|
||||
let paths = PathScope::of(&call)?;
|
||||
let windows = call.host.mcp_windows(call.root());
|
||||
let open = call.host.mcp_reports.editors(&windows);
|
||||
@@ -63,6 +84,7 @@ async fn open_editors(call: Call) -> IdeResult<Output> {
|
||||
}
|
||||
|
||||
async fn current_file(call: Call) -> IdeResult<Output> {
|
||||
reported_by_a_window(&call)?;
|
||||
let editor = call.host.mcp_reports.focused(call.window());
|
||||
Output::json(match editor {
|
||||
None => json!({}),
|
||||
@@ -85,6 +107,7 @@ pub(super) fn problem(d: Diagnostic, text: &str) -> Value {
|
||||
}
|
||||
|
||||
async fn file_problems(call: Call) -> IdeResult<Output> {
|
||||
problems_reported_by_a_window(&call)?;
|
||||
let path = call.resolve_readable(&call.str("filePath")?).await?;
|
||||
let errors_only = call.flag("errorsOnly", true)?;
|
||||
let files = call.host.mcp_reports.problems(&call.host.mcp_windows(call.root()));
|
||||
@@ -101,6 +124,7 @@ async fn file_problems(call: Call) -> IdeResult<Output> {
|
||||
}
|
||||
|
||||
async fn project_problems(call: Call) -> IdeResult<Output> {
|
||||
problems_reported_by_a_window(&call)?;
|
||||
let page = Page::of(&call, PROBLEMS_LIMIT)?;
|
||||
let errors_only = call.flag("errorsOnly", true)?;
|
||||
let paths = PathScope::of(&call)?;
|
||||
|
||||
@@ -1,10 +1,12 @@
|
||||
//! Built-in IDE tools. Transport and discovery live in `ide-mcp`.
|
||||
mod background;
|
||||
mod check;
|
||||
mod edit;
|
||||
mod editors;
|
||||
mod requests;
|
||||
pub(crate) mod run;
|
||||
mod vcs;
|
||||
pub use background::{BackgroundProjects, McpBackgroundHold, McpBackgroundProject};
|
||||
pub use requests::Requests;
|
||||
mod files;
|
||||
mod http;
|
||||
@@ -55,12 +57,13 @@ fn allowed(tool: &ide_mcp::Tool, trusted: bool) -> bool {
|
||||
}
|
||||
|
||||
impl Registry {
|
||||
fn target(&self, root: &Path) -> Result<(String, Arc<crate::Project>), String> {
|
||||
/// The window that answers for `root`: one with the root open, or one it is attached in.
|
||||
fn window(&self, root: &Path) -> Result<Option<(String, Arc<crate::Project>)>, String> {
|
||||
if self.0.mcp_reports.remote_roots().iter().any(|p| p == root) {
|
||||
return Err("project is on a remote host; connect to the MCP server on that host".into());
|
||||
}
|
||||
let projects = self.0.projects.read();
|
||||
let open = || projects.iter().filter(|(_, p)| !p.light);
|
||||
let open = || projects.iter().filter(|(w, p)| !p.light && !BackgroundProjects::is_key(w));
|
||||
let mut windows: Vec<_> = open().filter(|(_, p)| p.root == root).map(|(w, p)| (w.clone(), p.clone())).collect();
|
||||
if windows.is_empty() {
|
||||
// A project attached to an open one: the window it is attached in.
|
||||
@@ -74,23 +77,57 @@ impl Registry {
|
||||
windows.sort_by(|a, b| {
|
||||
(Some(&b.0) == focused.as_ref()).cmp(&(Some(&a.0) == focused.as_ref())).then(a.0.cmp(&b.0))
|
||||
});
|
||||
windows.into_iter().next().ok_or_else(|| "project is no longer open".into())
|
||||
Ok(windows.into_iter().next())
|
||||
}
|
||||
|
||||
/// The window and project a tool call for `root` runs in. Without a window the project
|
||||
/// is served in the background, under its key, and opened now if need be; the guard
|
||||
/// then keeps it loaded for as long as the caller holds it.
|
||||
fn target(&self, root: &Path) -> Result<background::Served, String> {
|
||||
match self.window(root)? {
|
||||
Some((window, project)) => Ok((window, project, None)),
|
||||
None => self.0.mcp_background.open(&self.0, root).map_err(|e| e.message),
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether the tools listed for `root` include those that write and run. Opens nothing:
|
||||
/// a background project that is not loaded is judged as its open will judge it.
|
||||
fn lists_as_trusted(&self, root: &Path) -> Result<bool, String> {
|
||||
if let Some((_, project)) = self.window(root)? {
|
||||
return Ok(project.is_trusted());
|
||||
}
|
||||
if let Some(project) = self.0.mcp_background.project(&self.0, root) {
|
||||
return Ok(project.is_trusted());
|
||||
}
|
||||
if background::serving_root(&self.0, root).as_deref() == Some(root) {
|
||||
return Ok(self.0.trust.window_trusted(root).unwrap_or(false));
|
||||
}
|
||||
Err("project is no longer open".into())
|
||||
}
|
||||
}
|
||||
impl ToolRegistry for Registry {
|
||||
fn projects(&self) -> Vec<PathBuf> {
|
||||
let open: Vec<_> = self.0.projects().into_iter().filter(|p| !p.light).collect();
|
||||
// Window projects only: a background project is reached through `resolve`, so a
|
||||
// request that names no folder still means the only window.
|
||||
let open: Vec<_> = {
|
||||
let projects = self.0.projects.read();
|
||||
let windows = projects.iter().filter(|(w, p)| !p.light && !BackgroundProjects::is_key(w));
|
||||
windows.map(|(_, p)| p.clone()).collect()
|
||||
};
|
||||
// Attached projects are listed too, so a `projectPath` inside one names it.
|
||||
let attached: Vec<_> = open.iter().flat_map(|p| tool::attached_projects(&p.root)).collect();
|
||||
open.into_iter().map(|p| p.root.clone()).chain(attached).chain(self.0.mcp_reports.remote_roots()).collect()
|
||||
}
|
||||
fn resolve(&self, path: &Path) -> Option<PathBuf> {
|
||||
background::serving_root(&self.0, path)
|
||||
}
|
||||
fn tools(&self, root: &Path) -> Result<Vec<ide_mcp::Tool>, String> {
|
||||
let (_, project) = self.target(root)?;
|
||||
let trusted = self.lists_as_trusted(root)?;
|
||||
let mut all: Vec<_> = tools().into_iter().map(|t| t.metadata).collect();
|
||||
if let Some(plugins) = self.0.plugin_host() {
|
||||
all.extend(plugins.mcp_tools(root).into_iter().map(|(_, _, tool)| tool));
|
||||
}
|
||||
Ok(all.into_iter().filter(|t| allowed(t, project.is_trusted())).collect())
|
||||
Ok(all.into_iter().filter(|t| allowed(t, trusted)).collect())
|
||||
}
|
||||
fn call(
|
||||
&self,
|
||||
@@ -109,7 +146,9 @@ impl ToolRegistry for Registry {
|
||||
cancel: CancellationToken,
|
||||
client: &str,
|
||||
) -> Result<String, ToolCallError> {
|
||||
let (window, project) = self.target(root).map_err(ToolCallError::Failed)?;
|
||||
// The guard lives until the call ends, whichever way it leaves: neither the idle
|
||||
// sweep nor the limit unloads a background project a call runs in.
|
||||
let (window, project, _activity) = self.target(root).map_err(ToolCallError::Failed)?;
|
||||
if let Some(plugins) = self.0.plugin_host()
|
||||
&& let Some((plugin, tool, metadata)) =
|
||||
plugins.mcp_tools(root).into_iter().find(|(_, _, t)| t.name == name && allowed(t, project.is_trusted()))
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
//! Agents › IDE MCP Server: runs `ide_mcp::McpServer` over built-in host tools
|
||||
//! while `mcpServer.enabled` is on, and reports where it listens.
|
||||
|
||||
use super::McpBackgroundProject;
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeResult, IpcPath};
|
||||
@@ -10,6 +11,7 @@ use specta::Type;
|
||||
use std::net::IpAddr;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
use std::time::Instant;
|
||||
|
||||
/// The server while it runs, or why it doesn't.
|
||||
#[derive(Default)]
|
||||
@@ -57,6 +59,17 @@ impl McpService {
|
||||
/// Starts, stops or restarts the server to match the global `mcpServer` settings:
|
||||
/// `enabled`, and the address, port and token it listens with.
|
||||
pub fn apply(&self, host: &Arc<Host>) {
|
||||
// Callers include the main thread (sync commands, app set-up), which must not wait for
|
||||
// a background project that is being opened.
|
||||
let worker = {
|
||||
let host = host.clone();
|
||||
host.runtime.clone().spawn_blocking(move || host.apply_background_policy())
|
||||
};
|
||||
host.runtime.spawn(async move {
|
||||
if let Err(error) = worker.await {
|
||||
tracing::warn!(%error, "applying the background project policy failed");
|
||||
}
|
||||
});
|
||||
let settings = host.global_settings.effective().mcp_server;
|
||||
let mut server = self.server.lock();
|
||||
if !settings.enabled {
|
||||
@@ -247,6 +260,24 @@ pub fn mcp_regenerate_token(host: &Arc<Host>) -> IdeResult<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Settings › Agents › IDE MCP Server › Background projects: the projects this host's server
|
||||
/// keeps loaded without a window.
|
||||
#[command(trust = always)]
|
||||
pub fn mcp_background_projects(host: &Host) -> IdeResult<Vec<McpBackgroundProject>> {
|
||||
Ok(host.mcp_background.snapshot(host, Instant::now()))
|
||||
}
|
||||
|
||||
/// Unloads one background project; a root that is not loaded is already unloaded.
|
||||
#[command(trust = always)]
|
||||
pub async fn mcp_unload_background_project(host: &Arc<Host>, root: IpcPath) -> IdeResult<()> {
|
||||
let h = host.clone();
|
||||
host.blocking(move || {
|
||||
h.mcp_background.detach(&h, &root, None);
|
||||
Ok(())
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub fn mcp_ui_ready(host: &Host, window: &str, ready: bool) -> IdeResult<()> {
|
||||
let window = host.owner_window(window);
|
||||
@@ -289,8 +320,10 @@ mod tests {
|
||||
ide_command::domain!(
|
||||
mcp:
|
||||
mcp_agent_run_closed,
|
||||
mcp_background_projects,
|
||||
mcp_regenerate_token,
|
||||
mcp_respond,
|
||||
mcp_server_status,
|
||||
mcp_ui_ready,
|
||||
mcp_unload_background_project,
|
||||
);
|
||||
@@ -176,7 +176,9 @@ impl Call {
|
||||
let r = ide_vfs::split_archive_path(&r).map_or(r.clone(), |(archive, _)| archive);
|
||||
dunce::canonicalize(r).is_ok_and(|r| real.starts_with(r))
|
||||
}) {
|
||||
return Err(IdeError::invalid("path is outside the project's content roots"));
|
||||
return Err(IdeError::invalid(
|
||||
"path is outside the project's content roots: ask the user before reading anything else outside the project",
|
||||
));
|
||||
}
|
||||
Ok(entry.map_or_else(|| real.clone(), |entry| PathBuf::from(format!("{}!/{entry}", real.display()))))
|
||||
})
|
||||
@@ -236,7 +238,7 @@ impl Tool {
|
||||
destructive: false,
|
||||
output_schema: None,
|
||||
input_schema: json!({ "type": "object", "properties": {
|
||||
"projectPath": { "type": "string", "description": "Any directory inside an open project. Defaults to the connection's project (`?project=`) or the only open one." }
|
||||
"projectPath": { "type": "string", "description": "Any directory inside a project that is open in a window or served in the background. Defaults to the connection's project (`?project=`) or the only one open in a window." }
|
||||
}, "required": [] }),
|
||||
},
|
||||
handler: Arc::new(move |call| Box::pin(handler(call))),
|
||||
@@ -307,7 +309,9 @@ pub fn resolve_inside(root: &Path, raw: &str) -> IdeResult<PathBuf> {
|
||||
}
|
||||
let root = dunce::canonicalize(root)?;
|
||||
if !real.starts_with(&root) {
|
||||
return Err(IdeError::invalid("path is outside the project"));
|
||||
return Err(IdeError::invalid(
|
||||
"path is outside the project: these tools change files inside it only; ask the user before touching anything outside it",
|
||||
));
|
||||
}
|
||||
if real
|
||||
.strip_prefix(&root)
|
||||
|
||||
@@ -33,6 +33,16 @@ pub fn agent_providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider
|
||||
Ok(providers)
|
||||
}
|
||||
|
||||
/// Hermes Agent profiles on this machine (`default` first); empty without Hermes.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_hermes_profiles(host: &Host, window: &str) -> IdeResult<Vec<ide_agent::hermes::HermesProfile>> {
|
||||
host.require_trust(window)?;
|
||||
let root = ide_agent::hermes::root(dirs::home_dir().as_deref());
|
||||
tokio::task::spawn_blocking(move || root.map(|r| ide_agent::hermes::labeled_profiles(&r)).unwrap_or_default())
|
||||
.await
|
||||
.map_err(join_err)
|
||||
}
|
||||
|
||||
/// Refreshes the model catalog; force bypasses freshness, not the cooldown.
|
||||
#[command(trust = trusted)]
|
||||
pub fn agent_refresh_models(
|
||||
@@ -1075,6 +1085,7 @@ ide_command::domain!(
|
||||
agent_external_sessions,
|
||||
agent_fork,
|
||||
agent_grouped_changes,
|
||||
agent_hermes_profiles,
|
||||
agent_import_session,
|
||||
agent_mcp_discover_sources,
|
||||
agent_mcp_import,
|
||||
|
||||
@@ -245,6 +245,7 @@ pub async fn build_sync(
|
||||
return Err(IdeError::not_found("Build project is no longer linked"));
|
||||
}
|
||||
let mut profiles_changed = false;
|
||||
let mut offline_changed = false;
|
||||
for scope in selected {
|
||||
if token.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
@@ -260,6 +261,10 @@ pub async fn build_sync(
|
||||
p.sink.emit(IdeEvent::ProjectRootsChanged { root: p.root.clone().into() });
|
||||
}
|
||||
profiles_changed |= changed;
|
||||
offline_changed |= ide_build::save_maven_offline(cache, offline).unwrap_or_else(|e| {
|
||||
tracing::warn!("Maven offline mode not saved: {e}");
|
||||
false
|
||||
});
|
||||
}
|
||||
let env = current
|
||||
.maven
|
||||
@@ -306,12 +311,12 @@ pub async fn build_sync(
|
||||
let scopes = workspace::scopes(&p, &config)?;
|
||||
let model = workspace::load_scopes(&p.root, &scopes);
|
||||
let updates = workspace::update_files(&p.root, &scopes, &model, tool);
|
||||
Ok::<_, IdeError>((model, profiles_changed, updates))
|
||||
Ok::<_, IdeError>((model, profiles_changed, offline_changed, updates))
|
||||
})
|
||||
.await
|
||||
.map_err(join_err);
|
||||
host.end_request(request);
|
||||
let (model, profiles_changed, updates) = result??;
|
||||
let (model, profiles_changed, offline_changed, updates) = result??;
|
||||
if completion_token.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
@@ -336,8 +341,8 @@ pub async fn build_sync(
|
||||
let lsp = project.lsp.clone();
|
||||
let documents = project.documents.clone();
|
||||
tokio::spawn(async move {
|
||||
if profiles_changed {
|
||||
// jdtls takes the profiles from its Maven settings (see `ide_sdk::maven_profiles`).
|
||||
if profiles_changed || offline_changed {
|
||||
// jdtls takes the profiles and offline mode from its Maven settings (see `ide_sdk::maven_profiles`).
|
||||
lsp.reconfigure().await;
|
||||
}
|
||||
let first = updates.first().cloned();
|
||||
|
||||
@@ -32,7 +32,12 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let agents = if is_jvm_launch(&config) { ide_run::java_agent::current() } else { Default::default() };
|
||||
let java_exec = java_exec_path(&config);
|
||||
let agents = if is_jvm_launch(&config) {
|
||||
ide_run::java_agent::current_for(java_exec.as_deref())
|
||||
} else {
|
||||
Default::default()
|
||||
};
|
||||
let config = add_java_agents(config, &agents.options);
|
||||
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
|
||||
if config.adapter == "debugpy"
|
||||
@@ -211,6 +216,12 @@ fn is_jvm_launch(config: &LaunchConfig) -> bool {
|
||||
&& matches!(config.adapter.as_str(), "java-debug" | ide_dap::kotlin::ADAPTER | ide_dap::adapter::JAVA_ANALYZER)
|
||||
}
|
||||
|
||||
/// `javaExec` from the launch extras, for gating contributed `vmOptions` on JetBrains Runtime.
|
||||
fn java_exec_path(config: &LaunchConfig) -> Option<std::path::PathBuf> {
|
||||
let extra: serde_json::Value = serde_json::from_str(config.extra_json.as_deref()?).ok()?;
|
||||
extra.get("javaExec").and_then(|v| v.as_str()).filter(|s| !s.is_empty()).map(std::path::PathBuf::from)
|
||||
}
|
||||
|
||||
/// Plugins' Java agents ([`ide_run::java_agent`]) after the configuration's VM options:
|
||||
/// java-debug's and java-analyzer's `vmArgs` (one line, or a list) or the Kotlin debugger's
|
||||
/// `vmArguments` (a list).
|
||||
|
||||
@@ -127,6 +127,13 @@ pub async fn doc_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec
|
||||
.await
|
||||
}
|
||||
|
||||
/// Structure view of a Flutter file: its declarations with the widgets they build. `None`
|
||||
/// when the Dart server published no widgets for it; `doc_outline` then applies.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_flutter_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Option<Vec<OutlineItem>>> {
|
||||
Ok(host.project(window)?.lsp.flutter_outline(doc))
|
||||
}
|
||||
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_folding(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<FoldRange>> {
|
||||
let project = host.project(window)?;
|
||||
@@ -227,6 +234,7 @@ pub async fn history_content(host: &Host, window: &str, id: String) -> IdeResult
|
||||
|
||||
ide_command::domain!(
|
||||
doc_commands:
|
||||
doc_flutter_outline,
|
||||
doc_folding,
|
||||
doc_highlights,
|
||||
doc_language,
|
||||
|
||||
@@ -6,14 +6,13 @@ use ide_core::{IdeError, IdeResult};
|
||||
use ide_docker::DockerEndpoint;
|
||||
use ide_ssh::Tunnel;
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
use std::sync::Arc;
|
||||
|
||||
/// What each tunnelled connection runs on the SSH host, as the Docker CLI's `ssh://` does.
|
||||
const DIAL: &str = "docker system dial-stdio";
|
||||
|
||||
/// Open tunnels of [`DockerEndpoint::Ssh`] connections, by SSH configuration id.
|
||||
#[derive(Default)]
|
||||
pub struct DockerTunnels(tokio::sync::Mutex<HashMap<String, Arc<Tunnel>>>);
|
||||
pub struct DockerTunnels(tokio::sync::Mutex<HashMap<String, Tunnel>>);
|
||||
|
||||
/// `endpoint` as docker can use it: an SSH configuration becomes the local end of a tunnel to its
|
||||
/// host's daemon (opened on first use, reopened when the SSH connection dropped).
|
||||
@@ -21,8 +20,8 @@ pub async fn resolve(host: &Host, endpoint: DockerEndpoint) -> IdeResult<DockerE
|
||||
let DockerEndpoint::Ssh { config } = endpoint else { return Ok(endpoint) };
|
||||
let id = config.trim().to_owned();
|
||||
let mut tunnels = host.docker_tunnels.0.lock().await;
|
||||
let tunnel = match tunnels.get(&id).filter(|t| !t.is_closed()) {
|
||||
Some(t) => t.clone(),
|
||||
let port = match tunnels.get(&id).filter(|t| !t.is_closed()) {
|
||||
Some(t) => t.port(),
|
||||
None => {
|
||||
let session = host.ssh.session(&id).await?;
|
||||
// Fail with the reason here: a missing docker only shows as a dropped connection later.
|
||||
@@ -35,12 +34,24 @@ pub async fn resolve(host: &Host, endpoint: DockerEndpoint) -> IdeResult<DockerE
|
||||
if why.is_empty() { String::new() } else { format!(": {why}") }
|
||||
)));
|
||||
}
|
||||
let t = Arc::new(Tunnel::command(session, DIAL).await?);
|
||||
tunnels.insert(id, t.clone());
|
||||
t
|
||||
let t = Tunnel::command(session, DIAL).await?;
|
||||
let port = t.port();
|
||||
tunnels.insert(id, t);
|
||||
port
|
||||
}
|
||||
};
|
||||
Ok(DockerEndpoint::Tcp { host: format!("tcp://127.0.0.1:{}", tunnel.port()), tls_cert_dir: None })
|
||||
Ok(DockerEndpoint::Tcp { host: format!("tcp://127.0.0.1:{port}"), tls_cert_dir: None })
|
||||
}
|
||||
|
||||
/// Closes what [`resolve`] opened for `endpoint`: an SSH configuration's tunnel, and then its SSH
|
||||
/// connection unless something else (a terminal, a transfer) holds it. The next [`resolve`] opens
|
||||
/// them again; other endpoints keep nothing open.
|
||||
pub async fn disconnect(host: &Host, endpoint: &DockerEndpoint) {
|
||||
let DockerEndpoint::Ssh { config } = endpoint else { return };
|
||||
let id = config.trim();
|
||||
let Some(tunnel) = host.docker_tunnels.0.lock().await.remove(id) else { return };
|
||||
tunnel.close().await;
|
||||
host.ssh.release(id);
|
||||
}
|
||||
|
||||
/// Environment for a Docker run configuration's command line: selects `endpoint`'s
|
||||
|
||||
@@ -2,8 +2,8 @@
|
||||
//! adapter run too, so a remote project lists the devices of its remote machine.
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::IdeResult;
|
||||
use ide_core::event::FlutterDeviceList;
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
|
||||
/// The project's Flutter devices, starting its `flutter daemon` on first use. Changes arrive as
|
||||
/// `IdeEvent::FlutterDevices`.
|
||||
@@ -25,4 +25,15 @@ pub fn flutter_daemon_restart(host: &Host, window: &str) -> IdeResult<FlutterDev
|
||||
Ok(host.project(window)?.flutter.restart())
|
||||
}
|
||||
|
||||
ide_command::domain!(flutter: flutter_devices, flutter_devices_refresh, flutter_daemon_restart);
|
||||
/// The address of the project's DevTools server, started on first use. A server that failed or
|
||||
/// exited is only started again by the next request.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn flutter_devtools_url(host: &Host, window: &str) -> IdeResult<String> {
|
||||
let project = host.project(window)?;
|
||||
tokio::task::spawn_blocking(move || project.devtools.url())
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
.map_err(IdeError::unavailable)
|
||||
}
|
||||
|
||||
ide_command::domain!(flutter: flutter_devices, flutter_devices_refresh, flutter_daemon_restart, flutter_devtools_url);
|
||||
@@ -1976,6 +1976,7 @@ pub struct PluginLanguageVisuals {
|
||||
pub injections: Vec<ide_plugin::language_features::Injection>,
|
||||
pub colors: Vec<(String, ide_plugin::language_features::ColorInfo)>,
|
||||
pub gutter_actions: Vec<(String, ide_plugin::language_features::GutterAction)>,
|
||||
pub hover_actions: Vec<(String, ide_plugin::language_features::HoverAction)>,
|
||||
}
|
||||
#[command(trust = trusted)]
|
||||
pub async fn plugin_language_visuals(host: &Host, window: &str, doc: DocId) -> IdeResult<PluginLanguageVisuals> {
|
||||
@@ -1989,14 +1990,20 @@ pub async fn plugin_language_visuals(host: &Host, window: &str, doc: DocId) -> I
|
||||
version: u64::from(snap.version),
|
||||
text: snap.text,
|
||||
};
|
||||
let mut out =
|
||||
PluginLanguageVisuals { version: d.version, injections: vec![], colors: vec![], gutter_actions: vec![] };
|
||||
let mut out = PluginLanguageVisuals {
|
||||
version: d.version,
|
||||
injections: vec![],
|
||||
colors: vec![],
|
||||
gutter_actions: vec![],
|
||||
hover_actions: vec![],
|
||||
};
|
||||
if d.text.len() <= crate::plugins::navigation::MAX_DOCUMENT_BYTES
|
||||
&& let Some(plugins) = crate::plugins::editor_plugin_host()
|
||||
{
|
||||
out.injections = plugins.provide_injections(&d);
|
||||
out.colors = plugins.language_colors(&d);
|
||||
out.gutter_actions = plugins.language_gutter_actions(&d);
|
||||
out.hover_actions = plugins.language_hover_actions(&d);
|
||||
}
|
||||
project.lsp.set_injections_at(
|
||||
doc,
|
||||
|
||||
@@ -542,7 +542,8 @@ fn add_java_agents(config: &mut RunConfig, on_output: &Emit<OutputChunk>, local:
|
||||
if !ide_run::java_agent::applies(&config.kind) {
|
||||
return;
|
||||
}
|
||||
let agents = ide_run::java_agent::current();
|
||||
let java = std::path::Path::new(&config.command);
|
||||
let agents = ide_run::java_agent::current_for(Some(java));
|
||||
let say = |text: &str| on_output(OutputChunk::System { text: format!("{text}\n") });
|
||||
if !local {
|
||||
if !agents.options.is_empty() {
|
||||
|
||||
@@ -17,11 +17,17 @@ fn tools(host: &Host, window: &str) -> IdeResult<Tools> {
|
||||
Ok(project) => (project.settings.effective(), project.root.clone()),
|
||||
Err(_) => (host.global_settings.effective(), Default::default()),
|
||||
};
|
||||
let custom = settings
|
||||
let mut custom: std::collections::BTreeMap<_, _> = settings
|
||||
.tools
|
||||
.iter()
|
||||
.filter_map(|(command, t)| Some((command.clone(), ide_sdk::apply::setting_path(&root, &t.path)?)))
|
||||
.collect();
|
||||
let langs = host.languages.all();
|
||||
custom.extend(ide_sdk::apply::server_command_paths(
|
||||
langs.iter().flat_map(|l| &l.language_servers),
|
||||
&root,
|
||||
&settings,
|
||||
));
|
||||
// Godot is usually an app bundle / Flatpak outside the search path.
|
||||
let found = ide_sdk::godot::find(None).map(|p| (ide_sdk::godot::COMMAND.to_owned(), p));
|
||||
let runtime = ide_sdk::apply::tool_install_environment(&root, &settings);
|
||||
|
||||
@@ -214,10 +214,6 @@ pub enum RemoteOp {
|
||||
tag: String,
|
||||
remote: String,
|
||||
},
|
||||
/// Fast-forwards local `branch` (not checked out) to its upstream.
|
||||
UpdateBranch {
|
||||
branch: String,
|
||||
},
|
||||
/// Pull dialog: `branches` of `remote` (none = the configured merge branch).
|
||||
PullFrom {
|
||||
remote: String,
|
||||
@@ -947,7 +943,6 @@ pub async fn vcs_remote(
|
||||
&cancel,
|
||||
&out,
|
||||
),
|
||||
RemoteOp::UpdateBranch { branch } => r.update_branch(&branch, &cancel, &out),
|
||||
RemoteOp::PushTag { tag, remote } => r.push_tag(&tag, &remote, &cancel, &out),
|
||||
RemoteOp::DeleteRemoteTag { tag, remote } => r.delete_remote_tag(&tag, &remote, &cancel, &out),
|
||||
RemoteOp::PullFrom { remote, branches, rebase, options } => {
|
||||
@@ -961,6 +956,32 @@ pub async fn vcs_remote(
|
||||
result
|
||||
}
|
||||
|
||||
/// Branches › Update Selected: fast-forwards local `branches` to their upstreams, one
|
||||
/// fetch per remote; the result says what happened to each. Cancellable.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn vcs_update_branches(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
repo: Option<PathBuf>,
|
||||
request: RequestId,
|
||||
branches: Vec<String>,
|
||||
on_output: Channel<String>,
|
||||
) -> IdeResult<Vec<BranchUpdate>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
let cancel = host.begin_request(request);
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
let out = |line: String| {
|
||||
let _ = on_output.send(line);
|
||||
};
|
||||
project.with_repo_recorded(repo.as_deref(), Some("Git pull"), |r| r.update_branches(&branches, &cancel, &out))
|
||||
})
|
||||
.await
|
||||
.map_err(|e| ide_core::IdeError::internal(e.to_string()))?;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
/// The user's side is `ours` (sides swapped during a rebase, as in IDEA).
|
||||
#[command(trust = always)]
|
||||
pub async fn vcs_conflict_versions(host: &Host, window: &str, path: PathBuf) -> IdeResult<ide_vcs::MergeVersions> {
|
||||
@@ -1630,6 +1651,7 @@ ide_command::domain!(
|
||||
vcs_rebase,
|
||||
vcs_rebase_with,
|
||||
vcs_remote,
|
||||
vcs_update_branches,
|
||||
vcs_remotes,
|
||||
vcs_remove_worktree,
|
||||
vcs_rename_branch,
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
use ide_core::event::NotifyLevel;
|
||||
use ide_core::output_encoding::decode_tool_output;
|
||||
use ide_core::{CancellationToken, Diagnostic, IdeEvent, Pos, Range, Severity, SharedSink};
|
||||
use ide_text::AppliedChange;
|
||||
use ide_workspace::SettingsStore;
|
||||
use ide_workspace::documents::DocumentObserver;
|
||||
use parking_lot::Mutex;
|
||||
@@ -51,6 +52,8 @@ pub(crate) struct Phpstan {
|
||||
changed: Notify,
|
||||
/// Files with PHPStan diagnostics, the only ones a clean result or a removal clears.
|
||||
shown: Mutex<HashSet<PathBuf>>,
|
||||
/// Files edited since their last save: a check of the saved text has no ranges for them.
|
||||
edited: Mutex<HashSet<PathBuf>>,
|
||||
}
|
||||
|
||||
impl Phpstan {
|
||||
@@ -71,6 +74,7 @@ impl Phpstan {
|
||||
queue: Mutex::new(Queue::default()),
|
||||
changed: Notify::new(),
|
||||
shown: Mutex::new(HashSet::new()),
|
||||
edited: Mutex::new(HashSet::new()),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -96,6 +100,12 @@ impl Phpstan {
|
||||
if self.lifetime.is_cancelled() || files.peek().is_none() {
|
||||
return;
|
||||
}
|
||||
let files: Vec<PathBuf> = files.collect();
|
||||
let mut edited = self.edited.lock();
|
||||
for path in &files {
|
||||
edited.remove(path);
|
||||
}
|
||||
drop(edited);
|
||||
self.queue.lock().push(files);
|
||||
self.changed.notify_one();
|
||||
}
|
||||
@@ -205,6 +215,10 @@ impl Phpstan {
|
||||
.await
|
||||
.unwrap_or_default();
|
||||
for (path, items) in results {
|
||||
// Edited while the saved text was checked: its lines moved since.
|
||||
if self.edited.lock().contains(&path) {
|
||||
continue;
|
||||
}
|
||||
// Severe errors (a syntax error) stop the analysis of the other files.
|
||||
if report.complete || !items.is_empty() {
|
||||
self.publish(path, items);
|
||||
@@ -246,6 +260,23 @@ impl DocumentObserver for Phpstan {
|
||||
fn saved(&self, _doc: ide_core::DocId, path: &Path, _text: &str) {
|
||||
self.files_saved([path.to_path_buf()]);
|
||||
}
|
||||
|
||||
/// The shown ranges belong to the saved text PHPStan ran on, so an edit that
|
||||
/// reaches the buffer before the next save would paint them on other lines
|
||||
/// (`issue #4482`): drop them until the file is saved again.
|
||||
fn changed(
|
||||
&self,
|
||||
_doc: ide_core::DocId,
|
||||
path: &Path,
|
||||
_version: u32,
|
||||
_changes: &[AppliedChange],
|
||||
_full_text: &dyn Fn() -> String,
|
||||
) {
|
||||
if !path.extension().is_some_and(|e| e == "php") || !self.edited.lock().insert(path.to_path_buf()) {
|
||||
return;
|
||||
}
|
||||
self.publish(path.to_path_buf(), Vec::new());
|
||||
}
|
||||
}
|
||||
|
||||
async fn debounce(cancel: &CancellationToken, lifetime: &CancellationToken) -> bool {
|
||||
@@ -847,4 +878,52 @@ mod tests {
|
||||
assert_eq!(f.diagnostics()[1], (a, vec![]));
|
||||
f.checker.stop();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn an_edit_before_the_next_save_drops_the_saved_text_diagnostics() {
|
||||
let f = Fixture::new();
|
||||
let a = f.file("A.php");
|
||||
f.report(&a, &["constant.notFound"]);
|
||||
f.checker.files_saved([a.clone()]);
|
||||
f.until("the check", |f| f.diagnostics().len() == 1).await;
|
||||
|
||||
let edit = || {
|
||||
[AppliedChange { range: ide_core::Range::point(ide_core::Pos::new(1, 0)), text: "$aaa = array();".into() }]
|
||||
};
|
||||
let full = || String::new();
|
||||
DocumentObserver::changed(f.checker.as_ref(), ide_core::DocId(0), &a, 1, &edit(), &full);
|
||||
f.until("the drop", |f| f.diagnostics().len() == 2).await;
|
||||
assert_eq!(f.diagnostics()[1], (a.clone(), vec![]));
|
||||
// Further edits of the same dirty buffer change nothing.
|
||||
DocumentObserver::changed(f.checker.as_ref(), ide_core::DocId(0), &a, 2, &edit(), &full);
|
||||
tokio::time::sleep(Duration::from_millis(150)).await;
|
||||
assert_eq!(f.diagnostics().len(), 2);
|
||||
|
||||
// The next save checks the file again.
|
||||
f.report(&a, &["constant.notFound"]);
|
||||
f.checker.files_saved([a.clone()]);
|
||||
f.until("the fresh check", |f| f.diagnostics().len() == 3).await;
|
||||
assert_eq!(f.diagnostics()[2], (a.clone(), vec![Some("constant.notFound".to_string())]));
|
||||
f.checker.stop();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_check_finishing_after_an_edit_shows_nothing_until_the_next_save() {
|
||||
let f = Fixture::new();
|
||||
let a = f.file("A.php");
|
||||
f.report(&a, &["constant.notFound"]);
|
||||
f.checker.files_saved([a.clone()]);
|
||||
let edit = [AppliedChange { range: ide_core::Range::point(ide_core::Pos::new(1, 0)), text: "\n".into() }];
|
||||
DocumentObserver::changed(f.checker.as_ref(), ide_core::DocId(0), &a, 1, &edit, &String::new);
|
||||
f.until("the check", |f| !f.runs().is_empty()).await;
|
||||
tokio::time::sleep(Duration::from_millis(300)).await;
|
||||
assert!(f.diagnostics().is_empty(), "{:?}", f.diagnostics());
|
||||
|
||||
f.checker.files_saved([a.clone()]);
|
||||
f.until("the next check", |f| f.diagnostics().len() == 1).await;
|
||||
assert_eq!(f.diagnostics()[0], (a.clone(), vec![Some("constant.notFound".to_string())]));
|
||||
f.checker.stop();
|
||||
}
|
||||
}
|
||||
@@ -406,15 +406,16 @@ impl Proc {
|
||||
}
|
||||
}
|
||||
|
||||
/// What it printed since the last call, each stream at most `max` bytes.
|
||||
/// What it printed since the last call, each stream at most `max` bytes. The status
|
||||
/// comes with the last chunk only: once it ended, its pipes reached the end and
|
||||
/// nothing is left to read, so a caller can stop at the first chunk that has one.
|
||||
fn chunk(&self, max: usize) -> ProcessChunk {
|
||||
let mut state = self.state.lock();
|
||||
let eof = state.readers == 0;
|
||||
ProcessChunk {
|
||||
stdout: take_text(&mut state.stdout, max, eof),
|
||||
stderr: take_text(&mut state.stderr, max, eof),
|
||||
status: state.status,
|
||||
}
|
||||
let stdout = take_text(&mut state.stdout, max, eof);
|
||||
let stderr = take_text(&mut state.stderr, max, eof);
|
||||
let drained = eof && state.stdout.is_empty() && state.stderr.is_empty();
|
||||
ProcessChunk { stdout, stderr, status: state.status.filter(|_| drained) }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2116,6 +2117,23 @@ impl HostApi for PluginApi {
|
||||
.emit(None, PluginEvent::StatusItemChanged { plugin_id: self.id().to_owned(), id: id.to_owned(), item });
|
||||
}
|
||||
|
||||
fn check_status_menu(&self, menu: &[ide_plugin::StatusMenuEntry]) -> Result<(), HostError> {
|
||||
let actions: Vec<ide_plugin::NotificationAction> = menu
|
||||
.iter()
|
||||
.filter_map(|entry| match entry {
|
||||
ide_plugin::StatusMenuEntry::Action { label, command, argument, .. } => {
|
||||
Some(ide_plugin::NotificationAction {
|
||||
label: label.clone(),
|
||||
command: command.clone(),
|
||||
argument: argument.clone(),
|
||||
})
|
||||
}
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
check_actions(self, &actions)
|
||||
}
|
||||
|
||||
fn window_status_item(&self, client: &str, id: &str, item: Option<StatusItem>) -> Result<(), HostError> {
|
||||
let closed = self.shared.closed_clients.lock();
|
||||
let blocked = self.shared.prompts_blocked.lock();
|
||||
@@ -4109,6 +4127,27 @@ mod tests {
|
||||
api.release_process(id);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn the_status_comes_with_the_last_of_the_output() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let api = shell_api(tmp.path());
|
||||
let token = CancellationToken::new();
|
||||
let id = api.start_process(shell("printf 'abcdefghij'; printf 'xyz' >&2"), None, None).unwrap();
|
||||
let first = api.wait_process(id, 4, Duration::from_secs(5), &token).unwrap();
|
||||
assert_eq!((first.stdout.as_str(), first.stderr.as_str(), first.status), ("abcd", "xyz", None));
|
||||
let mut stdout = first.stdout;
|
||||
let status = loop {
|
||||
let chunk = api.poll_process(id, 4).unwrap();
|
||||
stdout.push_str(&chunk.stdout);
|
||||
if let Some(status) = chunk.status {
|
||||
break status;
|
||||
}
|
||||
};
|
||||
assert_eq!((stdout.as_str(), status), ("abcdefghij", 0));
|
||||
api.release_process(id);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn programs_run_only_as_approved() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -1,10 +1,13 @@
|
||||
//! The `javaAgents` extension point (API 1.10): a Java agent the host loads into the
|
||||
//! JVM of Application, Spring Boot and JAR Application configurations.
|
||||
//! The `javaAgents` extension point (API 1.10; `vmOptions` / `jdk` in 1.14): a Java
|
||||
//! agent the host loads into the JVM of Application, Spring Boot and JAR Application
|
||||
//! configurations, with optional JVM flags.
|
||||
//!
|
||||
//! ```toml
|
||||
//! [[contributes.javaAgents]]
|
||||
//! path = "agent/openidea-spring-agent.jar" # inside the package
|
||||
//! args = "optional-arguments" # optional
|
||||
//! vmOptions = ["-XX:+AllowEnhancedClassRedefinition"] # optional, API 1.14
|
||||
//! jdk = "jetbrains" # optional: only those VM options on JBR
|
||||
//! ```
|
||||
//!
|
||||
//! One agent per plugin. The declaration derives the optional high-risk `java.agent`
|
||||
@@ -23,6 +26,8 @@ use std::sync::atomic::{AtomicU64, Ordering};
|
||||
|
||||
pub const POINT_ID: &str = "javaAgents";
|
||||
const MAX_ARGS: usize = 4096;
|
||||
const MAX_VM_OPTION: usize = 512;
|
||||
const MAX_VM_OPTIONS: usize = 32;
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
@@ -30,6 +35,10 @@ struct Decl {
|
||||
path: PathBuf,
|
||||
#[serde(default)]
|
||||
args: Option<String>,
|
||||
#[serde(default, rename = "vmOptions")]
|
||||
vm_options: Vec<String>,
|
||||
#[serde(default)]
|
||||
jdk: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
@@ -37,6 +46,8 @@ pub(super) struct Agent {
|
||||
/// The jar, resolved inside the package.
|
||||
pub(super) jar: PathBuf,
|
||||
pub(super) args: Option<String>,
|
||||
pub(super) vm_options: Vec<String>,
|
||||
pub(super) jdk: Option<String>,
|
||||
}
|
||||
|
||||
/// Agents of enabled plugins.
|
||||
@@ -95,20 +106,65 @@ impl ExtensionPoint for JavaAgentsPoint {
|
||||
{
|
||||
return Err(format!("contributes.javaAgents: `args` must be one line of at most {MAX_ARGS} bytes"));
|
||||
}
|
||||
let label = label(&d.path, args.as_deref());
|
||||
let vm_options = validate_vm_options(&d.vm_options)?;
|
||||
let jdk = validate_jdk(d.jdk)?;
|
||||
if !vm_options.is_empty() || jdk.is_some() {
|
||||
pkg.manifest.needs_api("contributes.javaAgents.vmOptions", 14)?;
|
||||
}
|
||||
let label = label(&d.path, args.as_deref(), &vm_options);
|
||||
let (store, plugin) = (self.store.clone(), pkg.id().to_owned());
|
||||
let agent = Agent { jar, args };
|
||||
let agent = Agent { jar, args, vm_options, jdk };
|
||||
Ok(Prepared::new(label, move || Ok(store.add(plugin, agent))).file(d.path).capability(Capability::JavaAgent))
|
||||
}
|
||||
}
|
||||
|
||||
/// What Settings › Plugins shows: the jar's file name and its arguments, as `-javaagent:` takes them.
|
||||
fn label(path: &Path, args: Option<&str>) -> String {
|
||||
fn validate_vm_options(raw: &[String]) -> Result<Vec<String>, String> {
|
||||
if raw.len() > MAX_VM_OPTIONS {
|
||||
return Err(format!("contributes.javaAgents: at most {MAX_VM_OPTIONS} `vmOptions`"));
|
||||
}
|
||||
let mut out = Vec::with_capacity(raw.len());
|
||||
for opt in raw {
|
||||
let opt = opt.trim();
|
||||
if opt.is_empty() {
|
||||
continue;
|
||||
}
|
||||
if !opt.starts_with('-')
|
||||
|| opt.len() > MAX_VM_OPTION
|
||||
|| opt.contains(|c: char| c.is_control() || c.is_whitespace())
|
||||
{
|
||||
return Err(format!(
|
||||
"contributes.javaAgents: each `vmOptions` entry must be one flag starting with `-` (at most {MAX_VM_OPTION} bytes, no spaces)"
|
||||
));
|
||||
}
|
||||
if !out.iter().any(|o: &String| o == opt) {
|
||||
out.push(opt.to_owned());
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn validate_jdk(jdk: Option<String>) -> Result<Option<String>, String> {
|
||||
let Some(raw) = jdk.map(|s| s.trim().to_ascii_lowercase()).filter(|s| !s.is_empty()) else {
|
||||
return Ok(None);
|
||||
};
|
||||
if raw != "jetbrains" {
|
||||
return Err("contributes.javaAgents: `jdk` must be \"jetbrains\" when set".into());
|
||||
}
|
||||
Ok(Some(raw))
|
||||
}
|
||||
|
||||
/// What Settings › Plugins shows: jar name, args, and any JVM options.
|
||||
fn label(path: &Path, args: Option<&str>, vm_options: &[String]) -> String {
|
||||
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
|
||||
match args {
|
||||
let mut out = match args {
|
||||
Some(args) => format!("{name}={args}"),
|
||||
None => name,
|
||||
};
|
||||
if !vm_options.is_empty() {
|
||||
out.push(' ');
|
||||
out.push_str(&vm_options.join(" "));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The jar a package's declaration names, as an absolute path inside the package:
|
||||
@@ -135,6 +191,16 @@ pub(super) fn declared_jar(manifest: &Manifest, dir: &Path) -> Option<PathBuf> {
|
||||
resolve(dir, &d.path).ok()
|
||||
}
|
||||
|
||||
/// Declared `vmOptions` (for consent / Settings copy), if the package has a valid declaration.
|
||||
pub(super) fn declared_vm_options(manifest: &Manifest) -> Vec<String> {
|
||||
let decl = manifest.declarations(POINT_ID).into_iter().next();
|
||||
let Some(decl) = decl else { return Vec::new() };
|
||||
let Ok(d) = decode::<Decl>(POINT_ID, decl) else {
|
||||
return Vec::new();
|
||||
};
|
||||
validate_vm_options(&d.vm_options).unwrap_or_default()
|
||||
}
|
||||
|
||||
type Pins = Arc<RwLock<HashMap<(String, String), ProgramPin>>>;
|
||||
|
||||
/// [`JavaAgentSource`] over the agents and the hashes granted for them.
|
||||
@@ -155,6 +221,8 @@ impl JavaAgentSource for PluginJavaAgents {
|
||||
plugin: plugin.clone(),
|
||||
jar: agent.jar.clone(),
|
||||
args: agent.args.clone(),
|
||||
vm_options: agent.vm_options.clone(),
|
||||
jdk: agent.jdk.clone(),
|
||||
approved_hash: pins.get(&(plugin.clone(), cap.clone())).map(|pin| pin.hash.clone()),
|
||||
})
|
||||
.collect()
|
||||
@@ -167,6 +235,8 @@ mod tests {
|
||||
|
||||
const MANIFEST: &str =
|
||||
"id = \"acme.spring\"\nname = \"Spring\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.10\"\n";
|
||||
const MANIFEST_14: &str =
|
||||
"id = \"acme.spring\"\nname = \"Spring\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.14\"\n";
|
||||
|
||||
fn package(dir: &Path, manifest: &str) -> Package {
|
||||
std::fs::create_dir_all(dir.join("agent")).unwrap();
|
||||
@@ -209,12 +279,33 @@ mod tests {
|
||||
(agents[0].plugin.as_str(), agents[0].args.as_deref(), agents[0].approved_hash.as_ref()),
|
||||
("acme.spring", Some("port=0,trace"), None)
|
||||
);
|
||||
assert!(agents[0].vm_options.is_empty());
|
||||
source.pins.write().insert(("acme.spring".into(), "java.agent".into()), ProgramPin::approve(&jar).unwrap());
|
||||
assert!(source.agents()[0].approved_hash.is_some());
|
||||
disposable.dispose();
|
||||
assert!(source.agents().is_empty(), "disabling the plugin drops its agent");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_vm_options_and_jdk_gate() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let toml = format!(
|
||||
"{MANIFEST_14}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nvmOptions = [\"-XX:+AllowEnhancedClassRedefinition\"]\njdk = \"jetbrains\"\n"
|
||||
);
|
||||
let pkg = package(tmp.path(), &toml);
|
||||
let prepared = prepare(&pkg).unwrap();
|
||||
assert_eq!(prepared.label, "spring agent.jar -XX:+AllowEnhancedClassRedefinition");
|
||||
assert_eq!(declared_vm_options(&pkg.manifest), ["-XX:+AllowEnhancedClassRedefinition"]);
|
||||
|
||||
let store: Arc<JavaAgents> = Arc::default();
|
||||
let point = JavaAgentsPoint::new(store.clone());
|
||||
let decl = pkg.manifest.declarations(POINT_ID).remove(0);
|
||||
let _keep = (point.prepare(&pkg, decl).unwrap().commit)().unwrap();
|
||||
let agent = store.for_plugin("acme.spring").unwrap();
|
||||
assert_eq!(agent.vm_options, ["-XX:+AllowEnhancedClassRedefinition"]);
|
||||
assert_eq!(agent.jdk.as_deref(), Some("jetbrains"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_what_would_fail_at_launch() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -242,6 +333,33 @@ mod tests {
|
||||
);
|
||||
let old = format!("{}{}", MANIFEST.replace("^1.10", "^1.9"), agent("agent/spring agent.jar"));
|
||||
assert!(refused(7, &old).contains("new in plugin API 1.10"));
|
||||
assert!(
|
||||
refused(
|
||||
9,
|
||||
&format!(
|
||||
"{MANIFEST}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nvmOptions = [\"-XX:+AllowEnhancedClassRedefinition\"]\n"
|
||||
),
|
||||
)
|
||||
.contains("new in plugin API 1.14")
|
||||
);
|
||||
assert!(
|
||||
refused(
|
||||
10,
|
||||
&format!(
|
||||
"{MANIFEST_14}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nvmOptions = [\"not-a-flag\"]\n"
|
||||
),
|
||||
)
|
||||
.contains("starting with `-`")
|
||||
);
|
||||
assert!(
|
||||
refused(
|
||||
11,
|
||||
&format!(
|
||||
"{MANIFEST_14}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\njdk = \"temurin\"\n"
|
||||
),
|
||||
)
|
||||
.contains("jetbrains")
|
||||
);
|
||||
#[cfg(unix)]
|
||||
{
|
||||
let dir = tmp.path().join("8");
|
||||
|
||||
@@ -276,6 +276,34 @@ impl PluginHost {
|
||||
}
|
||||
out
|
||||
}
|
||||
/// Optional API 1.14 hover actions. Only plugins declaring the
|
||||
/// `hover-actions` provider kind are asked; the released language-features
|
||||
/// export remains unchanged.
|
||||
pub fn language_hover_actions(&self, doc: &ProviderDocument) -> Vec<(String, HoverAction)> {
|
||||
let mut out = Vec::new();
|
||||
for (d, _bounds) in self.feature_documents(doc, None) {
|
||||
let snapshot = d.clone();
|
||||
let text = ide_text::Document::new(&snapshot.text);
|
||||
let d = Arc::new(d);
|
||||
let results = self
|
||||
.document_calls(ProviderKind::HoverActions, &snapshot, move |rt, t| rt.language_hover_actions(&d, t));
|
||||
for (p, items) in results {
|
||||
let commands: std::collections::HashSet<_> =
|
||||
self.ui.items(super::COMMANDS, Some(p.id())).into_iter().map(|c| c.key).collect();
|
||||
for i in items {
|
||||
let lines = text.line_count();
|
||||
let anchor_ok = i.line < lines;
|
||||
let range_ok = i.start_line <= i.end_line && i.end_line < lines;
|
||||
let contains_anchor = i.start_line <= i.line && i.line <= i.end_line;
|
||||
if anchor_ok && range_ok && contains_anchor && commands.contains(&i.command) {
|
||||
out.push((p.id().to_owned(), i));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
pub fn language_gutter_actions(&self, doc: &ProviderDocument) -> Vec<(String, GutterAction)> {
|
||||
let mut out = Vec::new();
|
||||
for (d, bounds) in self.feature_documents(doc, None) {
|
||||
|
||||
@@ -925,6 +925,7 @@ impl PluginHost {
|
||||
capabilities.push(CapabilityInfo::new(extra, true, granted(extra)));
|
||||
}
|
||||
}
|
||||
annotate_java_agent_vm_options(&mut capabilities, m);
|
||||
capabilities.sort_by(|a, b| b.risk.cmp(&a.risk).then(a.id.cmp(&b.id)));
|
||||
let signer_changed = self.signer_changed(&m.id, src);
|
||||
let answered = |c: &CapabilityInfo| {
|
||||
@@ -3085,6 +3086,7 @@ impl PluginHost {
|
||||
capabilities.push(CapabilityInfo::new(extra, true, granted(extra)));
|
||||
}
|
||||
}
|
||||
annotate_java_agent_vm_options(&mut capabilities, m);
|
||||
// Hosts remembered through `net:ask` are grants of their own: listed
|
||||
// separately so the user can revoke them one by one.
|
||||
let net_hosts = grant
|
||||
@@ -3118,6 +3120,8 @@ impl PluginHost {
|
||||
.map(|name| name.to_string_lossy().into_owned())
|
||||
.unwrap_or_else(|| agent.jar.display().to_string()),
|
||||
args: agent.args,
|
||||
vm_options: agent.vm_options,
|
||||
jdk: agent.jdk,
|
||||
approved,
|
||||
}
|
||||
}),
|
||||
@@ -3157,6 +3161,20 @@ fn agent_jar_grant(manifest: &Manifest, dir: &Path) -> Option<BinaryGrant> {
|
||||
Some(BinaryGrant { path, hash })
|
||||
}
|
||||
|
||||
/// Consent / Settings: surface exact contributed JVM flags on the `java.agent` permission.
|
||||
fn annotate_java_agent_vm_options(capabilities: &mut [CapabilityInfo], manifest: &Manifest) {
|
||||
let opts = java_agents::declared_vm_options(manifest);
|
||||
if opts.is_empty() {
|
||||
return;
|
||||
}
|
||||
let flags = opts.join(" ");
|
||||
for cap in capabilities.iter_mut() {
|
||||
if cap.id == "java.agent" {
|
||||
cap.description = format!("{}; JVM options: {flags}", cap.description);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn request_for<'a>(subject: &Subject, m: &'a Manifest, hash: &'a str, declared: &[Capability]) -> Request<'a> {
|
||||
let mut optional = m.capabilities.optional.clone();
|
||||
// What declarations need (a language server's `process:`) is optional:
|
||||
|
||||
@@ -54,6 +54,7 @@ pub enum ProviderKind {
|
||||
Implementation,
|
||||
TypeDefinition,
|
||||
GutterActions,
|
||||
HoverActions,
|
||||
Injections,
|
||||
}
|
||||
|
||||
@@ -204,11 +205,15 @@ impl ExtensionPoint for ProvidersPoint {
|
||||
| ProviderKind::Implementation
|
||||
| ProviderKind::TypeDefinition
|
||||
| ProviderKind::GutterActions
|
||||
| ProviderKind::HoverActions
|
||||
| ProviderKind::Injections
|
||||
)
|
||||
}) {
|
||||
pkg.manifest.needs_api("contributes.providers: language features and injections", 4)?;
|
||||
}
|
||||
if d.kinds.contains(&ProviderKind::HoverActions) {
|
||||
pkg.manifest.needs_api("contributes.providers: hover-actions", 14)?;
|
||||
}
|
||||
for l in &d.languages {
|
||||
if l != "*"
|
||||
&& (l.is_empty()
|
||||
|
||||
@@ -63,6 +63,10 @@ pub struct PluginJavaAgent {
|
||||
pub file_name: String,
|
||||
/// The optional argument passed after `=`.
|
||||
pub args: Option<String>,
|
||||
/// Extra JVM flags from `vmOptions` (API 1.14).
|
||||
pub vm_options: Vec<String>,
|
||||
/// When `Some("jetbrains")`, those VM options apply only on JetBrains Runtime.
|
||||
pub jdk: Option<String>,
|
||||
/// The jar still has the hash recorded when `java.agent` was granted.
|
||||
pub approved: bool,
|
||||
}
|
||||
|
||||
@@ -63,6 +63,8 @@ pub struct Project {
|
||||
pub notebooks: Arc<crate::notebook::NotebookService>,
|
||||
/// Flutter's devices; its daemon starts when the UI first asks for them.
|
||||
pub(crate) flutter: ide_flutter::FlutterDaemon,
|
||||
/// Flutter DevTools; its server starts when the UI first asks for it.
|
||||
pub(crate) devtools: ide_flutter::DevToolsServer,
|
||||
pub(crate) kotlin_bridge: Option<Arc<crate::kotlin_bridge::KotlinBridge>>,
|
||||
pub(crate) phpstan: Option<Arc<crate::phpstan::Phpstan>>,
|
||||
pub(crate) watcher: Arc<Watcher>,
|
||||
@@ -104,6 +106,9 @@ impl Host {
|
||||
{
|
||||
return Ok(current);
|
||||
}
|
||||
// A window takes the root over from the MCP server's background project, whose
|
||||
// shutdown the wait below sits out; none opens until this open is over.
|
||||
let _claim = (!crate::mcp::BackgroundProjects::is_key(window)).then(|| self.mcp_background.claim(self, &root));
|
||||
self.close_project(window);
|
||||
self.wait_detached_closes();
|
||||
let sink: SharedSink = (self.sink_for)(window);
|
||||
@@ -202,6 +207,7 @@ impl Host {
|
||||
};
|
||||
let profiles = ide_build::maven_profiles(&cache);
|
||||
ide_sdk::maven_profiles::configure_jdtls(cfg, root, &effective, &profiles, &cache);
|
||||
ide_sdk::maven_profiles::configure_offline(cfg, ide_build::maven_offline(&cache));
|
||||
}
|
||||
ide_sdk::java::cap_java_home(cfg, &ide_sdk::java::installed_jdks());
|
||||
if cfg.name == "jdtls" {
|
||||
@@ -604,6 +610,7 @@ impl Host {
|
||||
plugin_diagnostics,
|
||||
trusted,
|
||||
flutter: ide_flutter::FlutterDaemon::new(root.clone(), sink.clone()),
|
||||
devtools: ide_flutter::DevToolsServer::new(root.clone()),
|
||||
root,
|
||||
sink,
|
||||
languages,
|
||||
@@ -817,6 +824,7 @@ impl Host {
|
||||
plugin_diagnostics,
|
||||
trusted: Arc::new(AtomicBool::new(false)),
|
||||
flutter: ide_flutter::FlutterDaemon::new(dir.clone(), sink.clone()),
|
||||
devtools: ide_flutter::DevToolsServer::new(dir.clone()),
|
||||
sink,
|
||||
languages,
|
||||
settings,
|
||||
|
||||
@@ -177,6 +177,7 @@ pub fn event_sink(peer: Arc<OnceLock<Peer>>, window: Option<String>) -> ide_core
|
||||
pub fn client_accepts(event: &IdeEvent, trusted: bool) -> bool {
|
||||
match event {
|
||||
IdeEvent::WindowGroupsChanged
|
||||
| IdeEvent::McpBackgroundProjectsChanged
|
||||
| IdeEvent::WindowFullscreenChanged
|
||||
| IdeEvent::RemoteConnectionLost { .. }
|
||||
| IdeEvent::UpdateStatusChanged { .. }
|
||||
@@ -323,6 +324,7 @@ mod tests {
|
||||
},
|
||||
IdeEvent::WindowGroupsChanged,
|
||||
IdeEvent::WindowFullscreenChanged,
|
||||
IdeEvent::McpBackgroundProjectsChanged,
|
||||
] {
|
||||
assert!(!client_accepts(&event, true), "{event:?}");
|
||||
}
|
||||
|
||||
@@ -244,6 +244,9 @@ impl crate::Host {
|
||||
}
|
||||
|
||||
pub async fn refresh_project_trust(&self) -> IdeResult<()> {
|
||||
// A background project that is being opened read the trust before this decision and
|
||||
// is not among the projects yet: once its open is over, the loop below corrects it.
|
||||
Self::in_place(|| self.mcp_background.wait_for_open());
|
||||
for project in self.projects().into_iter().filter(|p| !p.light) {
|
||||
let trusted = self.trust.window_trusted(&project.root).unwrap_or(false);
|
||||
let roots = project.content_roots();
|
||||
@@ -283,6 +286,7 @@ impl crate::Host {
|
||||
self.environment.direnv_closed(&project.root);
|
||||
project.agents.shutdown();
|
||||
project.flutter.stop();
|
||||
project.devtools.stop();
|
||||
self.processes.kill_project(&project.root);
|
||||
project.notebooks.restrict().await;
|
||||
let windows: Vec<_> = self
|
||||
@@ -304,6 +308,9 @@ impl crate::Host {
|
||||
crate::ops::sdk::container_python::ensure(self, &project);
|
||||
project.sink.emit(ide_core::IdeEvent::ProjectTrustChanged { root: project.root.clone().into(), trusted });
|
||||
}
|
||||
// Trust decides which projects are served without a window. The step waits for a
|
||||
// background open under way and reads files: not on an async worker.
|
||||
Self::in_place(|| self.apply_background_policy());
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use ide_core::{CancellationToken, ChangeSet, Diagnostic, IdeEvent, Pos, Range, Severity, TextChange};
|
||||
use ide_host::mcp::{FileProblems, FocusedEditor, Registry};
|
||||
use ide_host::mcp::{BackgroundProjects, FileProblems, FocusedEditor, Registry};
|
||||
use ide_host::{Host, HostConfig};
|
||||
use ide_mcp::ToolRegistry;
|
||||
use serde_json::{Value, json};
|
||||
@@ -83,14 +83,65 @@ impl Harness {
|
||||
async fn json(&self, name: &str, args: Value) -> Value {
|
||||
serde_json::from_str(&self.call(name, args).await).unwrap()
|
||||
}
|
||||
fn set(&self, key: &str, value: Value) {
|
||||
let key = format!("mcpServer.{key}");
|
||||
self.host.global_settings.set(ide_workspace::SettingsScope::Global, &key, value).unwrap();
|
||||
}
|
||||
/// The folder `inventory` next to the open project, listed to be served without a window.
|
||||
fn serve_inventory(&self) -> PathBuf {
|
||||
let inventory = self.root.parent().unwrap().join("inventory");
|
||||
std::fs::create_dir_all(inventory.join("src")).unwrap();
|
||||
std::fs::write(inventory.join("src/stock.txt"), "forty crates\n").unwrap();
|
||||
self.set("enabled", json!(true));
|
||||
self.set("backgroundProjects", json!("listed"));
|
||||
self.set("backgroundProjectPaths", json!([inventory]));
|
||||
inventory
|
||||
}
|
||||
/// Roots of the projects loaded without a window.
|
||||
fn background(&self) -> Vec<PathBuf> {
|
||||
let loaded = self.host.mcp_background.snapshot(&self.host, std::time::Instant::now());
|
||||
loaded.into_iter().map(|project| project.root.into_path_buf()).collect()
|
||||
}
|
||||
/// A tool call for the project at `root`: its text, or its error.
|
||||
async fn call_at(&self, root: &Path, name: &str, args: Value) -> Result<String, String> {
|
||||
let (host, root, name) = (self.host.clone(), root.to_owned(), name.to_owned());
|
||||
let call = move || Registry::new(host).call(&root, &name, &args.to_string(), CancellationToken::new());
|
||||
tokio::task::spawn_blocking(call).await.unwrap().map_err(|e| match e {
|
||||
ide_mcp::ToolCallError::Failed(e) | ide_mcp::ToolCallError::UnknownTool(e) => e,
|
||||
})
|
||||
}
|
||||
fn server(&self) -> (ide_mcp::McpServer, PathBuf) {
|
||||
let discovery = ide_mcp::discovery_path(self.tmp.path());
|
||||
let registry = Arc::new(Registry::new(self.host.clone()));
|
||||
let runtime = tokio::runtime::Handle::current();
|
||||
(ide_mcp::McpServer::start(registry, Some(discovery.clone()), &runtime).unwrap(), discovery)
|
||||
}
|
||||
}
|
||||
impl Drop for Harness {
|
||||
fn drop(&mut self) {
|
||||
self.host.close_project("main");
|
||||
self.host.close_project("second");
|
||||
for root in self.background() {
|
||||
self.host.close_project(&BackgroundProjects::key(&root));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// What the stdio bridge started in `folder` answers to `requests`, by request id.
|
||||
async fn bridged(discovery: &Path, folder: &Path, requests: &[Value]) -> Vec<Value> {
|
||||
let input: String = requests.iter().map(|request| format!("{request}\n")).collect();
|
||||
let mut output = Vec::new();
|
||||
ide_mcp::stdio::bridge(discovery, folder, input.as_bytes(), &mut output).await.unwrap();
|
||||
let mut replies: Vec<Value> =
|
||||
String::from_utf8(output).unwrap().lines().map(|line| serde_json::from_str(line).unwrap()).collect();
|
||||
replies.sort_by_key(|reply| reply["id"].as_i64());
|
||||
replies
|
||||
}
|
||||
|
||||
fn rpc(id: u32, method: &str, params: Value) -> Value {
|
||||
json!({"jsonrpc":"2.0","id":id,"method":method,"params":params})
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn reads_unsaved_text_and_searches_the_overlay_with_a_limit() {
|
||||
let h = Harness::new();
|
||||
@@ -1300,3 +1351,235 @@ async fn call_hierarchy_pages_are_sorted_and_scoped() {
|
||||
assert_eq!(scoped["total"], 1);
|
||||
assert_eq!(scoped["root"]["name"], "price", "the root is shown whatever the paths");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_folder_without_a_window_is_opened_by_its_first_tool_call() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
let (_server, discovery) = h.server();
|
||||
let folder = inventory.join("src");
|
||||
let replies =
|
||||
bridged(&discovery, &folder, &[rpc(1, "initialize", json!({})), rpc(2, "tools/list", json!({}))]).await;
|
||||
let instructions = replies[0]["result"]["instructions"].as_str().unwrap();
|
||||
assert!(instructions.contains(inventory.to_str().unwrap()), "{instructions}");
|
||||
let tools = replies[1]["result"]["tools"].as_array().unwrap();
|
||||
assert!(tools.iter().any(|tool| tool["name"] == "read_file"), "{tools:?}");
|
||||
assert!(tools.iter().all(|tool| tool["annotations"]["readOnlyHint"] == true), "nobody trusted the folder");
|
||||
assert!(h.background().is_empty(), "initialize and tools/list open nothing");
|
||||
assert_eq!(h.host.projects().len(), 1);
|
||||
|
||||
let read = rpc(3, "tools/call", json!({"name":"read_file","arguments":{"file_path":"src/stock.txt"}}));
|
||||
let replies = bridged(&discovery, &folder, &[read]).await;
|
||||
assert_eq!(replies[0]["result"]["content"][0]["text"], "L1: forty crates\nL2: ", "{replies:?}");
|
||||
assert_eq!(h.background(), std::slice::from_ref(&inventory));
|
||||
// Loaded, it is still no project of a window.
|
||||
assert_eq!(Registry::new(h.host.clone()).projects(), std::slice::from_ref(&h.root));
|
||||
assert!(h.host.project("main").is_ok());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn with_background_projects_off_a_folder_outside_the_open_projects_is_refused() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.root.parent().unwrap().join("inventory");
|
||||
std::fs::create_dir_all(&inventory).unwrap();
|
||||
let (_server, discovery) = h.server();
|
||||
let list = rpc(1, "tools/list", json!({}));
|
||||
let read = rpc(2, "tools/call", json!({"name":"read_file","arguments":{"file_path":"a.txt"}}));
|
||||
for reply in bridged(&discovery, &inventory, &[list, read]).await {
|
||||
assert_eq!(reply["error"]["code"], -32001, "{reply}");
|
||||
let message = reply["error"]["message"].as_str().unwrap();
|
||||
assert!(message.contains("isn't served in the background"), "{message}");
|
||||
}
|
||||
assert!(h.background().is_empty());
|
||||
assert_eq!(h.host.projects().len(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn the_tools_of_a_background_project_are_the_same_before_and_after_it_opens() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
let registry = Registry::new(h.host.clone());
|
||||
let restricted = registry.tools(&inventory).unwrap();
|
||||
assert!(!restricted.is_empty() && restricted.iter().all(|t| t.read_only && !t.destructive));
|
||||
assert!(h.background().is_empty(), "listing opens nothing");
|
||||
h.call_at(&inventory, "read_file", json!({"file_path":"src/stock.txt"})).await.unwrap();
|
||||
assert_eq!(registry.tools(&inventory).unwrap(), restricted);
|
||||
|
||||
// Trusted, loaded or not, it has the tools that write and run as well.
|
||||
h.host.set_project_trust(&inventory, true, false).await.unwrap();
|
||||
let trusted = registry.tools(&inventory).unwrap();
|
||||
assert!(trusted.iter().any(|t| t.name == "create_new_file" && !t.read_only));
|
||||
assert!(h.host.mcp_background.detach(&h.host, &inventory, None));
|
||||
assert_eq!(registry.tools(&inventory).unwrap(), trusted);
|
||||
assert!(h.background().is_empty());
|
||||
// The project in the window lists what it did before.
|
||||
assert!(registry.tools(&h.root).unwrap().iter().all(|t| t.read_only));
|
||||
// A folder nothing serves has no tools.
|
||||
assert!(registry.tools(&inventory.join("src")).is_err());
|
||||
}
|
||||
|
||||
/// POSTs `body` to the server without naming a project.
|
||||
async fn post(server: &ide_mcp::McpServer, body: &Value) -> Value {
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
let (port, body) = (server.port(), body.to_string());
|
||||
let request = format!(
|
||||
"POST /mcp HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nAuthorization: Bearer {}\r\nContent-Type: application/json\r\nAccept: application/json, text/event-stream\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
|
||||
server.token(),
|
||||
body.len()
|
||||
);
|
||||
let mut stream = tokio::net::TcpStream::connect(("127.0.0.1", port)).await.unwrap();
|
||||
stream.write_all(request.as_bytes()).await.unwrap();
|
||||
let mut reply = String::new();
|
||||
stream.read_to_string(&mut reply).await.unwrap();
|
||||
serde_json::from_str(reply.split_once("\r\n\r\n").unwrap().1).unwrap()
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_project_open_in_a_window_answers_before_any_background_project() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
// A listed folder inside the open project: the window's project answers for it.
|
||||
h.set("backgroundProjectPaths", json!([inventory, h.root.join("src")]));
|
||||
let (server, discovery) = h.server();
|
||||
let inside = json!({"projectPath": h.root.join("src"), "file_path": "src/b.txt"});
|
||||
let read = rpc(1, "tools/call", json!({"name":"read_file","arguments":inside.clone()}));
|
||||
let replies = bridged(&discovery, &inventory, &[read]).await;
|
||||
assert_eq!(replies[0]["result"]["content"][0]["text"], "L1: needle\nL2: ", "{replies:?}");
|
||||
assert!(h.background().is_empty());
|
||||
|
||||
// With a background project loaded, a request that names no folder goes to the only window.
|
||||
h.call_at(&inventory, "read_file", json!({"file_path":"src/stock.txt"})).await.unwrap();
|
||||
assert_eq!(h.background(), std::slice::from_ref(&inventory));
|
||||
let unnamed = rpc(2, "tools/call", json!({"name":"read_file","arguments":{"file_path":"src/b.txt"}}));
|
||||
let reply = post(&server, &unnamed).await;
|
||||
assert_eq!(reply["result"]["content"][0]["text"], "L1: needle\nL2: ", "{reply}");
|
||||
// Nor does a background project loaded inside the window's project take its folder over.
|
||||
let nested = h.root.join("src");
|
||||
h.call_at(&nested, "read_file", json!({"file_path":"b.txt"})).await.unwrap();
|
||||
assert_eq!(h.background(), [inventory.clone(), nested]);
|
||||
let read = rpc(3, "tools/call", json!({"name":"read_file","arguments":inside}));
|
||||
let replies = bridged(&discovery, &inventory, &[read]).await;
|
||||
assert_eq!(replies[0]["result"]["content"][0]["text"], "L1: needle\nL2: ", "{replies:?}");
|
||||
// A second window on another root is served as before.
|
||||
let second = h.root.parent().unwrap().join("second");
|
||||
std::fs::create_dir_all(&second).unwrap();
|
||||
std::fs::write(second.join("unique.txt"), "second project").unwrap();
|
||||
h.host.open_project("second", &second).unwrap();
|
||||
let read = h.call_at(&second, "read_file", json!({"file_path":"unique.txt"})).await.unwrap();
|
||||
assert_eq!(read, "L1: second project");
|
||||
assert_eq!(h.background().len(), 2);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn tools_fed_by_a_window_say_that_a_background_project_has_none() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
for (tool, args, hint) in [
|
||||
("get_all_open_file_paths", json!({}), ""),
|
||||
("get_current_file", json!({}), ""),
|
||||
("get_file_problems", json!({"filePath":"src/stock.txt"}), " Use check_files for diagnostics."),
|
||||
("get_project_problems", json!({}), " Use check_files for diagnostics."),
|
||||
] {
|
||||
let error = h.call_at(&inventory, tool, args).await.unwrap_err();
|
||||
let root = inventory.display();
|
||||
let expected = format!("{tool} needs the project open in a window: {root} is served in the background.{hint}");
|
||||
assert_eq!(error, expected);
|
||||
}
|
||||
// `check_files` answers there, and the project in the window keeps its answers.
|
||||
let checked = h.call_at(&inventory, "check_files", json!({"filePaths":["src/stock.txt"]})).await.unwrap();
|
||||
assert_eq!(serde_json::from_str::<Value>(&checked).unwrap()["files"][0]["status"], "untrusted", "{checked}");
|
||||
assert_eq!(h.json("get_all_open_file_paths", json!({})).await["openFiles"], json!([]));
|
||||
assert_eq!(h.json("get_current_file", json!({})).await, json!({}));
|
||||
assert_eq!(h.json("get_project_problems", json!({})).await["files"], json!([]));
|
||||
let problems = h.json("get_file_problems", json!({"filePath":"src/a.txt"})).await;
|
||||
assert_eq!(problems["errors"], json!([]));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn tools_that_ask_the_user_fail_closed_in_a_background_project() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
h.host.trust.decide(&inventory, true, false).unwrap();
|
||||
for (tool, args) in [
|
||||
("build_project", json!({})),
|
||||
("run_command", json!({"name":"check","command":"true"})),
|
||||
("open_file_in_editor", json!({"filePath":"src/stock.txt"})),
|
||||
] {
|
||||
let error = h.call_at(&inventory, tool, args).await.unwrap_err();
|
||||
assert!(error.contains("no project window"), "{tool}: {error}");
|
||||
}
|
||||
assert!(h.host.processes.list().is_empty());
|
||||
// Running without confirmation does not give `run_command` or the editor a window.
|
||||
h.set("runWithoutConfirmation", json!(true));
|
||||
for (tool, args) in [
|
||||
("run_command", json!({"name":"check","command":"true"})),
|
||||
("open_file_in_editor", json!({"filePath":"src/stock.txt"})),
|
||||
] {
|
||||
let error = h.call_at(&inventory, tool, args).await.unwrap_err();
|
||||
assert!(error.contains("no project window"), "{tool}: {error}");
|
||||
}
|
||||
assert_eq!(h.background(), [inventory]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_cancelled_or_failed_call_leaves_nothing_holding_the_project() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
let (host, root, cancel) = (h.host.clone(), inventory.clone(), CancellationToken::new());
|
||||
cancel.cancel();
|
||||
let cancelled = tokio::task::spawn_blocking(move || {
|
||||
Registry::new(host).call(&root, "read_file", r#"{"file_path":"src/stock.txt"}"#, cancel)
|
||||
});
|
||||
assert!(cancelled.await.unwrap().is_err());
|
||||
assert!(h.call_at(&inventory, "read_file", json!({"file_path":"src/gone.txt"})).await.is_err());
|
||||
assert!(h.call_at(&inventory, "no_such_tool", json!({})).await.is_err());
|
||||
let loaded = h.host.mcp_background.snapshot(&h.host, std::time::Instant::now());
|
||||
assert_eq!(loaded.len(), 1);
|
||||
assert_eq!(loaded[0].kept_open_by, None);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_run_started_without_confirmation_works_in_a_background_project_and_holds_it() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
h.host.trust.decide(&inventory, true, false).unwrap();
|
||||
h.set("runWithoutConfirmation", json!(true));
|
||||
let config = ide_run::RunConfig {
|
||||
id: "serve".into(),
|
||||
name: "serve stock".into(),
|
||||
kind: "shell".into(),
|
||||
command: "sleep 30".into(),
|
||||
args: vec![],
|
||||
cwd: None,
|
||||
env: Default::default(),
|
||||
detected: false,
|
||||
is_test: false,
|
||||
debug_adapter: None,
|
||||
allow_parallel: false,
|
||||
extras: Default::default(),
|
||||
};
|
||||
ide_run::save_user_configs(&inventory, &[config]).unwrap();
|
||||
let call = h.call_at(&inventory, "execute_run_configuration", json!({"configurationName":"serve stock"}));
|
||||
let observe = async {
|
||||
let run = tokio::time::timeout(std::time::Duration::from_secs(30), async {
|
||||
loop {
|
||||
if let Some(run) = h.host.processes.running_in(&inventory).pop() {
|
||||
break run;
|
||||
}
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.expect("the run starts");
|
||||
// The call still waits for the run: it holds the project first, the run second.
|
||||
let held = h.host.mcp_background.snapshot(&h.host, std::time::Instant::now()).remove(0);
|
||||
assert_eq!(held.kept_open_by, Some(ide_host::mcp::McpBackgroundHold::Request));
|
||||
h.host.processes.stop(run.id).unwrap();
|
||||
};
|
||||
let (result, ()) = tokio::join!(call, observe);
|
||||
let result: Value = serde_json::from_str(&result.unwrap()).unwrap();
|
||||
assert!(result["exitCode"].is_number() || result["exitCode"].is_null(), "{result}");
|
||||
let loaded = h.host.mcp_background.snapshot(&h.host, std::time::Instant::now()).remove(0);
|
||||
assert_eq!(loaded.kept_open_by, None, "the call is over and the run has exited");
|
||||
}
|
||||
@@ -193,6 +193,41 @@ async fn mcp_listing_dispatch_confirmation_and_lifecycle_use_plugin_authority()
|
||||
assert!(spin.await.unwrap().is_err(), "command budget interrupts wasm");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_plugin_tool_call_holds_its_background_project_until_it_ends() {
|
||||
use ide_host::mcp::{BackgroundProjects, McpBackgroundHold};
|
||||
// The fixture's `spin` runs until it is cancelled or its budget ends.
|
||||
let f = Harness::with_timeout(Duration::from_secs(10));
|
||||
let inventory = f.root.parent().unwrap().join("inventory");
|
||||
std::fs::create_dir(&inventory).unwrap();
|
||||
for (key, value) in [
|
||||
("enabled", serde_json::json!(true)),
|
||||
("backgroundProjects", serde_json::json!("listed")),
|
||||
("backgroundProjectPaths", serde_json::json!([inventory])),
|
||||
] {
|
||||
let key = format!("mcpServer.{key}");
|
||||
f.host.global_settings.set(ide_workspace::SettingsScope::Global, &key, value).unwrap();
|
||||
}
|
||||
let held_by = || {
|
||||
let loaded = f.host.mcp_background.snapshot(&f.host, std::time::Instant::now());
|
||||
loaded.into_iter().next().map(|project| project.kept_open_by)
|
||||
};
|
||||
let (registry, root, cancel) = (Registry::new(f.host.clone()), inventory.clone(), CancellationToken::new());
|
||||
let stop = cancel.clone();
|
||||
let call = tokio::task::spawn_blocking(move || registry.call(&root, "test_data_tools__spin", "{}", cancel));
|
||||
tokio::time::timeout(Duration::from_secs(10), async {
|
||||
while held_by() != Some(Some(McpBackgroundHold::Request)) {
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.expect("the call holds the project while the plugin runs");
|
||||
stop.cancel();
|
||||
assert!(call.await.unwrap().is_err());
|
||||
assert_eq!(held_by(), Some(None), "the project stays loaded with nothing holding it");
|
||||
f.host.close_project(&BackgroundProjects::key(&inventory));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn database_imports_are_denied_without_the_optional_grant() {
|
||||
let f = Harness::new();
|
||||
|
||||
@@ -152,6 +152,9 @@ async fn editor_ops_merge_the_fixture_format_selection_and_execute_owned_command
|
||||
let visuals = ops::lsp::plugin_language_visuals(&host, "main", doc.id).await.unwrap();
|
||||
assert_eq!(visuals.colors.len(), 1);
|
||||
assert_eq!(visuals.gutter_actions.len(), 1);
|
||||
assert_eq!(visuals.hover_actions.len(), 1);
|
||||
assert_eq!(visuals.hover_actions[0].1.command, "run");
|
||||
assert_eq!(visuals.hover_actions[0].1.end_line, 2);
|
||||
assert_eq!(
|
||||
ops::lsp::plugin_color_presentations(&host, "main", doc.id, ID.into(), visuals.colors[0].1.clone())
|
||||
.await
|
||||
|
||||
@@ -471,7 +471,8 @@ async fn run_target_validation_gates_launches_and_preserves_selection() {
|
||||
f._tmp.path().join("plugins"),
|
||||
Arc::new(|_: Option<&str>, _| {}),
|
||||
Limits {
|
||||
timeout: Duration::from_millis(200),
|
||||
// Room for a reclaimed instance to start again on a slow runner.
|
||||
timeout: Duration::from_millis(750),
|
||||
idle_timeout: Some(Duration::from_millis(20)),
|
||||
restart_backoff: Duration::ZERO,
|
||||
..Default::default()
|
||||
|
||||
@@ -1560,7 +1560,11 @@ fn edit_path_calls_have_soft_and_hard_deadlines() {
|
||||
// Past the hard deadline: interrupted; the next call gets a new instance.
|
||||
assert!(provider.highlights(&mis, "spin").is_none());
|
||||
std::thread::sleep(Duration::from_millis(450));
|
||||
host.tick();
|
||||
// A slow runner may interrupt the spinning call a little after its deadline.
|
||||
assert!(eventually(|| {
|
||||
host.tick();
|
||||
host.info_of("misbehave").unwrap().stats.crashes > 0
|
||||
}));
|
||||
let info = host.info_of("misbehave").unwrap();
|
||||
assert_eq!(info.stats.crashes, 1, "{:?}", info.error);
|
||||
assert!(info.error.as_deref().is_some_and(|e| e.contains("timed out after 400ms")), "{:?}", info.error);
|
||||
@@ -2214,6 +2218,8 @@ fn java_agent_loads_only_while_granted_and_unchanged() {
|
||||
let agent = info.java_agent.clone().expect("agent metadata");
|
||||
assert_eq!(agent.file_name, "fixture agent.jar");
|
||||
assert_eq!(agent.args.as_deref(), Some("mode=test"));
|
||||
assert!(agent.vm_options.is_empty());
|
||||
assert!(agent.jdk.is_none());
|
||||
assert!(!agent.approved);
|
||||
let source = f.host.java_agents();
|
||||
let launch = || {
|
||||
@@ -6380,6 +6386,32 @@ fn api14_window_status_overrides_fall_back_and_are_withdrawn() {
|
||||
&& matches!(event, PluginEvent::WindowStatusItemChanged { item: None, .. })));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_status_item_menu_reaches_the_ui_and_names_only_declared_commands() {
|
||||
let f = fixture(Limits::default());
|
||||
f.install(&sample("api14"));
|
||||
f.run("api14", "menu-status", Some("App: running")).unwrap();
|
||||
let item = f.host.status_snapshot("main").into_iter().find(|i| i.id == "menu").unwrap().item;
|
||||
assert_eq!(item.text, "App: running");
|
||||
assert_eq!(
|
||||
item.menu,
|
||||
[
|
||||
ide_plugin::StatusMenuEntry::Header { label: "App".into() },
|
||||
ide_plugin::StatusMenuEntry::Action {
|
||||
label: "Open".into(),
|
||||
description: Some("https://app.test".into()),
|
||||
command: "events".into(),
|
||||
argument: Some("web".into()),
|
||||
},
|
||||
ide_plugin::StatusMenuEntry::Separator,
|
||||
]
|
||||
);
|
||||
let err = f.run("api14", "bad-menu-status", Some("changed")).unwrap_err();
|
||||
assert!(err.contains("undeclared"), "{err}");
|
||||
let item = f.host.status_snapshot("main").into_iter().find(|i| i.id == "menu").unwrap().item;
|
||||
assert_eq!(item.text, "App: running", "a refused menu changes nothing");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn api14_command_requests_preserve_window_result_and_reject_cycles() {
|
||||
let f = Arc::new(fixture(Limits::default()));
|
||||
|
||||
@@ -1,7 +1,10 @@
|
||||
use ide_core::remote_settings::{SshAuth, SshConfiguration};
|
||||
use ide_core::{IdeEvent, SharedSink};
|
||||
use ide_docker::DockerEndpoint;
|
||||
use ide_host::ops::docker;
|
||||
use ide_host::{Host, HostConfig};
|
||||
use ide_ssh::{SshFiles, SshManager};
|
||||
use std::path::Path;
|
||||
use std::sync::{Arc, Mutex, mpsc};
|
||||
use std::time::Duration;
|
||||
|
||||
@@ -16,14 +19,12 @@ fn read_until(rx: &mpsc::Receiver<String>, needle: &str) -> String {
|
||||
all
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn ssh_session_opens_a_shell_with_the_saved_password() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let port =
|
||||
ide_ssh::testing::sshd(tmp.path().join("server"), Arc::new(|cmd| panic!("unexpected exec: {cmd}"))).await;
|
||||
/// A host whose SSH configuration `box` reaches an in-process server answering `exec`.
|
||||
async fn host_with_ssh_box(tmp: &Path, exec: ide_ssh::testing::ExecFn) -> (Arc<Host>, mpsc::Receiver<IdeEvent>) {
|
||||
let port = ide_ssh::testing::sshd(tmp.join("server"), exec).await;
|
||||
let ssh = Arc::new(SshManager::with_files(
|
||||
tmp.path().join("secrets.json"),
|
||||
SshFiles { known_hosts: tmp.path().join("known_hosts"), config: None },
|
||||
tmp.join("secrets.json"),
|
||||
SshFiles { known_hosts: tmp.join("known_hosts"), config: None },
|
||||
));
|
||||
ssh.set_configs(vec![SshConfiguration {
|
||||
id: "box".into(),
|
||||
@@ -44,7 +45,7 @@ async fn ssh_session_opens_a_shell_with_the_saved_password() {
|
||||
let sink: SharedSink = Arc::new(move |e: IdeEvent| {
|
||||
let _ = events_tx.lock().unwrap().send(e);
|
||||
});
|
||||
let base = tmp.path().join("app");
|
||||
let base = tmp.join("app");
|
||||
let mut host = Arc::new(Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
@@ -58,6 +59,14 @@ async fn ssh_session_opens_a_shell_with_the_saved_password() {
|
||||
}));
|
||||
Arc::get_mut(&mut host).unwrap().ssh = ssh;
|
||||
|
||||
(host, events)
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn ssh_session_opens_a_shell_with_the_saved_password() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let (host, events) = host_with_ssh_box(tmp.path(), Arc::new(|cmd| panic!("unexpected exec: {cmd}"))).await;
|
||||
|
||||
let (tx, output) = mpsc::channel();
|
||||
let tx = Mutex::new(tx);
|
||||
let info = ide_host::ops::term::spawn_ssh(
|
||||
@@ -100,3 +109,55 @@ async fn ssh_session_opens_a_shell_with_the_saved_password() {
|
||||
assert_eq!(code, None);
|
||||
host.shutdown().await;
|
||||
}
|
||||
|
||||
/// Reads what a connection to the local end of a Docker tunnel gets back.
|
||||
async fn dial(port: u16) -> std::io::Result<String> {
|
||||
use tokio::io::AsyncReadExt;
|
||||
let mut socket = tokio::net::TcpStream::connect(("127.0.0.1", port)).await?;
|
||||
let mut out = String::new();
|
||||
socket.read_to_string(&mut out).await?;
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn tunnel_port(endpoint: &DockerEndpoint) -> u16 {
|
||||
let DockerEndpoint::Tcp { host, .. } = endpoint else { panic!("not a tunnel: {endpoint:?}") };
|
||||
host.rsplit(':').next().unwrap().parse().unwrap()
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn disconnecting_a_docker_connection_closes_its_tunnel_and_unused_ssh_session() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let (host, _events) = host_with_ssh_box(
|
||||
tmp.path(),
|
||||
Arc::new(|cmd| match cmd {
|
||||
"docker version --format {{.Client.Version}}" => ("27.0.3\n".into(), 0),
|
||||
"docker system dial-stdio" => ("daemon".into(), 0),
|
||||
other => panic!("unexpected exec: {other}"),
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
let ssh = DockerEndpoint::Ssh { config: "box".into() };
|
||||
|
||||
let port = tunnel_port(&docker::resolve(&host, ssh.clone()).await.unwrap());
|
||||
assert_eq!(dial(port).await.unwrap(), "daemon");
|
||||
assert_eq!(host.ssh.connected(), ["box"]);
|
||||
|
||||
docker::disconnect(&host, &ssh).await;
|
||||
assert!(dial(port).await.is_err(), "the tunnel stopped listening");
|
||||
assert!(host.ssh.connected().is_empty(), "nothing else used the SSH connection");
|
||||
|
||||
// Connecting again opens a new tunnel; a terminal on the same host keeps the session open.
|
||||
let port = tunnel_port(&docker::resolve(&host, ssh.clone()).await.unwrap());
|
||||
assert_eq!(dial(port).await.unwrap(), "daemon");
|
||||
let terminal = host.ssh.session("box").await.unwrap();
|
||||
docker::disconnect(&host, &ssh).await;
|
||||
assert!(dial(port).await.is_err());
|
||||
assert_eq!(host.ssh.connected(), ["box"]);
|
||||
assert!(!terminal.is_closed());
|
||||
|
||||
// Nothing to close: a second disconnect and other endpoints are no-ops.
|
||||
docker::disconnect(&host, &ssh).await;
|
||||
docker::disconnect(&host, &DockerEndpoint::Default).await;
|
||||
assert_eq!(host.ssh.connected(), ["box"]);
|
||||
host.shutdown().await;
|
||||
}
|
||||
@@ -65,8 +65,23 @@ pub fn build_with_redirect(proxy: &ProxySettings, redirect: reqwest::redirect::P
|
||||
/// The client for the current proxy settings, rebuilt when they change.
|
||||
pub fn shared() -> IdeResult<reqwest::Client> {
|
||||
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, build)
|
||||
}
|
||||
|
||||
/// The client the HTTP Client executes requests with: redirects off, `exec`
|
||||
/// follows them by hand — that is what lets a `POST` stay a `POST` on a
|
||||
/// 301/302 and puts the redirect chain into the response.
|
||||
pub fn shared_without_redirects() -> IdeResult<reqwest::Client> {
|
||||
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, |proxy| build_with_redirect(proxy, reqwest::redirect::Policy::none()))
|
||||
}
|
||||
|
||||
fn cached_client(
|
||||
slot: &Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>>,
|
||||
build: fn(&ProxySettings) -> IdeResult<reqwest::Client>,
|
||||
) -> IdeResult<reqwest::Client> {
|
||||
let proxy = ide_core::proxy_settings::proxy();
|
||||
let mut cached = CLIENT.lock();
|
||||
let mut cached = slot.lock();
|
||||
if let Some((settings, client)) = cached.as_ref()
|
||||
&& **settings == *proxy
|
||||
{
|
||||
|
||||
@@ -13,6 +13,19 @@ use std::time::Instant;
|
||||
/// Bodies above this are cut (the full size is still reported).
|
||||
pub const MAX_BODY: usize = 16 * 1024 * 1024;
|
||||
|
||||
/// Redirects followed per request; beyond this the redirect response itself is
|
||||
/// returned (IntelliJ's HTTP Client follows the same number).
|
||||
pub const MAX_REDIRECTS: usize = 50;
|
||||
|
||||
/// Responses whose `Location` is followed: 301, 302, 303, 307 and 308, the set
|
||||
/// IntelliJ's HTTP Client redirects on.
|
||||
const REDIRECT_STATUSES: [u16; 5] = [301, 302, 303, 307, 308];
|
||||
|
||||
/// Request headers not re-sent to a redirect on another host. IntelliJ's HTTP
|
||||
/// Client strips the same set and restores it when the redirect stays on the
|
||||
/// original host.
|
||||
const SENSITIVE_HEADERS: [&str; 5] = ["authorization", "cookie", "cookie2", "www-authenticate", "proxy-authorization"];
|
||||
|
||||
/// A request ready to send: variables substituted, includes read.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -24,6 +37,15 @@ pub struct PreparedRequest {
|
||||
pub body: Option<String>,
|
||||
}
|
||||
|
||||
/// One followed redirect: the response and the `Location` it pointed to.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct RedirectHop {
|
||||
pub status: u16,
|
||||
pub status_text: String,
|
||||
pub location: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct HttpResponse {
|
||||
@@ -32,6 +54,9 @@ pub struct HttpResponse {
|
||||
pub version: String,
|
||||
pub headers: Vec<(String, String)>,
|
||||
pub content_type: Option<String>,
|
||||
/// Followed redirects, first hop first; empty when not redirected.
|
||||
#[serde(default)]
|
||||
pub redirects: Vec<RedirectHop>,
|
||||
/// Body as text (lossy UTF-8); `None` for binary bodies.
|
||||
pub body: Option<String>,
|
||||
/// Size in bytes as received (after decompression).
|
||||
@@ -128,25 +153,84 @@ fn looks_textual(content_type: Option<&str>, bytes: &[u8]) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
/// Sends `req`; cancelled when `cancel` fires.
|
||||
/// The request for one hop: `req`'s headers and body against `url`, the
|
||||
/// sensitive headers dropped when the redirect crosses to another host.
|
||||
fn request_to(
|
||||
client: &reqwest::Client,
|
||||
method: &reqwest::Method,
|
||||
req: &PreparedRequest,
|
||||
body: Option<&str>,
|
||||
original: &reqwest::Url,
|
||||
url: &reqwest::Url,
|
||||
) -> IdeResult<reqwest::Request> {
|
||||
let same_host = url.host_str() == original.host_str();
|
||||
let mut builder = client.request(method.clone(), url.clone());
|
||||
for (k, v) in &req.headers {
|
||||
if same_host || !SENSITIVE_HEADERS.iter().any(|s| k.eq_ignore_ascii_case(s)) {
|
||||
builder = builder.header(k, v);
|
||||
}
|
||||
}
|
||||
if let Some(body) = body {
|
||||
builder = builder.body(body.to_owned());
|
||||
}
|
||||
builder.build().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))
|
||||
}
|
||||
|
||||
/// Sends `request`; cancelled when `cancel` fires.
|
||||
async fn send(
|
||||
client: &reqwest::Client,
|
||||
request: reqwest::Request,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<reqwest::Response> {
|
||||
let send = client.execute(request);
|
||||
tokio::select! {
|
||||
r = send => r.map_err(|e| IdeError::new(ide_core::error::ErrorKind::Io, describe(&e))),
|
||||
() = cancel.cancelled() => Err(IdeError::cancelled()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Sends `req`, following redirects the way IntelliJ's HTTP Client does:
|
||||
/// 301, 302, 303, 307 and 308 up to [`MAX_REDIRECTS`] times, `303` continuing
|
||||
/// as `GET` without the body, the other statuses keeping the method and body —
|
||||
/// so a `POST` redirected to `https` on the same host is re-sent as a `POST`.
|
||||
/// Sensitive headers (Authorization, cookies, proxy credentials) are not
|
||||
/// re-sent across hosts. The followed hops are reported in the response.
|
||||
/// Cancelled when `cancel` fires.
|
||||
pub async fn execute(req: &PreparedRequest, cancel: &CancellationToken) -> IdeResult<HttpResponse> {
|
||||
let client = crate::client::shared()?;
|
||||
let client = crate::client::shared_without_redirects()?;
|
||||
let method = reqwest::Method::from_bytes(req.method.as_bytes())
|
||||
.map_err(|_| IdeError::invalid(format!("invalid method {}", req.method)))?;
|
||||
let mut builder = client.request(method, &req.url);
|
||||
for (k, v) in &req.headers {
|
||||
builder = builder.header(k, v);
|
||||
}
|
||||
if let Some(body) = &req.body {
|
||||
builder = builder.body(body.clone());
|
||||
}
|
||||
let request = builder.build().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))?;
|
||||
let original = req.url.parse::<reqwest::Url>().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))?;
|
||||
let mut url = original.clone();
|
||||
let mut method = method;
|
||||
let mut body = req.body.clone();
|
||||
let mut redirects = Vec::new();
|
||||
let started = Instant::now();
|
||||
let send = client.execute(request);
|
||||
let mut response = tokio::select! {
|
||||
r = send => r.map_err(|e| IdeError::new(ide_core::error::ErrorKind::Io, describe(&e)))?,
|
||||
() = cancel.cancelled() => return Err(IdeError::cancelled()),
|
||||
};
|
||||
let mut response;
|
||||
loop {
|
||||
let request = request_to(&client, &method, req, body.as_deref(), &original, &url)?;
|
||||
response = send(&client, request, cancel).await?;
|
||||
let status = response.status();
|
||||
if redirects.len() >= MAX_REDIRECTS || !REDIRECT_STATUSES.contains(&status.as_u16()) {
|
||||
break;
|
||||
}
|
||||
let next = response
|
||||
.headers()
|
||||
.get(reqwest::header::LOCATION)
|
||||
.and_then(|v| v.to_str().ok())
|
||||
.and_then(|location| url.join(location).ok());
|
||||
let Some(next) = next else { break };
|
||||
redirects.push(RedirectHop {
|
||||
status: status.as_u16(),
|
||||
status_text: status.canonical_reason().unwrap_or("").to_owned(),
|
||||
location: next.to_string(),
|
||||
});
|
||||
if status == reqwest::StatusCode::SEE_OTHER {
|
||||
method = reqwest::Method::GET;
|
||||
body = None;
|
||||
}
|
||||
url = next;
|
||||
}
|
||||
let ttfb = started.elapsed();
|
||||
let status = response.status();
|
||||
let version = format!("{:?}", response.version());
|
||||
@@ -179,6 +263,7 @@ pub async fn execute(req: &PreparedRequest, cancel: &CancellationToken) -> IdeRe
|
||||
version,
|
||||
headers,
|
||||
content_type,
|
||||
redirects,
|
||||
body,
|
||||
size: size as f64,
|
||||
truncated: size > bytes.len(),
|
||||
@@ -249,6 +334,47 @@ mod tests {
|
||||
assert_eq!(url("GET https://api.test/cb?u=http://x\n"), "https://api.test/cb?u=http://x");
|
||||
}
|
||||
|
||||
/// A loopback server answering each accepted connection with the next of
|
||||
/// `responses`, returning every request as its head and body.
|
||||
async fn scripted(responses: Vec<String>) -> (u16, tokio::task::JoinHandle<Vec<(String, String)>>) {
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let handle = tokio::spawn(async move {
|
||||
let mut seen = Vec::new();
|
||||
for response in responses {
|
||||
let (mut socket, _) = listener.accept().await.unwrap();
|
||||
let mut request = Vec::new();
|
||||
let (head, body) = loop {
|
||||
let mut buffer = [0u8; 4096];
|
||||
let read = socket.read(&mut buffer).await.unwrap();
|
||||
assert!(read > 0, "request ended before its body");
|
||||
request.extend_from_slice(&buffer[..read]);
|
||||
let Some(end) = request.windows(4).position(|w| w == b"\r\n\r\n") else { continue };
|
||||
let head = String::from_utf8_lossy(&request[..end]).into_owned();
|
||||
let length: usize = head
|
||||
.lines()
|
||||
.find_map(|line| {
|
||||
let (name, value) = line.split_once(':')?;
|
||||
name.eq_ignore_ascii_case("content-length").then(|| value.trim().parse().unwrap())
|
||||
})
|
||||
.unwrap_or(0);
|
||||
if request.len() >= end + 4 + length {
|
||||
break (head, String::from_utf8_lossy(&request[end + 4..end + 4 + length]).into_owned());
|
||||
}
|
||||
};
|
||||
seen.push((head, body));
|
||||
socket.write_all(response.as_bytes()).await.unwrap();
|
||||
}
|
||||
seen
|
||||
});
|
||||
(port, handle)
|
||||
}
|
||||
|
||||
fn response(status_line: &str, headers: &str, body: &str) -> String {
|
||||
format!("HTTP/1.1 {status_line}\r\n{headers}Content-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sends_exact_environment_numbers_to_a_local_server() {
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
@@ -341,6 +467,7 @@ mod tests {
|
||||
assert_eq!(r.status_text, "Created");
|
||||
assert_eq!(r.body.as_deref(), Some("{\"ok\":true}"));
|
||||
assert!(r.headers.iter().any(|(k, v)| k == "x-a" && v == "b"));
|
||||
assert!(r.redirects.is_empty());
|
||||
assert!(r.total_ms >= r.ttfb_ms);
|
||||
}
|
||||
|
||||
@@ -369,4 +496,150 @@ mod tests {
|
||||
let err = execute(&req, &cancel).await.unwrap_err();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn post_keeps_method_and_body_on_301_302_307_308() {
|
||||
for status_line in ["301 Moved Permanently", "302 Found", "307 Temporary Redirect", "308 Permanent Redirect"] {
|
||||
let status: u16 = status_line[..3].parse().unwrap();
|
||||
let (port, server) =
|
||||
scripted(vec![response(status_line, "Location: /landing\r\n", ""), response("200 OK", "", "ok")]).await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "POST".into(),
|
||||
url: format!("http://127.0.0.1:{port}/submit"),
|
||||
headers: vec![("Content-Type".into(), "application/json".into())],
|
||||
body: Some("{\"a\":1}".into()),
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
let (head, body) = &seen[1];
|
||||
assert_eq!(head.lines().next().unwrap(), "POST /landing HTTP/1.1", "{status_line}");
|
||||
assert!(head.to_ascii_lowercase().contains("content-type: application/json"), "{head}");
|
||||
assert_eq!(body, "{\"a\":1}", "{status_line}");
|
||||
assert_eq!(r.status, 200, "{status_line}");
|
||||
assert_eq!(r.body.as_deref(), Some("ok"), "{status_line}");
|
||||
assert_eq!(
|
||||
r.redirects,
|
||||
vec![RedirectHop {
|
||||
status,
|
||||
status_text: status_line[4..].to_owned(),
|
||||
location: format!("http://127.0.0.1:{port}/landing"),
|
||||
}],
|
||||
"{status_line}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn see_other_303_resends_as_get_without_the_body() {
|
||||
let (port, server) =
|
||||
scripted(vec![response("303 See Other", "Location: /after\r\n", ""), response("200 OK", "", "done")]).await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "POST".into(),
|
||||
url: format!("http://127.0.0.1:{port}/submit"),
|
||||
headers: vec![],
|
||||
body: Some("{\"a\":1}".into()),
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
assert_eq!(seen[1].0.lines().next().unwrap(), "GET /after HTTP/1.1");
|
||||
assert_eq!(seen[1].1, "");
|
||||
assert_eq!(r.status, 200);
|
||||
assert_eq!(r.body.as_deref(), Some("done"));
|
||||
assert_eq!(r.redirects[0].status, 303);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn same_host_redirect_keeps_authorization() {
|
||||
let (port, server) = scripted(vec![
|
||||
response("301 Moved Permanently", "Location: /landing\r\n", ""),
|
||||
response("200 OK", "", "ok"),
|
||||
])
|
||||
.await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "GET".into(),
|
||||
url: format!("http://127.0.0.1:{port}/start"),
|
||||
headers: vec![("Authorization".into(), "Bearer secret".into())],
|
||||
body: None,
|
||||
};
|
||||
execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
assert!(seen[1].0.to_ascii_lowercase().contains("authorization: bearer secret"), "{}", seen[1].0);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn cross_host_redirect_keeps_the_method_but_drops_authorization() {
|
||||
let (port_b, server_b) = scripted(vec![response("200 OK", "", "moved")]).await;
|
||||
let (port_a, server_a) = scripted(vec![response(
|
||||
"301 Moved Permanently",
|
||||
&format!("Location: http://127.0.0.1:{port_b}/x\r\n"),
|
||||
"",
|
||||
)])
|
||||
.await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "POST".into(),
|
||||
url: format!("http://localhost:{port_a}/start"),
|
||||
headers: vec![("Authorization".into(), "Bearer secret".into())],
|
||||
body: Some("{\"a\":1}".into()),
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen_a = server_a.await.unwrap();
|
||||
let seen_b = server_b.await.unwrap();
|
||||
assert!(seen_a[0].0.to_ascii_lowercase().contains("authorization: bearer secret"), "{}", seen_a[0].0);
|
||||
assert_eq!(seen_b[0].0.lines().next().unwrap(), "POST /x HTTP/1.1");
|
||||
assert!(!seen_b[0].0.to_ascii_lowercase().contains("authorization"), "{}", seen_b[0].0);
|
||||
assert_eq!(seen_b[0].1, "{\"a\":1}");
|
||||
assert_eq!(r.status, 200);
|
||||
assert_eq!(r.body.as_deref(), Some("moved"));
|
||||
assert_eq!(r.redirects.len(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn redirects_beyond_the_limit_return_the_last_redirect_response() {
|
||||
let responses = vec![response("301 Moved Permanently", "Location: /loop\r\n", ""); MAX_REDIRECTS + 1];
|
||||
let (port, server) = scripted(responses).await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "GET".into(),
|
||||
url: format!("http://127.0.0.1:{port}/start"),
|
||||
headers: vec![],
|
||||
body: None,
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
assert_eq!(r.status, 301);
|
||||
assert_eq!(r.status_text, "Moved Permanently");
|
||||
assert_eq!(r.redirects.len(), MAX_REDIRECTS);
|
||||
assert_eq!(seen.len(), MAX_REDIRECTS + 1);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn redirect_chain_is_recorded_across_hops() {
|
||||
let (port, server) = scripted(vec![
|
||||
response("302 Found", "Location: /b\r\n", ""),
|
||||
response("302 Found", "Location: /c\r\n", ""),
|
||||
response("200 OK", "", "end"),
|
||||
])
|
||||
.await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "GET".into(),
|
||||
url: format!("http://127.0.0.1:{port}/a"),
|
||||
headers: vec![],
|
||||
body: None,
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
assert_eq!(r.status, 200);
|
||||
assert_eq!(r.body.as_deref(), Some("end"));
|
||||
assert_eq!(r.redirects.len(), 2);
|
||||
assert_eq!(r.redirects[0].status, 302);
|
||||
assert_eq!(r.redirects[0].location, format!("http://127.0.0.1:{port}/b"));
|
||||
assert_eq!(r.redirects[1].status, 302);
|
||||
assert_eq!(r.redirects[1].location, format!("http://127.0.0.1:{port}/c"));
|
||||
assert_eq!(seen[2].0.lines().next().unwrap(), "GET /c HTTP/1.1");
|
||||
}
|
||||
}
|
||||
@@ -690,7 +690,7 @@ mod tests {
|
||||
for (lang, servers) in [
|
||||
("python", vec!["basedpyright", "pyright", "ty", "pyrefly"]),
|
||||
("typescript", vec!["vtsls", "typescript-language-server"]),
|
||||
("java", vec!["jdtls", "kmp-lsp"]),
|
||||
("java", vec!["jdtls", "java-analyzer", "kmp-lsp"]),
|
||||
("kotlin", vec!["kotlin-lsp", "kotlin-language-server", "kmp-lsp"]),
|
||||
] {
|
||||
let cfg = reg.get(&LanguageId::new(lang)).unwrap();
|
||||
|
||||
@@ -31,3 +31,8 @@ zip.workspace = true
|
||||
tempfile.workspace = true
|
||||
encoding_rs.workspace = true
|
||||
tokio = { workspace = true, features = ["rt-multi-thread", "macros", "test-util"] }
|
||||
criterion = { version = "0.5", default-features = false }
|
||||
|
||||
[[bench]]
|
||||
name = "did_change"
|
||||
harness = false
|
||||
@@ -0,0 +1,158 @@
|
||||
//! `cargo bench -p ide-lsp`: an incremental LSP change on a 1 MB document.
|
||||
|
||||
use criterion::{Criterion, black_box, criterion_group, criterion_main};
|
||||
use ide_core::event::ServerStatus;
|
||||
use ide_core::{DocId, IdeEvent, LanguageId, Pos, Range};
|
||||
use ide_jsonrpc::{Handler, Peer};
|
||||
use ide_language::{LanguageConfig, LanguageRegistry, LanguageServerConfig};
|
||||
use ide_lsp::{Launcher, LspManager};
|
||||
use ide_text::AppliedChange;
|
||||
use serde_json::{Value, json};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
struct MockServer;
|
||||
|
||||
impl Handler for MockServer {
|
||||
fn on_notification(&self, _method: &str, _params: Value) {}
|
||||
|
||||
fn on_request(&self, method: &str, _params: Value) -> Result<Value, (i64, String)> {
|
||||
match method {
|
||||
"initialize" => Ok(json!({
|
||||
"capabilities": {
|
||||
"textDocumentSync": { "openClose": true, "change": 2 }
|
||||
}
|
||||
})),
|
||||
"shutdown" => Ok(Value::Null),
|
||||
_ => Ok(Value::Null),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct MockLauncher {
|
||||
servers: Mutex<Vec<Peer>>,
|
||||
}
|
||||
|
||||
impl Launcher for MockLauncher {
|
||||
fn launch(
|
||||
&self,
|
||||
_config: &LanguageServerConfig,
|
||||
_root: &Path,
|
||||
handler: Arc<dyn Handler>,
|
||||
_on_stderr: Box<dyn Fn(String) + Send + Sync>,
|
||||
) -> Result<Peer, ide_lsp::LaunchError> {
|
||||
let (server_io, client_io) = tokio::io::duplex(1 << 20);
|
||||
let (server_read, server_write) = tokio::io::split(server_io);
|
||||
let (client_read, client_write) = tokio::io::split(client_io);
|
||||
let server = Peer::connect(server_read, server_write, Arc::new(MockServer));
|
||||
self.servers.lock().unwrap().push(server);
|
||||
Ok(Peer::connect(client_read, client_write, handler))
|
||||
}
|
||||
}
|
||||
|
||||
fn server_config() -> LanguageServerConfig {
|
||||
LanguageServerConfig {
|
||||
name: "mock".into(),
|
||||
command: "mock".into(),
|
||||
args: vec![],
|
||||
env: Default::default(),
|
||||
requires_env: Vec::new(),
|
||||
root_markers: vec!["mock.toml".into()],
|
||||
require_root_marker: false,
|
||||
initialization_options: None,
|
||||
settings: None,
|
||||
install_hint: None,
|
||||
connect: None,
|
||||
fallback: false,
|
||||
replaces: Vec::new(),
|
||||
features: Vec::new(),
|
||||
code_action_kinds: Vec::new(),
|
||||
max_java: None,
|
||||
launch_error: None,
|
||||
tsserver_project: false,
|
||||
tsserver_project_extras: Default::default(),
|
||||
resync_on_configuration: false,
|
||||
display_name: None,
|
||||
pinned: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn language_config() -> LanguageConfig {
|
||||
LanguageConfig {
|
||||
id: LanguageId::new("mock"),
|
||||
name: "Mock".into(),
|
||||
extensions: vec!["mk".into()],
|
||||
filenames: vec![],
|
||||
first_line: None,
|
||||
line_comment: None,
|
||||
block_comment: None,
|
||||
indent: None,
|
||||
ui_mode: None,
|
||||
framework_ui_modes: Vec::new(),
|
||||
framework_files: Vec::new(),
|
||||
formatter: None,
|
||||
scratch_template: None,
|
||||
rainbow_brackets: Default::default(),
|
||||
tree_sitter: None,
|
||||
language_servers: vec![server_config()],
|
||||
debugger: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn sample_text(bytes: usize) -> String {
|
||||
let mut text = String::with_capacity(bytes);
|
||||
let mut i = 0;
|
||||
while text.len() < bytes {
|
||||
text.push_str(&format!(" let value_{i} = compute({i});\n"));
|
||||
i += 1;
|
||||
}
|
||||
text
|
||||
}
|
||||
|
||||
fn wait_until_ready(manager: &LspManager) {
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
|
||||
while manager.servers().iter().all(|server| server.status != ServerStatus::Ready) {
|
||||
assert!(std::time::Instant::now() < deadline, "mock language server did not become ready");
|
||||
std::thread::sleep(std::time::Duration::from_millis(10));
|
||||
}
|
||||
}
|
||||
|
||||
fn bench(c: &mut Criterion) {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let registry = Arc::new(LanguageRegistry::from_configs(vec![language_config()]));
|
||||
let manager = LspManager::with_launcher(
|
||||
root.path().to_owned(),
|
||||
registry,
|
||||
Arc::new(|_: IdeEvent| {}),
|
||||
Arc::new(MockLauncher::default()),
|
||||
);
|
||||
let text = sample_text(1 << 20);
|
||||
let path: PathBuf = root.path().join("large.mk");
|
||||
std::fs::write(&path, &text).unwrap();
|
||||
let doc = DocId::next();
|
||||
manager.did_open(doc, &path, &LanguageId::new("mock"), 1, &text);
|
||||
wait_until_ready(&manager);
|
||||
|
||||
let changes = [AppliedChange { range: Range::new(Pos::new(0, 4), Pos::new(0, 8)), text: "same".into() }];
|
||||
let mut version = 2;
|
||||
c.bench_function("lsp/did_change_incremental_1mb", |b| {
|
||||
b.iter(|| {
|
||||
manager.did_change(doc, version, black_box(&changes), &|| unreachable!("valid incremental edit"));
|
||||
version = version.wrapping_add(1);
|
||||
});
|
||||
});
|
||||
|
||||
tokio::runtime::Runtime::new().unwrap().block_on(manager.shutdown_all());
|
||||
}
|
||||
|
||||
criterion_group! {
|
||||
name = benches;
|
||||
config = Criterion::default()
|
||||
.sample_size(30)
|
||||
.warm_up_time(std::time::Duration::from_secs(1))
|
||||
.measurement_time(std::time::Duration::from_secs(3));
|
||||
targets = bench
|
||||
}
|
||||
|
||||
criterion_main!(benches);
|
||||
@@ -0,0 +1,196 @@
|
||||
//! The Dart analysis server's Flutter outline (`dart/textDocument/publishFlutterOutline`):
|
||||
//! a file's declarations with the widgets built inside them, in source order.
|
||||
|
||||
use crate::convert::Conv;
|
||||
use ide_core::{OutlineItem, SymbolKind};
|
||||
use lsp_types as lsp;
|
||||
use serde::Deserialize;
|
||||
use std::path::Path;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
pub(crate) struct Params {
|
||||
pub uri: String,
|
||||
pub outline: Node,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub(crate) struct Node {
|
||||
kind: String,
|
||||
label: Option<String>,
|
||||
class_name: Option<String>,
|
||||
variable_name: Option<String>,
|
||||
attributes: Option<Vec<Attribute>>,
|
||||
dart_element: Option<Element>,
|
||||
range: lsp::Range,
|
||||
children: Option<Vec<Node>>,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct Attribute {
|
||||
name: String,
|
||||
label: String,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct Element {
|
||||
name: String,
|
||||
kind: String,
|
||||
range: Option<lsp::Range>,
|
||||
parameters: Option<String>,
|
||||
type_parameters: Option<String>,
|
||||
return_type: Option<String>,
|
||||
}
|
||||
|
||||
/// The items below the compilation unit; `None` when no widget is built in the file, whose
|
||||
/// structure is then the ordinary one.
|
||||
pub(crate) fn items(conv: &Conv, path: &Path, root: Node) -> Option<Vec<OutlineItem>> {
|
||||
let children = root.children?;
|
||||
children.iter().any(has_widget).then(|| children.into_iter().map(|n| item(conv, path, n)).collect())
|
||||
}
|
||||
|
||||
fn has_widget(node: &Node) -> bool {
|
||||
node.dart_element.is_none() || node.children.iter().flatten().any(has_widget)
|
||||
}
|
||||
|
||||
fn item(conv: &Conv, path: &Path, node: Node) -> OutlineItem {
|
||||
let range = conv.range(path, node.range);
|
||||
let detail = widget_detail(&node);
|
||||
let children = node.children.unwrap_or_default().into_iter().map(|n| item(conv, path, n)).collect();
|
||||
let (name, detail, kind, selection_range) = match node.dart_element {
|
||||
Some(e) => (
|
||||
format!("{}{}{}", e.name, e.type_parameters.unwrap_or_default(), e.parameters.unwrap_or_default()),
|
||||
e.return_type.filter(|t| !t.is_empty()).map(|t| format!("→ {t}")),
|
||||
element_kind(&e.kind),
|
||||
e.range.map_or(range, |r| conv.range(path, r)),
|
||||
),
|
||||
None => (node.class_name.or(node.label).unwrap_or(node.kind), detail, SymbolKind::Widget, range),
|
||||
};
|
||||
OutlineItem { name, detail, kind, range, selection_range, children, visibility: None }
|
||||
}
|
||||
|
||||
/// What follows a widget's class, as the Flutter plugin's outline shows it: the variable holding
|
||||
/// it, a generic node's expression, then its attributes (`Text 'Hi'`, `Icon icon: add, size: 24`).
|
||||
fn widget_detail(node: &Node) -> Option<String> {
|
||||
let mut parts: Vec<String> = node.variable_name.iter().cloned().collect();
|
||||
if node.kind == "GENERIC" {
|
||||
parts.extend(node.label.iter().cloned());
|
||||
}
|
||||
match node.attributes.as_deref().unwrap_or_default() {
|
||||
[only] if matches!(only.name.as_str(), "text" | "icon") => parts.push(only.label.clone()),
|
||||
attributes if !attributes.is_empty() => parts.push(
|
||||
attributes
|
||||
.iter()
|
||||
.map(|a| if a.name == "data" { a.label.clone() } else { format!("{}: {}", a.name, a.label) })
|
||||
.collect::<Vec<_>>()
|
||||
.join(", "),
|
||||
),
|
||||
_ => {}
|
||||
}
|
||||
(!parts.is_empty()).then(|| parts.join(" "))
|
||||
}
|
||||
|
||||
fn element_kind(kind: &str) -> SymbolKind {
|
||||
match kind {
|
||||
"CLASS" | "CLASS_TYPE_ALIAS" | "EXTENSION" | "EXTENSION_TYPE" => SymbolKind::Class,
|
||||
"MIXIN" => SymbolKind::Interface,
|
||||
"ENUM" => SymbolKind::Enum,
|
||||
"ENUM_CONSTANT" => SymbolKind::EnumMember,
|
||||
"CONSTRUCTOR" => SymbolKind::Constructor,
|
||||
"METHOD" => SymbolKind::Method,
|
||||
"FUNCTION" => SymbolKind::Function,
|
||||
"FIELD" => SymbolKind::Field,
|
||||
"GETTER" | "SETTER" => SymbolKind::Property,
|
||||
"TOP_LEVEL_VARIABLE" => SymbolKind::Variable,
|
||||
"FUNCTION_TYPE_ALIAS" | "TYPE_ALIAS" => SymbolKind::TypeAlias,
|
||||
_ => SymbolKind::Unknown,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::text::{DocText, Encoding};
|
||||
use ide_core::{Pos, Range};
|
||||
use serde_json::{Value, json};
|
||||
use std::sync::Arc;
|
||||
|
||||
fn range(line: u32, from: u32, to: u32) -> Value {
|
||||
json!({ "start": { "line": line, "character": from }, "end": { "line": line, "character": to } })
|
||||
}
|
||||
|
||||
fn element(kind: &str, name: &str, extra: Value, children: Value) -> Value {
|
||||
let mut e = json!({ "kind": kind, "name": name, "range": range(1, 9, 14) });
|
||||
e.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
|
||||
json!({ "kind": "DART_ELEMENT", "dartElement": e, "range": range(0, 0, 40), "codeRange": range(0, 0, 40), "children": children })
|
||||
}
|
||||
|
||||
fn widget(kind: &str, class: &str, extra: Value) -> Value {
|
||||
let mut w = json!({ "kind": kind, "className": class, "range": range(3, 4, 12), "codeRange": range(3, 4, 12) });
|
||||
w.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
|
||||
w
|
||||
}
|
||||
|
||||
fn convert(conv: &Conv, children: Value) -> Option<Vec<OutlineItem>> {
|
||||
let root: Node = serde_json::from_value(element("COMPILATION_UNIT", "<unit>", json!({}), children)).unwrap();
|
||||
items(conv, Path::new("/p/a.dart"), root)
|
||||
}
|
||||
|
||||
fn utf16() -> Conv<'static> {
|
||||
Conv::new(Encoding::Utf16, |_: &Path| None)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn declarations_keep_their_widgets_in_source_order() {
|
||||
let outline = json!([element(
|
||||
"METHOD",
|
||||
"build",
|
||||
json!({ "parameters": "(BuildContext context)", "returnType": "Widget" }),
|
||||
json!([widget("NEW_INSTANCE", "Scaffold", json!({})), widget("NEW_INSTANCE", "Align", json!({}))]),
|
||||
)]);
|
||||
let items = convert(&utf16(), outline).unwrap();
|
||||
let build = &items[0];
|
||||
assert_eq!(build.name, "build(BuildContext context)");
|
||||
assert_eq!(build.detail.as_deref(), Some("→ Widget"));
|
||||
assert_eq!(build.kind, SymbolKind::Method);
|
||||
assert_eq!(build.selection_range, Range::new(Pos::new(1, 9), Pos::new(1, 14)));
|
||||
let names: Vec<_> = build.children.iter().map(|c| c.name.as_str()).collect();
|
||||
assert_eq!(names, ["Scaffold", "Align"]);
|
||||
assert_eq!(build.children[0].kind, SymbolKind::Widget);
|
||||
assert_eq!(build.children[0].selection_range, build.children[0].range);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn widget_details_read_like_the_flutter_plugin() {
|
||||
let attr = |name: &str, label: &str| json!({ "name": name, "label": label });
|
||||
let detail = |w: Value| convert(&utf16(), json!([w])).unwrap().remove(0).detail;
|
||||
let w = widget("NEW_INSTANCE", "Text", json!({ "attributes": [attr("data", "'Hi'")] }));
|
||||
assert_eq!(detail(w).as_deref(), Some("'Hi'"));
|
||||
let w = widget("NEW_INSTANCE", "Icon", json!({ "attributes": [attr("icon", "Icons.add")] }));
|
||||
assert_eq!(detail(w).as_deref(), Some("Icons.add"));
|
||||
let w =
|
||||
widget("NEW_INSTANCE", "Icon", json!({ "attributes": [attr("icon", "Icons.add"), attr("size", "24")] }));
|
||||
assert_eq!(detail(w).as_deref(), Some("icon: Icons.add, size: 24"));
|
||||
assert_eq!(detail(widget("VARIABLE", "Text", json!({ "variableName": "title" }))).as_deref(), Some("title"));
|
||||
assert_eq!(detail(widget("GENERIC", "Widget", json!({ "label": "_footer()" }))).as_deref(), Some("_footer()"));
|
||||
assert_eq!(detail(widget("NEW_INSTANCE", "Column", json!({}))), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_file_without_widgets_has_no_flutter_outline() {
|
||||
let plain =
|
||||
json!([element("CLASS", "Plain", json!({}), json!([element("METHOD", "run", json!({}), json!([]))]))]);
|
||||
assert!(convert(&utf16(), plain).is_none());
|
||||
assert!(convert(&utf16(), json!([])).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn positions_become_utf16_columns() {
|
||||
let text = Arc::new(DocText::new("\n\n\n🙂🙂 Text('x')\n"));
|
||||
let conv = Conv::new(Encoding::Utf8, move |_: &Path| Some(text.clone()));
|
||||
let w = json!({ "kind": "NEW_INSTANCE", "className": "Text", "range": range(3, 9, 13), "codeRange": range(3, 9, 13) });
|
||||
let item = convert(&conv, json!([w])).unwrap().remove(0);
|
||||
assert_eq!(item.range, Range::new(Pos::new(3, 5), Pos::new(3, 9)));
|
||||
}
|
||||
}
|
||||
@@ -355,6 +355,24 @@ impl ClientHandler {
|
||||
mgr.emit_diagnostics(&self.server, path, shown, self.encoding());
|
||||
}
|
||||
|
||||
fn publish_flutter_outline(&self, mgr: &LspManager, params: Value) {
|
||||
let params: crate::flutter_outline::Params = match serde_json::from_value(params) {
|
||||
Ok(p) => p,
|
||||
Err(e) => {
|
||||
tracing::debug!("{}: bad publishFlutterOutline: {e}", self.server.name);
|
||||
return;
|
||||
}
|
||||
};
|
||||
let Some(path) = uri_to_path(¶ms.uri) else { return };
|
||||
if !self.server.is_live(self.generation) {
|
||||
return;
|
||||
}
|
||||
let items = crate::flutter_outline::items(&mgr.conv(self.encoding()), &path, params.outline);
|
||||
if mgr.set_flutter_outline(&path, &self.server, self.generation, items) {
|
||||
mgr.sink().emit(IdeEvent::LspRefresh { server: self.server.id, kind: LspRefreshKind::FlutterOutline });
|
||||
}
|
||||
}
|
||||
|
||||
/// Once per unresolved plugin, whether m2e marked a `pom.xml` or only logged it.
|
||||
fn build_plan_failure(&self, mgr: &LspManager, (plugin, body): (String, String)) {
|
||||
if mgr.first_message(&self.server.name, &format!("build plan: {plugin}")) {
|
||||
@@ -562,6 +580,7 @@ impl Handler for ClientHandler {
|
||||
}
|
||||
}
|
||||
"textDocument/publishDiagnostics" => self.publish_diagnostics(&mgr, params),
|
||||
"dart/textDocument/publishFlutterOutline" => self.publish_flutter_outline(&mgr, params),
|
||||
"window/showMessage" => self.show_message(&mgr, ¶ms),
|
||||
"window/logMessage" => {
|
||||
let text = params.get("message").and_then(Value::as_str).unwrap_or_default();
|
||||
|
||||
@@ -15,6 +15,7 @@ mod convert;
|
||||
mod external_project;
|
||||
mod file_ops;
|
||||
mod file_watch;
|
||||
mod flutter_outline;
|
||||
mod go_mod;
|
||||
mod go_scope;
|
||||
mod handler;
|
||||
@@ -78,7 +79,7 @@ use server::{Conn, Running, Server};
|
||||
use std::collections::{BTreeMap, HashMap, HashSet};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::{Arc, Weak};
|
||||
use std::sync::{Arc, OnceLock, Weak};
|
||||
use std::time::Duration;
|
||||
use text::{DocText, Encoding};
|
||||
use types::*;
|
||||
@@ -87,6 +88,21 @@ const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);
|
||||
const COMPLETION_TIMEOUT: Duration = Duration::from_secs(5);
|
||||
const LONG_TIMEOUT: Duration = Duration::from_secs(30);
|
||||
|
||||
fn did_change_content(
|
||||
sync: SyncKind,
|
||||
in_sync: bool,
|
||||
key: u8,
|
||||
events: &HashMap<u8, Vec<Value>>,
|
||||
full: &OnceLock<Value>,
|
||||
text: &str,
|
||||
) -> Value {
|
||||
if !in_sync || sync == SyncKind::Full {
|
||||
full.get_or_init(|| json!([{ "text": text }])).clone()
|
||||
} else {
|
||||
Value::Array(events.get(&key).cloned().unwrap_or_default())
|
||||
}
|
||||
}
|
||||
|
||||
/// How long a server may take to answer `initialize`. Some import the whole
|
||||
/// build there (kotlin-lsp, jdtls on a large Gradle project) and need minutes
|
||||
/// on a cold start; the status shows "starting" meanwhile, and a crash still
|
||||
@@ -131,6 +147,15 @@ struct DocState {
|
||||
notebook: Option<PathBuf>,
|
||||
/// When the servers last got new text (open or change): diagnostics published before are stale.
|
||||
changed: std::time::Instant,
|
||||
flutter_outline: Option<FlutterOutline>,
|
||||
}
|
||||
|
||||
/// The widget tree last published for a document, valid while that server instance runs.
|
||||
/// ponytail: positions lag edits until the server's next publish, which follows each analysis.
|
||||
struct FlutterOutline {
|
||||
server: ide_core::ServerId,
|
||||
generation: u64,
|
||||
items: Vec<OutlineItem>,
|
||||
}
|
||||
|
||||
impl DocState {
|
||||
@@ -1268,6 +1293,7 @@ impl LspManager {
|
||||
compose_detected,
|
||||
notebook: None,
|
||||
changed: std::time::Instant::now(),
|
||||
flutter_outline: None,
|
||||
};
|
||||
let compose_added = {
|
||||
let mut docs = self.docs.lock();
|
||||
@@ -1355,18 +1381,14 @@ impl LspManager {
|
||||
tracing::warn!("lsp text copy of {} out of sync; resending full text", d.path.display());
|
||||
text.set(&full_text());
|
||||
}
|
||||
let full = json!([{ "text": text.as_str() }]);
|
||||
let full = OnceLock::new();
|
||||
for (server, run, sync, enc) in targets {
|
||||
let key = match enc {
|
||||
Encoding::Utf8 => 8,
|
||||
Encoding::Utf16 => 16,
|
||||
Encoding::Utf32 => 32,
|
||||
};
|
||||
let content = if !in_sync || sync == SyncKind::Full {
|
||||
full.clone()
|
||||
} else {
|
||||
Value::Array(events.get(&key).cloned().unwrap_or_default())
|
||||
};
|
||||
let content = did_change_content(sync, in_sync, key, &events, &full, text.as_str());
|
||||
let params = json!({
|
||||
"textDocument": { "uri": d.uri, "version": d.version },
|
||||
"contentChanges": content,
|
||||
@@ -2406,6 +2428,33 @@ impl LspManager {
|
||||
out.finish(None)
|
||||
}
|
||||
|
||||
/// The document's widget tree, when its running Dart server published one.
|
||||
pub fn flutter_outline(&self, doc: DocId) -> Option<Vec<OutlineItem>> {
|
||||
let docs = self.docs.lock();
|
||||
let d = docs.get(&doc)?;
|
||||
let outline = d.flutter_outline.as_ref()?;
|
||||
d.servers
|
||||
.iter()
|
||||
.any(|a| a.server.id == outline.server && a.server.is_live(outline.generation))
|
||||
.then(|| outline.items.clone())
|
||||
}
|
||||
|
||||
/// Records a published outline; whether what the open documents of `path` show changed.
|
||||
fn set_flutter_outline(
|
||||
&self,
|
||||
path: &Path,
|
||||
server: &Server,
|
||||
generation: u64,
|
||||
items: Option<Vec<OutlineItem>>,
|
||||
) -> bool {
|
||||
let mut changed = false;
|
||||
for d in self.docs.lock().values_mut().filter(|d| d.path == path) {
|
||||
changed |= d.flutter_outline.is_some() || items.is_some();
|
||||
d.flutter_outline = items.clone().map(|items| FlutterOutline { server: server.id, generation, items });
|
||||
}
|
||||
changed
|
||||
}
|
||||
|
||||
pub async fn workspace_symbols(&self, query: &str, cancel: CancellationToken) -> IdeResult<Vec<WorkspaceSymbol>> {
|
||||
let servers: Vec<Arc<Server>> = self.servers.lock().clone();
|
||||
let targets = self.ready_targets(&servers, |c| c.has("workspaceSymbolProvider")).await;
|
||||
@@ -4340,6 +4389,56 @@ mod code_action_tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod did_change_content_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn incremental_content_does_not_build_the_full_document() {
|
||||
let full = OnceLock::new();
|
||||
let key = 16;
|
||||
let events = HashMap::from([(
|
||||
key,
|
||||
vec![json!({
|
||||
"range": {
|
||||
"start": { "line": 0, "character": 0 },
|
||||
"end": { "line": 0, "character": 1 }
|
||||
},
|
||||
"text": "x"
|
||||
})],
|
||||
)]);
|
||||
|
||||
let content = did_change_content(SyncKind::Incremental, true, key, &events, &full, "1 MB document");
|
||||
|
||||
assert_eq!(content, Value::Array(events[&key].clone()));
|
||||
assert!(full.get().is_none(), "incremental sync must not materialize the full document");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_sync_reuses_the_full_document_payload() {
|
||||
let full = OnceLock::new();
|
||||
let key = 16;
|
||||
let events = HashMap::new();
|
||||
|
||||
let first = did_change_content(SyncKind::Full, true, key, &events, &full, "whole document");
|
||||
let second = did_change_content(SyncKind::Full, true, key, &events, &full, "whole document");
|
||||
|
||||
assert_eq!(first, json!([{ "text": "whole document" }]));
|
||||
assert_eq!(second, first);
|
||||
assert!(full.get().is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn out_of_sync_incremental_change_sends_the_full_document() {
|
||||
let full = OnceLock::new();
|
||||
let events = HashMap::new();
|
||||
|
||||
let content = did_change_content(SyncKind::Incremental, false, 16, &events, &full, "whole document");
|
||||
|
||||
assert_eq!(content, json!([{ "text": "whole document" }]));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod external_go_routing_tests {
|
||||
use super::*;
|
||||
|
||||
@@ -236,6 +236,7 @@ impl LspManager {
|
||||
compose_detected: false,
|
||||
notebook: Some(path.to_owned()),
|
||||
changed: std::time::Instant::now(),
|
||||
flutter_outline: None,
|
||||
},
|
||||
);
|
||||
state.cells.push((cell.id.clone(), doc));
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
//! Protocol tests against in-memory mock language servers.
|
||||
|
||||
use ide_core::event::ServerStatus;
|
||||
use ide_core::event::{LspRefreshKind, ServerStatus};
|
||||
use ide_core::{
|
||||
CancellationToken, DocId, FileEdit, IdeEvent, LanguageId, Pos, Range, ServerId, Severity, WorkspaceEdit,
|
||||
};
|
||||
@@ -1459,6 +1459,65 @@ async fn unsupported_feature_names_the_running_servers_that_lack_it() {
|
||||
assert_eq!(e.message, "plain, other doesn't support type hierarchy");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn flutter_outline_follows_the_document_and_the_server_instance() {
|
||||
let h = harness(&[("mock", incremental_caps())]);
|
||||
let (doc, path) = h.open("a.mk", "Text('x')\n");
|
||||
h.wait_status("mock", ServerStatus::Ready).await;
|
||||
let refreshes = || {
|
||||
h.events
|
||||
.lock()
|
||||
.iter()
|
||||
.filter(|e| matches!(e, IdeEvent::LspRefresh { kind: LspRefreshKind::FlutterOutline, .. }))
|
||||
.count()
|
||||
};
|
||||
let at = json!({"start":{"line":0,"character":0},"end":{"line":0,"character":9}});
|
||||
let unit = |children: Value| {
|
||||
json!({ "uri": uri_of(&path), "outline": {
|
||||
"kind": "DART_ELEMENT", "range": at, "codeRange": at,
|
||||
"dartElement": { "kind": "COMPILATION_UNIT", "name": "<unit>" },
|
||||
"children": children,
|
||||
}})
|
||||
};
|
||||
let widgets = json!([{ "kind": "NEW_INSTANCE", "className": "Text", "range": at, "codeRange": at }]);
|
||||
let peer = h.launcher.state("mock").peer();
|
||||
assert!(h.mgr.flutter_outline(doc).is_none());
|
||||
|
||||
peer.notify("dart/textDocument/publishFlutterOutline", unit(widgets.clone())).unwrap();
|
||||
eventually(|| refreshes() == 1).await;
|
||||
assert_eq!(h.mgr.flutter_outline(doc).unwrap()[0].name, "Text");
|
||||
|
||||
// The widgets are gone from the file: the ordinary structure applies again.
|
||||
peer.notify("dart/textDocument/publishFlutterOutline", unit(json!([]))).unwrap();
|
||||
eventually(|| refreshes() == 2).await;
|
||||
assert!(h.mgr.flutter_outline(doc).is_none());
|
||||
|
||||
peer.notify("dart/textDocument/publishFlutterOutline", unit(widgets.clone())).unwrap();
|
||||
eventually(|| refreshes() == 3).await;
|
||||
|
||||
// Reopening starts without the closed document's tree.
|
||||
h.mgr.did_close(doc);
|
||||
assert!(h.mgr.flutter_outline(doc).is_none());
|
||||
let (reopened, _) = h.open("a.mk", "Text('x')\n");
|
||||
assert!(h.mgr.flutter_outline(reopened).is_none());
|
||||
peer.notify("dart/textDocument/publishFlutterOutline", unit(widgets)).unwrap();
|
||||
eventually(|| refreshes() == 4).await;
|
||||
assert!(h.mgr.flutter_outline(reopened).is_some());
|
||||
|
||||
// A restarted server has analysed nothing yet.
|
||||
let server = h
|
||||
.events
|
||||
.lock()
|
||||
.iter()
|
||||
.find_map(|e| match e {
|
||||
IdeEvent::LanguageServer { server, name, .. } if name == "mock" => Some(*server),
|
||||
_ => None,
|
||||
})
|
||||
.unwrap();
|
||||
h.mgr.restart(server).await.unwrap();
|
||||
assert!(h.mgr.flutter_outline(reopened).is_none());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn diagnostics_become_events_and_feed_code_actions() {
|
||||
let h = harness(&[("mock", incremental_caps())]);
|
||||
|
||||
@@ -8,7 +8,8 @@
|
||||
//! `Authorization: Bearer <token>` (random, per run); requests from another
|
||||
//! `Origin` or `Host` are refused (DNS rebinding).
|
||||
//! - **Projects:** the `X-OpenIDEA-Project` header or the `?project=` query
|
||||
//! names a folder; the server picks the open project containing it.
|
||||
//! names a folder; the server picks the open project containing it, or the
|
||||
//! project the IDE serves it from without a window.
|
||||
//! - **Discovery:** `<app-data>/mcp/server.json` (`address`, `port`, `token`,
|
||||
//! `pid`, `version`; readable only by the user) while the server runs.
|
||||
//! - **Stdio:** `<app exe> --mcp-stdio [--project <path>]` reads the discovery
|
||||
@@ -60,10 +61,16 @@ pub enum ToolCallError {
|
||||
/// Where the tools come from (the IDE host). Calls block; the server runs
|
||||
/// them off its async threads.
|
||||
pub trait ToolRegistry: Send + Sync + 'static {
|
||||
/// Roots of the projects open in the IDE that the server serves.
|
||||
/// Roots of the projects open in a window of the IDE that the server serves.
|
||||
fn projects(&self) -> Vec<PathBuf>;
|
||||
/// The tools callable for `project` (one of [`Self::projects`]). `Err`
|
||||
/// says why there are none (an unsupported project).
|
||||
/// The root of the project the IDE serves `path` from without a window (a background
|
||||
/// project), asked when no project of [`Self::projects`] contains `path`. Opens nothing:
|
||||
/// the first call for that root does.
|
||||
fn resolve(&self, _path: &Path) -> Option<PathBuf> {
|
||||
None
|
||||
}
|
||||
/// The tools callable for `project` (one of [`Self::projects`] or a root
|
||||
/// [`Self::resolve`] gave). `Err` says why there are none (an unsupported project).
|
||||
fn tools(&self, project: &Path) -> Result<Vec<Tool>, String>;
|
||||
fn call_with_client(
|
||||
&self,
|
||||
|
||||
@@ -34,7 +34,7 @@ const PARSE_ERROR: i64 = -32700;
|
||||
const INVALID_REQUEST: i64 = -32600;
|
||||
const METHOD_NOT_FOUND: i64 = -32601;
|
||||
const INVALID_PARAMS: i64 = -32602;
|
||||
/// The requested folder isn't a project open in the IDE (or has no tools there).
|
||||
/// The requested folder isn't in a project the IDE serves (or has no tools there).
|
||||
pub(crate) const NOT_OPEN: i64 = -32001;
|
||||
|
||||
pub(crate) struct RpcError {
|
||||
@@ -158,15 +158,16 @@ impl Session<'_> {
|
||||
let asked = params.get("protocolVersion").and_then(Value::as_str).unwrap_or(LATEST);
|
||||
let version = if SUPPORTED.contains(&asked) { asked } else { LATEST };
|
||||
let about = match self.project() {
|
||||
Ok(root) => format!("the project open in OpenIDEA at {}", root.display()),
|
||||
Err(_) => "a project open in OpenIDEA".to_owned(),
|
||||
Ok(root) => format!("the project OpenIDEA serves at {}", root.display()),
|
||||
Err(_) => "a project open in OpenIDEA or served in the background".to_owned(),
|
||||
};
|
||||
json!({
|
||||
"protocolVersion": version,
|
||||
"capabilities": { "tools": { "listChanged": false } },
|
||||
"serverInfo": { "name": "OpenIDEA", "version": env!("CARGO_PKG_VERSION") },
|
||||
"instructions": format!(
|
||||
"Built-in OpenIDEA tools for {about}: they see the files and editors the IDE has open."
|
||||
"Built-in OpenIDEA tools for {about}: they see the files as the IDE has them and, \
|
||||
for a project open in a window, its editors."
|
||||
),
|
||||
})
|
||||
}
|
||||
@@ -205,7 +206,7 @@ impl Session<'_> {
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
/// The open project the request names.
|
||||
/// The project the request names.
|
||||
fn project(&self) -> Result<PathBuf, RpcError> {
|
||||
self.resolve_project(self.project)
|
||||
}
|
||||
@@ -215,11 +216,14 @@ impl Session<'_> {
|
||||
roots.sort();
|
||||
roots.dedup();
|
||||
if let Some(requested) = requested.filter(|p| !p.trim().is_empty()) {
|
||||
return resolve(&roots, Path::new(requested)).ok_or_else(|| {
|
||||
let path = Path::new(requested);
|
||||
// An open project wins; the registry is asked only for a folder outside all of them.
|
||||
return resolve(&roots, path).or_else(|| self.registry.resolve(path)).ok_or_else(|| {
|
||||
RpcError::new(
|
||||
NOT_OPEN,
|
||||
format!(
|
||||
"this folder isn't open in OpenIDEA: {requested}. Open projects: {}",
|
||||
"this folder isn't open in OpenIDEA and isn't served in the background \
|
||||
(Settings › Agents › IDE MCP Server): {requested}. Open projects: {}",
|
||||
roots.iter().map(|p| p.display().to_string()).collect::<Vec<_>>().join(", ")
|
||||
),
|
||||
)
|
||||
|
||||
@@ -213,6 +213,87 @@ async fn folders_that_are_not_open_are_named_in_the_error() {
|
||||
assert!(serde_json::from_str::<Value>(&body).unwrap()["result"]["tools"].is_array());
|
||||
}
|
||||
|
||||
/// One project open in a window and, optionally, one folder served without a window.
|
||||
struct WithBackground {
|
||||
open: PathBuf,
|
||||
background: Option<PathBuf>,
|
||||
}
|
||||
|
||||
impl ToolRegistry for WithBackground {
|
||||
fn projects(&self) -> Vec<PathBuf> {
|
||||
vec![self.open.clone()]
|
||||
}
|
||||
fn resolve(&self, path: &Path) -> Option<PathBuf> {
|
||||
self.background.clone().filter(|root| path.starts_with(root))
|
||||
}
|
||||
fn tools(&self, project: &Path) -> Result<Vec<Tool>, String> {
|
||||
Ok(vec![Tool {
|
||||
name: "where".into(),
|
||||
description: format!("Names {}", project.display()),
|
||||
input_schema: json!({ "type": "object" }),
|
||||
read_only: true,
|
||||
destructive: false,
|
||||
output_schema: None,
|
||||
}])
|
||||
}
|
||||
fn call(&self, project: &Path, _: &str, _: &str, _: ide_mcp::CancellationToken) -> Result<String, ToolCallError> {
|
||||
Ok(json!({"project":project}).to_string())
|
||||
}
|
||||
}
|
||||
|
||||
/// The server over [`WithBackground`]; the folder `inventory` next to the open project.
|
||||
fn setup_with_background(served: bool) -> (Setup, PathBuf) {
|
||||
let mut s = setup();
|
||||
s.server.take().unwrap().stop();
|
||||
let inventory = s.project.parent().unwrap().join("inventory");
|
||||
std::fs::create_dir_all(inventory.join("src")).unwrap();
|
||||
let registry = WithBackground { open: s.project.clone(), background: served.then(|| inventory.clone()) };
|
||||
s.server = Some(McpServer::start(Arc::new(registry), None, &tokio::runtime::Handle::current()).unwrap());
|
||||
(s, inventory)
|
||||
}
|
||||
|
||||
async fn rpc_for(s: &Setup, folder: &Path, method: &str, params: Value) -> Value {
|
||||
let project = format!("X-OpenIDEA-Project: {}", folder.display());
|
||||
let body = json!({ "jsonrpc": "2.0", "id": 7, "method": method, "params": params });
|
||||
let (status, body) = post(s, "/mcp", &[&bearer(s), &project], &body).await;
|
||||
assert_eq!(status, 200, "{body}");
|
||||
serde_json::from_str(&body).unwrap()
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_folder_served_in_the_background_answers_initialize_list_and_call() {
|
||||
let (s, inventory) = setup_with_background(true);
|
||||
let inside = inventory.join("src");
|
||||
let init = rpc_for(&s, &inside, "initialize", json!({})).await;
|
||||
let instructions = init["result"]["instructions"].as_str().unwrap();
|
||||
assert!(instructions.contains(inventory.to_str().unwrap()), "{instructions}");
|
||||
let list = rpc_for(&s, &inside, "tools/list", json!({})).await;
|
||||
assert_eq!(list["result"]["tools"][0]["description"], format!("Names {}", inventory.display()), "{list}");
|
||||
let call = rpc_for(&s, &inside, "tools/call", json!({ "name": "where" })).await;
|
||||
assert_eq!(call["result"]["structuredContent"]["project"], json!(inventory), "{call}");
|
||||
// The argument names it as well, whatever project the header is for.
|
||||
let routed = rpc(&s, "tools/call", json!({ "name": "where", "arguments": { "projectPath": inside } })).await;
|
||||
assert_eq!(routed["result"]["structuredContent"]["project"], json!(inventory), "{routed}");
|
||||
// A folder inside the open project stays with that project.
|
||||
let open = rpc(&s, "tools/call", json!({ "name": "where" })).await;
|
||||
assert_eq!(open["result"]["structuredContent"]["project"], json!(s.project), "{open}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_folder_that_is_neither_open_nor_served_in_the_background_says_where_to_turn_it_on() {
|
||||
let (s, inventory) = setup_with_background(false);
|
||||
for (method, params) in [("tools/list", json!({})), ("tools/call", json!({ "name": "where" }))] {
|
||||
let reply = rpc_for(&s, &inventory, method, params).await;
|
||||
assert_eq!(reply["error"]["code"], -32001, "{method}: {reply}");
|
||||
let message = reply["error"]["message"].as_str().unwrap();
|
||||
assert!(message.contains("isn't open in OpenIDEA and isn't served in the background"), "{message}");
|
||||
assert!(message.contains("Settings › Agents › IDE MCP Server"), "{message}");
|
||||
assert!(message.contains(inventory.to_str().unwrap()) && message.contains(s.project.to_str().unwrap()));
|
||||
}
|
||||
let init = rpc_for(&s, &inventory, "initialize", json!({})).await;
|
||||
assert!(init["result"]["instructions"].is_string(), "initialize answers without a project: {init}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn the_discovery_file_lives_while_the_server_runs() {
|
||||
let mut s = setup();
|
||||
|
||||
@@ -100,6 +100,22 @@ pub struct GutterAction {
|
||||
pub command: String,
|
||||
pub argument: Option<String>,
|
||||
}
|
||||
/// An action rendered at the left edge of a line and revealed by hover.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct HoverAction {
|
||||
/// The line the button is drawn on; normally the declaration line.
|
||||
pub line: u32,
|
||||
/// First line whose leftmost strip reveals this action, inclusive.
|
||||
pub start_line: u32,
|
||||
/// Last line whose leftmost strip reveals this action, inclusive.
|
||||
pub end_line: u32,
|
||||
pub icon: Option<String>,
|
||||
pub label: String,
|
||||
pub tooltip: Option<String>,
|
||||
pub command: String,
|
||||
pub argument: Option<String>,
|
||||
}
|
||||
/// Injection data.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
|
||||
@@ -16,6 +16,7 @@ use crate::types::{
|
||||
FieldValue, ServiceLog, ServiceLogToggle, ServicePane, ServiceTab, TableSort, View, ViewBody, ViewButton,
|
||||
ViewEvent, ViewField, ViewListItem, ViewTable, ViewTreeItem, Viewport,
|
||||
};
|
||||
use crate::wit_host::hover_actions_bindings::exports::openidea::plugin::hover_actions as wit_hia;
|
||||
use crate::wit_host::injections_bindings::exports::openidea::plugin::injections as wit_inj;
|
||||
use crate::wit_host::language_features_bindings::exports::openidea::plugin::language_features as wit_lf;
|
||||
use crate::wit_host::run_target_validation_bindings::exports::openidea::plugin::run_target_validation as wit_rtv;
|
||||
@@ -57,7 +58,7 @@ use views_bindings::exports::openidea::plugin::view_provider as wit_view;
|
||||
use views_bindings::openidea::plugin::view_types as wit_vt;
|
||||
|
||||
/// The API version of the world above, `major.minor` of [`host_api`].
|
||||
pub const API_VERSION: &str = "1.13";
|
||||
pub const API_VERSION: &str = "1.14";
|
||||
const EPOCH_TICK: Duration = Duration::from_millis(10);
|
||||
pub(crate) const MAX_TEXT: usize = 1 << 20;
|
||||
/// The most text, and the most PNG bytes, `ui.read-clipboard` returns.
|
||||
@@ -387,6 +388,11 @@ pub trait HostApi: Send + Sync {
|
||||
}
|
||||
/// Sets (`Some`) or removes the plugin's status bar item `id`.
|
||||
fn status_item(&self, id: &str, item: Option<StatusItem>);
|
||||
/// Checks a status item menu before it is set: its actions name commands the plugin declares.
|
||||
fn check_status_menu(&self, menu: &[crate::StatusMenuEntry]) -> Result<(), HostError> {
|
||||
let _ = menu;
|
||||
Ok(())
|
||||
}
|
||||
/// Sets or removes the status override in the invoking window.
|
||||
fn window_status_item(&self, client: &str, id: &str, item: Option<StatusItem>) -> Result<(), HostError> {
|
||||
let _ = (client, id, item);
|
||||
@@ -1049,6 +1055,7 @@ struct Exports {
|
||||
inlay: Option<wit_inlay::Guest>,
|
||||
endpoints: Option<wit_endpoints::Guest>,
|
||||
search: Option<wit_search::Guest>,
|
||||
hover_actions: Option<wit_hia::Guest>,
|
||||
run_configurations: Option<wit_configs::Guest>,
|
||||
launch_configurations: Option<wit_launch::Guest>,
|
||||
test_results: Option<wit_tests::Guest>,
|
||||
@@ -1190,6 +1197,7 @@ impl Runtime {
|
||||
let inlay_indices = wit_inlay::GuestIndices::new(&pre).ok();
|
||||
let endpoint_indices = wit_endpoints::GuestIndices::new(&pre).ok();
|
||||
let search_indices = wit_search::GuestIndices::new(&pre).ok();
|
||||
let hover_actions_indices = wit_hia::GuestIndices::new(&pre).ok();
|
||||
let configs_indices = wit_configs::GuestIndices::new(&pre).ok();
|
||||
let launch_indices = wit_launch::GuestIndices::new(&pre).ok();
|
||||
let tests_indices = wit_tests::GuestIndices::new(&pre).ok();
|
||||
@@ -1255,6 +1263,8 @@ impl Runtime {
|
||||
None => None,
|
||||
};
|
||||
let search = search_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
|
||||
let hover_actions =
|
||||
hover_actions_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
|
||||
let endpoints = match endpoint_indices {
|
||||
Some(indices) => Some(indices.load(&mut store, &instance).map_err(api_hint)?),
|
||||
None => None,
|
||||
@@ -1278,6 +1288,7 @@ impl Runtime {
|
||||
inlay,
|
||||
endpoints,
|
||||
search,
|
||||
hover_actions,
|
||||
run_configurations,
|
||||
launch_configurations,
|
||||
test_results,
|
||||
@@ -2616,6 +2627,19 @@ fn gutter_action_from(v: wit_lf::GutterAction) -> crate::language_features::Gutt
|
||||
argument: v.argument.map(|v| crate::runtime::clip(v, 65536)),
|
||||
}
|
||||
}
|
||||
fn hover_action_from(v: wit_hia::HoverAction) -> crate::language_features::HoverAction {
|
||||
crate::language_features::HoverAction {
|
||||
line: v.line,
|
||||
start_line: v.start_line,
|
||||
end_line: v.end_line,
|
||||
icon: v.icon.map(|v| crate::runtime::clip(v, 65536)),
|
||||
label: crate::runtime::clip(v.label, 65536),
|
||||
tooltip: v.tooltip.map(|v| crate::runtime::clip(v, 65536)),
|
||||
command: crate::runtime::clip(v.command, 65536),
|
||||
argument: v.argument.map(|v| crate::runtime::clip(v, 65536)),
|
||||
}
|
||||
}
|
||||
|
||||
fn parameter_label_from(v: wit_lf::ParameterLabel) -> crate::language_features::ParameterLabel {
|
||||
use crate::language_features::ParameterLabel as P;
|
||||
match v {
|
||||
@@ -2844,6 +2868,30 @@ impl Runtime {
|
||||
let result = self.language_feature_call(timeout, |p, s| p.call_gutter_actions(s, &d))?;
|
||||
Ok(result.into_iter().take(10000).map(gutter_action_from).collect())
|
||||
}
|
||||
pub fn has_hover_actions(&self) -> bool {
|
||||
self.exports.hover_actions.is_some()
|
||||
}
|
||||
|
||||
pub fn language_hover_actions(
|
||||
&mut self,
|
||||
doc: &ProviderDocument,
|
||||
timeout: Duration,
|
||||
) -> Result<Vec<crate::language_features::HoverAction>, CallError> {
|
||||
if self.exports.hover_actions.is_none() {
|
||||
return Err(CallError::missing_export("hover-actions"));
|
||||
}
|
||||
let d = wit_hia::Document {
|
||||
path: to_ipc(&doc.path),
|
||||
language: doc.language.clone(),
|
||||
version: doc.version,
|
||||
text: doc.text.clone(),
|
||||
};
|
||||
let result = self.call(Invocation::default(), timeout, |exports, store| {
|
||||
exports.hover_actions.as_ref().expect("checked").call_hover_actions(store, &d)
|
||||
})?;
|
||||
Ok(result.into_iter().take(10_000).map(hover_action_from).collect())
|
||||
}
|
||||
|
||||
pub fn provide_injections(
|
||||
&mut self,
|
||||
doc: &ProviderDocument,
|
||||
|
||||
@@ -70,6 +70,28 @@ pub struct StatusItem {
|
||||
pub tooltip: Option<String>,
|
||||
/// One of the plugin's commands, run on click.
|
||||
pub command: Option<String>,
|
||||
/// Opened on click instead of running `command` when not empty (API 1.14).
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
#[specta(optional)]
|
||||
pub menu: Vec<StatusMenuEntry>,
|
||||
}
|
||||
|
||||
/// An entry of a plugin status bar item's menu (API 1.14, `ui.set-status-item-menu`).
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase")]
|
||||
pub enum StatusMenuEntry {
|
||||
/// Runs one of the plugin's commands with `argument`.
|
||||
#[serde(rename_all = "camelCase")]
|
||||
Action {
|
||||
label: String,
|
||||
description: Option<String>,
|
||||
command: String,
|
||||
argument: Option<String>,
|
||||
},
|
||||
Separator,
|
||||
Header {
|
||||
label: String,
|
||||
},
|
||||
}
|
||||
|
||||
/// A plugin's highlight rule for Run and Debug console output (API 1.12, `ui.set-console-rules`).
|
||||
|
||||
@@ -72,6 +72,46 @@ pub(crate) mod syntax_bindings {
|
||||
});
|
||||
}
|
||||
|
||||
/// The optional `hover-actions` export, bound on its own when present.
|
||||
pub(crate) mod hover_actions_bindings {
|
||||
wasmtime::component::bindgen!({
|
||||
world: "plugin-hover-actions",
|
||||
path: "../../wit",
|
||||
imports: { default: trappable },
|
||||
with: {
|
||||
"openidea:plugin/types": super::bindings::openidea::plugin::types,
|
||||
"openidea:plugin/log": super::bindings::openidea::plugin::log,
|
||||
"openidea:plugin/ui": super::bindings::openidea::plugin::ui,
|
||||
"openidea:plugin/storage": super::bindings::openidea::plugin::storage,
|
||||
"openidea:plugin/workspace": super::bindings::openidea::plugin::workspace,
|
||||
"openidea:plugin/editor": super::bindings::openidea::plugin::editor,
|
||||
"openidea:plugin/decorations": super::bindings::openidea::plugin::decorations,
|
||||
"openidea:plugin/invocation": super::bindings::openidea::plugin::invocation,
|
||||
"openidea:plugin/vcs": super::bindings::openidea::plugin::vcs,
|
||||
"openidea:plugin/build": super::bindings::openidea::plugin::build,
|
||||
"openidea:plugin/commit": super::bindings::openidea::plugin::commit,
|
||||
"openidea:plugin/events": super::bindings::openidea::plugin::events,
|
||||
"openidea:plugin/tasks": super::bindings::openidea::plugin::tasks,
|
||||
"openidea:plugin/diagnostics": super::bindings::openidea::plugin::diagnostics,
|
||||
"openidea:plugin/net": super::bindings::openidea::plugin::net,
|
||||
"openidea:plugin/secrets": super::bindings::openidea::plugin::secrets,
|
||||
"openidea:plugin/run": super::bindings::openidea::plugin::run,
|
||||
"openidea:plugin/process": super::bindings::openidea::plugin::process,
|
||||
"openidea:plugin/output": super::bindings::openidea::plugin::output,
|
||||
"openidea:plugin/auth": super::bindings::openidea::plugin::auth,
|
||||
"openidea:plugin/command-runner": super::bindings::openidea::plugin::command_runner,
|
||||
"openidea:plugin/language-servers": super::bindings::openidea::plugin::language_servers,
|
||||
"openidea:plugin/ipc": super::bindings::openidea::plugin::ipc,
|
||||
"openidea:plugin/fs": super::bindings::openidea::plugin::fs,
|
||||
"openidea:plugin/views": super::bindings::openidea::plugin::views,
|
||||
"openidea:plugin/settings": super::bindings::openidea::plugin::settings,
|
||||
"openidea:plugin/database": super::bindings::openidea::plugin::database,
|
||||
"openidea:plugin/mcp": super::bindings::openidea::plugin::mcp,
|
||||
"openidea:plugin/extensions": super::bindings::openidea::plugin::extensions,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
/// The optional `providers` export.
|
||||
pub(crate) mod providers_bindings {
|
||||
wasmtime::component::bindgen!({
|
||||
@@ -387,6 +427,22 @@ impl StoreData {
|
||||
self.ask(Prompt::QuickPick { title: clip(title, MAX_TITLE), items, multiple })
|
||||
}
|
||||
|
||||
/// A status item with its checked menu (`ui.set-status-item-menu`).
|
||||
fn status_item_with_menu(
|
||||
&self,
|
||||
item: ui::StatusItem,
|
||||
menu: Vec<ui::StatusMenuEntry>,
|
||||
) -> Result<StatusItem, wit::Error> {
|
||||
let menu = status_menu(menu)?;
|
||||
self.host.check_status_menu(&menu).map_err(to_wit)?;
|
||||
Ok(StatusItem {
|
||||
text: clip(item.text, MAX_STATUS_TEXT),
|
||||
tooltip: item.tooltip.map(|t| clip(t, 1024)),
|
||||
command: item.command.map(|c| clip(c, 128)),
|
||||
menu,
|
||||
})
|
||||
}
|
||||
|
||||
fn require_window(&self) -> Result<(), wit::Error> {
|
||||
self.require_interactive()?;
|
||||
if self.invocation.client.is_none() {
|
||||
@@ -404,6 +460,47 @@ impl StoreData {
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks a status item's menu (`ui.set-status-item-menu`); the host checks that its commands are declared.
|
||||
fn status_menu(entries: Vec<ui::StatusMenuEntry>) -> Result<Vec<crate::StatusMenuEntry>, wit::Error> {
|
||||
const MAX_ENTRIES: usize = 64;
|
||||
if entries.len() > MAX_ENTRIES {
|
||||
return Err(wit::Error::Invalid(format!("a status item menu has at most {MAX_ENTRIES} entries")));
|
||||
}
|
||||
let line = |text: &str, what: &str| {
|
||||
if text.trim().is_empty() || text.len() > 256 || text.chars().any(char::is_control) {
|
||||
Err(wit::Error::Invalid(format!("invalid menu {what} {text:?}")))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
};
|
||||
let mut checked = Vec::with_capacity(entries.len());
|
||||
for entry in entries {
|
||||
checked.push(match entry {
|
||||
ui::StatusMenuEntry::Action(a) => {
|
||||
line(&a.label, "label")?;
|
||||
if let Some(description) = &a.description {
|
||||
line(description, "description")?;
|
||||
}
|
||||
if a.argument.as_ref().is_some_and(|arg| arg.len() > 64 << 10) {
|
||||
return Err(wit::Error::Invalid("a menu argument is limited to 64 KiB".into()));
|
||||
}
|
||||
crate::StatusMenuEntry::Action {
|
||||
label: a.label,
|
||||
description: a.description,
|
||||
command: a.command,
|
||||
argument: a.argument,
|
||||
}
|
||||
}
|
||||
ui::StatusMenuEntry::Separator => crate::StatusMenuEntry::Separator,
|
||||
ui::StatusMenuEntry::Header(label) => {
|
||||
line(&label, "header")?;
|
||||
crate::StatusMenuEntry::Header { label }
|
||||
}
|
||||
});
|
||||
}
|
||||
Ok(checked)
|
||||
}
|
||||
|
||||
/// Checks `ui.notify` buttons; the host checks that their commands are declared.
|
||||
fn notification_actions(actions: Vec<ui::NotificationAction>) -> Result<Vec<crate::NotificationAction>, wit::Error> {
|
||||
const MAX_ACTIONS: usize = 3;
|
||||
@@ -473,6 +570,7 @@ impl ui::Host for StoreData {
|
||||
text: clip(item.text, MAX_STATUS_TEXT),
|
||||
tooltip: item.tooltip.map(|t| clip(t, 1024)),
|
||||
command: item.command.map(|c| clip(c, 128)),
|
||||
menu: Vec::new(),
|
||||
};
|
||||
self.host.status_item(&clip(id, 64), Some(item));
|
||||
Ok(())
|
||||
@@ -491,6 +589,38 @@ impl ui::Host for StoreData {
|
||||
text: clip(item.text, MAX_STATUS_TEXT),
|
||||
tooltip: item.tooltip.map(|t| clip(t, 1024)),
|
||||
command: item.command.map(|c| clip(c, 128)),
|
||||
menu: Vec::new(),
|
||||
};
|
||||
Ok(self
|
||||
.host
|
||||
.window_status_item(self.invocation.client.as_deref().expect("checked"), &clip(id, 64), Some(item))
|
||||
.map_err(to_wit))
|
||||
}
|
||||
fn set_status_item_menu(
|
||||
&mut self,
|
||||
id: String,
|
||||
item: ui::StatusItem,
|
||||
menu: Vec<ui::StatusMenuEntry>,
|
||||
) -> Fallible<()> {
|
||||
let item = match self.status_item_with_menu(item, menu) {
|
||||
Ok(item) => item,
|
||||
Err(e) => return Ok(Err(e)),
|
||||
};
|
||||
self.host.status_item(&clip(id, 64), Some(item));
|
||||
Ok(Ok(()))
|
||||
}
|
||||
fn set_window_status_item_menu(
|
||||
&mut self,
|
||||
id: String,
|
||||
item: ui::StatusItem,
|
||||
menu: Vec<ui::StatusMenuEntry>,
|
||||
) -> Fallible<()> {
|
||||
if let Err(e) = self.require_window() {
|
||||
return Ok(Err(e));
|
||||
}
|
||||
let item = match self.status_item_with_menu(item, menu) {
|
||||
Ok(item) => item,
|
||||
Err(e) => return Ok(Err(e)),
|
||||
};
|
||||
Ok(self
|
||||
.host
|
||||
|
||||
@@ -33,6 +33,7 @@ fn components() -> Vec<PathBuf> {
|
||||
repo().join("crates/ide-plugin/tests/fixtures/diagnostics/dist/plugin.wasm"),
|
||||
repo().join("crates/ide-plugin/tests/fixtures/inlay-hints/dist/plugin.wasm"),
|
||||
repo().join("crates/ide-plugin/tests/fixtures/language-features/dist/plugin.wasm"),
|
||||
repo().join("crates/ide-plugin/tests/fixtures/hover-actions/dist/plugin.wasm"),
|
||||
repo().join("crates/ide-plugin/tests/fixtures/symbols/dist/plugin.wasm"),
|
||||
repo().join("crates/ide-plugin/tests/fixtures/api14/dist/plugin.wasm"),
|
||||
repo().join("crates/ide-plugin/tests/fixtures/execution/dist/plugin.wasm"),
|
||||
@@ -92,7 +93,7 @@ fn the_sdk_carries_the_hosts_wit() {
|
||||
|
||||
#[test]
|
||||
fn the_version_check_runs_compatible_components_and_explains_the_rest() {
|
||||
let host = v("1.13.0");
|
||||
let host = v("1.14.0");
|
||||
for ok in [
|
||||
"1.0.0",
|
||||
"1.3.0",
|
||||
@@ -106,15 +107,16 @@ fn the_version_check_runs_compatible_components_and_explains_the_rest() {
|
||||
"1.11.0",
|
||||
"1.12.0",
|
||||
"1.13.0",
|
||||
"1.14.0",
|
||||
"1.0.0-rc.1",
|
||||
] {
|
||||
assert_eq!(check_api(&v(ok), &host), Ok(()), "{ok}");
|
||||
}
|
||||
let newer = check_api(&v("1.14.0"), &host).unwrap_err();
|
||||
assert!(newer.contains("1.13") && newer.contains("update OpenIDEA"), "{newer}");
|
||||
let newer = check_api(&v("1.15.0"), &host).unwrap_err();
|
||||
assert!(newer.contains("1.15") && newer.contains("update OpenIDEA"), "{newer}");
|
||||
assert!(check_api(&v("2.0.0"), &host).unwrap_err().contains("update OpenIDEA"));
|
||||
let older = check_api(&v("0.2.0"), &host).unwrap_err();
|
||||
assert!(older.contains("rebuild it with the 1.13 SDK"), "{older}");
|
||||
assert!(older.contains("rebuild it with the 1.14 SDK"), "{older}");
|
||||
// 0.x: every minor is its own API.
|
||||
assert_eq!(check_api(&v("0.2.0"), &v("0.2.5")), Ok(()));
|
||||
assert!(check_api(&v("0.1.0"), &v("0.2.0")).is_err());
|
||||
@@ -141,6 +143,21 @@ fn shipped_components_are_built_for_this_api() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_1_14_component_exports_the_optional_hover_actions_world() {
|
||||
let engine = PluginEngine::new().unwrap();
|
||||
let component =
|
||||
engine.compile(&repo().join("crates/ide-plugin/tests/fixtures/hover-actions/dist/plugin.wasm")).unwrap();
|
||||
let exports: Vec<String> =
|
||||
component.component_type().exports(engine.engine()).map(|(name, _)| name.to_owned()).collect();
|
||||
assert!(exports.iter().any(|name| name.starts_with("openidea:plugin/[email protected]")), "{exports:?}");
|
||||
// A 1.13-compatible plugin that does not export the new world stays valid.
|
||||
let old = engine.compile(&repo().join("plugins/official/test-runner/dist/plugin.wasm")).unwrap();
|
||||
let old_exports: Vec<String> =
|
||||
old.component_type().exports(engine.engine()).map(|(name, _)| name.to_owned()).collect();
|
||||
assert!(!old_exports.iter().any(|name| name.starts_with("openidea:plugin/hover-actions")));
|
||||
}
|
||||
|
||||
// --- a later host, simulated -------------------------------------------------------------
|
||||
|
||||
struct Data {
|
||||
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
1e2844d1172750841afd4ba2a8b811522e90522588b1330474207468cbf2a3df
|
||||
b59392bcc1999048f0ab922ec659bc21d9e825c696fa41d9f0a40c85627a5b2c
|
||||
@@ -28,6 +28,14 @@ title = "fetch"
|
||||
id = "window-status"
|
||||
title = "window-status"
|
||||
|
||||
[[contributes.commands]]
|
||||
id = "menu-status"
|
||||
title = "menu-status"
|
||||
|
||||
[[contributes.commands]]
|
||||
id = "bad-menu-status"
|
||||
title = "bad-menu-status"
|
||||
|
||||
[[contributes.commands]]
|
||||
id = "remove-window-status"
|
||||
title = "remove-window-status"
|
||||
|
||||
+12
-1
@@ -1,4 +1,4 @@
|
||||
use openidea_plugin::{Error, Event, Invocation, Plugin, StatusItem, host, register_plugin};
|
||||
use openidea_plugin::{Error, Event, Invocation, Plugin, StatusItem, StatusMenuEntry, host, register_plugin};
|
||||
#[derive(Default)]
|
||||
struct Api14;
|
||||
impl Plugin for Api14 {
|
||||
@@ -82,6 +82,17 @@ impl Plugin for Api14 {
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
"menu-status" | "bad-menu-status" => {
|
||||
let item = StatusItem { text: arg.into(), tooltip: None, command: None };
|
||||
let command = if id == "menu-status" { "events" } else { "undeclared" };
|
||||
let menu = [
|
||||
StatusMenuEntry::Header("App".into()),
|
||||
StatusMenuEntry::action("Open", command).with_description("https://app.test").with_argument("web"),
|
||||
StatusMenuEntry::Separator,
|
||||
];
|
||||
host::set_status_item_menu("menu", &item, &menu)?;
|
||||
Ok(None)
|
||||
}
|
||||
"remove-window-status" => {
|
||||
host::remove_window_status_item("state")?;
|
||||
Ok(None)
|
||||
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
c4d00fe3170a0159e56af61fe715ffb892755cce17cdae5ecb1355fd8e90189e
|
||||
034b99891313c03eb2a6b8c3cb2e4784129e1936965be803512f1d869b1768c2
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
ce791decf9a771b43872777a5c97050d9b7b48f5dd0ba0342ad0580bceb93d8c
|
||||
29ec0a96e2a0f6965915c7c25e35036743fc27a49037df588c217e8abfff93e3
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
f8e768db576e717ec00696098faa3434e9cea0680a1770f303bc071206727607
|
||||
87b367cfdd65c360920eff7be4d6a8d6b939721f6398aa6a01e39a289590699e
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
2bd0f9e7f3ca03410389d0b125372eb322fae411272b597795cbd77ea894076d
|
||||
7d034ee1a4b99615642d5bf033802f8e4662216d45b209c4c7a24eb8f1338f48
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
30dee06cb90e54e7d930996569a3d44e9c9013077c2439880f99e1c99e15cf58
|
||||
3fdf985273ec14ae623fa84602a9220cfbfb2e0e587ab192fc2bcb8d990ce9e3
|
||||
Бінарний файл не відображається.
Loaded 100 of 752 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача