дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-17 23:25:45 +02:00
Порівняти коміти
208
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
b3dc32c5ec | ||
|
|
7e5277eaa6 | ||
|
|
2278cf6e8f | ||
|
|
d4f6114be1 | ||
|
|
ad93e491c9 | ||
|
|
098e80dbef | ||
|
|
6ab7627fc4 | ||
|
|
55e778897f | ||
|
|
cc6ed6b5fd | ||
|
|
5efd58d3af | ||
|
|
d250b351bb | ||
|
|
033f049caf | ||
|
|
74157ffe54 | ||
|
|
732e92f756 | ||
|
|
a83bad107c | ||
|
|
39f709def5 | ||
|
|
ea6638b05e | ||
|
|
a91421c6e0 | ||
|
|
973f0a18a8 | ||
|
|
fb64f0cd26 | ||
|
|
34f2e18ff1 | ||
|
|
83a949ffe9 | ||
|
|
af8bd1afcd | ||
|
|
ce12f68613 | ||
|
|
77996f17e7 | ||
|
|
bacdd3e5c3 | ||
|
|
cb7bddec14 | ||
|
|
407561e59a | ||
|
|
e34e925b8f | ||
|
|
04ab9e8999 | ||
|
|
4a9927c256 | ||
|
|
084be4fb51 | ||
|
|
5c0ff2a918 | ||
|
|
c65acc902e | ||
|
|
ec0a681b72 | ||
|
|
5895022904 | ||
|
|
215023e85c | ||
|
|
aab53f89b3 | ||
|
|
519f1d43f4 | ||
|
|
88368033be | ||
|
|
d952827557 | ||
|
|
bb3fd570a6 | ||
|
|
92119e2040 | ||
|
|
93d7f76b20 | ||
|
|
f53a7ec42c | ||
|
|
be384e460a | ||
|
|
f86c5e3460 | ||
|
|
0fb574e815 | ||
|
|
43f9ec99f6 | ||
|
|
e86e2e8e5c | ||
|
|
811b98dd4b | ||
|
|
76377b6eec | ||
|
|
61ba70394f | ||
|
|
bbc5412605 | ||
|
|
3032bf108f | ||
|
|
bde17e4f47 | ||
|
|
af55109b27 | ||
|
|
3663556a2e | ||
|
|
217bd29860 | ||
|
|
25d6e8ac7c | ||
|
|
280760a5d4 | ||
|
|
b3008be32b | ||
|
|
577193d387 | ||
|
|
449db6baa7 | ||
|
|
ea1f1e54d0 | ||
|
|
4201aad9f9 | ||
|
|
678407f4c0 | ||
|
|
7392bd2547 | ||
|
|
b1f73e3920 | ||
|
|
e8b12dfb51 | ||
|
|
fd828c0ade | ||
|
|
ebc879dc8b | ||
|
|
7096a1c374 | ||
|
|
a1d4d6fb7f | ||
|
|
7596e95b76 | ||
|
|
cc471029d2 | ||
|
|
ee8afe39a2 | ||
|
|
5f606219b2 | ||
|
|
0590a255e8 | ||
|
|
32d5232010 | ||
|
|
382f5d71fa | ||
|
|
0cd7d9c30e | ||
|
|
dfbe87161b | ||
|
|
7a351fe4b0 | ||
|
|
153a184eac | ||
|
|
868f5b18d0 | ||
|
|
8d87b0de6e | ||
|
|
c791f2c34c | ||
|
|
a52e416ad5 | ||
|
|
a7464bf631 | ||
|
|
26810fbcbd | ||
|
|
72b17683c9 | ||
|
|
e916af15d4 | ||
|
|
88eeb57000 | ||
|
|
ba5c56ade8 | ||
|
|
88a5602239 | ||
|
|
907ed1d85f | ||
|
|
7f229acbd9 | ||
|
|
41bae970e0 | ||
|
|
44b5515432 | ||
|
|
64d5618cc7 | ||
|
|
1a21efa4aa | ||
|
|
72cf2f488e | ||
|
|
53495fbc26 | ||
|
|
224099992a | ||
|
|
0dafd649da | ||
|
|
d2c5532ccb | ||
|
|
a03923f744 | ||
|
|
8668fdd731 | ||
|
|
17e7b98cfc | ||
|
|
77e6679701 | ||
|
|
5a0bd7d1fc | ||
|
|
e6daffae76 | ||
|
|
2b69d64055 | ||
|
|
6c9556ef54 | ||
|
|
64ee712401 | ||
|
|
0ff491cce8 | ||
|
|
4ce661ee1f | ||
|
|
55e89eac1a | ||
|
|
fcc8467657 | ||
|
|
489dd408bb | ||
|
|
4010f61453 | ||
|
|
00bbc474c0 | ||
|
|
2f68c83bcd | ||
|
|
567e45f830 | ||
|
|
245679cef8 | ||
|
|
3f3ad03d7c | ||
|
|
03ee687353 | ||
|
|
2e9e2c1699 | ||
|
|
d84d8829c4 | ||
|
|
38dfa37c88 | ||
|
|
447560e505 | ||
|
|
9bf1f320eb | ||
|
|
921378d531 | ||
|
|
1531220eea | ||
|
|
96e80f2028 | ||
|
|
e4ac29486c | ||
|
|
540094d1ae | ||
|
|
a9ec26aa08 | ||
|
|
8b6c71095a | ||
|
|
abe7c58cb9 | ||
|
|
d3d799b8fe | ||
|
|
122d7f3d0f | ||
|
|
6cdb2f1f1e | ||
|
|
dbf6de6d24 | ||
|
|
80cb458395 | ||
|
|
612cca2ec9 | ||
|
|
458286b046 | ||
|
|
043584b7de | ||
|
|
ab1a4db606 | ||
|
|
2d85e745e7 | ||
|
|
741730b7e0 | ||
|
|
026b493e93 | ||
|
|
711ef3ec96 | ||
|
|
b35bf882b5 | ||
|
|
a816a57004 | ||
|
|
52017a1172 | ||
|
|
80f50ccdfa | ||
|
|
ec76dcde7f | ||
|
|
3c624ccb22 | ||
|
|
5a000983c7 | ||
|
|
03ad6c12ca | ||
|
|
1dbd2847b9 | ||
|
|
c9f5ac9cd5 | ||
|
|
06c7127b6b | ||
|
|
635ec2d7bd | ||
|
|
ac3c564249 | ||
|
|
f76ac263a0 | ||
|
|
7a97fba491 | ||
|
|
205b4bcc5f | ||
|
|
cd574a3e28 | ||
|
|
8aed4156f4 | ||
|
|
0221034936 | ||
|
|
0d432bf1a6 | ||
|
|
cbac930a6f | ||
|
|
33f082e32f | ||
|
|
0bbf5568cd | ||
|
|
2277c1cdfd | ||
|
|
a537223233 | ||
|
|
19c7947fc4 | ||
|
|
98f9fc0063 | ||
|
|
0d5ef48a94 | ||
|
|
444b620985 | ||
|
|
0c45a96d84 | ||
|
|
fd8f8d6dd0 | ||
|
|
c1bec5182c | ||
|
|
dcb4835a87 | ||
|
|
f74bc7abac | ||
|
|
c871c164c1 | ||
|
|
db65b12afe | ||
|
|
0cc873565a | ||
|
|
7cc100367d | ||
|
|
39c0f6676e | ||
|
|
f19d5dc3f9 | ||
|
|
0a8df16941 | ||
|
|
6dcece3081 | ||
|
|
5c59566897 | ||
|
|
6b3edb6cf5 | ||
|
|
e598936529 | ||
|
|
8b7318e59a | ||
|
|
faa9a91953 | ||
|
|
c805173467 | ||
|
|
94b72c271a | ||
|
|
610d68ee41 | ||
|
|
c6bd809d08 | ||
|
|
401d66d850 | ||
|
|
4561ae05b2 | ||
|
|
34c81a61e4 |
No files matched your search
@@ -98,6 +98,9 @@ jobs:
|
||||
# Test fixtures write LF files; keep Git from converting them on checkout.
|
||||
- run: git config --global core.autocrlf false
|
||||
- run: cargo nextest run --workspace --no-fail-fast
|
||||
# nextest skips doctests; ide-command's are its compile-fail tests.
|
||||
- if: runner.os == 'Linux'
|
||||
run: cargo test --doc -p ide-command
|
||||
# nextest ran export_bindings, which rewrites src/bindings.ts and the command snapshot.
|
||||
- name: Bindings and command snapshot are up to date
|
||||
if: runner.os == 'Linux'
|
||||
|
||||
@@ -1,119 +0,0 @@
|
||||
name: Nightly
|
||||
|
||||
# Twice a day, builds the newest main commit that passed CI as a prerelease tagged with its own
|
||||
# version, so remote development finds the server of that version. The `nightly` release holds
|
||||
# the manifest the nightly app updates from; its tag marks the commit last built, and a run with
|
||||
# nothing newer stops there. Only the latest builds are kept.
|
||||
on:
|
||||
schedule:
|
||||
- cron: "17 2,14 * * *"
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
force:
|
||||
description: "Build even if nothing is newer than the last nightly"
|
||||
type: boolean
|
||||
default: false
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
concurrency:
|
||||
group: nightly
|
||||
|
||||
env:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
GH_REPO: ${{ github.repository }}
|
||||
|
||||
jobs:
|
||||
prepare:
|
||||
permissions:
|
||||
actions: read
|
||||
contents: write
|
||||
if: github.repository == 'l0ng-ai/openidea'
|
||||
runs-on: ubuntu-latest
|
||||
outputs:
|
||||
sha: ${{ steps.commit.outputs.sha }}
|
||||
tag: ${{ steps.release.outputs.tag }}
|
||||
release_id: ${{ steps.release.outputs.id }}
|
||||
steps:
|
||||
- id: commit
|
||||
env:
|
||||
FORCE: ${{ inputs.force }}
|
||||
run: |
|
||||
sha="$(gh run list --workflow ci.yml --branch main --event push --status success --limit 1 \
|
||||
--json headSha --jq '.[0].headSha // ""')"
|
||||
if [ -z "$sha" ]; then
|
||||
echo "::notice::no main commit has passed CI"
|
||||
exit 0
|
||||
fi
|
||||
# No `nightly` tag yet (the first run): compare fails and the build goes on.
|
||||
status="$(gh api "repos/$GH_REPO/compare/nightly...$sha" --jq .status 2>/dev/null)" || status=ahead
|
||||
if [ "$status" != ahead ] && [ "$FORCE" != true ]; then
|
||||
echo "::notice::$sha is not newer than the last nightly"
|
||||
exit 0
|
||||
fi
|
||||
echo "sha=$sha" >> "$GITHUB_OUTPUT"
|
||||
- uses: actions/checkout@v5
|
||||
if: steps.commit.outputs.sha != ''
|
||||
with: { ref: "${{ steps.commit.outputs.sha }}" }
|
||||
- uses: actions/setup-node@v5
|
||||
if: steps.commit.outputs.sha != ''
|
||||
with: { node-version: 22 }
|
||||
- uses: dtolnay/rust-toolchain@stable
|
||||
if: steps.commit.outputs.sha != ''
|
||||
- id: release
|
||||
if: steps.commit.outputs.sha != ''
|
||||
env:
|
||||
SHA: ${{ steps.commit.outputs.sha }}
|
||||
run: |
|
||||
version="$(node scripts/nightly-prepare.ts "$(date -u +%Y%m%d%H%M)")"
|
||||
tag="v$version"
|
||||
git config user.name "github-actions[bot]"
|
||||
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
|
||||
git commit -am "chore: $tag"
|
||||
git tag "$tag"
|
||||
git push origin "$tag"
|
||||
id="$(gh api -X POST "repos/$GH_REPO/releases" -f tag_name="$tag" -f name="OpenIDEA Nightly $version" \
|
||||
-F draft=true -F prerelease=true -f body="Built from $SHA." --jq .id)"
|
||||
echo "tag=$tag" >> "$GITHUB_OUTPUT"
|
||||
echo "id=$id" >> "$GITHUB_OUTPUT"
|
||||
|
||||
binaries:
|
||||
permissions:
|
||||
contents: write
|
||||
needs: prepare
|
||||
if: needs.prepare.outputs.tag != ''
|
||||
uses: ./.github/workflows/release-build.yml
|
||||
with:
|
||||
tag: ${{ needs.prepare.outputs.tag }}
|
||||
release_id: ${{ needs.prepare.outputs.release_id }}
|
||||
secrets: inherit
|
||||
|
||||
publish:
|
||||
permissions:
|
||||
contents: write
|
||||
needs: [prepare, binaries]
|
||||
runs-on: ubuntu-latest
|
||||
env:
|
||||
TAG: ${{ needs.prepare.outputs.tag }}
|
||||
SHA: ${{ needs.prepare.outputs.sha }}
|
||||
KEEP: 14
|
||||
steps:
|
||||
- name: Publish the build
|
||||
run: gh release edit "$TAG" --tag "$TAG" --draft=false
|
||||
- name: Point the updater at it
|
||||
run: |
|
||||
gh release download "$TAG" -p latest.json -D "$RUNNER_TEMP"
|
||||
gh release view nightly >/dev/null 2>&1 ||
|
||||
gh release create nightly --prerelease --latest=false --target "$SHA" --title "OpenIDEA Nightly" \
|
||||
--notes "The update manifest of the nightly builds, and the commit last built."
|
||||
gh release upload nightly "$RUNNER_TEMP/latest.json" --clobber
|
||||
gh api -X PATCH "repos/$GH_REPO/git/refs/tags/nightly" -f sha="$SHA" -F force=true --silent
|
||||
# Failed builds' drafts go too, once they are this old.
|
||||
- name: Delete old builds
|
||||
run: |
|
||||
gh release list --limit 200 --json tagName,createdAt --jq \
|
||||
'[.[] | select(.tagName | contains("-nightly."))] | sort_by(.createdAt) | reverse | .[env.KEEP | tonumber:][].tagName' |
|
||||
while read -r tag; do
|
||||
gh release delete "$tag" --cleanup-tag --yes
|
||||
done
|
||||
@@ -1,7 +1,7 @@
|
||||
name: Release build
|
||||
|
||||
# Builds a tag's desktop apps, remote servers and updater manifest into its draft release.
|
||||
# Stable releases (release.yml) and nightly builds (nightly.yml) both run it.
|
||||
# Builds a tag's desktop apps, remote servers and updater manifest into its draft release
|
||||
# (run by release.yml).
|
||||
on:
|
||||
workflow_call:
|
||||
inputs:
|
||||
@@ -224,18 +224,17 @@ jobs:
|
||||
return;
|
||||
}
|
||||
// Bundle suffix → updater platform keys, as tauri-action names them.
|
||||
// Nightly versions don't fit MSI or RPM, so those builds offer NSIS on Windows.
|
||||
const nightly = tag.includes("-nightly.");
|
||||
const windows = (arch, msi, nsis) => nightly
|
||||
? [[nsis, [`windows-${arch}`, `windows-${arch}-nsis`]]]
|
||||
: [[msi, [`windows-${arch}`, `windows-${arch}-msi`]], [nsis, [`windows-${arch}-nsis`]]];
|
||||
const windows = (arch, msi, nsis) => [
|
||||
[msi, [`windows-${arch}`, `windows-${arch}-msi`]],
|
||||
[nsis, [`windows-${arch}-nsis`]],
|
||||
];
|
||||
const kinds = [
|
||||
[/_aarch64\.AppImage$/, ["linux-aarch64", "linux-aarch64-appimage"]],
|
||||
[/_arm64\.deb$/, ["linux-aarch64-deb"]],
|
||||
...(nightly ? [] : [[/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]]]),
|
||||
[/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]],
|
||||
[/_amd64\.AppImage$/, ["linux-x86_64", "linux-x86_64-appimage"]],
|
||||
[/_amd64\.deb$/, ["linux-x86_64-deb"]],
|
||||
...(nightly ? [] : [[/\.x86_64\.rpm$/, ["linux-x86_64-rpm"]]]),
|
||||
[/\.x86_64\.rpm$/, ["linux-x86_64-rpm"]],
|
||||
[/_aarch64\.app\.tar\.gz$/, ["darwin-aarch64", "darwin-aarch64-app"]],
|
||||
[/_x64\.app\.tar\.gz$/, ["darwin-x86_64", "darwin-x86_64-app"]],
|
||||
...windows("aarch64", /_arm64_en-US\.msi$/, /_arm64-setup\.exe$/),
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
name: Release
|
||||
on:
|
||||
push:
|
||||
tags: ["v*", "!v*-nightly.*"]
|
||||
tags: ["v*"]
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
tag:
|
||||
@@ -23,7 +23,6 @@ env:
|
||||
jobs:
|
||||
# Creates (or reuses) one draft release that every platform build uploads into.
|
||||
create-release:
|
||||
if: ${{ !contains(github.event.inputs.tag || github.ref_name, '-nightly.') }}
|
||||
permissions:
|
||||
contents: write
|
||||
runs-on: ubuntu-latest
|
||||
@@ -62,7 +61,7 @@ jobs:
|
||||
core.setOutput("id", existing.id);
|
||||
return;
|
||||
}
|
||||
// Nightly builds are prereleases: the notes span stable release to stable release.
|
||||
// Prereleases are skipped: the notes span stable release to stable release.
|
||||
const previous = releases.find((r) => !r.draft && !r.prerelease);
|
||||
const { data: notes } = await github.rest.repos.generateReleaseNotes({
|
||||
owner, repo, tag_name: tag, previous_tag_name: previous?.tag_name,
|
||||
|
||||
+5
-1
@@ -9,7 +9,8 @@ Visual style: dark, low-contrast greys, one cool accent
|
||||
- `crates/ide-*` — backend crates; one domain each. Depend on `ide-core` for shared
|
||||
types; never reach into another crate's internals.
|
||||
- `src-tauri/` — glue only: `state.rs` (AppState / Project), `commands/<domain>.rs`
|
||||
(thin typed IPC adapters), `events.rs`. No domain logic here.
|
||||
(desktop-only commands; the adapters of `ide-host` commands are derived), `events.rs`.
|
||||
No domain logic here.
|
||||
- `src/bindings.ts` — generated by tauri-specta (`pnpm gen:bindings`). Never edit.
|
||||
- `src/platform/` — ipc (`call`, `onIdeEvent`, `nextRequestId`), actions registry,
|
||||
keymap + dispatcher, context keys / `when` clauses, project store.
|
||||
@@ -33,6 +34,9 @@ Visual style: dark, low-contrast greys, one cool accent
|
||||
|
||||
- IPC coordinates: 0-based lines, **UTF-16** columns/offsets everywhere (`ide-core::text`).
|
||||
- Every command returns `IdeResult<T>`; convert internal errors at the crate edge.
|
||||
- Declare a command once, on its implementation: `#[command(trust = …)]` in `ide-host::ops`
|
||||
plus its module's `domain!` list (Tauri adapter, server handler and bindings are derived);
|
||||
desktop-only commands use `#[desktop_command(trust = …)]` and `desktop_domain!`.
|
||||
- Streaming → `tauri::ipc::Channel<T>`; cancellable → UI-allocated `RequestId` +
|
||||
`cancel_request`. Backend → UI notifications → `IdeEvent` via `EventSink`.
|
||||
- Long work never blocks the UI thread or a Tauri command thread: use
|
||||
|
||||
Створено
+72
-44
@@ -4144,7 +4144,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
|
||||
|
||||
[[package]]
|
||||
name = "ide-agent"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4169,7 +4169,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-analysis"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ast-grep-core",
|
||||
"ide-core",
|
||||
@@ -4183,7 +4183,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-android"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"serde",
|
||||
@@ -4194,7 +4194,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-build"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"chardetng",
|
||||
@@ -4212,7 +4212,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-cli"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"serde",
|
||||
@@ -4226,7 +4226,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-clipboard"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"gtk",
|
||||
"objc2 0.6.5",
|
||||
@@ -4235,9 +4235,20 @@ dependencies = [
|
||||
"png 0.18.1",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-command"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"heck 0.5.0",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"serde",
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-core"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4254,7 +4265,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-coverage"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-run",
|
||||
@@ -4268,7 +4279,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-dap"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"futures",
|
||||
@@ -4297,7 +4308,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-db"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"bb8",
|
||||
@@ -4333,7 +4344,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-docker"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"serde",
|
||||
@@ -4346,7 +4357,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-extension"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -4367,7 +4378,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-fonts"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"objc2-core-foundation",
|
||||
"objc2-core-text",
|
||||
@@ -4379,7 +4390,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-github"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-vcs",
|
||||
@@ -4392,7 +4403,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-heap"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"ide-core",
|
||||
@@ -4410,7 +4421,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-host"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -4424,6 +4435,7 @@ dependencies = [
|
||||
"ide-agent",
|
||||
"ide-analysis",
|
||||
"ide-build",
|
||||
"ide-command",
|
||||
"ide-core",
|
||||
"ide-coverage",
|
||||
"ide-dap",
|
||||
@@ -4435,6 +4447,7 @@ dependencies = [
|
||||
"ide-index",
|
||||
"ide-jsonrpc",
|
||||
"ide-jvm-attach",
|
||||
"ide-jvm-inspect",
|
||||
"ide-language",
|
||||
"ide-lsp",
|
||||
"ide-mcp",
|
||||
@@ -4447,6 +4460,7 @@ dependencies = [
|
||||
"ide-search",
|
||||
"ide-spell",
|
||||
"ide-ssh",
|
||||
"ide-streams",
|
||||
"ide-syntax",
|
||||
"ide-terminal",
|
||||
"ide-text",
|
||||
@@ -4481,7 +4495,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-http"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-vfs",
|
||||
@@ -4500,7 +4514,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-index"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"criterion",
|
||||
@@ -4522,7 +4536,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jdwp"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-jvm-inspect",
|
||||
"proptest",
|
||||
@@ -4534,7 +4548,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jsonrpc"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"encoding_rs",
|
||||
"futures",
|
||||
@@ -4551,7 +4565,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jvm-attach"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"tempfile",
|
||||
@@ -4560,7 +4574,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jvm-inspect"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"futures",
|
||||
"serde",
|
||||
@@ -4571,7 +4585,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-language"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"criterion",
|
||||
@@ -4629,7 +4643,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-lsp"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4657,7 +4671,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-mcp"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"bytes",
|
||||
"dunce",
|
||||
@@ -4676,7 +4690,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-notebook"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"futures",
|
||||
"ide-core",
|
||||
@@ -4699,7 +4713,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-plugin"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4722,7 +4736,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-profiler"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-jvm-attach",
|
||||
@@ -4736,7 +4750,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-remote"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"futures",
|
||||
@@ -4756,7 +4770,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-run"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4780,7 +4794,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-scaffold"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-tools",
|
||||
@@ -4796,7 +4810,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-sdk"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"flate2",
|
||||
@@ -4819,7 +4833,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-search"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"encoding_rs",
|
||||
@@ -4840,7 +4854,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-spell"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"parking_lot",
|
||||
@@ -4853,7 +4867,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-ssh"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"flate2",
|
||||
@@ -4876,9 +4890,22 @@ dependencies = [
|
||||
"uuid",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-streams"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-language",
|
||||
"ide-syntax",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"specta",
|
||||
"tree-sitter",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-syntax"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-language",
|
||||
@@ -4893,7 +4920,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-terminal"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"libc",
|
||||
@@ -4906,7 +4933,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-text"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"ide-core",
|
||||
@@ -4919,7 +4946,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-tools"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"flate2",
|
||||
"hex",
|
||||
@@ -4940,7 +4967,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-vcs"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4961,7 +4988,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-vfs"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"chardetng",
|
||||
"dunce",
|
||||
@@ -4987,7 +5014,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-web"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"ide-core",
|
||||
@@ -5003,7 +5030,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-workspace"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -6632,7 +6659,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "openidea"
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -6646,6 +6673,7 @@ dependencies = [
|
||||
"ide-build",
|
||||
"ide-cli",
|
||||
"ide-clipboard",
|
||||
"ide-command",
|
||||
"ide-core",
|
||||
"ide-coverage",
|
||||
"ide-dap",
|
||||
|
||||
+9
-1
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
|
||||
exclude = ["sdk", "plugins"]
|
||||
|
||||
[workspace.package]
|
||||
version = "0.1.45"
|
||||
version = "0.1.47"
|
||||
edition = "2024"
|
||||
rust-version = "1.96"
|
||||
license = "Apache-2.0"
|
||||
@@ -42,6 +42,7 @@ ide-fonts = { path = "crates/ide-fonts" }
|
||||
ide-ssh = { path = "crates/ide-ssh" }
|
||||
ide-remote = { path = "crates/ide-remote" }
|
||||
ide-host = { path = "crates/ide-host" }
|
||||
ide-command = { path = "crates/ide-command" }
|
||||
ide-mcp = { path = "crates/ide-mcp" }
|
||||
ide-scaffold = { path = "crates/ide-scaffold" }
|
||||
ide-notebook = { path = "crates/ide-notebook" }
|
||||
@@ -52,6 +53,7 @@ ide-jvm-attach = { path = "crates/ide-jvm-attach" }
|
||||
ide-jvm-inspect = { path = "crates/ide-jvm-inspect" }
|
||||
ide-jdwp = { path = "crates/ide-jdwp" }
|
||||
ide-heap = { path = "crates/ide-heap" }
|
||||
ide-streams = { path = "crates/ide-streams" }
|
||||
|
||||
# serialization & IPC typing
|
||||
serde = { version = "1", features = ["derive"] }
|
||||
@@ -123,6 +125,12 @@ uuid = { version = "1", features = ["v4"] }
|
||||
keyring = "4.2"
|
||||
keyring-core = "1"
|
||||
|
||||
# proc macros
|
||||
heck = "0.5"
|
||||
proc-macro2 = "1"
|
||||
quote = "1"
|
||||
syn = { version = "2", features = ["full"] }
|
||||
|
||||
# testing
|
||||
insta = { version = "1", features = ["yaml"] }
|
||||
proptest = "1"
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
`src/ui/brands/*.svg` use the unmodified logo paths from
|
||||
[Simple Icons](https://github.com/simple-icons/simple-icons), retrieved through
|
||||
Iconify (`simple-icons:angular`, `simple-icons:astro`, `simple-icons:cplusplus`, `simple-icons:dart`, `simple-icons:django`, `simple-icons:dotnet`, `simple-icons:elixir`, `simple-icons:express`, `simple-icons:fastapi`, `simple-icons:flask`, `simple-icons:flutter`, `simple-icons:go`, `simple-icons:haskell`, `simple-icons:html5`, `simple-icons:kotlin`, `simple-icons:ktor`, `simple-icons:laravel`, `simple-icons:nestjs`, `simple-icons:nextdotjs`, `simple-icons:nodedotjs`, `simple-icons:nuxt`, `simple-icons:openjdk`, `simple-icons:phoenixframework`, `simple-icons:php`, `simple-icons:python`, `simple-icons:quarkus`, `simple-icons:ruby`, `simple-icons:rubyonrails`, `simple-icons:rust`, `simple-icons:scala`, `simple-icons:springboot`, `simple-icons:svelte`, `simple-icons:swift`, `simple-icons:symfony`, `simple-icons:vite`, `simple-icons:zig`) and filled with the brand colors (the standard icon grey for black logos). Licensed under [CC0 1.0 Universal](https://github.com/simple-icons/simple-icons/blob/develop/LICENSE.md).
|
||||
Iconify (`simple-icons:angular`, `simple-icons:astro`, `simple-icons:cplusplus`, `simple-icons:dart`, `simple-icons:deepseek`, `simple-icons:django`, `simple-icons:dotnet`, `simple-icons:elixir`, `simple-icons:express`, `simple-icons:fastapi`, `simple-icons:flask`, `simple-icons:flutter`, `simple-icons:go`, `simple-icons:haskell`, `simple-icons:html5`, `simple-icons:kotlin`, `simple-icons:ktor`, `simple-icons:laravel`, `simple-icons:nestjs`, `simple-icons:nextdotjs`, `simple-icons:nodedotjs`, `simple-icons:nuxt`, `simple-icons:openjdk`, `simple-icons:phoenixframework`, `simple-icons:php`, `simple-icons:python`, `simple-icons:quarkus`, `simple-icons:ruby`, `simple-icons:rubyonrails`, `simple-icons:rust`, `simple-icons:scala`, `simple-icons:springboot`, `simple-icons:svelte`, `simple-icons:swift`, `simple-icons:symfony`, `simple-icons:vite`, `simple-icons:zig`) and filled with the brand colors (the standard icon grey for black logos). Licensed under [CC0 1.0 Universal](https://github.com/simple-icons/simple-icons/blob/develop/LICENSE.md).
|
||||
|
||||
## Project Lombok
|
||||
|
||||
|
||||
@@ -14,20 +14,21 @@ use std::collections::BTreeMap;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
const CONFIG_UPDATE_TIMEOUT: Duration = if cfg!(test) { Duration::from_millis(100) } else { Duration::from_secs(5) };
|
||||
const DISCOVER_TIMEOUT: Duration = if cfg!(test) { Duration::from_secs(3) } else { Duration::from_secs(120) };
|
||||
|
||||
/// Opens `session/new`, reads `configOptions`, and records the `thought_level` choices of the
|
||||
/// session's model: they describe that model only, and other models may offer different ones.
|
||||
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec) -> Result<Discovered, String> {
|
||||
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec, model: Option<&str>) -> Result<Discovered, String> {
|
||||
let prefer_stored = crate::provider::prefer_stored_copilot_auth();
|
||||
match run_once(shared, spec, prefer_stored).await {
|
||||
match run_once(shared, spec, prefer_stored, model).await {
|
||||
Err(err)
|
||||
if !prefer_stored
|
||||
&& crate::provider::is_copilot_provider(&spec.id)
|
||||
&& crate::provider::has_unconfigured_copilot_ambient_token(&spec.env)
|
||||
&& super::auth_required(0, &err) =>
|
||||
{
|
||||
let retry = run_once(shared, spec, true).await;
|
||||
let retry = run_once(shared, spec, true, model).await;
|
||||
if retry.is_ok() {
|
||||
crate::provider::mark_prefer_stored_copilot_auth();
|
||||
}
|
||||
@@ -37,7 +38,12 @@ pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec) -> Result<Dis
|
||||
}
|
||||
}
|
||||
|
||||
async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool) -> Result<Discovered, String> {
|
||||
async fn run_once(
|
||||
shared: &Arc<Shared>,
|
||||
spec: &ProviderSpec,
|
||||
strip_ambient: bool,
|
||||
selected_model: Option<&str>,
|
||||
) -> Result<Discovered, String> {
|
||||
let root = shared.paths.project_root.clone();
|
||||
let launch = spec.clone();
|
||||
let launch = tokio::task::spawn_blocking({
|
||||
@@ -47,28 +53,68 @@ async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
let cwd = dunce::canonicalize(&root).unwrap_or(root);
|
||||
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), commands: Mutex::new(None) });
|
||||
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), ..Default::default() });
|
||||
let client = Dialect::wrap(updates.clone());
|
||||
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(|_| {});
|
||||
let peer = (shared.connector)(&launch, &cwd, client.clone(), on_stderr)
|
||||
.map_err(|e| format!("Couldn't start {} (`{}`): {e}", launch.name, launch.command))?;
|
||||
.map_err(|e| format!("Couldn't start {} for model discovery: {e}", launch.name))?;
|
||||
let _stop = crate::catalogs::KillPeer(peer.clone());
|
||||
let conn = Conn::new(peer.clone(), client);
|
||||
let work = async {
|
||||
conn.initialize(&client_info()).await.map_err(|e| e.to_string())?;
|
||||
conn.initialize(&client_info()).await.map_err(discovery_error)?;
|
||||
let cwd_s = cwd.to_string_lossy().into_owned();
|
||||
// No project MCP during discovery: Cursor can spend a long time spawning servers.
|
||||
let new: Value = conn
|
||||
.request("session/new", json!({ "cwd": cwd_s, "mcpServers": [] }), None)
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
.map_err(discovery_error)?;
|
||||
let mut options = config::options_of(&new);
|
||||
config::add_client_options(&launch.id, &mut options);
|
||||
let model = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.clone());
|
||||
let levels = match (model, levels_for_model_from_slice(&options)) {
|
||||
(Some(model), Some(effort)) => BTreeMap::from([(model, effort)]),
|
||||
_ => BTreeMap::new(),
|
||||
};
|
||||
let model_option = options.iter().find(|o| o.category.as_deref() == Some("model"));
|
||||
let mut levels = BTreeMap::new();
|
||||
let has_config = new.get("configOptions").is_some_and(Value::is_array);
|
||||
if has_config && let Some(model) = model_option.and_then(|o| o.current.as_ref()) {
|
||||
levels.insert(model.clone(), levels_for_model_from_slice(&options));
|
||||
}
|
||||
if let Some(selected) = selected_model
|
||||
&& let Some(option) = model_option.filter(|o| o.values.iter().any(|v| v.value == selected))
|
||||
&& !levels.contains_key(selected)
|
||||
{
|
||||
let session =
|
||||
new.get("sessionId").and_then(Value::as_str).ok_or("The agent did not return a session ID")?;
|
||||
let (method, mut params) = config::set_request(option, selected);
|
||||
params["sessionId"] = json!(session);
|
||||
updates.config.lock().session = Some(session.to_owned());
|
||||
let response: Value = conn.request(method, params, None).await.map_err(discovery_error)?;
|
||||
let settings = if let Some(settings) = selected_settings(&response, selected) {
|
||||
Some(settings)
|
||||
} else {
|
||||
tokio::time::timeout(CONFIG_UPDATE_TIMEOUT, async {
|
||||
loop {
|
||||
let notified = updates.changed.notified();
|
||||
if let Some(settings) = updates
|
||||
.config
|
||||
.lock()
|
||||
.options
|
||||
.as_ref()
|
||||
.and_then(|options| selected_settings(options, selected))
|
||||
{
|
||||
return settings;
|
||||
}
|
||||
notified.await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.ok()
|
||||
};
|
||||
match settings {
|
||||
Some(settings) => levels.insert(selected.to_owned(), levels_for_model_from_slice(&settings)),
|
||||
// An agent on the legacy `models` field that says nothing more: the model has
|
||||
// no settings of its own, and switching to it must not fail.
|
||||
None if !has_config => levels.insert(selected.to_owned(), Vec::new()),
|
||||
None => return Err("The agent did not report settings for the selected model".to_owned()),
|
||||
};
|
||||
}
|
||||
let commands = updates
|
||||
.commands
|
||||
.lock()
|
||||
@@ -88,16 +134,38 @@ async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool
|
||||
struct DiscoveryUpdates {
|
||||
provider: String,
|
||||
commands: Mutex<Option<Vec<crate::AgentCommand>>>,
|
||||
config: Mutex<DiscoveryConfig>,
|
||||
changed: tokio::sync::Notify,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct DiscoveryConfig {
|
||||
session: Option<String>,
|
||||
options: Option<Value>,
|
||||
}
|
||||
|
||||
impl ide_jsonrpc::Handler for DiscoveryUpdates {
|
||||
fn on_notification(&self, method: &str, params: Value) {
|
||||
if method == "session/update"
|
||||
&& let Some(update) = params.get("update")
|
||||
&& update["sessionUpdate"] == "available_commands_update"
|
||||
{
|
||||
// Commands are protocol data, not stderr (which may contain credentials).
|
||||
*self.commands.lock() = Some(config::commands_of(update, &self.provider));
|
||||
if method != "session/update" {
|
||||
return;
|
||||
}
|
||||
let Some(update) = params.get("update") else { return };
|
||||
match update["sessionUpdate"].as_str() {
|
||||
Some("available_commands_update") => {
|
||||
// Commands are protocol data, not stderr (which may contain credentials).
|
||||
*self.commands.lock() = Some(config::commands_of(update, &self.provider));
|
||||
}
|
||||
Some("config_option_update") => {
|
||||
let mut config = self.config.lock();
|
||||
if config.session.as_deref() == params.get("sessionId").and_then(Value::as_str)
|
||||
&& config.session.is_some()
|
||||
&& update.get("configOptions").is_some_and(Value::is_array)
|
||||
{
|
||||
config.options = Some(update.clone());
|
||||
self.changed.notify_one();
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -106,8 +174,24 @@ impl ide_jsonrpc::Handler for DiscoveryUpdates {
|
||||
}
|
||||
}
|
||||
|
||||
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option<Vec<AgentConfigOption>> {
|
||||
let levels: Vec<_> = options
|
||||
fn discovery_error(error: ide_jsonrpc::RpcError) -> String {
|
||||
match error {
|
||||
ide_jsonrpc::RpcError::Server { code, message, .. } if super::auth_required(code, &message) => {
|
||||
"Sign in required: the agent could not authenticate model discovery".into()
|
||||
}
|
||||
other => format!("The agent could not complete model discovery: {other}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn selected_settings(response: &Value, model: &str) -> Option<Vec<AgentConfigOption>> {
|
||||
response.get("configOptions")?.as_array()?;
|
||||
let options = config::options_of(response);
|
||||
let current = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.as_deref());
|
||||
current.is_none_or(|current| current == model).then_some(options)
|
||||
}
|
||||
|
||||
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Vec<AgentConfigOption> {
|
||||
options
|
||||
.iter()
|
||||
.filter(|o| config::is_per_model_option(o))
|
||||
.cloned()
|
||||
@@ -121,6 +205,5 @@ fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option<Vec<Agen
|
||||
}
|
||||
o
|
||||
})
|
||||
.collect();
|
||||
(!levels.is_empty()).then_some(levels)
|
||||
.collect()
|
||||
}
|
||||
@@ -27,7 +27,7 @@ use serde::de::DeserializeOwned;
|
||||
use serde_json::{Value, json};
|
||||
use std::collections::HashMap;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicU8, Ordering};
|
||||
use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
|
||||
use tokio::sync::oneshot;
|
||||
|
||||
/// ACP's error code for a request that needs the user to sign in.
|
||||
@@ -162,9 +162,16 @@ impl Negotiated {
|
||||
Self { generation: 2, capabilities, agent_info: response.get("info").cloned(), auth_methods, meta }
|
||||
}
|
||||
|
||||
/// Whether a saved session can be reopened (`session/load` on v1, `session/resume` on v2).
|
||||
/// Whether a saved session can be reopened: `loadSession`, or a v1 agent's
|
||||
/// `sessionCapabilities.resume` (DeepSeek Harness), which stands in for it.
|
||||
pub fn load_session(&self) -> bool {
|
||||
self.capabilities.get("loadSession").and_then(Value::as_bool) == Some(true)
|
||||
self.capabilities.get("loadSession").and_then(Value::as_bool) == Some(true) || self.session("resume")
|
||||
}
|
||||
|
||||
/// Whether `session/load` must be sent as `session/resume`: a v1 agent that advertises
|
||||
/// `sessionCapabilities.resume` instead of `loadSession` (DeepSeek Harness).
|
||||
pub fn resume_instead_of_load(&self) -> bool {
|
||||
self.capabilities.get("loadSession").and_then(Value::as_bool) != Some(true) && self.session("resume")
|
||||
}
|
||||
|
||||
/// `promptCapabilities.<name>` (`image`, `audio`, `embeddedContext`).
|
||||
@@ -205,6 +212,8 @@ pub(crate) struct Dialect {
|
||||
inner: Arc<dyn Handler>,
|
||||
/// 0 until `initialize` answers; then 1 or 2.
|
||||
generation: AtomicU8,
|
||||
/// Set by `initialize`: a v1 agent's `session/load` is sent as `session/resume`.
|
||||
resume_load: AtomicBool,
|
||||
normalizer: Mutex<Normalizer>,
|
||||
/// Running v2 prompts, by session id.
|
||||
turns: Mutex<HashMap<String, Turn>>,
|
||||
@@ -222,6 +231,7 @@ impl Dialect {
|
||||
Arc::new(Self {
|
||||
inner,
|
||||
generation: AtomicU8::new(0),
|
||||
resume_load: AtomicBool::new(false),
|
||||
normalizer: Mutex::new(Normalizer::default()),
|
||||
turns: Mutex::new(HashMap::new()),
|
||||
})
|
||||
@@ -231,6 +241,10 @@ impl Dialect {
|
||||
self.generation.load(Ordering::Acquire)
|
||||
}
|
||||
|
||||
fn resume_load(&self) -> bool {
|
||||
self.resume_load.load(Ordering::Acquire)
|
||||
}
|
||||
|
||||
fn v2(&self) -> bool {
|
||||
self.generation() == 2
|
||||
}
|
||||
@@ -380,6 +394,7 @@ impl Conn {
|
||||
let response: Value = self.peer.request("initialize", initialize_params(client_info), None).await?;
|
||||
let negotiated = Negotiated::from_initialize(&response);
|
||||
self.dialect.generation.store(negotiated.generation, Ordering::Release);
|
||||
self.dialect.resume_load.store(negotiated.resume_instead_of_load(), Ordering::Release);
|
||||
Ok(negotiated)
|
||||
}
|
||||
|
||||
@@ -393,6 +408,9 @@ impl Conn {
|
||||
let params = serde_json::to_value(params).map_err(|e| RpcError::Protocol(e.to_string()))?;
|
||||
let value = if self.dialect.v2() {
|
||||
self.request_v2(method, params, cancel).await?
|
||||
} else if method == "session/load" && self.dialect.resume_load() {
|
||||
// Same request shape, without a replay and without v2's setup translation.
|
||||
self.peer.request("session/resume", params, cancel).await?
|
||||
} else {
|
||||
self.peer.request(method, params, cancel).await?
|
||||
};
|
||||
|
||||
@@ -180,6 +180,7 @@ async fn discovery_reads_effort_and_fast_from_session_new_then_stops_the_agent()
|
||||
fn a_v2_initialize_response_reads_as_v1_capabilities() {
|
||||
let n = Negotiated::from_initialize(&result(TURN, 1));
|
||||
assert_eq!(n.generation, 2);
|
||||
assert!(!n.resume_instead_of_load(), "v2 maps `session/load` itself");
|
||||
assert!(n.load_session());
|
||||
assert!(n.prompt("image") && n.prompt("embeddedContext") && !n.prompt("audio"));
|
||||
assert!(n.session("fork") && n.session("resume") && n.session("close") && n.session("delete"));
|
||||
@@ -681,3 +682,87 @@ fn stdio_mcp_is_v1_baseline_and_negotiated_in_v2() {
|
||||
.mcp_stdio()
|
||||
);
|
||||
}
|
||||
|
||||
/// A v1 agent that answers `initialize` with `init` and records every request it gets.
|
||||
/// Keeps its own `Peer` so the duplex stays open while the client sends.
|
||||
struct V1Agent {
|
||||
init: Value,
|
||||
peer: std::sync::OnceLock<Peer>,
|
||||
requests: parking_lot::Mutex<Vec<(String, Value)>>,
|
||||
}
|
||||
|
||||
impl Handler for V1Agent {
|
||||
fn on_notification(&self, _: &str, _: Value) {}
|
||||
|
||||
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
|
||||
self.requests.lock().push((method.to_owned(), params));
|
||||
Ok(if method == "initialize" { self.init.clone() } else { json!({}) })
|
||||
}
|
||||
}
|
||||
|
||||
async fn connect_v1(agent: Arc<V1Agent>) -> (Conn, Negotiated) {
|
||||
let (a, b) = tokio::io::duplex(1 << 20);
|
||||
let (ar, aw) = tokio::io::split(a);
|
||||
let (br, bw) = tokio::io::split(b);
|
||||
let _ = agent.peer.set(Peer::connect_framed(br, bw, agent.clone(), Framing::Lines));
|
||||
let dialect = Dialect::wrap(Arc::new(Recorder::default()));
|
||||
let conn = Conn::new(Peer::connect_framed(ar, aw, dialect.clone(), Framing::Lines), dialect);
|
||||
let n = conn.initialize(&json!({ "name": "OpenIDEA", "version": "0" })).await.unwrap();
|
||||
assert_eq!((n.generation, conn.generation()), (1, 1));
|
||||
(conn, n)
|
||||
}
|
||||
|
||||
fn v1_agent(init: Value) -> Arc<V1Agent> {
|
||||
Arc::new(V1Agent { init, peer: Default::default(), requests: Default::default() })
|
||||
}
|
||||
|
||||
/// A v1 agent that advertises `sessionCapabilities.resume` instead of `loadSession`
|
||||
/// (DeepSeek Harness) can reopen a saved session, but only through `session/resume`.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_v1_agent_with_resume_instead_of_load_reopens_through_session_resume() {
|
||||
let agent = v1_agent(json!({
|
||||
"protocolVersion": 1,
|
||||
"agentInfo": { "name": "deepseek-harness-acp", "version": "0.0.1" },
|
||||
"agentCapabilities": { "sessionCapabilities": { "close": {}, "list": {}, "resume": {} } },
|
||||
}));
|
||||
let (conn, n) = connect_v1(agent.clone()).await;
|
||||
assert!(n.load_session(), "a resume-only agent is reloadable");
|
||||
assert!(n.resume_instead_of_load());
|
||||
assert!(n.session("resume"));
|
||||
|
||||
let params = json!({ "sessionId": "s1", "cwd": "/p", "mcpServers": [] });
|
||||
let _: Value = conn.request("session/load", params.clone(), None).await.unwrap();
|
||||
let requests = agent.requests.lock().clone();
|
||||
assert_eq!(requests.iter().map(|(m, _)| m.as_str()).collect::<Vec<_>>(), ["initialize", "session/resume"]);
|
||||
assert_eq!(requests[1].1, params, "same request shape as `session/load`");
|
||||
}
|
||||
|
||||
/// Every other v1 agent is untouched: `loadSession` still sends `session/load`, and an
|
||||
/// agent advertising neither capability is not treated as loadable.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn v1_agents_that_do_not_advertise_resume_keep_session_load() {
|
||||
for (init, loadable) in [
|
||||
(json!({ "protocolVersion": 1, "agentCapabilities": { "loadSession": true } }), true),
|
||||
(json!({ "protocolVersion": 1, "agentCapabilities": { "loadSession": false } }), false),
|
||||
(json!({ "protocolVersion": 1, "agentCapabilities": { "sessionCapabilities": { "resume": null } } }), false),
|
||||
(json!({ "protocolVersion": 1 }), false),
|
||||
] {
|
||||
let agent = v1_agent(init);
|
||||
let (conn, n) = connect_v1(agent.clone()).await;
|
||||
assert_eq!(n.load_session(), loadable);
|
||||
assert!(!n.resume_instead_of_load());
|
||||
let _: Value = conn.request("session/load", json!({ "sessionId": "s1" }), None).await.unwrap();
|
||||
let methods: Vec<String> = agent.requests.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
assert_eq!(methods, ["initialize", "session/load"]);
|
||||
}
|
||||
// `loadSession: true` wins over a resume-only advertisement.
|
||||
let agent = v1_agent(json!({
|
||||
"protocolVersion": 1,
|
||||
"agentCapabilities": { "loadSession": true, "sessionCapabilities": { "resume": {} } },
|
||||
}));
|
||||
let (conn, n) = connect_v1(agent.clone()).await;
|
||||
assert!(n.load_session() && !n.resume_instead_of_load());
|
||||
let _: Value = conn.request("session/load", json!({ "sessionId": "s1" }), None).await.unwrap();
|
||||
let methods: Vec<String> = agent.requests.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
assert_eq!(methods, ["initialize", "session/load"]);
|
||||
}
|
||||
@@ -45,9 +45,18 @@ struct Entry {
|
||||
error: Option<String>,
|
||||
flight: Option<watch::Receiver<bool>>,
|
||||
abort: Option<tokio::task::AbortHandle>,
|
||||
flight_model: Option<String>,
|
||||
requested_model: Option<String>,
|
||||
model_failures: HashMap<String, ModelFailure>,
|
||||
catalog: Option<CatalogData>,
|
||||
}
|
||||
|
||||
struct ModelFailure {
|
||||
completed: Instant,
|
||||
retry_at_ms: f64,
|
||||
error: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Default, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub(crate) struct CatalogData {
|
||||
@@ -204,6 +213,24 @@ impl AgentCatalogs {
|
||||
.unwrap_or_else(|| Self::fallback(shared, provider))
|
||||
}
|
||||
|
||||
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
|
||||
let state = self.state.lock();
|
||||
if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref())
|
||||
{
|
||||
return catalog.thought_levels.get(model).cloned();
|
||||
}
|
||||
drop(state);
|
||||
let cache = shared.known.lock();
|
||||
let known = cache.get(provider)?;
|
||||
known
|
||||
.catalogs
|
||||
.get(&shared.root_key())
|
||||
.map(|saved| &saved.catalog.thought_levels)
|
||||
.unwrap_or(&known.thought_levels)
|
||||
.get(model)
|
||||
.cloned()
|
||||
}
|
||||
|
||||
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
|
||||
let key = Self::key(shared, provider);
|
||||
let mut state = self.state.lock();
|
||||
@@ -214,16 +241,27 @@ impl AgentCatalogs {
|
||||
|
||||
fn snapshot(&self, shared: &Shared, provider: &str, entry: &Entry) -> AgentModelCatalog {
|
||||
let catalog = entry.catalog.clone().unwrap_or_else(|| Self::fallback(shared, provider));
|
||||
let model_failure = entry.requested_model.as_ref().and_then(|model| entry.model_failures.get(model));
|
||||
let unknown_model = entry
|
||||
.requested_model
|
||||
.as_deref()
|
||||
.is_some_and(|model| catalog.lists(model) && !catalog.thought_levels.contains_key(model));
|
||||
AgentModelCatalog {
|
||||
provider: provider.to_owned(),
|
||||
config: shared.config_for_new_task(catalog.config, provider),
|
||||
thought_levels: catalog.thought_levels,
|
||||
refreshing: entry.flight.is_some(),
|
||||
refreshed_at_ms: catalog.refreshed_at_ms,
|
||||
retry_at_ms: entry
|
||||
.retry_at_ms
|
||||
.filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN)),
|
||||
error: entry.error.clone(),
|
||||
retry_at_ms: model_failure
|
||||
.filter(|failure| self.now().duration_since(failure.completed) < COOLDOWN)
|
||||
.map(|failure| failure.retry_at_ms)
|
||||
.or_else(|| {
|
||||
(!unknown_model)
|
||||
.then_some(entry.retry_at_ms)
|
||||
.flatten()
|
||||
.filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN))
|
||||
}),
|
||||
error: model_failure.map(|failure| failure.error.clone()).or_else(|| entry.error.clone()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -233,6 +271,7 @@ impl AgentCatalogs {
|
||||
shared: &Arc<Shared>,
|
||||
spec: provider::ProviderSpec,
|
||||
force: bool,
|
||||
model: Option<&str>,
|
||||
) -> (AgentModelCatalog, Option<watch::Receiver<bool>>) {
|
||||
let key = Self::key(shared, &spec.id);
|
||||
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
|
||||
@@ -264,6 +303,7 @@ impl AgentCatalogs {
|
||||
let mut catalog = saved.catalog;
|
||||
if !matching {
|
||||
catalog.refreshed_at_ms = None;
|
||||
catalog.thought_levels.clear();
|
||||
}
|
||||
catalog
|
||||
});
|
||||
@@ -279,31 +319,73 @@ impl AgentCatalogs {
|
||||
error: None,
|
||||
flight: None,
|
||||
abort: None,
|
||||
flight_model: None,
|
||||
requested_model: None,
|
||||
model_failures: HashMap::new(),
|
||||
},
|
||||
);
|
||||
}
|
||||
let fallback =
|
||||
state.entries.get(&key).filter(|entry| entry.catalog.is_none()).map(|_| Self::fallback(shared, &spec.id));
|
||||
state.generation += 1;
|
||||
let generation = state.generation;
|
||||
let entry = state.entries.get_mut(&key).expect("catalog entry");
|
||||
let cooling = entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN);
|
||||
let catalog = entry.catalog.as_ref().or(fallback.as_ref()).expect("cached catalog");
|
||||
let fresh = entry.successful.is_some_and(|at| now.duration_since(at) < FRESH_FOR);
|
||||
let target = model
|
||||
.filter(|model| {
|
||||
(catalog.lists(model) && !catalog.thought_levels.contains_key(*model))
|
||||
|| (!fresh && catalog.model_option().is_none())
|
||||
})
|
||||
.map(str::to_owned);
|
||||
if model.is_some() && entry.requested_model.as_deref() != model {
|
||||
entry.requested_model = model.map(str::to_owned);
|
||||
}
|
||||
let superseded = model.is_some()
|
||||
&& entry.flight.is_some()
|
||||
&& (entry.flight_model.is_some() || target.is_some())
|
||||
&& entry.flight_model.as_deref() != target.as_deref();
|
||||
if superseded {
|
||||
if let Some(abort) = entry.abort.take() {
|
||||
abort.abort();
|
||||
}
|
||||
entry.flight = None;
|
||||
entry.generation = generation;
|
||||
entry.flight_model = None;
|
||||
}
|
||||
let cooling = match target.as_ref() {
|
||||
Some(model) => entry.model_failures.get(model).is_some_and(|f| now.duration_since(f.completed) < COOLDOWN),
|
||||
None => entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN),
|
||||
};
|
||||
let eligible = !cooling && (target.is_some() || force || !fresh);
|
||||
let mut start = None;
|
||||
if entry.flight.is_none() && !cooling && (force || !fresh) {
|
||||
if entry.flight.is_none() && eligible {
|
||||
let (done, ready) = watch::channel(false);
|
||||
entry.flight = Some(ready);
|
||||
entry.flight_model = target.clone();
|
||||
entry.error = None;
|
||||
if let Some(model) = target.as_ref() {
|
||||
entry.model_failures.remove(model);
|
||||
}
|
||||
entry.retry_at_ms = None;
|
||||
start = Some((entry.generation, done));
|
||||
// Every flight has its own generation, including superseded model selections.
|
||||
entry.generation = generation;
|
||||
start = Some((entry.generation, target, done));
|
||||
}
|
||||
let snapshot = self.snapshot(shared, &spec.id, entry);
|
||||
let flight = entry.flight.clone();
|
||||
drop(state);
|
||||
if let Some((generation, done)) = start {
|
||||
if superseded && start.is_none() {
|
||||
self.broadcast(shared, &snapshot);
|
||||
}
|
||||
if let Some((generation, model, done)) = start {
|
||||
self.broadcast(shared, &snapshot);
|
||||
let coordinator = self.clone();
|
||||
let shared = shared.clone();
|
||||
let flight_key = key.clone();
|
||||
let task = shared.runtime.clone().spawn(async move {
|
||||
let result = discover(&shared, spec).await;
|
||||
coordinator.complete(&shared, flight_key, generation, result);
|
||||
let result = discover(&shared, spec, model.as_deref()).await;
|
||||
coordinator.complete(&shared, flight_key, generation, model, result);
|
||||
let _ = done.send(true);
|
||||
});
|
||||
// A subscriber can re-enter and change configuration during the start event.
|
||||
@@ -319,7 +401,14 @@ impl AgentCatalogs {
|
||||
(snapshot, flight)
|
||||
}
|
||||
|
||||
fn complete(&self, shared: &Shared, key: Key, generation: u64, result: Result<Discovered, String>) {
|
||||
fn complete(
|
||||
&self,
|
||||
shared: &Shared,
|
||||
key: Key,
|
||||
generation: u64,
|
||||
model: Option<String>,
|
||||
result: Result<Discovered, String>,
|
||||
) {
|
||||
let current = provider::load(shared.paths.custom_agents_dir.as_deref(), shared.env_secrets())
|
||||
.into_iter()
|
||||
.find(|spec| spec.id == key.2)
|
||||
@@ -330,6 +419,7 @@ impl AgentCatalogs {
|
||||
if current.as_ref() != Some(&entry.context) {
|
||||
entry.flight = None;
|
||||
entry.abort = None;
|
||||
entry.flight_model = None;
|
||||
entry.completed = None;
|
||||
entry.retry_at_ms = None;
|
||||
entry.error = None;
|
||||
@@ -340,12 +430,16 @@ impl AgentCatalogs {
|
||||
return;
|
||||
}
|
||||
let now = self.now();
|
||||
entry.completed = Some(now);
|
||||
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
|
||||
if model.is_none() {
|
||||
entry.completed = Some(now);
|
||||
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
|
||||
}
|
||||
entry.flight = None;
|
||||
entry.abort = None;
|
||||
entry.flight_model = None;
|
||||
let success = match result {
|
||||
Ok(found) => {
|
||||
let previous = entry.catalog.take().unwrap_or_else(|| Self::fallback(shared, &key.2));
|
||||
let mut cache = shared.known.lock();
|
||||
let known = cache.entry(key.2.clone()).or_default();
|
||||
let mut catalog = CatalogData {
|
||||
@@ -354,7 +448,7 @@ impl AgentCatalogs {
|
||||
refreshed_at_ms: Some(self.epoch_ms()),
|
||||
};
|
||||
// Efforts sessions reported for models discovery doesn't read stay while listed.
|
||||
for (model, levels) in entry.catalog.take().map(|old| old.thought_levels).unwrap_or_default() {
|
||||
for (model, levels) in previous.thought_levels {
|
||||
if catalog.lists(&model) && !catalog.thought_levels.contains_key(&model) {
|
||||
catalog.thought_levels.insert(model, levels);
|
||||
}
|
||||
@@ -373,11 +467,30 @@ impl AgentCatalogs {
|
||||
entry.catalog = Some(catalog);
|
||||
shared.persist_known(&cache);
|
||||
entry.successful = Some(now);
|
||||
entry.completed = Some(now);
|
||||
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
|
||||
entry.model_failures.retain(|model, _| {
|
||||
entry
|
||||
.catalog
|
||||
.as_ref()
|
||||
.is_some_and(|catalog| catalog.lists(model) && !catalog.thought_levels.contains_key(model))
|
||||
});
|
||||
entry.error = None;
|
||||
true
|
||||
}
|
||||
Err(error) => {
|
||||
entry.error = Some(error);
|
||||
if let Some(model) = model {
|
||||
entry.model_failures.insert(
|
||||
model,
|
||||
ModelFailure {
|
||||
completed: now,
|
||||
retry_at_ms: self.epoch_ms() + COOLDOWN.as_millis() as f64,
|
||||
error,
|
||||
},
|
||||
);
|
||||
} else {
|
||||
entry.error = Some(error);
|
||||
}
|
||||
false
|
||||
}
|
||||
};
|
||||
@@ -448,18 +561,22 @@ impl AgentCatalogs {
|
||||
|
||||
impl crate::AgentManager {
|
||||
/// Return cached choices immediately and schedule discovery when eligible.
|
||||
pub fn refresh_models(&self, provider: &str, force: bool) -> IdeResult<AgentModelCatalog> {
|
||||
pub fn refresh_models(&self, provider: &str, force: bool, model: Option<&str>) -> IdeResult<AgentModelCatalog> {
|
||||
// Settings and environment secrets can change while this window is open.
|
||||
*self.shared.providers.write() =
|
||||
provider::load(self.shared.paths.custom_agents_dir.as_deref(), self.shared.env_secrets());
|
||||
let spec = self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?;
|
||||
Ok(self.shared.paths.catalogs.request(&self.shared, spec, force).0)
|
||||
Ok(self.shared.paths.catalogs.request(&self.shared, spec, force, model).0)
|
||||
}
|
||||
}
|
||||
|
||||
async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<Discovered, String> {
|
||||
async fn discover(
|
||||
shared: &Arc<Shared>,
|
||||
spec: provider::ProviderSpec,
|
||||
model: Option<&str>,
|
||||
) -> Result<Discovered, String> {
|
||||
match spec.driver {
|
||||
provider::Driver::Acp => acp::discover::run(shared, &spec).await,
|
||||
provider::Driver::Acp => acp::discover::run(shared, &spec, model).await,
|
||||
provider::Driver::Codex => native::codex::discover(spec, shared.paths.project_root.clone()).await,
|
||||
provider::Driver::Claude => {
|
||||
let found = native::claude::discover(spec.clone(), shared.paths.project_root.clone()).await?;
|
||||
@@ -484,7 +601,7 @@ async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<
|
||||
provider::Driver::Copilot => {
|
||||
if shared.uses_copilot_acp_fallback(&spec) {
|
||||
let acp_spec = native::copilot::acp_fallback_spec(&spec);
|
||||
return acp::discover::run(shared, &acp_spec).await;
|
||||
return acp::discover::run(shared, &acp_spec, model).await;
|
||||
}
|
||||
match native::copilot::discover(spec.clone(), shared.paths.project_root.clone()).await {
|
||||
Ok(found) => Ok(Discovered {
|
||||
@@ -513,7 +630,7 @@ async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<
|
||||
);
|
||||
shared.mark_copilot_acp_fallback(&spec);
|
||||
let acp_spec = native::copilot::acp_fallback_spec(&spec);
|
||||
acp::discover::run(shared, &acp_spec).await
|
||||
acp::discover::run(shared, &acp_spec, model).await
|
||||
}
|
||||
Err(err) => Err(err.message),
|
||||
}
|
||||
|
||||
@@ -11,8 +11,10 @@ const PROVIDER: &str = "catalog-test";
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Pending {
|
||||
method: String,
|
||||
params: Value,
|
||||
reply: oneshot::Sender<Result<Value, String>>,
|
||||
notifications: mpsc::UnboundedSender<Value>,
|
||||
}
|
||||
|
||||
struct Harness {
|
||||
@@ -31,6 +33,10 @@ impl Drop for Live {
|
||||
|
||||
impl Harness {
|
||||
fn new() -> Self {
|
||||
Self::with_initialize(json!({ "protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] }))
|
||||
}
|
||||
|
||||
fn with_initialize(initialize: Value) -> Self {
|
||||
let (pending_tx, pending) = mpsc::unbounded_channel();
|
||||
let launches = Arc::new(AtomicUsize::new(0));
|
||||
let live = Arc::new(AtomicUsize::new(0));
|
||||
@@ -42,26 +48,53 @@ impl Harness {
|
||||
live.fetch_add(1, Ordering::SeqCst);
|
||||
let guard = Live(live.clone());
|
||||
let pending = pending_tx.clone();
|
||||
let initialize = initialize.clone();
|
||||
let (notifications_tx, mut notifications) = mpsc::unbounded_channel::<Value>();
|
||||
let (client_io, server_io) = tokio::io::duplex(1 << 16);
|
||||
let (read, mut write) = tokio::io::split(server_io);
|
||||
tokio::spawn(async move {
|
||||
let _guard = guard;
|
||||
let mut lines = BufReader::new(read).lines();
|
||||
while let Some(line) = lines.next_line().await.unwrap() {
|
||||
loop {
|
||||
let line = tokio::select! {
|
||||
line = lines.next_line() => match line.unwrap() {
|
||||
Some(line) => line,
|
||||
None => break,
|
||||
},
|
||||
Some(notification) = notifications.recv() => {
|
||||
if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() {
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
};
|
||||
let request: Value = serde_json::from_str(&line).unwrap();
|
||||
let id = &request["id"];
|
||||
if id.is_null() {
|
||||
continue;
|
||||
}
|
||||
let response = match request["method"].as_str().unwrap() {
|
||||
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": {
|
||||
"protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] } }),
|
||||
"session/new" => {
|
||||
let (reply, result) = oneshot::channel();
|
||||
pending.send(Pending { params: request["params"].clone(), reply }).unwrap();
|
||||
let result = tokio::select! {
|
||||
result = result => result.unwrap(),
|
||||
_ = lines.next_line() => break,
|
||||
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }),
|
||||
"session/new" | "session/set_config_option" | "session/set_model" => {
|
||||
let (reply, mut result) = oneshot::channel();
|
||||
pending
|
||||
.send(Pending {
|
||||
method: request["method"].as_str().unwrap().to_owned(),
|
||||
params: request["params"].clone(),
|
||||
reply,
|
||||
notifications: notifications_tx.clone(),
|
||||
})
|
||||
.unwrap();
|
||||
let result = loop {
|
||||
tokio::select! {
|
||||
result = &mut result => break result.unwrap(),
|
||||
_ = lines.next_line() => return,
|
||||
Some(notification) = notifications.recv() => {
|
||||
if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
match result {
|
||||
Ok(result) => json!({ "id": id, "jsonrpc": "2.0", "result": result }),
|
||||
@@ -190,7 +223,7 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
|
||||
let mut events = events(&manager);
|
||||
let old = config::options_of(&response(&["old", "retained"], &["low", "high"]));
|
||||
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
|
||||
let cached = manager.refresh_models(PROVIDER, false).unwrap();
|
||||
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert!(cached.refreshing);
|
||||
assert_eq!(model_values(&cached), ["old", "retained"]);
|
||||
assert!(cached.refreshed_at_ms.is_none(), "session reports are not fresh discovery");
|
||||
@@ -204,13 +237,13 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
|
||||
assert_eq!(fresh.thought_levels["retained"][0].values[0].value, "medium");
|
||||
assert!(fresh.refreshed_at_ms.is_some() && fresh.retry_at_ms.is_some());
|
||||
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
|
||||
assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config);
|
||||
assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config);
|
||||
let provider = manager.providers().into_iter().find(|p| p.id == PROVIDER).unwrap();
|
||||
assert_eq!(provider.config, fresh.config);
|
||||
let persisted = std::fs::read_to_string(tmp.path().join("models.json")).unwrap();
|
||||
assert!(!persisted.contains("secret-one") && !persisted.contains("TOKEN"));
|
||||
let restored = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let restored_snapshot = restored.refresh_models(PROVIDER, false).unwrap();
|
||||
let restored_snapshot = restored.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert!(!restored_snapshot.refreshing, "matching persisted launch context remains fresh");
|
||||
assert_eq!(restored_snapshot.refreshed_at_ms, fresh.refreshed_at_ms);
|
||||
let provider = restored.providers().into_iter().find(|p| p.id == PROVIDER).unwrap();
|
||||
@@ -229,7 +262,7 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["first", "second"], &["low", "high"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
// A session on "second" reports its own efforts; one on a model the catalog lacks, or on
|
||||
@@ -241,16 +274,16 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
|
||||
let efforts = |catalog: &AgentModelCatalog, model: &str| -> Vec<String> {
|
||||
catalog.thought_levels[model][0].values.iter().map(|v| v.value.clone()).collect()
|
||||
};
|
||||
let catalog = manager.refresh_models(PROVIDER, false).unwrap();
|
||||
let catalog = manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert_eq!(catalog.thought_levels.keys().map(String::as_str).collect::<Vec<_>>(), ["first", "second"]);
|
||||
assert_eq!(efforts(&catalog, "first"), ["low", "high"]);
|
||||
assert_eq!(efforts(&catalog, "second"), ["off", "auto"]);
|
||||
let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false).unwrap();
|
||||
let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert_eq!(efforts(&restored, "second"), ["off", "auto"], "persisted with the project's catalog");
|
||||
// Discovery again reads "first" only; "second" keeps what its session reported.
|
||||
advance(&catalogs, 60);
|
||||
while events.try_recv().is_ok() {}
|
||||
manager.refresh_models(PROVIDER, true).unwrap();
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["first", "second"], &["medium"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
assert_eq!(efforts(&fresh, "first"), ["medium"]);
|
||||
@@ -273,7 +306,7 @@ async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
let cached = manager.refresh_models(PROVIDER, false).unwrap();
|
||||
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert_eq!(model_values(&cached), ["legacy"]);
|
||||
assert!(cached.refreshing && cached.refreshed_at_ms.is_none());
|
||||
harness.next().await.reply.send(Err("Sign in required".into())).unwrap();
|
||||
@@ -292,11 +325,11 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co
|
||||
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut first_events = events(&first);
|
||||
let mut second_events = events(&second);
|
||||
assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
let pending = harness.next().await;
|
||||
for _ in 0..10 {
|
||||
assert!(second.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(second.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
}
|
||||
let commands = tokio::spawn({
|
||||
let first = first.clone();
|
||||
@@ -309,21 +342,21 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co
|
||||
assert_eq!(completed(&mut second_events).await, done);
|
||||
commands.await.unwrap().unwrap();
|
||||
for force in [false, true, false, true] {
|
||||
assert!(!second.refresh_models(PROVIDER, force).unwrap().refreshing);
|
||||
assert!(!second.refresh_models(PROVIDER, force, None).unwrap().refreshing);
|
||||
}
|
||||
advance(&catalogs, 29);
|
||||
assert!(!first.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
advance(&catalogs, 1);
|
||||
assert!(!first.refresh_models(PROVIDER, false).unwrap().refreshing, "automatic refresh remains fresh");
|
||||
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!first.refresh_models(PROVIDER, false, None).unwrap().refreshing, "automatic refresh remains fresh");
|
||||
assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["two"], &["high"]))).unwrap();
|
||||
let newer = completed(&mut first_events).await;
|
||||
assert_eq!(model_values(&newer), ["two"]);
|
||||
assert_eq!(completed(&mut second_events).await, newer);
|
||||
advance(&catalogs, 15 * 60 - 1);
|
||||
assert!(!second.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(!second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
advance(&catalogs, 1);
|
||||
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["three"], &["low"]))).unwrap();
|
||||
completed(&mut first_events).await;
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 3);
|
||||
@@ -337,25 +370,25 @@ async fn failure_keeps_successful_choices_and_throttles_manual_and_auto_retries(
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, true).unwrap();
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["cached"], &["low"]))).unwrap();
|
||||
let success = completed(&mut events).await;
|
||||
let disk = std::fs::read(tmp.path().join("models.json")).unwrap();
|
||||
advance(&catalogs, 15 * 60);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Err("Authentication expired".into())).unwrap();
|
||||
let failed = completed(&mut events).await;
|
||||
assert_eq!(failed.config, success.config);
|
||||
assert_eq!(failed.thought_levels, success.thought_levels);
|
||||
assert_eq!(failed.refreshed_at_ms, success.refreshed_at_ms);
|
||||
assert!(failed.error.as_deref().unwrap().contains("Authentication expired"));
|
||||
assert!(failed.error.as_deref().unwrap().contains("Sign in required"));
|
||||
assert_eq!(std::fs::read(tmp.path().join("models.json")).unwrap(), disk);
|
||||
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
advance(&catalogs, 29);
|
||||
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
advance(&catalogs, 1);
|
||||
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["recovered"], &["high"]))).unwrap();
|
||||
let recovered = completed(&mut events).await;
|
||||
assert_eq!(model_values(&recovered), ["recovered"]);
|
||||
@@ -370,21 +403,21 @@ async fn timeout_cleans_up_and_enters_the_same_failure_cooldown() {
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let pending = harness.next().await;
|
||||
tokio::time::pause();
|
||||
tokio::time::advance(Duration::from_secs(4)).await;
|
||||
let failed = completed(&mut events).await;
|
||||
assert!(failed.error.as_deref().unwrap().contains("time"));
|
||||
assert!(failed.retry_at_ms.is_some());
|
||||
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
tokio::time::resume();
|
||||
stopped(&harness).await;
|
||||
assert_eq!(harness.live.load(Ordering::SeqCst), 0, "timed-out connection must close");
|
||||
assert!(pending.reply.is_closed());
|
||||
advance(&catalogs, 30);
|
||||
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["retry"], &["low"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
}
|
||||
@@ -398,16 +431,16 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() {
|
||||
let first = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&second);
|
||||
first.refresh_models(PROVIDER, false).unwrap();
|
||||
first.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
configure(tmp.path(), "two");
|
||||
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
let latest = harness.next().await;
|
||||
latest.reply.send(Ok(response(&["latest"], &["high"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"])));
|
||||
stopped(&harness).await;
|
||||
let shown = first.refresh_models(PROVIDER, false).unwrap();
|
||||
let shown = first.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert_eq!(shown.config, fresh.config);
|
||||
assert_eq!(shown.refreshed_at_ms, fresh.refreshed_at_ms);
|
||||
assert!(!shown.refreshing);
|
||||
@@ -415,7 +448,7 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() {
|
||||
assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete"));
|
||||
// A changed configuration also invalidates successful freshness/cooldown.
|
||||
configure(tmp.path(), "three");
|
||||
assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["new-config"], &["medium"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
}
|
||||
@@ -425,7 +458,7 @@ async fn invalid_provider_is_a_request_error_and_does_not_launch() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
assert!(manager.refresh_models("missing-provider", true).is_err());
|
||||
assert!(manager.refresh_models("missing-provider", true, None).is_err());
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 0);
|
||||
}
|
||||
|
||||
@@ -437,18 +470,18 @@ async fn replacing_the_executable_at_the_same_path_invalidates_freshness_and_obs
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs, &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
std::fs::write(tmp.path().join("catalog-test-bin"), "replacement executable with different size").unwrap();
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let latest = harness.next().await;
|
||||
latest.reply.send(Ok(response(&["updated"], &["high"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"])));
|
||||
stopped(&harness).await;
|
||||
assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config);
|
||||
assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config);
|
||||
std::fs::write(tmp.path().join("catalog-test-bin"), "another executable").unwrap();
|
||||
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["new-install"], &["medium"]))).unwrap();
|
||||
assert_eq!(model_values(&completed(&mut events).await), ["new-install"]);
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 3);
|
||||
@@ -468,18 +501,18 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts()
|
||||
let second = make_manager_at(&b, &models_file, catalogs, &harness);
|
||||
let mut first_events = events(&first);
|
||||
let mut second_events = events(&second);
|
||||
first.refresh_models(PROVIDER, false).unwrap();
|
||||
first.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["account-a-model"], &["low"]))).unwrap();
|
||||
let a_catalog = completed(&mut first_events).await;
|
||||
second.refresh_models(PROVIDER, false).unwrap();
|
||||
second.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["account-b-model"], &["high"]))).unwrap();
|
||||
let b_catalog = completed(&mut second_events).await;
|
||||
assert_eq!(first.refresh_models(PROVIDER, false).unwrap().config, a_catalog.config);
|
||||
assert_eq!(second.refresh_models(PROVIDER, false).unwrap().config, b_catalog.config);
|
||||
assert_eq!(first.refresh_models(PROVIDER, false, None).unwrap().config, a_catalog.config);
|
||||
assert_eq!(second.refresh_models(PROVIDER, false, None).unwrap().config, b_catalog.config);
|
||||
assert_eq!(first.providers().into_iter().find(|p| p.id == PROVIDER).unwrap().config, a_catalog.config);
|
||||
for (root, expected) in [(&a, &a_catalog), (&b, &b_catalog)] {
|
||||
let restored = make_manager_at(root, &models_file, Arc::default(), &harness);
|
||||
let cached = restored.refresh_models(PROVIDER, false).unwrap();
|
||||
let cached = restored.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert!(!cached.refreshing, "matching persisted context should retain freshness");
|
||||
assert_eq!(cached.config, expected.config);
|
||||
assert_eq!(cached.refreshed_at_ms, expected.refreshed_at_ms);
|
||||
@@ -488,7 +521,7 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts()
|
||||
configure(&a, "new-account");
|
||||
let changed = make_manager_at(&a, &models_file, Arc::default(), &harness);
|
||||
let mut events = events(&changed);
|
||||
let stale = changed.refresh_models(PROVIDER, false).unwrap();
|
||||
let stale = changed.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert!(stale.refreshing, "a different launch environment cannot reuse persisted freshness");
|
||||
assert!(stale.refreshed_at_ms.is_none());
|
||||
assert_eq!(stale.config, a_catalog.config, "stale cached choices remain selectable");
|
||||
@@ -505,7 +538,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
configure(tmp.path(), "after");
|
||||
obsolete.reply.send(Ok(response(&["obsolete"], &["low"]))).unwrap();
|
||||
@@ -513,7 +546,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove
|
||||
assert!(model_values(&discarded).is_empty());
|
||||
assert!(discarded.refreshed_at_ms.is_none());
|
||||
assert!(!tmp.path().join("models.json").exists());
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["current"], &["high"]))).unwrap();
|
||||
assert_eq!(model_values(&completed(&mut events).await), ["current"]);
|
||||
}
|
||||
@@ -526,13 +559,296 @@ async fn successful_empty_catalog_removes_all_previous_models_and_efforts() {
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, true).unwrap();
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["removed"], &["low"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
advance(&catalogs, 30);
|
||||
manager.refresh_models(PROVIDER, true).unwrap();
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&[], &[]))).unwrap();
|
||||
let empty = completed(&mut events).await;
|
||||
assert!(model_values(&empty).is_empty() && empty.thought_levels.is_empty());
|
||||
assert!(empty.refreshed_at_ms.is_some() && empty.error.is_none());
|
||||
}
|
||||
|
||||
fn selected_response(model: &str, effort: &[&str]) -> Value {
|
||||
let mut result = response(&[model], effort);
|
||||
if effort.is_empty() {
|
||||
result["configOptions"].as_array_mut().unwrap().retain(|option| option["id"] != "effort");
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn config_notification(session: &str, result: &Value) -> Value {
|
||||
json!({ "jsonrpc": "2.0", "method": "session/update", "params": {
|
||||
"sessionId": session,
|
||||
"update": { "sessionUpdate": "config_option_update", "configOptions": result["configOptions"] }
|
||||
} })
|
||||
}
|
||||
|
||||
fn efforts<'a>(catalog: &'a AgentModelCatalog, model: &str) -> Vec<&'a str> {
|
||||
catalog.thought_levels[model]
|
||||
.iter()
|
||||
.filter(|option| option.category.as_deref() == Some("thought_level"))
|
||||
.flat_map(|option| option.values.iter().map(|value| value.value.as_str()))
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn selected_models_report_their_own_controls_before_any_task_or_prompt() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let models = ["default", "second", "plain", "unknown"];
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
|
||||
let original = completed(&mut events).await;
|
||||
assert!(!original.thought_levels.contains_key("second"));
|
||||
|
||||
// A fresh catalog and its global cooldown must not delay an unknown selection.
|
||||
assert!(manager.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
|
||||
let pending = harness.next().await;
|
||||
assert_eq!(pending.method, "session/set_config_option");
|
||||
assert_eq!(pending.params, json!({ "sessionId": "discovery-only", "configId": "model", "value": "second" }));
|
||||
let mut second = selected_response("second", &["off", "auto", "max"]);
|
||||
second["configOptions"].as_array_mut().unwrap().push(json!({
|
||||
"id": "context_tier", "type": "select", "currentValue": "large",
|
||||
"options": [{ "value": "normal" }, { "value": "large" }]
|
||||
}));
|
||||
pending.reply.send(Ok(second)).unwrap();
|
||||
let learned = completed(&mut events).await;
|
||||
assert_eq!(learned.config, original.config, "selection discovery never changes the default model");
|
||||
assert_eq!(efforts(&learned, "default"), ["low", "high"]);
|
||||
assert_eq!(efforts(&learned, "second"), ["off", "auto", "max"]);
|
||||
assert!(learned.thought_levels["second"].iter().any(|option| option.id == "context_tier"));
|
||||
assert!(!learned.thought_levels.contains_key("unknown"));
|
||||
|
||||
manager.refresh_models(PROVIDER, false, Some("plain")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
|
||||
harness.next().await.reply.send(Ok(selected_response("plain", &[]))).unwrap();
|
||||
let plain = completed(&mut events).await;
|
||||
assert!(plain.thought_levels["plain"].is_empty(), "an authoritative no-control result is cached");
|
||||
for model in ["default", "second", "plain"] {
|
||||
assert!(!manager.refresh_models(PROVIDER, false, Some(model)).unwrap().refreshing);
|
||||
}
|
||||
let restored = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let cached = restored.refresh_models(PROVIDER, false, Some("plain")).unwrap();
|
||||
assert!(!cached.refreshing);
|
||||
assert!(cached.thought_levels["plain"].is_empty());
|
||||
assert_eq!(efforts(&cached, "second"), ["off", "auto", "max"]);
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "never iterate unselected models");
|
||||
assert!(!tmp.path().join("store").exists(), "no task or prompt is needed");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn missing_or_failed_selected_settings_remain_unknown_and_have_model_scoped_retry_cooldowns() {
|
||||
for reply in [Ok(json!({})), Ok(selected_response("default", &["wrong"])), Err("token=secret-one".into())] {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
let models = ["default", "unsupported", "other"];
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
let original = completed(&mut events).await;
|
||||
manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
harness.next().await.reply.send(reply).unwrap();
|
||||
let failed = completed(&mut events).await;
|
||||
assert_eq!(failed.config, original.config);
|
||||
assert!(!failed.thought_levels.contains_key("unsupported"));
|
||||
assert!(failed.error.is_some() && failed.retry_at_ms.is_some());
|
||||
assert!(!failed.error.as_deref().unwrap().contains("secret-one"));
|
||||
assert!(!manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing);
|
||||
// The failed model cannot block another model, and its cooldown survives that success.
|
||||
assert!(manager.refresh_models(PROVIDER, false, Some("other")).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
harness.next().await.reply.send(Ok(selected_response("other", &[]))).unwrap();
|
||||
assert!(completed(&mut events).await.error.is_none());
|
||||
assert!(!manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap().refreshing);
|
||||
advance(&catalogs, 30);
|
||||
assert!(manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
harness.next().await.reply.send(Ok(selected_response("unsupported", &["high"]))).unwrap();
|
||||
let retried = completed(&mut events).await;
|
||||
assert_eq!(efforts(&retried, "unsupported"), ["high"]);
|
||||
assert!(retried.error.is_none());
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rapid_model_selections_share_the_current_flight_and_discard_superseded_results() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let mut harness = Harness::new();
|
||||
let first = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&first);
|
||||
let models = ["default", "second", "third"];
|
||||
first.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
first.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
for _ in 0..5 {
|
||||
assert!(second.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing);
|
||||
}
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 2);
|
||||
second.refresh_models(PROVIDER, false, Some("third")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
let current = harness.next().await;
|
||||
assert_eq!(current.params["value"], "third");
|
||||
current.reply.send(Ok(selected_response("third", &["max"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
let _ = obsolete.reply.send(Ok(selected_response("second", &["obsolete"])));
|
||||
stopped(&harness).await;
|
||||
let cached = first.refresh_models(PROVIDER, false, Some("third")).unwrap();
|
||||
assert_eq!(cached, fresh);
|
||||
assert_eq!(efforts(&cached, "third"), ["max"]);
|
||||
assert!(!cached.thought_levels.contains_key("second"));
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "no stale requests are queued");
|
||||
assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn switching_back_to_a_known_model_cancels_the_unknown_model_flight() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
let known = manager.refresh_models(PROVIDER, false, Some("default")).unwrap();
|
||||
assert!(!known.refreshing);
|
||||
assert_eq!(completed(&mut events).await, known, "other subscribers also leave loading state");
|
||||
let _ = obsolete.reply.send(Err("late failure".into()));
|
||||
stopped(&harness).await;
|
||||
let cached = manager.refresh_models(PROVIDER, false, Some("default")).unwrap();
|
||||
assert!(cached.error.is_none() && !cached.thought_levels.contains_key("second"));
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 2);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn selected_model_uses_legacy_set_model_and_authoritative_notifications() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
// No cache is needed: the selected model is resolved in the same short-lived session.
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
harness
|
||||
.next()
|
||||
.await
|
||||
.reply
|
||||
.send(Ok(json!({
|
||||
"sessionId": "discovery-only",
|
||||
"models": { "currentModelId": "default", "availableModels": [
|
||||
{ "modelId": "default", "name": "Default" }, { "modelId": "second", "name": "Second" }
|
||||
] }
|
||||
})))
|
||||
.unwrap();
|
||||
let selected = harness.next().await;
|
||||
assert_eq!(selected.method, "session/set_model");
|
||||
assert_eq!(selected.params, json!({ "sessionId": "discovery-only", "modelId": "second" }));
|
||||
let notifications = selected.notifications;
|
||||
selected.reply.send(Ok(json!({}))).unwrap();
|
||||
notifications.send(config_notification("different-session", &selected_response("second", &["wrong"]))).unwrap();
|
||||
notifications
|
||||
.send(config_notification("discovery-only", &selected_response("second", &["medium", "high"])))
|
||||
.unwrap();
|
||||
let catalog = completed(&mut events).await;
|
||||
assert_eq!(efforts(&catalog, "second"), ["medium", "high"]);
|
||||
assert_eq!(catalog.config.iter().find(|option| option.id == "model").unwrap().current.as_deref(), Some("default"));
|
||||
assert!(!catalog.thought_levels.contains_key("default"), "legacy model lists alone do not assert no controls");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn selected_legacy_model_without_settings_has_no_levels_instead_of_failing() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
harness
|
||||
.next()
|
||||
.await
|
||||
.reply
|
||||
.send(Ok(json!({
|
||||
"sessionId": "discovery-only",
|
||||
"models": { "currentModelId": "default", "availableModels": [
|
||||
{ "modelId": "default", "name": "Default" }, { "modelId": "second", "name": "Second" }
|
||||
] }
|
||||
})))
|
||||
.unwrap();
|
||||
let selected = harness.next().await;
|
||||
assert_eq!(selected.method, "session/set_model");
|
||||
selected.reply.send(Ok(json!({}))).unwrap();
|
||||
let catalog = completed(&mut events).await;
|
||||
assert!(catalog.error.is_none(), "{:?}", catalog.error);
|
||||
assert_eq!(catalog.thought_levels.get("second"), Some(&Vec::new()));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn catalog_replacement_removes_selected_metadata_for_models_no_longer_listed() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap();
|
||||
harness.next().await.reply.send(Ok(selected_response("second", &["max"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
advance(&catalogs, 30);
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["default", "new"], &["medium"]))).unwrap();
|
||||
let replaced = completed(&mut events).await;
|
||||
assert_eq!(model_values(&replaced), ["default", "new"]);
|
||||
assert_eq!(efforts(&replaced, "default"), ["medium"]);
|
||||
assert!(!replaced.thought_levels.contains_key("second") && !replaced.thought_levels.contains_key("new"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn selected_model_discovery_uses_the_negotiated_v2_wire_format_and_config_updates() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::with_initialize(json!({
|
||||
"protocolVersion": 2, "info": { "name": "V2 Catalog Test" }, "capabilities": { "session": {} }
|
||||
}));
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
let mut initial = response(&["default", "second"], &["low"]);
|
||||
for option in initial["configOptions"].as_array_mut().unwrap() {
|
||||
option["configId"] = option.as_object_mut().unwrap().remove("id").unwrap();
|
||||
}
|
||||
harness.next().await.reply.send(Ok(initial)).unwrap();
|
||||
let selected = harness.next().await;
|
||||
assert_eq!(selected.method, "session/set_config_option");
|
||||
assert_eq!(
|
||||
selected.params,
|
||||
json!({
|
||||
"sessionId": "discovery-only", "configId": "model", "value": "second", "type": "id"
|
||||
})
|
||||
);
|
||||
// Notifications may arrive before the request response as well as after it.
|
||||
selected.notifications.send(config_notification("discovery-only", &selected_response("second", &[]))).unwrap();
|
||||
selected.reply.send(Ok(json!({}))).unwrap();
|
||||
let catalog = completed(&mut events).await;
|
||||
assert!(catalog.thought_levels["second"].is_empty());
|
||||
assert_eq!(efforts(&catalog, "default"), ["low"]);
|
||||
}
|
||||
+288
-305
@@ -70,6 +70,8 @@ pub(crate) const LIMITS_UPDATE: &str = "openidea_limits";
|
||||
/// A native agent's own update: the background tasks its session runs
|
||||
/// (see [`TaskState::background_tasks`]).
|
||||
pub(crate) const BACKGROUND_TASKS_UPDATE: &str = "openidea_background_tasks";
|
||||
/// A native agent's diagnostic, including warnings emitted before a session exists.
|
||||
pub(crate) const WARNING_NOTIFICATION: &str = "_openidea/warning";
|
||||
/// Referenced files up to this size are embedded in the prompt (when the agent takes it).
|
||||
const MAX_EMBED: u64 = 256 * 1024;
|
||||
/// How long a probe waits for the agent to answer `initialize`.
|
||||
@@ -208,20 +210,36 @@ impl Shared {
|
||||
}
|
||||
}
|
||||
|
||||
/// The MCP servers passed to a session, and the names of the ones off for it.
|
||||
fn mcp_servers_for_session(
|
||||
&self,
|
||||
provider: &str,
|
||||
init: &acp::Negotiated,
|
||||
overrides: &BTreeMap<String, bool>,
|
||||
) -> Vec<Value> {
|
||||
let mut servers = if overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false) {
|
||||
Vec::new()
|
||||
} else {
|
||||
mcp_servers_for(init.mcp_stdio(), &self.paths.project_root)
|
||||
};
|
||||
) -> McpForSession {
|
||||
let builtin_off = overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false);
|
||||
let mut servers =
|
||||
if builtin_off { Vec::new() } else { mcp_servers_for(init.mcp_stdio(), &self.paths.project_root) };
|
||||
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
|
||||
servers.extend(mcp::acp_mcp_servers(&configured, provider, init, overrides));
|
||||
servers
|
||||
let off = Self::mcp_off(&configured, provider, overrides);
|
||||
McpForSession { servers, off }
|
||||
}
|
||||
|
||||
fn mcp_servers_off_for_session(&self, provider: &str, overrides: &BTreeMap<String, bool>) -> Vec<String> {
|
||||
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
|
||||
Self::mcp_off(&configured, provider, overrides)
|
||||
}
|
||||
|
||||
fn mcp_off(configured: &[McpServer], provider: &str, overrides: &BTreeMap<String, bool>) -> Vec<String> {
|
||||
let mut off = mcp::servers_off(configured, provider, overrides);
|
||||
if overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false) {
|
||||
off.push(BUILTIN_SERVER.to_owned());
|
||||
off.push(mcp::BUILTIN_MCP_NAME.to_owned());
|
||||
off.sort();
|
||||
off.dedup();
|
||||
}
|
||||
off
|
||||
}
|
||||
|
||||
fn known_config(&self, provider: &str) -> Vec<AgentConfigOption> {
|
||||
@@ -358,6 +376,7 @@ struct TaskState {
|
||||
session_id: Option<String>,
|
||||
conversation: Conversation,
|
||||
wanted: Vec<AgentConfigChoice>,
|
||||
model_choice: u64,
|
||||
before: Arc<BTreeMap<String, worktree::Stamp>>,
|
||||
saved: Option<String>,
|
||||
/// See `TaskFile::touched`.
|
||||
@@ -367,11 +386,6 @@ struct TaskState {
|
||||
title_renamed: bool,
|
||||
/// A turn is running or about to (prompts arriving now are queued).
|
||||
busy: bool,
|
||||
/// A temporary side conversation: lives in memory only, never persisted.
|
||||
ephemeral: bool,
|
||||
/// The conversation a temporary side conversation starts with, sent to the agent with
|
||||
/// its first real message; the task's own entries hold only the questions.
|
||||
ephemeral_context: Option<String>,
|
||||
/// Background tasks the agent reported as running (`run_in_background` commands and
|
||||
/// the like), as it sent them: unlike a turn they outlive it, so an idle release
|
||||
/// waits for the last one. A (re)started process runs nothing yet.
|
||||
@@ -498,14 +512,8 @@ impl AgentManager {
|
||||
}
|
||||
|
||||
/// Routes events to `sink` (replacing the previous subscriber); returns every task.
|
||||
/// Ephemeral tasks belonged to the previous page session: a fresh one starts without them.
|
||||
pub fn subscribe(&self, sink: AgentSink) -> Vec<AgentTask> {
|
||||
*self.shared.sink.write() = Some(sink);
|
||||
let stale: Vec<Arc<Task>> = self.tasks.read().values().filter(|t| t.state.lock().ephemeral).cloned().collect();
|
||||
for task in &stale {
|
||||
self.drop_in_memory(task);
|
||||
self.shared.emit(AgentEvent::Removed { id: task.id.clone() });
|
||||
}
|
||||
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().task.clone()).collect();
|
||||
tasks.sort_by(|a, b| b.updated_ms.total_cmp(&a.updated_ms));
|
||||
tasks
|
||||
@@ -627,7 +635,7 @@ impl AgentManager {
|
||||
.into_iter()
|
||||
.find(|spec| spec.id == provider)
|
||||
{
|
||||
let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false);
|
||||
let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, None);
|
||||
if let Some(mut ready) = flight {
|
||||
while !*ready.borrow_and_update() {
|
||||
if ready.changed().await.is_err() {
|
||||
@@ -637,14 +645,9 @@ impl AgentManager {
|
||||
}
|
||||
offered = self.shared.known_commands(&provider);
|
||||
}
|
||||
for &(name, description) in builtin_commands(&provider) {
|
||||
if !offered.iter().any(|c| c.name == name) {
|
||||
offered.push(AgentCommand {
|
||||
name: name.to_owned(),
|
||||
description: description.to_owned(),
|
||||
hint: None,
|
||||
source: AgentCommandSource::Command,
|
||||
});
|
||||
for command in builtin_commands(&provider) {
|
||||
if !offered.iter().any(|c| c.name == command.name) {
|
||||
offered.push(command);
|
||||
}
|
||||
}
|
||||
if provider != "claude" && provider != "claude-acp" {
|
||||
@@ -737,7 +740,7 @@ impl AgentManager {
|
||||
background: Box::default(),
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
};
|
||||
let handle = self.register(TaskFile {
|
||||
let file = TaskFile {
|
||||
task: task.clone(),
|
||||
session_id: Some(session_id.to_owned()),
|
||||
entries: Vec::new(),
|
||||
@@ -748,7 +751,9 @@ impl AgentManager {
|
||||
subagents: Vec::new(),
|
||||
pending_rollback: 0,
|
||||
title_renamed: true,
|
||||
});
|
||||
};
|
||||
let handle = Task::restore(file, self.shared.clone());
|
||||
self.tasks.write().insert(task.id.clone(), handle.clone());
|
||||
handle.emit_task();
|
||||
handle.persist();
|
||||
Ok(task)
|
||||
@@ -786,8 +791,27 @@ impl AgentManager {
|
||||
(root, None, base, commit, before)
|
||||
}
|
||||
};
|
||||
// The session's settings: what the agent offered last time, with the choices applied.
|
||||
let config = self.merged_config(&spec.id, &req.config);
|
||||
// Until the session reports its own, show what the agent offered last time with the choices applied.
|
||||
let catalog = self.shared.paths.catalogs.cached(&self.shared, &spec.id);
|
||||
let mut levels = catalog.thought_levels;
|
||||
let mut config = self.shared.config_for_new_task(catalog.config, &spec.id);
|
||||
for choice in &req.config {
|
||||
if let Some(o) = config.iter_mut().find(|o| o.id == choice.id) {
|
||||
o.current = Some(choice.value.clone());
|
||||
}
|
||||
}
|
||||
if let Some(model) = model_of(&config)
|
||||
&& let Some(levels) = levels.remove(&model)
|
||||
{
|
||||
config.extend(levels.into_iter().map(|mut o| {
|
||||
if let Some(choice) =
|
||||
req.config.iter().find(|c| c.id == o.id && o.values.iter().any(|v| v.value == c.value))
|
||||
{
|
||||
o.current = Some(choice.value.clone());
|
||||
}
|
||||
o
|
||||
}));
|
||||
}
|
||||
let now = now_ms();
|
||||
let id = uuid::Uuid::new_v4().simple().to_string();
|
||||
// Copies of the files the user had changed already, for rolling back the task's changes to them.
|
||||
@@ -829,7 +853,7 @@ impl AgentManager {
|
||||
background: Box::default(),
|
||||
mcp_overrides: req.mcp_overrides,
|
||||
};
|
||||
let handle = self.register(TaskFile {
|
||||
let file = TaskFile {
|
||||
task: task.clone(),
|
||||
session_id: None,
|
||||
entries: Vec::new(),
|
||||
@@ -840,118 +864,16 @@ impl AgentManager {
|
||||
subagents: Vec::new(),
|
||||
pending_rollback: 0,
|
||||
title_renamed: false,
|
||||
});
|
||||
};
|
||||
let handle = Task::restore(file, self.shared.clone());
|
||||
handle.state.lock().busy = true;
|
||||
self.tasks.write().insert(task.id.clone(), handle.clone());
|
||||
handle.emit_task();
|
||||
handle.persist();
|
||||
self.shared.runtime.spawn(async move { handle.run(prompt).await });
|
||||
Ok(task)
|
||||
}
|
||||
|
||||
/// Builds the in-memory handle of a fresh task, registers it and announces it. The
|
||||
/// caller decides what else its life starts with (a persisted file, a session, a run).
|
||||
fn register(&self, file: TaskFile) -> Arc<Task> {
|
||||
let handle = Task::restore(file, self.shared.clone());
|
||||
self.tasks.write().insert(handle.id.clone(), handle.clone());
|
||||
handle.emit_task();
|
||||
handle
|
||||
}
|
||||
|
||||
/// The session's settings: what the agent offered last time, with the request's
|
||||
/// choices — and the chosen model's thought levels — applied.
|
||||
fn merged_config(&self, provider: &str, req: &[AgentConfigChoice]) -> Vec<AgentConfigOption> {
|
||||
let catalog = self.shared.paths.catalogs.cached(&self.shared, provider);
|
||||
let mut levels = catalog.thought_levels;
|
||||
let mut config = self.shared.config_for_new_task(catalog.config, provider);
|
||||
for choice in req {
|
||||
if let Some(o) = config.iter_mut().find(|o| o.id == choice.id) {
|
||||
o.current = Some(choice.value.clone());
|
||||
}
|
||||
}
|
||||
if let Some(model) = model_of(&config)
|
||||
&& let Some(levels) = levels.remove(&model)
|
||||
{
|
||||
config.extend(levels.into_iter().map(|mut o| {
|
||||
if let Some(choice) = req.iter().find(|c| c.id == o.id && o.values.iter().any(|v| v.value == c.value)) {
|
||||
o.current = Some(choice.value.clone());
|
||||
}
|
||||
o
|
||||
}));
|
||||
}
|
||||
config
|
||||
}
|
||||
|
||||
/// Creates a temporary side conversation of `source`: an in-memory task that is never
|
||||
/// persisted, whose session starts with its first real message (`prompt` only names
|
||||
/// the title). `source`'s conversation rides along as the context of that message.
|
||||
/// The task is read-only: its settings are pushed to a mode that asks before anything,
|
||||
/// and requests that would change the project are denied regardless. Fails for an
|
||||
/// agent that offers no way to ask.
|
||||
pub async fn create_ephemeral(&self, req: NewAgentTask, source: &str) -> IdeResult<AgentTask> {
|
||||
let spec = self
|
||||
.shared
|
||||
.spec(&req.provider)
|
||||
.ok_or_else(|| IdeError::invalid(format!("unknown agent {}", req.provider)))?;
|
||||
let prompt = clean(req.prompt).ok_or_else(|| IdeError::invalid("describe the topic first"))?;
|
||||
let title = title_of(&prompt);
|
||||
let mut config = self.merged_config(&spec.id, &req.config);
|
||||
config::ask_for_approvals(&mut config);
|
||||
if config::bypass_approvals(&config) {
|
||||
return Err(IdeError::invalid(
|
||||
"this agent has no mode that asks before changing things, so it can't run a side conversation",
|
||||
));
|
||||
}
|
||||
let read_only = !config::bypass_approvals(&config);
|
||||
let context = context_transcript(&self.task(source)?.state.lock().conversation.main.entries);
|
||||
let root = self.shared.paths.project_root.clone();
|
||||
let before = blocking(move || Ok(worktree::snapshot(&root).unwrap_or_default())).await?;
|
||||
let now = now_ms();
|
||||
let mut capabilities = self.shared.probes.lock().get(&spec.id).map(|p| p.capabilities).unwrap_or_default();
|
||||
capabilities.read_only = read_only;
|
||||
let task = AgentTask {
|
||||
project_root: Some(IpcPath(self.shared.paths.project_root.clone())),
|
||||
id: uuid::Uuid::new_v4().simple().to_string(),
|
||||
title,
|
||||
provider: spec.id.clone(),
|
||||
model: model_of(&config),
|
||||
status: AgentStatus::Ready,
|
||||
isolation: Isolation::Local,
|
||||
cwd: IpcPath(self.shared.paths.project_root.clone()),
|
||||
branch: None,
|
||||
base: None,
|
||||
base_commit: None,
|
||||
error: None,
|
||||
created_ms: now,
|
||||
updated_ms: now,
|
||||
commands: self.shared.known_commands(&spec.id),
|
||||
usage: None,
|
||||
queue: Vec::new(),
|
||||
capabilities,
|
||||
resets_ms: None,
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: req.mcp_overrides,
|
||||
config,
|
||||
};
|
||||
let handle = self.register(TaskFile {
|
||||
task: task.clone(),
|
||||
session_id: None,
|
||||
entries: Vec::new(),
|
||||
wanted: req.config,
|
||||
before,
|
||||
saved: None,
|
||||
touched: None,
|
||||
subagents: Vec::new(),
|
||||
pending_rollback: 0,
|
||||
title_renamed: false,
|
||||
});
|
||||
{
|
||||
let mut s = handle.state.lock();
|
||||
s.ephemeral = true;
|
||||
s.ephemeral_context = Some(context);
|
||||
}
|
||||
Ok(task)
|
||||
}
|
||||
|
||||
/// Sends a message. While the agent works it is queued, or with `now` the current turn
|
||||
/// is cancelled and the message goes next.
|
||||
pub async fn prompt(&self, id: &str, prompt: AgentPrompt, now: bool) -> IdeResult<()> {
|
||||
@@ -1013,29 +935,50 @@ impl AgentManager {
|
||||
Ok(item)
|
||||
}
|
||||
|
||||
/// Sends queued message `queued` next, cancelling the current turn if there is one.
|
||||
pub fn send_queued_now(&self, id: &str, queued: &str) -> IdeResult<()> {
|
||||
/// Sends queued message `queued` now: into the running turn when the agent takes
|
||||
/// messages mid-turn, else next, cancelling the current turn if there is one.
|
||||
pub async fn send_queued_now(&self, id: &str, queued: &str) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
let idle = {
|
||||
let (item, busy) = {
|
||||
let mut s = task.state.lock();
|
||||
let i =
|
||||
s.task.queue.iter().position(|q| q.id == queued).ok_or_else(|| IdeError::not_found("already sent"))?;
|
||||
let item = s.task.queue.remove(i);
|
||||
if s.busy {
|
||||
s.task.queue.insert(0, item);
|
||||
None
|
||||
} else {
|
||||
let busy = s.busy;
|
||||
if !busy {
|
||||
s.busy = true;
|
||||
Some(item)
|
||||
}
|
||||
(item, busy)
|
||||
};
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
match idle {
|
||||
Some(item) => {
|
||||
self.shared.runtime.spawn(async move { task.run(item.prompt).await });
|
||||
if !busy {
|
||||
self.shared.runtime.spawn(async move { task.run(item.prompt).await });
|
||||
return Ok(());
|
||||
}
|
||||
// Out of the queue while it is steered, so the turn ending meanwhile doesn't send it twice.
|
||||
let prompt = match task.steer(item.prompt).await {
|
||||
Ok(()) => return Ok(()),
|
||||
Err(prompt) => prompt,
|
||||
};
|
||||
let start = {
|
||||
let mut s = task.state.lock();
|
||||
if s.busy {
|
||||
s.task.queue.insert(0, AgentQueued { id: item.id, prompt });
|
||||
None
|
||||
} else {
|
||||
// The turn ended while steering was tried: nothing is left to interrupt.
|
||||
s.busy = true;
|
||||
Some(prompt)
|
||||
}
|
||||
};
|
||||
match start {
|
||||
Some(prompt) => {
|
||||
self.shared.runtime.spawn(async move { task.run(prompt).await });
|
||||
}
|
||||
None => {
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
task.send_now.store(true, Ordering::Release);
|
||||
task.cancel();
|
||||
}
|
||||
@@ -1046,19 +989,36 @@ impl AgentManager {
|
||||
/// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts.
|
||||
pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
let target = {
|
||||
let s = task.state.lock();
|
||||
let o =
|
||||
s.task.config.iter().find(|o| o.id == option).ok_or_else(|| IdeError::not_found("no such setting"))?;
|
||||
if !o.values.iter().any(|v| v.value == value) {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", o.name)));
|
||||
let (target, model_choice, previous_levels) = {
|
||||
let mut s = task.state.lock();
|
||||
let target = s
|
||||
.task
|
||||
.config
|
||||
.iter()
|
||||
.find(|o| o.id == option)
|
||||
.ok_or_else(|| IdeError::not_found("no such setting"))?
|
||||
.clone();
|
||||
if !target.values.iter().any(|v| v.value == value) {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
}
|
||||
o.clone()
|
||||
if target.category.as_deref() == Some("model") {
|
||||
s.model_choice += 1;
|
||||
}
|
||||
let previous_levels =
|
||||
if target.category.as_deref() == Some("model") && target.current.as_deref() != Some(value.as_str()) {
|
||||
Some(s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>())
|
||||
} else {
|
||||
None
|
||||
};
|
||||
s.wanted.retain(|c| c.id != option);
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
|
||||
s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current = Some(value.clone());
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
(target, s.model_choice, previous_levels)
|
||||
};
|
||||
let previous = target.current.clone();
|
||||
// Cursor's `session/set_config_option` (Fast, effort) can take seconds. Show the
|
||||
// choice first so the switch and slider move immediately.
|
||||
apply_config_choice(&task, option, &value);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
|
||||
@@ -1068,36 +1028,77 @@ impl AgentManager {
|
||||
let mut model_options = (target.category.as_deref() != Some("model")
|
||||
|| previous.as_deref() == Some(value.as_str()))
|
||||
&& task.state.lock().task.config.iter().any(config::is_per_model_option);
|
||||
if live.is_none()
|
||||
&& target.category.as_deref() == Some("model")
|
||||
&& (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);
|
||||
}
|
||||
// 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 mut s = task.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
s.task.config.retain(|o| !config::is_per_model_option(o));
|
||||
s.task.config.extend(levels);
|
||||
model_options = true;
|
||||
}
|
||||
if let Some(live) = live.filter(|_| option != config::CURSOR_APPROVAL) {
|
||||
let (method, mut params) = config::set_request(&target, &value);
|
||||
params["sessionId"] = json!(live.session);
|
||||
let reply: Value = match live.peer.request(method, params, None).await {
|
||||
Ok(reply) => reply,
|
||||
Err(e) => {
|
||||
{
|
||||
let mut s = task.state.lock();
|
||||
s.wanted.retain(|c| c.id != option);
|
||||
if let Some(prev) = previous.clone() {
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: prev });
|
||||
}
|
||||
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
|
||||
o.current = previous.clone();
|
||||
}
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
}
|
||||
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
return Err(IdeError::internal(task.describe(e)));
|
||||
}
|
||||
};
|
||||
if target.category.as_deref() == Some("model") && task.state.lock().model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if let Some(options) = reply.get("configOptions") {
|
||||
config::merge_update(&mut task.state.lock().task.config, options);
|
||||
model_options = true;
|
||||
} else if target.category.as_deref() == Some("model") {
|
||||
// Old model controls were removed above, so these came from an update
|
||||
// that preceded the response.
|
||||
model_options = task.state.lock().task.config.iter().any(config::is_per_model_option);
|
||||
}
|
||||
}
|
||||
{
|
||||
let mut s = task.state.lock();
|
||||
if !model_options {
|
||||
if target.category.as_deref() == Some("model") && s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if !model_options && target.category.as_deref() == Some("model") {
|
||||
s.task.config.retain(|o| !config::is_per_model_option(o));
|
||||
}
|
||||
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
|
||||
@@ -1141,7 +1142,11 @@ impl AgentManager {
|
||||
.peer
|
||||
.request(
|
||||
"session/fork",
|
||||
json!({ "sessionId": live.session, "cwd": cwd_s, "mcpServers": mcp_servers }),
|
||||
{
|
||||
let mut params = session_params(&cwd_s, &mcp_servers);
|
||||
params["sessionId"] = json!(live.session);
|
||||
params
|
||||
},
|
||||
None,
|
||||
)
|
||||
.await
|
||||
@@ -1412,15 +1417,6 @@ impl AgentManager {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Removes a task from the manager's table and stops its agent. The disk (its file,
|
||||
/// its worktree) is the caller's business.
|
||||
fn drop_in_memory(&self, task: &Arc<Task>) {
|
||||
task.kill();
|
||||
self.tasks.write().remove(&task.id);
|
||||
*task.deleted.lock() = true;
|
||||
let _ = std::fs::remove_file(self.shared.paths.store_dir.join(format!("{}.json", task.id)));
|
||||
}
|
||||
|
||||
/// Returns an archived task to the active list without starting the agent.
|
||||
pub fn unarchive(&self, id: &str) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
@@ -1656,6 +1652,26 @@ impl AgentManager {
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Recycles idle resumable live sessions (or schedules reload after the running turn) when
|
||||
/// global, workspace, or built-in IDE MCP server settings change.
|
||||
pub fn notify_mcp_servers_changed(&self) {
|
||||
let tasks: Vec<Arc<Task>> = self.tasks.read().values().cloned().collect();
|
||||
for task in tasks {
|
||||
let (archived, busy, has_bg) = {
|
||||
let s = task.state.lock();
|
||||
(s.task.status == AgentStatus::Archived, s.busy, !s.background_tasks.is_empty())
|
||||
};
|
||||
if archived {
|
||||
continue;
|
||||
}
|
||||
if busy || has_bg || !task.permissions.lock().is_empty() {
|
||||
task.mcp_reload_pending.store(true, Ordering::Release);
|
||||
} else {
|
||||
task.recycle_resumable_session();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Stops every agent (project closed).
|
||||
pub fn shutdown(&self) {
|
||||
for task in self.tasks.read().values() {
|
||||
@@ -1680,14 +1696,13 @@ impl Task {
|
||||
session_id: file.session_id,
|
||||
conversation,
|
||||
wanted: file.wanted,
|
||||
model_choice: 0,
|
||||
before: Arc::new(file.before),
|
||||
saved: file.saved,
|
||||
touched: file.touched.map(Arc::new),
|
||||
pending_rollback: file.pending_rollback,
|
||||
title_renamed: file.title_renamed,
|
||||
busy: false,
|
||||
ephemeral: false,
|
||||
ephemeral_context: None,
|
||||
background_tasks: Vec::new(),
|
||||
}),
|
||||
live: Mutex::new(None),
|
||||
@@ -1847,9 +1862,6 @@ impl Task {
|
||||
if *deleted {
|
||||
return;
|
||||
}
|
||||
if self.state.lock().ephemeral {
|
||||
return;
|
||||
}
|
||||
let bytes = {
|
||||
let s = self.state.lock();
|
||||
serde_json::to_vec(&TaskFile {
|
||||
@@ -2119,20 +2131,7 @@ impl Task {
|
||||
if !prompt.images.is_empty() && !live.capabilities.images {
|
||||
return Err(Failure::from("This agent can't read images.".to_owned()));
|
||||
}
|
||||
// A temporary side conversation's context rides with its first real message; the
|
||||
// conversation itself records only the question (and whatever comes after).
|
||||
let prompt = {
|
||||
let context = self.state.lock().ephemeral_context.take();
|
||||
match context {
|
||||
Some(context) => {
|
||||
let mut owned = prompt.clone();
|
||||
owned.text = format!("{context}\n\n---\n\n{}", owned.text);
|
||||
owned
|
||||
}
|
||||
None => prompt.clone(),
|
||||
}
|
||||
};
|
||||
let mut content = self.content(&live, &prompt).await;
|
||||
let mut content = self.content(&live, prompt).await;
|
||||
let mut result: Result<Value, RpcError> =
|
||||
live.peer.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None).await;
|
||||
if live.driver == provider::Driver::Copilot
|
||||
@@ -2154,7 +2153,7 @@ impl Task {
|
||||
if !prompt.images.is_empty() && !live.capabilities.images {
|
||||
return Err(Failure::from("This agent can't read images.".to_owned()));
|
||||
}
|
||||
content = self.content(&live, &prompt).await;
|
||||
content = self.content(&live, prompt).await;
|
||||
result = live
|
||||
.peer
|
||||
.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None)
|
||||
@@ -2273,9 +2272,16 @@ impl Task {
|
||||
saved: Option<String>,
|
||||
) -> Result<Live, SessionOpenError> {
|
||||
let launch_cwd = cwd.to_path_buf();
|
||||
let spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
.await
|
||||
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?;
|
||||
if spec.driver == provider::Driver::Acp && provider::is_copilot_provider(provider_id) {
|
||||
let mcp_overrides = self.state.lock().task.mcp_overrides.clone();
|
||||
for name in self.shared.mcp_servers_off_for_session(provider_id, &mcp_overrides) {
|
||||
spec.args.push("--disable-mcp-server".into());
|
||||
spec.args.push(name);
|
||||
}
|
||||
}
|
||||
self.stderr.lock().clear();
|
||||
self.config_sent.lock().clear();
|
||||
let weak = Arc::downgrade(self);
|
||||
@@ -2314,7 +2320,8 @@ impl Task {
|
||||
let mut session = None;
|
||||
if let (Some(id), true) = (saved, can_load) {
|
||||
self.replaying.store(true, Ordering::Release);
|
||||
let params = json!({ "sessionId": &id, "cwd": &cwd_s, "mcpServers": &mcp_servers });
|
||||
let mut params = session_params(&cwd_s, &mcp_servers);
|
||||
params["sessionId"] = json!(&id);
|
||||
let loaded = self.request_with_auth(&peer, &init, &mut tried_auth, "session/load", params).await;
|
||||
tokio::time::sleep(REPLAY_GRACE).await;
|
||||
self.replaying.store(false, Ordering::Release);
|
||||
@@ -2327,7 +2334,7 @@ impl Task {
|
||||
let (session_id, result) = match session {
|
||||
Some(s) => s,
|
||||
None => {
|
||||
let params = json!({ "cwd": &cwd_s, "mcpServers": &mcp_servers });
|
||||
let params = session_params(&cwd_s, &mcp_servers);
|
||||
let v = self.request_with_auth(&peer, &init, &mut tried_auth, "session/new", params).await.map_err(
|
||||
|e| match self.sign_in_error(&e, Some(&sign_in_message)) {
|
||||
Some(msg) => SessionOpenError { message: msg, allow_acp_fallback: false },
|
||||
@@ -2368,7 +2375,9 @@ impl Task {
|
||||
}
|
||||
let (mut options, mut wanted) = {
|
||||
let s = self.state.lock();
|
||||
(if known { reported } else { s.task.config.clone() }, s.wanted.clone())
|
||||
let options = if known { reported } else { s.task.config.clone() };
|
||||
let wanted = s.wanted.clone();
|
||||
(options, wanted)
|
||||
};
|
||||
config::add_client_options(provider_id, &mut options);
|
||||
// Changing model can replace the effort / context-tier choices; validate those only afterwards.
|
||||
@@ -2558,11 +2567,20 @@ impl Task {
|
||||
if let Some(title) = title {
|
||||
// Check and write under one lock: a rename landing between them would be lost.
|
||||
let mut s = self.state.lock();
|
||||
if !s.title_renamed && s.task.title != title {
|
||||
let user_named = update.get("userNamed").and_then(Value::as_bool) == Some(true);
|
||||
let flag_changed = user_named && !s.title_renamed;
|
||||
if user_named {
|
||||
s.title_renamed = true;
|
||||
}
|
||||
if (user_named || !s.title_renamed) && s.task.title != title {
|
||||
s.task.title = title.to_owned();
|
||||
drop(s);
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
} else if flag_changed {
|
||||
drop(s);
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
}
|
||||
}
|
||||
return;
|
||||
@@ -2667,30 +2685,6 @@ impl Task {
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
// A side conversation is read-only: deny anything that would change the project
|
||||
// (its task is deleted when its pane closes, leaving nothing to review or revert).
|
||||
if self.state.lock().ephemeral
|
||||
&& params
|
||||
.pointer("/toolCall/kind")
|
||||
.or_else(|| params.pointer("/subject/toolCall/kind"))
|
||||
.and_then(Value::as_str)
|
||||
.is_some_and(|kind| matches!(kind, "edit" | "delete" | "move" | "execute"))
|
||||
{
|
||||
let reject = options.iter().find(|o| o.kind.starts_with("reject")).cloned();
|
||||
let _ = self.push_entry(AgentEntry::Permission {
|
||||
id,
|
||||
title,
|
||||
command: None,
|
||||
options,
|
||||
questions: Vec::new(),
|
||||
form: None,
|
||||
chosen: Some("Denied: side conversations are read-only".to_owned()),
|
||||
});
|
||||
return match reject {
|
||||
Some(option) => json!({ "outcome": { "outcome": "selected", "optionId": option.id } }),
|
||||
None => json!({ "outcome": { "outcome": "cancelled" } }),
|
||||
};
|
||||
}
|
||||
let asked: Vec<String> = questions
|
||||
.iter()
|
||||
.map(|question| question.answer_key.clone().unwrap_or_else(|| question.question.clone()))
|
||||
@@ -2912,6 +2906,15 @@ struct Client {
|
||||
|
||||
impl Handler for Client {
|
||||
fn on_notification(&self, method: &str, params: Value) {
|
||||
if method == WARNING_NOTIFICATION {
|
||||
if let Some(task) = self.task.upgrade()
|
||||
&& let Some(message) = params.get("message").and_then(Value::as_str).filter(|s| !s.trim().is_empty())
|
||||
{
|
||||
task.push_entry(AgentEntry::Error { message: message.to_owned() });
|
||||
task.persist();
|
||||
}
|
||||
return;
|
||||
}
|
||||
if method == "session/update"
|
||||
&& let (Some(task), Some(update)) = (self.task.upgrade(), params.get("update"))
|
||||
{
|
||||
@@ -2943,72 +2946,6 @@ fn clean(mut prompt: AgentPrompt) -> Option<AgentPrompt> {
|
||||
(!prompt.text.is_empty() || !prompt.images.is_empty() || !prompt.files.is_empty()).then_some(prompt)
|
||||
}
|
||||
|
||||
/// The character budget of a side conversation's context: the newest entries win, the
|
||||
/// oldest are dropped first. Leaves room for the question and the agent's answer.
|
||||
const CONTEXT_BUDGET: usize = 100_000;
|
||||
|
||||
/// A long tool output trimmed to its first and last few lines, with the elided middle noted.
|
||||
fn trimmed_output(output: &str) -> String {
|
||||
const KEPT: usize = 4;
|
||||
let lines: Vec<&str> = output.lines().collect();
|
||||
if lines.len() <= KEPT * 2 + 1 {
|
||||
return output.to_owned();
|
||||
}
|
||||
let omitted = lines.len() - KEPT * 2;
|
||||
let mut out = lines[..KEPT].join("\n");
|
||||
out.push_str(&format!("\n… {omitted} lines omitted …\n"));
|
||||
out.push_str(&lines[lines.len() - KEPT..].join("\n"));
|
||||
out
|
||||
}
|
||||
|
||||
fn context_entry(e: &AgentEntry) -> Option<String> {
|
||||
match e {
|
||||
AgentEntry::User { text, .. } => Some(format!("User: {text}")),
|
||||
AgentEntry::Agent { text, .. } if !text.trim().is_empty() => Some(format!("Agent: {text}")),
|
||||
AgentEntry::Thought { text, .. } if !text.trim().is_empty() => Some(format!("Thought: {text}")),
|
||||
AgentEntry::Tool { title, output, .. } => match output.as_deref() {
|
||||
Some(output) if !output.trim().is_empty() => Some(format!("Tool: {title}\n{}", trimmed_output(output))),
|
||||
_ => Some(format!("Tool: {title}")),
|
||||
},
|
||||
AgentEntry::Error { message, .. } => Some(format!("Error: {message}")),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The conversation as the context a temporary side conversation starts with: what was
|
||||
/// said, what was done (tool calls with trimmed output), errors and the agent's reasoning,
|
||||
/// oldest first, within [`CONTEXT_BUDGET`].
|
||||
fn context_transcript(entries: &[AgentEntry]) -> String {
|
||||
// Newest wins: walk back until the budget is spent, dropping the oldest entries first.
|
||||
let mut lines: Vec<String> = Vec::new();
|
||||
let mut used = 0usize;
|
||||
for e in entries.iter().rev() {
|
||||
let Some(line) = context_entry(e) else { continue };
|
||||
if used + line.len() > CONTEXT_BUDGET {
|
||||
if lines.is_empty() {
|
||||
// Even the newest entry alone exceeds the budget: keep its head.
|
||||
lines.push(line.chars().take(CONTEXT_BUDGET).collect());
|
||||
}
|
||||
break;
|
||||
}
|
||||
used += line.len();
|
||||
lines.push(line);
|
||||
}
|
||||
lines.reverse();
|
||||
let dropped = entries.iter().rev().filter_map(context_entry).count() - lines.len();
|
||||
let mut context = String::from(
|
||||
"You are answering a side question in a temporary conversation. The conversation so far is below, \
|
||||
for context only; answer the new question after the marker, and do not continue the main task \
|
||||
unless asked.\n\n<conversation>\n",
|
||||
);
|
||||
if dropped > 0 {
|
||||
context.push_str(&format!("(The {dropped} oldest entries are omitted.)\n\n"));
|
||||
}
|
||||
context.push_str(&lines.join("\n\n"));
|
||||
context.push_str("\n</conversation>");
|
||||
context
|
||||
}
|
||||
|
||||
fn permission_title(params: &Value) -> String {
|
||||
let call = ¶ms["toolCall"];
|
||||
let title = call.get("title").and_then(Value::as_str).filter(|t| !t.is_empty());
|
||||
@@ -3105,7 +3042,7 @@ fn blocks(prompt: &AgentPrompt, contents: &[Option<String>]) -> Vec<Value> {
|
||||
});
|
||||
}
|
||||
for i in &prompt.images {
|
||||
out.push(json!({ "type": "image", "mimeType": i.mime_type, "data": i.data }));
|
||||
out.push(json!({ "type": "image", "mimeType": i.media_type(), "data": i.data }));
|
||||
}
|
||||
out
|
||||
}
|
||||
@@ -3227,7 +3164,6 @@ fn capabilities_of(init: &acp::Negotiated) -> (AgentCapabilities, bool) {
|
||||
rollback: meta("/openidea/rollback"),
|
||||
steer: steer_method(init).is_some(),
|
||||
background_tasks: meta("/openidea/backgroundTasks"),
|
||||
read_only: false,
|
||||
};
|
||||
(capabilities, init.prompt("embeddedContext"))
|
||||
}
|
||||
@@ -3242,6 +3178,23 @@ fn turn_starts(entries: &[AgentEntry]) -> Vec<usize> {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The MCP servers of a session, and the names of the ones off for it.
|
||||
struct McpForSession {
|
||||
servers: Vec<Value>,
|
||||
off: Vec<String>,
|
||||
}
|
||||
|
||||
/// The session parameters `session/new`, `session/load` and `session/fork` share: the MCP
|
||||
/// servers, and the ones off for this session, so an agent that also loads its own
|
||||
/// configuration (Claude Code) can keep a same-named server of it off too.
|
||||
fn session_params(cwd: &str, mcp: &McpForSession) -> Value {
|
||||
let mut params = json!({ "cwd": cwd, "mcpServers": mcp.servers });
|
||||
if !mcp.off.is_empty() {
|
||||
params["_meta"] = json!({ "openidea": { "mcpServersOff": mcp.off } });
|
||||
}
|
||||
params
|
||||
}
|
||||
|
||||
fn is_false(b: &bool) -> bool {
|
||||
!*b
|
||||
}
|
||||
@@ -3261,12 +3214,32 @@ fn retry_of(update: &Value, now: f64) -> Option<AgentRetry> {
|
||||
})
|
||||
}
|
||||
|
||||
fn apply_config_choice(task: &Task, option: &str, value: &str) {
|
||||
fn restore_config_choice(
|
||||
task: &Task,
|
||||
target: &AgentConfigOption,
|
||||
value: &str,
|
||||
previous: Option<&str>,
|
||||
model_choice: u64,
|
||||
previous_levels: Option<Vec<AgentConfigOption>>,
|
||||
) {
|
||||
let option = target.id.as_str();
|
||||
let is_model = target.category.as_deref() == Some("model");
|
||||
let mut s = task.state.lock();
|
||||
if (is_model && s.model_choice != model_choice)
|
||||
|| !s.task.config.iter().any(|o| o.id == option && o.current.as_deref() == Some(value))
|
||||
{
|
||||
return;
|
||||
}
|
||||
s.wanted.retain(|c| c.id != option);
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.to_owned() });
|
||||
if let Some(previous) = previous {
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: previous.to_owned() });
|
||||
}
|
||||
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
|
||||
o.current = Some(value.to_owned());
|
||||
o.current = previous.map(str::to_owned);
|
||||
}
|
||||
if let Some(levels) = previous_levels {
|
||||
s.task.config.retain(|o| !config::is_per_model_option(o));
|
||||
s.task.config.extend(levels);
|
||||
}
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
}
|
||||
@@ -3275,13 +3248,20 @@ fn model_of(config: &[AgentConfigOption]) -> Option<String> {
|
||||
config.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.clone())
|
||||
}
|
||||
|
||||
/// Commands the agent implements on its own and never lists in `availableCommands` —
|
||||
/// its CLI builtins, passed through as prompt text (e.g. `/compact`). `(name, description)`.
|
||||
fn builtin_commands(provider: &str) -> &'static [(&'static str, &'static str)] {
|
||||
/// Commands the agent implements on its own and never lists in `availableCommands`.
|
||||
fn builtin_commands(provider: &str) -> Vec<AgentCommand> {
|
||||
match provider {
|
||||
// Codex app-server has no command-list API, so the native adapter supplies its
|
||||
// stable builtins and merges the session's dynamic skills separately.
|
||||
"codex" => native::codex::builtin_commands(),
|
||||
// OpenCode ACP handles `/compact` via session.summarize but omits it from its command list.
|
||||
"opencode" => &[("compact", "compact the conversation")],
|
||||
_ => &[],
|
||||
"opencode" => vec![AgentCommand {
|
||||
name: "compact".into(),
|
||||
description: "compact the conversation".into(),
|
||||
hint: None,
|
||||
source: AgentCommandSource::Command,
|
||||
}],
|
||||
_ => Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3343,6 +3323,9 @@ mod replay_tests;
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
/// The name agents know the built-in server by (its tools are `mcp__OpenIDEA__…` in Claude Code).
|
||||
const BUILTIN_SERVER: &str = "OpenIDEA";
|
||||
|
||||
// The desktop advertises its relay only while the built-in server is listening.
|
||||
static MCP_EXECUTABLE: parking_lot::RwLock<Option<std::path::PathBuf>> = parking_lot::RwLock::new(None);
|
||||
|
||||
@@ -3357,7 +3340,7 @@ fn mcp_servers_for(supported: bool, root: &std::path::Path) -> Vec<Value> {
|
||||
fn stdio_mcp_servers(executable: Option<&std::path::Path>, supported: bool, root: &std::path::Path) -> Vec<Value> {
|
||||
let Some(executable) = executable.filter(|_| supported) else { return Vec::new() };
|
||||
let command = ide_mcp::stdio_command(executable, root);
|
||||
vec![json!({ "name": "OpenIDEA", "command": command[0], "args": command[1..], "env": [] })]
|
||||
vec![json!({ "name": BUILTIN_SERVER, "command": command[0], "args": command[1..], "env": [] })]
|
||||
}
|
||||
|
||||
/// What was sent of a streaming message: its first `bytes` (`utf16` UTF-16 units), which
|
||||
|
||||
@@ -10,7 +10,7 @@ use crate::{
|
||||
};
|
||||
use ide_core::IpcPath;
|
||||
use serde_json::{Value, json};
|
||||
use std::collections::{BTreeMap, HashSet};
|
||||
use std::collections::{BTreeMap, BTreeSet, HashSet};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
@@ -86,6 +86,66 @@ fn matches_agent(agents: &[String], provider: &str) -> bool {
|
||||
})
|
||||
}
|
||||
|
||||
/// The configured servers off for this session: off by default and not switched on for it, or
|
||||
/// switched off for it. Named so an agent that also loads its own configuration can keep a
|
||||
/// same-named server of it off too. Workspace entries take precedence, as in [`acp_mcp_servers`].
|
||||
pub(crate) fn servers_off(all: &[McpServer], provider: &str, overrides: &BTreeMap<String, bool>) -> Vec<String> {
|
||||
let mut seen_configured = HashSet::new();
|
||||
let mut enabled_names = HashSet::new();
|
||||
let mut off = BTreeSet::new();
|
||||
|
||||
let ordered = all
|
||||
.iter()
|
||||
.filter(|s| s.scope == McpScope::Workspace && !s.unapproved)
|
||||
.chain(all.iter().filter(|s| s.scope == McpScope::User));
|
||||
|
||||
for srv in ordered {
|
||||
if !seen_configured.insert(srv.name.as_str()) {
|
||||
continue;
|
||||
}
|
||||
let explicit = overrides.get(&srv.name).copied();
|
||||
let matches = explicit == Some(true) || matches_agent(&srv.agents, provider);
|
||||
let active = explicit.unwrap_or(srv.enabled) && matches;
|
||||
if active {
|
||||
enabled_names.insert(srv.name.as_str());
|
||||
} else {
|
||||
off.insert(srv.name.clone());
|
||||
}
|
||||
}
|
||||
|
||||
for srv in all.iter().filter(|s| s.scope == McpScope::Workspace && s.unapproved) {
|
||||
if !enabled_names.contains(srv.name.as_str()) {
|
||||
off.insert(srv.name.clone());
|
||||
}
|
||||
}
|
||||
|
||||
// A server switched off that the IDE doesn't configure may still be the agent's own.
|
||||
for (name, &on) in overrides {
|
||||
if !on && name.as_str() != BUILTIN_MCP_NAME && !enabled_names.contains(name.as_str()) {
|
||||
off.insert(name.clone());
|
||||
}
|
||||
}
|
||||
|
||||
off.into_iter().collect()
|
||||
}
|
||||
|
||||
/// Names of MCP servers present in Codex's own TOML configuration files (`~/.codex/config.toml`
|
||||
/// and `<workspace_root>/.codex/config.toml`).
|
||||
pub(crate) fn codex_external_server_names(home_dir: Option<&Path>, workspace_root: &Path) -> BTreeSet<String> {
|
||||
let mut names = BTreeSet::new();
|
||||
let mut paths = Vec::new();
|
||||
if let Some(home) = home_dir {
|
||||
paths.push(home.join(".codex").join("config.toml"));
|
||||
}
|
||||
paths.push(workspace_root.join(".codex").join("config.toml"));
|
||||
for path in paths {
|
||||
if let Ok(text) = std::fs::read_to_string(&path) {
|
||||
names.extend(parse_codex_toml_servers(&text).into_keys());
|
||||
}
|
||||
}
|
||||
names
|
||||
}
|
||||
|
||||
/// Builds the ACP `mcpServers` array for `session/new`, `session/load`, and `session/fork`.
|
||||
/// Workspace entries take precedence over User entries with the same name. Per-session
|
||||
/// `overrides` (`server_name` -> `enabled`) can enable a disabled server or disable an enabled one
|
||||
@@ -1016,6 +1076,54 @@ fn parse_key_values_map(val: Option<&Value>) -> BTreeMap<String, String> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn configured(name: &str, scope: McpScope, enabled: bool) -> McpServer {
|
||||
McpServer {
|
||||
id: format!("{scope:?}:{name}"),
|
||||
name: name.into(),
|
||||
scope,
|
||||
transport: McpTransport::Stdio,
|
||||
enabled,
|
||||
command: Some("x".into()),
|
||||
args: Vec::new(),
|
||||
env: Vec::new(),
|
||||
url: None,
|
||||
headers: Vec::new(),
|
||||
agents: Vec::new(),
|
||||
unapproved: false,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn servers_off_follow_the_effective_state() {
|
||||
let mut claude_only = configured("claude-only", McpScope::User, true);
|
||||
claude_only.agents = vec!["claude".into()];
|
||||
let mut unapproved_ws = configured("unapproved-ws", McpScope::Workspace, false);
|
||||
unapproved_ws.unapproved = true;
|
||||
|
||||
let all = [
|
||||
configured("default-off", McpScope::User, false),
|
||||
configured("switched-on", McpScope::User, false),
|
||||
configured("on", McpScope::User, true),
|
||||
configured("switched-off", McpScope::User, true),
|
||||
// The workspace entry decides for its name.
|
||||
configured("both", McpScope::User, true),
|
||||
configured("both", McpScope::Workspace, false),
|
||||
claude_only,
|
||||
unapproved_ws,
|
||||
];
|
||||
let overrides = BTreeMap::from([
|
||||
("switched-on".to_owned(), true),
|
||||
("switched-off".to_owned(), false),
|
||||
("agent-own".to_owned(), false),
|
||||
(BUILTIN_MCP_NAME.to_owned(), false),
|
||||
]);
|
||||
assert_eq!(
|
||||
servers_off(&all, "copilot", &overrides),
|
||||
["agent-own", "both", "claude-only", "default-off", "switched-off", "unapproved-ws"]
|
||||
);
|
||||
assert_eq!(servers_off(&all[2..4], "copilot", &BTreeMap::new()), Vec::<String>::new());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn crud_and_acp_filtering_by_scope_agent_and_transport() {
|
||||
let mut user = BTreeMap::new();
|
||||
|
||||
@@ -45,9 +45,6 @@ pub struct AgentCapabilities {
|
||||
pub steer: bool,
|
||||
/// It reports its background tasks and stops them one by one.
|
||||
pub background_tasks: bool,
|
||||
/// The task runs read-only: it asks before anything, and requests that would change
|
||||
/// the project are denied (a temporary side conversation).
|
||||
pub read_only: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
@@ -284,6 +281,22 @@ pub struct AgentImage {
|
||||
pub name: Option<String>,
|
||||
}
|
||||
|
||||
impl AgentImage {
|
||||
/// The type the bytes are in. Agents reject an image whose declared type doesn't match its
|
||||
/// bytes, and a pasted image's declared type can be wrong (a browser's JPEG or WebP copied as
|
||||
/// `image/png`). Falls back to `mime_type` for formats not recognised here.
|
||||
pub fn media_type(&self) -> &str {
|
||||
let head = crate::acp::normalize_base64(&self.data[..self.data.len().min(16)]);
|
||||
match head.as_slice() {
|
||||
[0x89, b'P', b'N', b'G', ..] => "image/png",
|
||||
[0xFF, 0xD8, 0xFF, ..] => "image/jpeg",
|
||||
[b'G', b'I', b'F', b'8', ..] => "image/gif",
|
||||
[b'R', b'I', b'F', b'F', _, _, _, _, b'W', b'E', b'B', b'P', ..] => "image/webp",
|
||||
_ => &self.mime_type,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A message to the agent: text, plus files to look at and images.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
|
||||
@@ -170,6 +170,8 @@ struct Session {
|
||||
id: String,
|
||||
cwd: PathBuf,
|
||||
mcp_config: Option<tempfile::TempPath>,
|
||||
/// MCP servers switched off for this session (`--disallowedTools`), its own config's too.
|
||||
mcp_off: Vec<String>,
|
||||
shim: Weak<Shim>,
|
||||
st: Mutex<State>,
|
||||
/// Serializes (re)starting the process.
|
||||
@@ -344,9 +346,10 @@ impl Shim {
|
||||
cwd: PathBuf,
|
||||
start: Start,
|
||||
pending: bool,
|
||||
mcp_config: Option<String>,
|
||||
params: &Value,
|
||||
) -> Arc<Session> {
|
||||
let mcp_config = mcp_config.and_then(|json| match write_mcp_config(&json) {
|
||||
let mcp_off = mcp_off(params);
|
||||
let mcp_config = mcp_config(params).and_then(|json| match write_mcp_config(&json) {
|
||||
Ok(path) => Some(path),
|
||||
Err(e) => {
|
||||
tracing::warn!("Claude Code session {id}: cannot write its MCP configuration: {e}");
|
||||
@@ -356,6 +359,7 @@ impl Shim {
|
||||
let session = Arc::new(Session {
|
||||
id: id.to_owned(),
|
||||
mcp_config,
|
||||
mcp_off,
|
||||
shim: Arc::downgrade(self),
|
||||
st: Mutex::new(State {
|
||||
proc: None,
|
||||
@@ -411,13 +415,8 @@ impl Shim {
|
||||
}
|
||||
"session/new" => {
|
||||
let id = new_uuid(false);
|
||||
let session = self.add_session(
|
||||
&id,
|
||||
self.cwd_of(¶ms),
|
||||
Start::New { id: id.clone() },
|
||||
false,
|
||||
mcp_config(¶ms),
|
||||
);
|
||||
let session =
|
||||
self.add_session(&id, self.cwd_of(¶ms), Start::New { id: id.clone() }, false, ¶ms);
|
||||
rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
|
||||
session.announce_commands();
|
||||
Ok(json!({ "sessionId": id, "configOptions": session.st.lock().settings.options() }))
|
||||
@@ -433,7 +432,7 @@ impl Shim {
|
||||
None => return Err(invalid(format!("no Claude Code session {id} in {}", cwd.display()))),
|
||||
};
|
||||
let chain = self.base_chain(&cwd, &start).map_err(internal)?;
|
||||
let session = self.add_session(id, cwd, start, pending, mcp_config(¶ms));
|
||||
let session = self.add_session(id, cwd, start, pending, ¶ms);
|
||||
rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
|
||||
if method == "session/load" {
|
||||
session.replay(&chain);
|
||||
@@ -459,7 +458,7 @@ impl Shim {
|
||||
(start, st.settings.clone())
|
||||
};
|
||||
self.save_pending(&id, Some(&start));
|
||||
let session = self.add_session(&id, source.cwd.clone(), start, true, mcp_config(¶ms));
|
||||
let session = self.add_session(&id, source.cwd.clone(), start, true, ¶ms);
|
||||
session.st.lock().settings = settings;
|
||||
let options = session.st.lock().settings.options();
|
||||
Ok(json!({ "sessionId": id, "configOptions": options }))
|
||||
@@ -666,6 +665,9 @@ impl Session {
|
||||
if let Some(config) = &self.mcp_config {
|
||||
args.extend(["--mcp-config".to_owned(), config.to_string_lossy().into_owned()]);
|
||||
}
|
||||
if !self.mcp_off.is_empty() {
|
||||
args.extend(["--disallowedTools".to_owned(), self.mcp_off.join(",")]);
|
||||
}
|
||||
args.extend(start.args());
|
||||
let launch =
|
||||
Launch { program: shim.config.program.clone(), args, cwd: self.cwd.clone(), env: shim.config.env.clone() };
|
||||
@@ -1497,6 +1499,24 @@ fn write_mcp_config(json: &str) -> std::io::Result<tempfile::TempPath> {
|
||||
Ok(file.into_temp_path())
|
||||
}
|
||||
|
||||
/// The servers switched off for the session (`_meta.openidea.mcpServersOff`) as Claude Code
|
||||
/// permission rules that deny all of a server's tools (`mcp__<server>`), so a server of
|
||||
/// Claude Code's own configuration stays off too.
|
||||
fn mcp_off(params: &Value) -> Vec<String> {
|
||||
params
|
||||
.pointer("/_meta/openidea/mcpServersOff")
|
||||
.and_then(Value::as_array)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(Value::as_str)
|
||||
.map(|name| {
|
||||
let name: String =
|
||||
name.chars().map(|c| if c.is_ascii_alphanumeric() || c == '_' || c == '-' { c } else { '_' }).collect();
|
||||
format!("mcp__{name}")
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// ACP `mcpServers` as Claude Code's `--mcp-config` JSON (`None` when there are none).
|
||||
fn mcp_config(params: &Value) -> Option<String> {
|
||||
let servers = params.get("mcpServers")?.as_array()?;
|
||||
|
||||
@@ -48,10 +48,17 @@ impl Settings {
|
||||
.filter_map(|m| {
|
||||
let s = |k: &str| m.get(k).and_then(Value::as_str).map(str::to_owned);
|
||||
let value = s("value")?;
|
||||
let resolved = s("resolvedModel");
|
||||
// The default entry follows the account's default model, so "Default
|
||||
// (recommended)" hides what actually runs: name the model it resolves to.
|
||||
let name = match (value.as_str(), resolved.as_deref()) {
|
||||
("default", Some(r)) if !r.is_empty() => format!("Default ({r})"),
|
||||
_ => s("displayName").unwrap_or_else(|| value.clone()),
|
||||
};
|
||||
Some(Model {
|
||||
name: s("displayName").unwrap_or_else(|| value.clone()),
|
||||
name,
|
||||
description: s("description"),
|
||||
resolved: s("resolvedModel"),
|
||||
resolved,
|
||||
efforts: if m.get("supportsEffort").and_then(Value::as_bool) == Some(true) {
|
||||
m.get("supportedEffortLevels")
|
||||
.and_then(Value::as_array)
|
||||
@@ -230,6 +237,19 @@ mod tests {
|
||||
assert_eq!(s.model, "claude-x-1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_default_entry_is_named_by_the_model_it_runs() {
|
||||
let s = Settings::from_cli(&init(), &json!({"applied": {"model": "claude-sonnet-5-5"}}));
|
||||
let names: Vec<_> = s.models.iter().map(|m| m.name.as_str()).collect();
|
||||
assert_eq!(names, ["Default (claude-sonnet-5-5)", "Opus", "Haiku 4.5"]);
|
||||
// Without a resolved model, the agent's own name stands.
|
||||
let s = Settings::from_cli(
|
||||
&json!({"models": [{"value": "default", "displayName": "Default (recommended)"}]}),
|
||||
&json!({}),
|
||||
);
|
||||
assert_eq!(s.models[0].name, "Default (recommended)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn options_follow_the_model() {
|
||||
let mut s = Settings::from_cli(&init(), &json!({"applied": {"model": "claude-sonnet-5-5", "effort": "high"}}));
|
||||
|
||||
@@ -1243,6 +1243,13 @@ async fn skipped_questions_have_no_answers() {
|
||||
assert_eq!(cancelled, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn servers_switched_off_become_disallowed_tools() {
|
||||
assert!(mcp_off(&json!({})).is_empty());
|
||||
let off = mcp_off(&json!({ "_meta": { "openidea": { "mcpServersOff": ["github", "my server.v2"] } } }));
|
||||
assert_eq!(off, ["mcp__github", "mcp__my_server_v2"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mcp_servers_become_an_mcp_config() {
|
||||
assert_eq!(mcp_config(&json!({ "mcpServers": [] })), None);
|
||||
|
||||
@@ -0,0 +1,155 @@
|
||||
//! Codex's built-in slash commands. `codex app-server` has no command-list API, so the
|
||||
//! native adapter owns this stable compatibility table; skills stay dynamic via `skills/list`.
|
||||
|
||||
use serde_json::Value;
|
||||
|
||||
/// Menu metadata shared by agent_commands and the prompt dispatcher.
|
||||
pub(crate) struct BuiltinCommandSpec {
|
||||
pub name: &'static str,
|
||||
pub description: &'static str,
|
||||
pub hint: Option<&'static str>,
|
||||
}
|
||||
|
||||
pub(crate) const BUILTIN_COMMANDS: &[BuiltinCommandSpec] = &[
|
||||
BuiltinCommandSpec { name: "plan", description: "Turn plan mode on or off.", hint: None },
|
||||
BuiltinCommandSpec {
|
||||
name: "mcp",
|
||||
description: "Show the status of the MCP servers, or reconnect them.",
|
||||
hint: Some("[reconnect]"),
|
||||
},
|
||||
BuiltinCommandSpec { name: "skills", description: "List available skills.", hint: None },
|
||||
BuiltinCommandSpec { name: "status", description: "Display session configuration and token usage.", hint: None },
|
||||
BuiltinCommandSpec {
|
||||
name: "review",
|
||||
description: "Review uncommitted changes, or review with custom instructions.",
|
||||
hint: Some("optional review instructions"),
|
||||
},
|
||||
BuiltinCommandSpec {
|
||||
name: "review-branch",
|
||||
description: "Review changes relative to a base branch.",
|
||||
hint: Some("branch name"),
|
||||
},
|
||||
BuiltinCommandSpec { name: "review-commit", description: "Review a specific commit.", hint: Some("commit sha") },
|
||||
BuiltinCommandSpec {
|
||||
name: "compact",
|
||||
description: "Summarize conversation to avoid hitting the context limit.",
|
||||
hint: None,
|
||||
},
|
||||
BuiltinCommandSpec {
|
||||
name: "goal",
|
||||
description: "Set a goal to keep pursuing.",
|
||||
hint: Some("[<objective>|clear|pause|resume]"),
|
||||
},
|
||||
BuiltinCommandSpec { name: "rename", description: "Rename the current session.", hint: Some("new name") },
|
||||
BuiltinCommandSpec {
|
||||
name: "logout",
|
||||
description: "Sign out of Codex. This option is available when you are logged in via ChatGPT.",
|
||||
hint: None,
|
||||
},
|
||||
];
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(super) enum BuiltinCommand {
|
||||
Plan,
|
||||
Mcp,
|
||||
Skills,
|
||||
Status,
|
||||
Review,
|
||||
ReviewBranch,
|
||||
ReviewCommit,
|
||||
Compact,
|
||||
Goal,
|
||||
Rename,
|
||||
Logout,
|
||||
}
|
||||
|
||||
impl BuiltinCommand {
|
||||
fn from_name(name: &str) -> Option<Self> {
|
||||
Some(match name {
|
||||
"plan" => Self::Plan,
|
||||
"mcp" => Self::Mcp,
|
||||
"skills" => Self::Skills,
|
||||
"status" => Self::Status,
|
||||
"review" => Self::Review,
|
||||
"review-branch" => Self::ReviewBranch,
|
||||
"review-commit" => Self::ReviewCommit,
|
||||
"compact" => Self::Compact,
|
||||
"goal" => Self::Goal,
|
||||
"rename" => Self::Rename,
|
||||
"logout" => Self::Logout,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub(super) struct ParsedCommand {
|
||||
pub command: BuiltinCommand,
|
||||
/// Everything after the command name, trimmed but otherwise unchanged.
|
||||
pub rest: String,
|
||||
}
|
||||
|
||||
impl ParsedCommand {
|
||||
/// Commands that Codex completes as a turn. Missing review arguments stay local so the
|
||||
/// adapter can print the command's usage without starting an unnecessary model request.
|
||||
pub fn starts_turn(&self) -> bool {
|
||||
matches!(self.command, BuiltinCommand::Compact | BuiltinCommand::Review)
|
||||
|| (matches!(self.command, BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit)
|
||||
&& !self.rest.is_empty())
|
||||
}
|
||||
}
|
||||
|
||||
/// A recognized Codex builtin at the start of the prompt. Unknown slash commands and
|
||||
/// `$skill` invocations return `None`, so they continue through Codex as ordinary prompts.
|
||||
pub(super) fn parse(prompt: &Value) -> Option<ParsedCommand> {
|
||||
let text = prompt.as_array()?.first()?.get("text")?.as_str()?.trim();
|
||||
let command_text = text.strip_prefix('/')?.trim();
|
||||
let (name, rest) = command_text.split_once(char::is_whitespace).unwrap_or((command_text, ""));
|
||||
let command = BuiltinCommand::from_name(&name.to_ascii_lowercase())?;
|
||||
Some(ParsedCommand { command, rest: rest.trim().to_owned() })
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
fn text(value: &str) -> Value {
|
||||
json!([{ "type": "text", "text": value }])
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_builtin_is_registered_and_parsed() {
|
||||
let expected = [
|
||||
"plan",
|
||||
"mcp",
|
||||
"skills",
|
||||
"status",
|
||||
"review",
|
||||
"review-branch",
|
||||
"review-commit",
|
||||
"compact",
|
||||
"goal",
|
||||
"rename",
|
||||
"logout",
|
||||
];
|
||||
assert_eq!(BUILTIN_COMMANDS.iter().map(|c| c.name).collect::<Vec<_>>(), expected);
|
||||
for name in expected {
|
||||
assert!(parse(&text(&format!("/{name}"))).is_some(), "{name}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parsing_keeps_arguments_and_leaves_non_builtins_alone() {
|
||||
let parsed = parse(&text(" /review-branch origin/main ")).unwrap();
|
||||
assert_eq!(parsed.command, BuiltinCommand::ReviewBranch);
|
||||
assert_eq!(parsed.rest, "origin/main");
|
||||
assert!(parsed.starts_turn());
|
||||
assert!(!parse(&text("/review-branch")).unwrap().starts_turn());
|
||||
assert!(parse(&text("/$review check this")).is_none());
|
||||
assert!(parse(&text("review")).is_none());
|
||||
|
||||
let prompt = json!([{ "type": "text", "text": "/compact" }, { "type": "image", "data": "AA==" }]);
|
||||
assert_eq!(parse(&prompt).unwrap().command, BuiltinCommand::Compact);
|
||||
}
|
||||
}
|
||||
@@ -2,7 +2,11 @@
|
||||
//! translated to and from ACP. A codex thread is an ACP session; a subagent's thread is
|
||||
//! a subagent session of the thread that spawned it.
|
||||
|
||||
mod commands;
|
||||
mod translate;
|
||||
mod trust;
|
||||
|
||||
pub(crate) use commands::BUILTIN_COMMANDS;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -10,6 +14,8 @@ mod tests;
|
||||
use super::Shim;
|
||||
use crate::acp::AUTH_REQUIRED;
|
||||
use crate::provider::ProviderSpec;
|
||||
use crate::{AgentCommand, AgentCommandSource};
|
||||
use commands::{BuiltinCommand, ParsedCommand};
|
||||
use ide_jsonrpc::{Framing, Handler, Peer, RpcError, codes};
|
||||
use parking_lot::Mutex;
|
||||
use serde_json::{Value, json};
|
||||
@@ -32,6 +38,19 @@ const EXIT_GRACE: Duration = Duration::from_millis(100);
|
||||
const NAME_PROMPT: &str = "Name this conversation for a list of tasks: a short title of at most six words, in the \
|
||||
language the user writes in. Reply with the title only, without quotes or a closing period.";
|
||||
|
||||
/// Slash-command metadata for provider discovery and sessions without an advertised list.
|
||||
pub(crate) fn builtin_commands() -> Vec<AgentCommand> {
|
||||
BUILTIN_COMMANDS
|
||||
.iter()
|
||||
.map(|command| AgentCommand {
|
||||
name: command.name.to_owned(),
|
||||
description: command.description.to_owned(),
|
||||
hint: command.hint.map(str::to_owned),
|
||||
source: AgentCommandSource::Command,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub(crate) fn connect(
|
||||
spec: &ProviderSpec,
|
||||
cwd: &Path,
|
||||
@@ -183,6 +202,8 @@ struct State {
|
||||
threads: HashMap<String, Thread>,
|
||||
/// The last `account/rateLimits/updated` snapshot.
|
||||
rate_limits: Option<Value>,
|
||||
/// Project trust has been checked (and, when needed, asked about) on this connection.
|
||||
trust_checked: HashSet<String>,
|
||||
/// Codex exited.
|
||||
gone: bool,
|
||||
}
|
||||
@@ -215,6 +236,8 @@ struct Thread {
|
||||
early_cancel: Option<Instant>,
|
||||
/// The latest agent message (a subagent's answer).
|
||||
answer: String,
|
||||
/// The latest `thread/tokenUsage/updated` payload, for the `/status` command.
|
||||
token_usage: Option<Value>,
|
||||
/// The thread has a name.
|
||||
named: bool,
|
||||
/// A name is being asked for.
|
||||
@@ -320,6 +343,12 @@ impl CodexShim {
|
||||
self.codex().request(method, params, None).await.map_err(from_codex)
|
||||
}
|
||||
|
||||
fn warning(&self, message: impl Into<String>) {
|
||||
if let Some(client) = self.client.get() {
|
||||
let _ = client.notify(crate::WARNING_NOTIFICATION, json!({ "message": message.into() }));
|
||||
}
|
||||
}
|
||||
|
||||
async fn handle(&self, method: &str, params: Value) -> Result<Value, ResponseError> {
|
||||
match method {
|
||||
"initialize" => self.initialize().await,
|
||||
@@ -403,6 +432,7 @@ impl CodexShim {
|
||||
|
||||
async fn new_session(&self, params: &Value) -> Result<Value, ResponseError> {
|
||||
let models = self.models().await?;
|
||||
self.prepare_project_trust(params).await;
|
||||
let mut request = json!({ "cwd": params.get("cwd") });
|
||||
if let Some(config) = translate::mcp_config(params) {
|
||||
request["config"] = config;
|
||||
@@ -420,6 +450,7 @@ impl CodexShim {
|
||||
async fn load_session(&self, params: &Value) -> Result<Value, ResponseError> {
|
||||
let id = str_param(params, "sessionId")?;
|
||||
let models = self.models().await?;
|
||||
self.prepare_project_trust(params).await;
|
||||
let mut request = json!({ "threadId": id, "cwd": params.get("cwd") });
|
||||
if let Some(config) = translate::mcp_config(params) {
|
||||
request["config"] = config;
|
||||
@@ -438,6 +469,7 @@ impl CodexShim {
|
||||
async fn fork_session(&self, params: &Value) -> Result<Value, ResponseError> {
|
||||
let source = str_param(params, "sessionId")?;
|
||||
let models = self.models().await?;
|
||||
self.prepare_project_trust(params).await;
|
||||
let settings = self.state.lock().threads.get(source).and_then(|t| t.settings.clone());
|
||||
let mut request = json!({ "threadId": source, "cwd": params.get("cwd") });
|
||||
if let Some(config) = translate::mcp_config(params) {
|
||||
@@ -471,11 +503,18 @@ impl CodexShim {
|
||||
|
||||
async fn prompt(&self, params: &Value) -> Result<Value, ResponseError> {
|
||||
let session = str_param(params, "sessionId")?.to_owned();
|
||||
let input = translate::user_input(params.get("prompt").unwrap_or(&Value::Null));
|
||||
let prompt = params.get("prompt").unwrap_or(&Value::Null);
|
||||
let command = commands::parse(prompt);
|
||||
if let Some(command) = command.as_ref()
|
||||
&& !command.starts_turn()
|
||||
{
|
||||
return self.local_command(&session, command).await;
|
||||
}
|
||||
let input = translate::user_input(prompt);
|
||||
if input.is_empty() {
|
||||
return Err(invalid("empty prompt"));
|
||||
}
|
||||
let models = self.models().await?;
|
||||
let models = if command.is_none() { Some(self.models().await?) } else { None };
|
||||
let (done, ended) = oneshot::channel();
|
||||
let settings = {
|
||||
let mut state = self.state.lock();
|
||||
@@ -491,33 +530,213 @@ impl CodexShim {
|
||||
t.error = None;
|
||||
t.settings.clone()
|
||||
};
|
||||
let mut request = json!({ "threadId": session, "input": input, "summary": "auto" });
|
||||
if let Some(s) = settings {
|
||||
request["model"] = json!(s.model_slug(&models));
|
||||
request["approvalPolicy"] = json!(s.mode.approval_policy());
|
||||
request["sandboxPolicy"] = s.mode.sandbox_policy();
|
||||
if let Some(effort) = &s.effort {
|
||||
request["effort"] = json!(effort);
|
||||
let started = match command.as_ref() {
|
||||
Some(command) => match command.command {
|
||||
BuiltinCommand::Compact => {
|
||||
// Codex reports compaction as its own turn, using the same started/completed
|
||||
// notifications that finish the pending session/prompt above.
|
||||
self.call("thread/compact/start", json!({ "threadId": session })).await
|
||||
}
|
||||
BuiltinCommand::Review | BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit => {
|
||||
self.call("review/start", json!({ "threadId": session, "target": review_target(command) })).await
|
||||
}
|
||||
_ => unreachable!("local commands return before a pending turn is created"),
|
||||
},
|
||||
None => {
|
||||
let models = models.expect("ordinary prompts load the model catalog");
|
||||
let mut request = json!({ "threadId": session, "input": input, "summary": "auto" });
|
||||
if let Some(s) = &settings {
|
||||
request["model"] = json!(s.model_slug(&models));
|
||||
request["approvalPolicy"] = json!(s.mode.approval_policy());
|
||||
request["sandboxPolicy"] = s.mode.sandbox_policy();
|
||||
// Omit the default so older app-server versions keep accepting normal
|
||||
// turns; selecting Plan opts into this newer request field.
|
||||
if s.collaboration_mode == translate::PLAN_COLLABORATION_MODE
|
||||
|| s.collaboration_mode_override.is_some()
|
||||
{
|
||||
request["collaborationMode"] = translate::collaboration_mode(s, &models);
|
||||
}
|
||||
if let Some(effort) = &s.effort {
|
||||
request["effort"] = json!(effort);
|
||||
}
|
||||
}
|
||||
self.call("turn/start", request).await
|
||||
}
|
||||
};
|
||||
if let Ok(started) = &started
|
||||
&& let Some(turn) = started.pointer("/turn/id").and_then(Value::as_str)
|
||||
{
|
||||
self.turn_known(&session, turn, false);
|
||||
}
|
||||
match self.call("turn/start", request).await {
|
||||
Ok(started) => {
|
||||
if let Some(turn) = started.pointer("/turn/id").and_then(Value::as_str) {
|
||||
self.turn_known(&session, turn, false);
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
if let Some(t) = self.state.lock().threads.get_mut(&session) {
|
||||
t.prompt = None;
|
||||
}
|
||||
return Err(e);
|
||||
if started.is_ok()
|
||||
&& command.is_none()
|
||||
&& let Some(thread) = self.state.lock().threads.get_mut(&session)
|
||||
&& let Some(settings) = thread.settings.as_mut()
|
||||
{
|
||||
// A Default override is needed only for the first turn that resets a resumed
|
||||
// Plan thread; omitting it afterwards preserves compatibility with older Codex.
|
||||
settings.collaboration_mode_override = None;
|
||||
}
|
||||
if let Err(e) = started {
|
||||
if let Some(t) = self.state.lock().threads.get_mut(&session) {
|
||||
t.prompt = None;
|
||||
}
|
||||
return Err(e);
|
||||
}
|
||||
let (turn, last_error) = ended.await.map_err(|_| error(codes::INTERNAL_ERROR, "Codex exited"))?;
|
||||
let rate_limits = self.state.lock().rate_limits.clone();
|
||||
stop_reason(&turn, last_error, rate_limits.as_ref())
|
||||
}
|
||||
|
||||
/// Runs commands that codex-acp historically handled locally: configuration, status,
|
||||
/// inventory, naming and account actions. They complete without starting a model turn.
|
||||
async fn local_command(&self, session: &str, command: &ParsedCommand) -> Result<Value, ResponseError> {
|
||||
let (settings, cwd, token_usage, rate_limits) = {
|
||||
let state = self.state.lock();
|
||||
if state.gone {
|
||||
return Err(error(codes::INTERNAL_ERROR, "Codex exited"));
|
||||
}
|
||||
let thread = state.threads.get(session).ok_or_else(|| invalid(format!("no session {session}")))?;
|
||||
if thread.prompt.is_some() || thread.turn.is_some() {
|
||||
return Err(invalid("a turn is already running"));
|
||||
}
|
||||
(thread.settings.clone(), thread.cwd.clone(), thread.token_usage.clone(), state.rate_limits.clone())
|
||||
};
|
||||
|
||||
match command.command {
|
||||
BuiltinCommand::Plan => {
|
||||
if !command.rest.is_empty() {
|
||||
self.say(session, command_usage(BuiltinCommand::Plan));
|
||||
return Ok(json!({ "stopReason": "end_turn" }));
|
||||
}
|
||||
let models = self.models().await?;
|
||||
let options = {
|
||||
let mut state = self.state.lock();
|
||||
let thread =
|
||||
state.threads.get_mut(session).ok_or_else(|| invalid(format!("no session {session}")))?;
|
||||
let settings = thread.settings.as_mut().ok_or_else(|| invalid(format!("no session {session}")))?;
|
||||
settings.collaboration_mode = if settings.collaboration_mode == translate::PLAN_COLLABORATION_MODE {
|
||||
translate::DEFAULT_COLLABORATION_MODE.to_owned()
|
||||
} else {
|
||||
translate::PLAN_COLLABORATION_MODE.to_owned()
|
||||
};
|
||||
settings.collaboration_mode_override = Some(settings.collaboration_mode.clone());
|
||||
translate::config_options(&models, settings)
|
||||
};
|
||||
self.emit(session, json!({ "sessionUpdate": "config_option_update", "configOptions": options }));
|
||||
}
|
||||
BuiltinCommand::Status => {
|
||||
let text =
|
||||
status_text(session, settings.as_ref(), cwd.as_deref(), token_usage.as_ref(), rate_limits.as_ref());
|
||||
self.say(session, text);
|
||||
}
|
||||
BuiltinCommand::Skills => {
|
||||
let cwd = cwd.ok_or_else(|| invalid(format!("no session {session}")))?;
|
||||
let found = self.call("skills/list", json!({ "cwds": [cwd] })).await?;
|
||||
self.say(session, skills_text(&found));
|
||||
}
|
||||
BuiltinCommand::Mcp => match command.rest.as_str() {
|
||||
"" => self.say(session, self.mcp_text(session).await?),
|
||||
rest if rest.eq_ignore_ascii_case("reconnect") => {
|
||||
self.call("config/mcpServer/reload", json!({})).await?;
|
||||
self.say(session, self.mcp_text(session).await?);
|
||||
}
|
||||
_ => self.say(session, command_usage(BuiltinCommand::Mcp)),
|
||||
},
|
||||
BuiltinCommand::Rename => {
|
||||
if command.rest.is_empty() {
|
||||
self.say(session, command_usage(BuiltinCommand::Rename));
|
||||
} else {
|
||||
self.call("thread/name/set", json!({ "threadId": session, "name": command.rest })).await?;
|
||||
// User commands are authoritative over the automatic title, so the manager
|
||||
// must retain this title through later generated-name updates.
|
||||
self.emit(
|
||||
session,
|
||||
json!({ "sessionUpdate": "session_info_update", "title": command.rest, "userNamed": true }),
|
||||
);
|
||||
}
|
||||
}
|
||||
BuiltinCommand::Logout => {
|
||||
self.call("account/logout", Value::Null).await?;
|
||||
self.say(session, "Logged out from Codex account.");
|
||||
}
|
||||
BuiltinCommand::Goal => self.goal_command(session, &command.rest).await?,
|
||||
BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit if command.rest.is_empty() => {
|
||||
self.say(session, command_usage(command.command));
|
||||
}
|
||||
BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit => {
|
||||
return Err(invalid("review command did not start a turn"));
|
||||
}
|
||||
BuiltinCommand::Review | BuiltinCommand::Compact => {
|
||||
return Err(invalid("turn command reached the local command path"));
|
||||
}
|
||||
}
|
||||
Ok(json!({ "stopReason": "end_turn" }))
|
||||
}
|
||||
|
||||
async fn goal_command(&self, session: &str, rest: &str) -> Result<(), ResponseError> {
|
||||
let argument = rest.trim();
|
||||
if argument.is_empty() {
|
||||
self.say(session, command_usage(BuiltinCommand::Goal));
|
||||
return Ok(());
|
||||
}
|
||||
match argument.to_ascii_lowercase().as_str() {
|
||||
"clear" => {
|
||||
self.call("thread/goal/clear", json!({ "threadId": session })).await?;
|
||||
self.say(session, "Goal cleared.");
|
||||
}
|
||||
"pause" => {
|
||||
let response = self
|
||||
.call("thread/goal/set", json!({ "threadId": session, "status": "paused", "origin": "user" }))
|
||||
.await?;
|
||||
self.say(
|
||||
session,
|
||||
format!(
|
||||
"Goal is now {}.",
|
||||
response.pointer("/goal/status").and_then(Value::as_str).unwrap_or("paused")
|
||||
),
|
||||
);
|
||||
}
|
||||
"resume" => {
|
||||
let response = self
|
||||
.call("thread/goal/set", json!({ "threadId": session, "status": "active", "origin": "user" }))
|
||||
.await?;
|
||||
self.say(
|
||||
session,
|
||||
format!(
|
||||
"Goal is now {}.",
|
||||
response.pointer("/goal/status").and_then(Value::as_str).unwrap_or("active")
|
||||
),
|
||||
);
|
||||
}
|
||||
_ if argument.chars().count() > 4000 => {
|
||||
self.say(session, "Command \"/goal\" requires goal text of at most 4000 characters.");
|
||||
}
|
||||
_ => {
|
||||
let response = self
|
||||
.call(
|
||||
"thread/goal/set",
|
||||
json!({ "threadId": session, "objective": argument, "status": "active", "origin": "user" }),
|
||||
)
|
||||
.await?;
|
||||
let status = response.pointer("/goal/status").and_then(Value::as_str).unwrap_or("active");
|
||||
self.say(session, format!("Goal set and {status}."));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn mcp_text(&self, session: &str) -> Result<String, ResponseError> {
|
||||
let response = self
|
||||
.call("mcpServerStatus/list", json!({ "threadId": session, "detail": "toolsAndAuthOnly", "limit": 100 }))
|
||||
.await?;
|
||||
Ok(mcp_text(&response))
|
||||
}
|
||||
|
||||
fn say(&self, session: &str, text: impl AsRef<str>) {
|
||||
self.emit(session, translate::chunk("agent_message_chunk", text.as_ref()));
|
||||
}
|
||||
|
||||
async fn steer(&self, params: &Value) -> Result<Value, ResponseError> {
|
||||
let session = str_param(params, "sessionId")?;
|
||||
let turn = self.state.lock().threads.get(session).and_then(|t| t.turn.clone());
|
||||
@@ -643,6 +862,25 @@ impl CodexShim {
|
||||
fn on_codex_notification(self: &Arc<Self>, method: &str, params: &Value) {
|
||||
let thread = params.get("threadId").and_then(Value::as_str).unwrap_or_default();
|
||||
match method {
|
||||
"configWarning" => {
|
||||
let Some(summary) = params.get("summary").and_then(Value::as_str).filter(|s| !s.trim().is_empty())
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let mut message = summary.trim().to_owned();
|
||||
for key in ["details", "path"] {
|
||||
if let Some(value) = params.get(key).and_then(Value::as_str).filter(|s| !s.trim().is_empty()) {
|
||||
message.push_str("\n\n");
|
||||
message.push_str(value.trim());
|
||||
}
|
||||
}
|
||||
self.warning(message);
|
||||
}
|
||||
"warning" => {
|
||||
if let Some(message) = params.get("message").and_then(Value::as_str).filter(|s| !s.trim().is_empty()) {
|
||||
self.warning(message);
|
||||
}
|
||||
}
|
||||
"skills/changed" => {
|
||||
let shim = self.clone();
|
||||
let sessions: Vec<String> = self
|
||||
@@ -693,7 +931,12 @@ impl CodexShim {
|
||||
t.last_chunk = None;
|
||||
Some(translate::plan(params))
|
||||
}),
|
||||
"thread/tokenUsage/updated" => self.with_thread(thread, |_, _| translate::usage(params)),
|
||||
"thread/tokenUsage/updated" => self.with_thread(thread, |t, _| {
|
||||
if let Some(usage) = params.get("tokenUsage") {
|
||||
t.token_usage = Some(usage.clone());
|
||||
}
|
||||
translate::usage(params)
|
||||
}),
|
||||
"thread/name/updated" => self.with_thread(thread, |t, _| {
|
||||
let title = params.get("threadName").and_then(Value::as_str)?;
|
||||
t.named = true;
|
||||
@@ -1182,3 +1425,114 @@ fn stop_reason(turn: &Value, last_error: Option<Value>, rate_limits: Option<&Val
|
||||
};
|
||||
Ok(json!({ "stopReason": stop }))
|
||||
}
|
||||
|
||||
/// The `review/start` target of a parsed review command.
|
||||
fn review_target(command: &ParsedCommand) -> Value {
|
||||
match command.command {
|
||||
BuiltinCommand::Review if command.rest.is_empty() => json!({ "type": "uncommittedChanges" }),
|
||||
BuiltinCommand::Review => json!({ "type": "custom", "instructions": command.rest }),
|
||||
BuiltinCommand::ReviewBranch => json!({ "type": "baseBranch", "branch": command.rest }),
|
||||
BuiltinCommand::ReviewCommit => json!({ "type": "commit", "sha": command.rest, "title": null }),
|
||||
_ => unreachable!("only review commands have review targets"),
|
||||
}
|
||||
}
|
||||
|
||||
fn command_usage(command: BuiltinCommand) -> String {
|
||||
match command {
|
||||
BuiltinCommand::Plan => "Command \"/plan\" accepts no arguments.".to_owned(),
|
||||
BuiltinCommand::Mcp => "Command \"/mcp\" accepts no arguments, or `reconnect`.".to_owned(),
|
||||
BuiltinCommand::ReviewBranch => "Command \"/review-branch\" requires branch name.".to_owned(),
|
||||
BuiltinCommand::ReviewCommit => "Command \"/review-commit\" requires commit sha.".to_owned(),
|
||||
BuiltinCommand::Goal => "Command \"/goal\" requires [<objective>|clear|pause|resume].".to_owned(),
|
||||
BuiltinCommand::Rename => "Command \"/rename\" requires new name.".to_owned(),
|
||||
_ => "This command does not accept arguments.".to_owned(),
|
||||
}
|
||||
}
|
||||
|
||||
fn status_text(
|
||||
session: &str,
|
||||
settings: Option<&Settings>,
|
||||
cwd: Option<&str>,
|
||||
token_usage: Option<&Value>,
|
||||
rate_limits: Option<&Value>,
|
||||
) -> String {
|
||||
let mut lines = Vec::new();
|
||||
if let Some(settings) = settings {
|
||||
lines.push(format!("**Model:** {}", settings.model));
|
||||
lines.push(format!("**Collaboration:** {}", settings.collaboration_mode));
|
||||
lines.push(format!("**Approval:** {}", settings.mode.approval_policy()));
|
||||
lines.push(format!("**Sandbox:** {}", settings.mode.sandbox_mode()));
|
||||
}
|
||||
if let Some(cwd) = cwd {
|
||||
lines.push(format!("**Directory:** {cwd}"));
|
||||
}
|
||||
lines.push(format!("**Session:** `{session}`"));
|
||||
if let Some(usage) = token_usage {
|
||||
let total = usage.pointer("/total/totalTokens").and_then(Value::as_u64);
|
||||
let used = usage.pointer("/last/totalTokens").and_then(Value::as_u64);
|
||||
let window = usage.get("modelContextWindow").and_then(Value::as_u64).filter(|window| *window > 0);
|
||||
if let (Some(total), Some(used), Some(window)) = (total, used, window) {
|
||||
let percent = (used.saturating_mul(100) + window / 2) / window;
|
||||
lines.push(format!("**Token usage:** {total} total"));
|
||||
lines.push(format!("**Context window:** {used} / {window} ({percent}%)"));
|
||||
}
|
||||
}
|
||||
if let Some(primary) = rate_limits.and_then(|r| r.get("primary"))
|
||||
&& let Some(used) = primary.get("usedPercent").and_then(Value::as_f64)
|
||||
{
|
||||
lines.push(format!("**Rate limit:** {used:.0}% used"));
|
||||
}
|
||||
lines.join(" \n")
|
||||
}
|
||||
|
||||
fn skills_text(response: &Value) -> String {
|
||||
let mut seen = HashSet::new();
|
||||
let names: Vec<String> = response
|
||||
.get("data")
|
||||
.and_then(Value::as_array)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|entry| entry.get("skills").and_then(Value::as_array))
|
||||
.flatten()
|
||||
.filter(|skill| skill.get("enabled") != Some(&Value::Bool(false)))
|
||||
.filter_map(|skill| {
|
||||
let name = skill.get("name").and_then(Value::as_str)?.trim();
|
||||
if name.is_empty() || !seen.insert(name.to_owned()) {
|
||||
return None;
|
||||
}
|
||||
let description = skill
|
||||
.pointer("/interface/shortDescription")
|
||||
.or_else(|| skill.get("shortDescription"))
|
||||
.or_else(|| skill.get("description"))
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or_default();
|
||||
Some(if description.is_empty() { name.to_owned() } else { format!("{name}: {description}") })
|
||||
})
|
||||
.collect();
|
||||
if names.is_empty() {
|
||||
"No skills configured.".to_owned()
|
||||
} else {
|
||||
format!("Available skills:\n{}", names.iter().map(|name| format!("- {name}")).collect::<Vec<_>>().join("\n"))
|
||||
}
|
||||
}
|
||||
|
||||
fn mcp_text(response: &Value) -> String {
|
||||
let servers = response.get("data").and_then(Value::as_array).map(Vec::as_slice).unwrap_or_default();
|
||||
if servers.is_empty() {
|
||||
return "No MCP servers configured.".to_owned();
|
||||
}
|
||||
let lines = servers
|
||||
.iter()
|
||||
.filter_map(|server| {
|
||||
let name = server.get("name").and_then(Value::as_str)?;
|
||||
let status = server
|
||||
.get("runtimeStatus")
|
||||
.and_then(Value::as_str)
|
||||
.or_else(|| server.get("authStatus").and_then(Value::as_str))
|
||||
.unwrap_or("unknown");
|
||||
let tools = server.get("tools").and_then(Value::as_object).map_or(0, serde_json::Map::len);
|
||||
Some(format!("- {name}: {status}, {tools} tools"))
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
format!("MCP servers:\n{}", lines.join("\n"))
|
||||
}
|
||||
@@ -180,24 +180,38 @@ fn settings_follow_the_thread_and_the_models() {
|
||||
let result = json!({"model": "big", "reasoningEffort": null, "approvalPolicy": "untrusted",
|
||||
"sandbox": {"type": "workspaceWrite"}});
|
||||
let mut s = Settings::of(&result, &models);
|
||||
assert_eq!(s, Settings { model: "big".into(), effort: Some("low".into()), mode: Mode::Ask });
|
||||
assert_eq!(
|
||||
s,
|
||||
Settings {
|
||||
model: "big".into(),
|
||||
effort: Some("low".into()),
|
||||
mode: Mode::Ask,
|
||||
collaboration_mode: DEFAULT_COLLABORATION_MODE.into(),
|
||||
collaboration_mode_override: None,
|
||||
}
|
||||
);
|
||||
|
||||
let options = config_options(&models, &s);
|
||||
let ids: Vec<&str> = options.as_array().unwrap().iter().map(|o| o["id"].as_str().unwrap()).collect();
|
||||
assert_eq!(ids, [MODEL, EFFORT, MODE]);
|
||||
assert_eq!(ids, [MODEL, EFFORT, MODE, COLLABORATION_MODE]);
|
||||
assert_eq!(options[0]["options"].as_array().unwrap().len(), 2, "hidden models are left out");
|
||||
assert_eq!(options[1]["category"], "thought_level");
|
||||
assert_eq!(options[1]["options"][1]["name"], "Extra high");
|
||||
assert_eq!(options[2]["currentValue"], "ask");
|
||||
assert_eq!(options[3]["currentValue"], "default");
|
||||
|
||||
// A model without efforts drops the option; its slug is what codex gets.
|
||||
s.set(&models, MODEL, "plain").unwrap();
|
||||
assert_eq!((s.effort.as_deref(), s.model_slug(&models).as_str()), (None, "plain-slug"));
|
||||
assert_eq!(config_options(&models, &s).as_array().unwrap().len(), 2);
|
||||
assert_eq!(config_options(&models, &s).as_array().unwrap().len(), 3);
|
||||
assert!(s.set(&models, EFFORT, "low").is_err());
|
||||
assert!(s.set(&models, MODEL, "nope").is_err());
|
||||
s.set(&models, MODE, "full-access").unwrap();
|
||||
assert_eq!((s.mode.approval_policy(), s.mode.sandbox_policy()), ("never", json!({"type": "dangerFullAccess"})));
|
||||
s.set(&models, COLLABORATION_MODE, PLAN_COLLABORATION_MODE).unwrap();
|
||||
assert_eq!(collaboration_mode(&s, &models)["mode"], PLAN_COLLABORATION_MODE);
|
||||
s.set(&models, COLLABORATION_MODE, DEFAULT_COLLABORATION_MODE).unwrap();
|
||||
assert_eq!(collaboration_mode(&s, &models)["mode"], DEFAULT_COLLABORATION_MODE);
|
||||
|
||||
// A model codex runs that it doesn't list is still offered.
|
||||
let s = Settings::of(&json!({"model": "custom", "sandbox": {"type": "readOnly"}}), &models);
|
||||
@@ -226,6 +240,18 @@ fn prompts_become_user_input() {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn compact_is_recognized_with_completion_whitespace_and_attachments() {
|
||||
// Completion leaves trailing whitespace and images can remain in the prompt. The first
|
||||
// text block still names the command; unknown slash-shaped text continues normally.
|
||||
assert_eq!(commands::parse(&text("/compact")).unwrap().command, BuiltinCommand::Compact);
|
||||
assert_eq!(commands::parse(&text(" /compact \n")).unwrap().command, BuiltinCommand::Compact);
|
||||
assert_eq!(commands::parse(&text("/compact now")).unwrap().rest, "now");
|
||||
let prompt = json!([{"type": "text", "text": "/compact"}, {"type": "image", "data": "AA=="}]);
|
||||
assert_eq!(commands::parse(&prompt).unwrap().command, BuiltinCommand::Compact);
|
||||
assert!(commands::parse(&text("x/compact")).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn commands_are_titled_by_what_they_do() {
|
||||
let cmd = |actions: Value| {
|
||||
@@ -453,6 +479,7 @@ fn history_replays_turns() {
|
||||
#[derive(Default)]
|
||||
struct Client {
|
||||
updates: Mutex<Vec<Value>>,
|
||||
warnings: Mutex<Vec<Value>>,
|
||||
asked: Mutex<Vec<Value>>,
|
||||
/// Option ids to choose; `None` (or none left) cancels.
|
||||
answers: Mutex<VecDeque<Option<&'static str>>>,
|
||||
@@ -462,6 +489,8 @@ impl Handler for Client {
|
||||
fn on_notification(&self, method: &str, params: Value) {
|
||||
if method == "session/update" {
|
||||
self.updates.lock().push(params);
|
||||
} else if method == "_openidea/warning" {
|
||||
self.warnings.lock().push(params);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -527,6 +556,10 @@ async fn questions_share_one_card_and_keep_their_ids() {
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
enum Scenario {
|
||||
AuthFailure,
|
||||
Command(&'static str),
|
||||
Compact,
|
||||
PlanThenPrompt,
|
||||
PlanToggleThenPrompt,
|
||||
Interrupt,
|
||||
Resume,
|
||||
Steer,
|
||||
@@ -541,6 +574,10 @@ impl Scenario {
|
||||
fn file(self) -> &'static str {
|
||||
match self {
|
||||
Scenario::AuthFailure => "auth_failure",
|
||||
Scenario::Command(_) => "simple",
|
||||
Scenario::Compact => "simple",
|
||||
Scenario::PlanThenPrompt => "simple",
|
||||
Scenario::PlanToggleThenPrompt => "simple",
|
||||
Scenario::Interrupt => "interrupt",
|
||||
Scenario::Resume => "resume",
|
||||
Scenario::Steer => "steer",
|
||||
@@ -598,6 +635,21 @@ async fn drive(scenario: Scenario, acp: &Peer, client: &Client, cwd: &str, threa
|
||||
Scenario::AuthFailure | Scenario::Simple | Scenario::UsageLimit | Scenario::Subagent => {
|
||||
out.push(("prompt", request(acp, "session/prompt", prompt("Reply with the single word: hi")).await));
|
||||
}
|
||||
Scenario::Compact => {
|
||||
out.push(("prompt", request(acp, "session/prompt", prompt("/compact")).await));
|
||||
}
|
||||
Scenario::Command(command) => {
|
||||
out.push(("prompt", request(acp, "session/prompt", prompt(command)).await));
|
||||
}
|
||||
Scenario::PlanThenPrompt => {
|
||||
out.push(("plan", request(acp, "session/prompt", prompt("/plan")).await));
|
||||
out.push(("prompt", request(acp, "session/prompt", prompt("Reply with the single word: hi")).await));
|
||||
}
|
||||
Scenario::PlanToggleThenPrompt => {
|
||||
out.push(("plan", request(acp, "session/prompt", prompt("/plan")).await));
|
||||
out.push(("default", request(acp, "session/prompt", prompt("/plan")).await));
|
||||
out.push(("prompt", request(acp, "session/prompt", prompt("Reply with the single word: hi")).await));
|
||||
}
|
||||
Scenario::Interrupt => {
|
||||
out.push(("mode", request(acp, "session/set_config_option", set(MODE, "read-only")).await));
|
||||
let running = {
|
||||
@@ -665,6 +717,37 @@ fn load(name: &str) -> Transcript {
|
||||
Transcript { meta, frames }
|
||||
}
|
||||
|
||||
/// The simple fixture through session setup. Local commands add only the app-server calls
|
||||
/// they need after it; turn commands keep the fixture's turn notifications.
|
||||
fn command_transcript(calls: &[(&'static str, Value)]) -> Transcript {
|
||||
let mut transcript = load(Scenario::Simple.file());
|
||||
let prompt = transcript
|
||||
.frames
|
||||
.iter()
|
||||
.position(|(out, frame)| *out && frame["method"] == "turn/start")
|
||||
.expect("the scenario starts a turn");
|
||||
transcript.frames.truncate(prompt);
|
||||
transcript.frames.push((true, json!({ "id": 4, "method": "skills/list" })));
|
||||
transcript.frames.push((false, json!({ "id": 4, "result": { "data": [] } })));
|
||||
for (index, (method, result)) in calls.iter().enumerate() {
|
||||
let id = 10 + index;
|
||||
transcript.frames.push((true, json!({ "id": id, "method": method })));
|
||||
transcript.frames.push((false, json!({ "id": id, "result": result })));
|
||||
}
|
||||
transcript
|
||||
}
|
||||
|
||||
fn turn_command_transcript(method: &str) -> Transcript {
|
||||
let mut transcript = load(Scenario::Simple.file());
|
||||
let start = transcript
|
||||
.frames
|
||||
.iter_mut()
|
||||
.find(|(out, frame)| *out && frame["method"] == "turn/start")
|
||||
.expect("the scenario starts a turn");
|
||||
start.1["method"] = json!(method);
|
||||
transcript
|
||||
}
|
||||
|
||||
/// Plays codex: waits for each frame the shim should send, sends what codex sent.
|
||||
/// Returns the frames the shim sent.
|
||||
async fn play<R: AsyncRead + Unpin, W: AsyncWrite + Unpin>(
|
||||
@@ -684,10 +767,10 @@ async fn play<R: AsyncRead + Unpin, W: AsyncWrite + Unpin>(
|
||||
.unwrap()
|
||||
.unwrap_or_else(|| panic!("the shim closed before {frame}"));
|
||||
let actual: Value = serde_json::from_str(&line).unwrap();
|
||||
// Older recordings predate skill discovery and thread naming; play an
|
||||
// Older recordings predate config inspection, skill discovery and thread naming; play an
|
||||
// unsupported server.
|
||||
let method = actual["method"].as_str().unwrap_or_default();
|
||||
if matches!(method, "skills/list" | "thread/sample") && frame["method"] != method {
|
||||
if matches!(method, "config/read" | "skills/list" | "thread/sample") && frame["method"] != method {
|
||||
let reply = json!({ "id": actual["id"], "error": { "code": -32601, "message": "unsupported" } });
|
||||
write.write_all(format!("{reply}\n").as_bytes()).await.unwrap();
|
||||
continue;
|
||||
@@ -760,6 +843,149 @@ fn session_of(results: &Results, label: &str) -> String {
|
||||
result(results, label).as_ref().unwrap()["sessionId"].as_str().unwrap().to_owned()
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn configuration_warnings_before_a_session_and_runtime_warnings_reach_the_client() {
|
||||
let mut transcript = load(Scenario::Simple.file());
|
||||
transcript.frames.insert(
|
||||
0,
|
||||
(
|
||||
false,
|
||||
json!({"method": "configWarning", "params": {
|
||||
"summary": "Project-local config is disabled until the project is trusted.",
|
||||
"details": "Update the project's trust setting.", "path": "/work/.codex/config.toml"
|
||||
}}),
|
||||
),
|
||||
);
|
||||
let at = transcript.frames.iter().position(|(out, f)| *out && f["method"] == "turn/start").unwrap();
|
||||
transcript
|
||||
.frames
|
||||
.insert(at, (false, json!({"method": "warning", "params": {"message": "MCP server unavailable"}})));
|
||||
let (results, client, frames, _, _codex) = replay_transcript(Scenario::Simple, transcript).await;
|
||||
assert!(result(&results, "new").is_ok());
|
||||
assert_eq!(
|
||||
*client.warnings.lock(),
|
||||
[
|
||||
json!({"message": "Project-local config is disabled until the project is trusted.\n\nUpdate the project's trust setting.\n\n/work/.codex/config.toml"}),
|
||||
json!({"message": "MCP server unavailable"}),
|
||||
]
|
||||
);
|
||||
assert!(sent(&frames, "config/value/write").is_empty());
|
||||
assert!(sent(&frames, "config/batchWrite").is_empty());
|
||||
}
|
||||
|
||||
struct TrustServer {
|
||||
cwd: String,
|
||||
disabled: bool,
|
||||
other_project: bool,
|
||||
write_error: bool,
|
||||
overridden: bool,
|
||||
calls: Mutex<Vec<(String, Value)>>,
|
||||
}
|
||||
|
||||
impl Handler for TrustServer {
|
||||
fn on_notification(&self, _: &str, _: Value) {}
|
||||
|
||||
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
|
||||
self.calls.lock().push((method.to_owned(), params));
|
||||
match method {
|
||||
"initialize" => Ok(json!({})),
|
||||
"model/list" => Ok(json!({"data": []})),
|
||||
"config/read" => {
|
||||
let cwd =
|
||||
if self.other_project { Path::new(&self.cwd).join("other") } else { PathBuf::from(&self.cwd) };
|
||||
Ok(json!({"layers": [
|
||||
{"name": {"type": "user", "profile": null}, "version": "original"},
|
||||
{"name": {"type": "project", "dotCodexFolder": cwd.join(".codex")},
|
||||
"disabledReason": self.disabled.then_some("Project config is disabled until trusted.")}
|
||||
]}))
|
||||
}
|
||||
"config/value/write" if self.write_error => Err((-32001, "Config changed concurrently".into())),
|
||||
"config/value/write" => Ok(json!({"status": if self.overridden {"okOverridden"} else {"ok"}})),
|
||||
"thread/start" | "thread/resume" | "thread/fork" => {
|
||||
Ok(json!({"thread": {"id": "s", "turns": []}, "cwd": self.cwd}))
|
||||
}
|
||||
"skills/list" => Ok(json!({"data": []})),
|
||||
_ => Err((codes::METHOD_NOT_FOUND, method.to_owned())),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn project_trust_is_confirmed_before_new_resumed_and_forked_sessions() {
|
||||
for method in ["session/new", "session/load", "session/fork"] {
|
||||
for (answer, disabled, other_project, write_error, overridden) in [
|
||||
(Some("codex-trust-project"), true, false, false, false),
|
||||
(Some("codex-keep-untrusted"), true, false, false, false),
|
||||
(None, true, false, false, false),
|
||||
(Some("codex-trust-project"), false, false, false, false),
|
||||
(Some("codex-trust-project"), true, true, false, false),
|
||||
(Some("codex-trust-project"), true, false, true, false),
|
||||
(Some("codex-trust-project"), true, false, false, true),
|
||||
] {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let cwd = tmp.path().join("project.with.dots-项目").to_string_lossy().into_owned();
|
||||
let server = Arc::new(TrustServer {
|
||||
cwd: cwd.clone(),
|
||||
disabled,
|
||||
other_project,
|
||||
write_error,
|
||||
overridden,
|
||||
calls: Mutex::default(),
|
||||
});
|
||||
let client = Arc::new(Client::default());
|
||||
client.answers.lock().push_back(answer);
|
||||
let (ours, theirs) = tokio::io::duplex(1 << 16);
|
||||
let (read, write) = tokio::io::split(theirs);
|
||||
let native = Peer::connect_framed(read, write, server.clone(), Framing::Lines);
|
||||
let acp = attach(client.clone(), |events| {
|
||||
let (read, write) = tokio::io::split(ours);
|
||||
Ok(Peer::connect_framed(read, write, events, Framing::Lines))
|
||||
})
|
||||
.unwrap();
|
||||
request(&acp, "initialize", json!({})).await.unwrap();
|
||||
let params = json!({"cwd": cwd, "sessionId": "source", "mcpServers": []});
|
||||
request(&acp, method, params.clone()).await.unwrap();
|
||||
// The same connection must not ask repeatedly after a decline.
|
||||
request(&acp, method, params).await.unwrap();
|
||||
let approved = answer == Some("codex-trust-project") && disabled && !other_project;
|
||||
{
|
||||
let asked = client.asked.lock();
|
||||
assert_eq!(asked.len(), usize::from(disabled && !other_project));
|
||||
if let Some(permission) = asked.first() {
|
||||
assert!(permission["toolCall"]["title"].as_str().unwrap().contains(&cwd));
|
||||
assert_eq!(
|
||||
permission["toolCall"]["kind"], "edit",
|
||||
"side conversations must deny persistent trust changes"
|
||||
);
|
||||
assert_eq!(
|
||||
permission["options"][0]["kind"], "allow_always",
|
||||
"task bypass must not grant permanent trust"
|
||||
);
|
||||
}
|
||||
let calls = server.calls.lock();
|
||||
let writes: Vec<_> = calls.iter().filter(|(m, _)| m == "config/value/write").collect();
|
||||
assert_eq!(writes.len(), usize::from(approved));
|
||||
if let Some((_, write)) = writes.first() {
|
||||
assert_eq!(
|
||||
*write,
|
||||
json!({"keyPath": format!("projects.{}.trust_level", json!(cwd)), "value": "trusted", "mergeStrategy": "replace", "expectedVersion": "original"})
|
||||
);
|
||||
let written = calls.iter().position(|(m, _)| m == "config/value/write").unwrap();
|
||||
let started = calls.iter().position(|(m, _)| m.starts_with("thread/")).unwrap();
|
||||
assert!(written < started, "the session must load config after the write");
|
||||
}
|
||||
}
|
||||
// Drain notifications sent before the last response.
|
||||
tokio::time::sleep(Duration::from_millis(20)).await;
|
||||
if approved && (write_error || overridden) {
|
||||
assert!(!client.warnings.lock().is_empty());
|
||||
}
|
||||
acp.kill();
|
||||
native.kill();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn auth_failure_names_auth() {
|
||||
let (results, _client, frames, _) = replay(Scenario::AuthFailure).await;
|
||||
@@ -771,7 +997,7 @@ async fn auth_failure_names_auth() {
|
||||
let categories: Vec<&str> =
|
||||
new["configOptions"].as_array().unwrap().iter().map(|o| o["category"].as_str().unwrap()).collect();
|
||||
// The model the user's codex config names; codex doesn't list it, so its efforts are unknown.
|
||||
assert_eq!(categories, ["model", "mode"]);
|
||||
assert_eq!(categories, ["model", "mode", "collaboration_mode"]);
|
||||
let model = new["configOptions"][0]["currentValue"].as_str().unwrap();
|
||||
assert_eq!(model, "gpt-6-luna");
|
||||
assert!(new["configOptions"][0]["options"].as_array().unwrap().iter().any(|o| o["value"] == model));
|
||||
@@ -1011,6 +1237,7 @@ async fn settings_apply_to_the_next_turn() {
|
||||
(starts[0]["params"]["model"].as_str(), starts[0]["params"]["effort"].as_str()),
|
||||
(Some("gpt-5.6-luna"), Some("medium"))
|
||||
);
|
||||
assert!(starts[0]["params"].get("collaborationMode").is_none());
|
||||
assert_eq!(
|
||||
(starts[1]["params"]["model"].as_str(), starts[1]["params"]["effort"].as_str()),
|
||||
(Some("gpt-5.5"), Some("high"))
|
||||
@@ -1019,6 +1246,192 @@ async fn settings_apply_to_the_next_turn() {
|
||||
assert_eq!(client.text(&session, "agent_message_chunk"), "oneOn it.\n\ntwo");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn compact_is_started_through_its_app_server_method() {
|
||||
// Play the ordinary-turn fixture with the request swapped: the notifications are the
|
||||
// same, while this pins the user-visible command to `thread/compact/start`, not a prompt.
|
||||
let mut transcript = load(Scenario::Simple.file());
|
||||
let start = transcript
|
||||
.frames
|
||||
.iter_mut()
|
||||
.find(|(out, frame)| *out && frame["method"] == "turn/start")
|
||||
.expect("the scenario starts a turn");
|
||||
start.1["method"] = json!("thread/compact/start");
|
||||
let (results, _client, frames, _meta, _codex) = replay_transcript(Scenario::Compact, transcript).await;
|
||||
|
||||
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({"stopReason": "end_turn"}));
|
||||
assert!(sent(&frames, "turn/start").is_empty());
|
||||
assert_eq!(sent(&frames, "thread/compact/start").len(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn review_commands_start_the_matching_review_target() {
|
||||
for (prompt, target) in [
|
||||
("/review", json!({ "type": "uncommittedChanges" })),
|
||||
("/review focus on errors", json!({ "type": "custom", "instructions": "focus on errors" })),
|
||||
("/review-branch origin/main", json!({ "type": "baseBranch", "branch": "origin/main" })),
|
||||
("/review-commit abc123", json!({ "type": "commit", "sha": "abc123", "title": null })),
|
||||
] {
|
||||
let (results, _client, frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::Command(prompt), turn_command_transcript("review/start")).await;
|
||||
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }), "{prompt}");
|
||||
assert!(sent(&frames, "turn/start").is_empty(), "{prompt}");
|
||||
assert_eq!(sent(&frames, "review/start")[0]["params"]["target"], target, "{prompt}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn plan_toggles_collaboration_mode_and_updates_the_composer() {
|
||||
let (results, client, _frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::Command("/plan"), command_transcript(&[])).await;
|
||||
let session = session_of(&results, "new");
|
||||
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
|
||||
let update = client.of(&session).into_iter().find(|u| u["sessionUpdate"] == "config_option_update").unwrap();
|
||||
let plan =
|
||||
update["configOptions"].as_array().unwrap().iter().find(|o| o["category"] == "collaboration_mode").unwrap();
|
||||
assert_eq!(plan["currentValue"], "plan");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn plan_applies_to_the_next_normal_turn() {
|
||||
let (results, _client, frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::PlanThenPrompt, load(Scenario::Simple.file())).await;
|
||||
assert_eq!(result(&results, "plan").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
|
||||
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
|
||||
let start = sent(&frames, "turn/start")[0];
|
||||
assert_eq!(start["params"]["collaborationMode"]["mode"], "plan");
|
||||
assert_eq!(start["params"]["collaborationMode"]["settings"]["model"], "gpt-5.6-luna");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn toggling_plan_off_sends_an_explicit_default_once() {
|
||||
let (results, _client, frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::PlanToggleThenPrompt, load(Scenario::Simple.file())).await;
|
||||
assert_eq!(result(&results, "default").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
|
||||
let start = sent(&frames, "turn/start")[0];
|
||||
assert_eq!(start["params"]["collaborationMode"]["mode"], "default");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn informational_commands_report_skills_mcp_and_status() {
|
||||
let skills = json!({ "data": [{ "skills": [
|
||||
{ "name": "review", "enabled": true, "description": "Review changes" },
|
||||
{ "name": "hidden", "enabled": false, "description": "Hidden" }
|
||||
] }] });
|
||||
let servers = json!({ "data": [
|
||||
{ "name": "github", "runtimeStatus": "connected", "authStatus": "oAuth", "tools": { "search": {} } },
|
||||
{ "name": "docs", "runtimeStatus": "failed", "authStatus": "unknown", "tools": {} }
|
||||
] });
|
||||
for (prompt, method, response, expected) in [
|
||||
("/skills", "skills/list", skills, "Available skills:\n- review: Review changes"),
|
||||
(
|
||||
"/mcp",
|
||||
"mcpServerStatus/list",
|
||||
servers,
|
||||
"MCP servers:\n- github: connected, 1 tools\n- docs: failed, 0 tools",
|
||||
),
|
||||
("/status", "", Value::Null, "**Session:**"),
|
||||
] {
|
||||
let calls: &[(&str, Value)] = if method.is_empty() { &[] } else { &[(method, response)] };
|
||||
let calls: Vec<(&'static str, Value)> = calls
|
||||
.iter()
|
||||
.map(|(method, response)| {
|
||||
let method = match *method {
|
||||
"skills/list" => "skills/list",
|
||||
"mcpServerStatus/list" => "mcpServerStatus/list",
|
||||
other => panic!("unexpected method {other}"),
|
||||
};
|
||||
(method, response.clone())
|
||||
})
|
||||
.collect();
|
||||
let (results, client, _frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::Command(prompt), command_transcript(&calls)).await;
|
||||
let session = session_of(&results, "new");
|
||||
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
|
||||
assert!(client.text(&session, "agent_message_chunk").contains(expected), "{prompt}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn rename_and_logout_use_their_app_server_actions() {
|
||||
let (results, client, frames, _meta, _codex) = replay_transcript(
|
||||
Scenario::Command("/rename Better name"),
|
||||
command_transcript(&[("thread/name/set", json!({}))]),
|
||||
)
|
||||
.await;
|
||||
let session = session_of(&results, "new");
|
||||
assert_eq!(sent(&frames, "thread/name/set")[0]["params"], json!({ "threadId": session, "name": "Better name" }));
|
||||
let info = client.of(&session).into_iter().find(|u| u["sessionUpdate"] == "session_info_update").unwrap();
|
||||
assert_eq!((info["title"].as_str(), info["userNamed"].as_bool()), (Some("Better name"), Some(true)));
|
||||
|
||||
let (results, client, frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::Command("/logout"), command_transcript(&[("account/logout", json!({}))])).await;
|
||||
let session = session_of(&results, "new");
|
||||
assert_eq!(sent(&frames, "account/logout").len(), 1);
|
||||
assert_eq!(client.text(&session, "agent_message_chunk"), "Logged out from Codex account.");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn goal_commands_set_pause_resume_and_clear_through_app_server() {
|
||||
for (prompt, method, params, result) in [
|
||||
(
|
||||
"/goal fix the failing tests",
|
||||
"thread/goal/set",
|
||||
json!({ "threadId": "s", "objective": "fix the failing tests", "status": "active", "origin": "user" }),
|
||||
json!({ "goal": { "status": "active" } }),
|
||||
),
|
||||
(
|
||||
"/goal pause",
|
||||
"thread/goal/set",
|
||||
json!({ "threadId": "s", "status": "paused", "origin": "user" }),
|
||||
json!({ "goal": { "status": "paused" } }),
|
||||
),
|
||||
(
|
||||
"/goal resume",
|
||||
"thread/goal/set",
|
||||
json!({ "threadId": "s", "status": "active", "origin": "user" }),
|
||||
json!({ "goal": { "status": "active" } }),
|
||||
),
|
||||
("/goal clear", "thread/goal/clear", json!({ "threadId": "s" }), json!({ "cleared": true })),
|
||||
] {
|
||||
let (results, _client, frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::Command(prompt), command_transcript(&[(method, result)])).await;
|
||||
let session = session_of(&results, "new");
|
||||
let sent = sent(&frames, method);
|
||||
assert_eq!(sent.len(), 1, "{prompt}");
|
||||
let mut expected = params;
|
||||
expected["threadId"] = json!(session);
|
||||
assert_eq!(sent[0]["params"], expected, "{prompt}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn missing_review_arguments_print_usage_without_starting_a_turn() {
|
||||
for prompt in ["/review-branch", "/review-commit", "/rename", "/goal"] {
|
||||
let (results, client, frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::Command(prompt), command_transcript(&[])).await;
|
||||
let session = session_of(&results, "new");
|
||||
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
|
||||
assert!(sent(&frames, "turn/start").is_empty());
|
||||
assert!(client.text(&session, "agent_message_chunk").starts_with("Command \""), "{prompt}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn mcp_reconnect_reloads_before_reporting_status() {
|
||||
let servers =
|
||||
json!({ "data": [{ "name": "github", "runtimeStatus": "connected", "authStatus": "oAuth", "tools": {} }] });
|
||||
let (results, client, frames, _meta, _codex) = replay_transcript(
|
||||
Scenario::Command("/mcp reconnect"),
|
||||
command_transcript(&[("config/mcpServer/reload", json!({})), ("mcpServerStatus/list", servers)]),
|
||||
)
|
||||
.await;
|
||||
let session = session_of(&results, "new");
|
||||
assert_eq!(sent(&frames, "config/mcpServer/reload").len(), 1);
|
||||
assert_eq!(sent(&frames, "mcpServerStatus/list").len(), 1);
|
||||
assert!(client.text(&session, "agent_message_chunk").contains("github: connected"));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn approvals_are_asked_and_answered() {
|
||||
let (results, client, frames, _) = replay(Scenario::Approvals).await;
|
||||
@@ -1258,6 +1671,17 @@ fn session_mcp_servers_become_thread_configuration() {
|
||||
json!({"mcp_servers":{"OpenIDEA":{"command":"/app/openidea","args":["--mcp-stdio","--project","/project"],"env":{"K":"V"}}}})
|
||||
)
|
||||
);
|
||||
let external = std::collections::BTreeSet::from(["linear".to_owned()]);
|
||||
assert_eq!(
|
||||
super::translate::mcp_config_with_external(
|
||||
&json!({
|
||||
"mcpServers": [],
|
||||
"_meta": { "openidea": { "mcpServersOff": ["linear", "not-in-codex"] } }
|
||||
}),
|
||||
&external,
|
||||
),
|
||||
Some(json!({ "mcp_servers": { "linear": { "enabled": false } } }))
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
|
||||
@@ -138,6 +138,12 @@ pub(super) struct Settings {
|
||||
pub model: String,
|
||||
pub effort: Option<String>,
|
||||
pub mode: Mode,
|
||||
/// Codex's Default/Plan collaboration mode. It is sent with each turn because it is
|
||||
/// part of the turn contract rather than the sandbox permission mode above.
|
||||
pub collaboration_mode: String,
|
||||
/// A mode just chosen by the user, sent once even when it is Default so a resumed Plan
|
||||
/// thread is explicitly reset. Subsequent default turns can omit the field again.
|
||||
pub collaboration_mode_override: Option<String>,
|
||||
}
|
||||
|
||||
impl Settings {
|
||||
@@ -156,6 +162,12 @@ impl Settings {
|
||||
result.get("approvalPolicy").unwrap_or(&Value::Null),
|
||||
result.get("sandbox").unwrap_or(&Value::Null),
|
||||
),
|
||||
collaboration_mode: result
|
||||
.pointer("/collaborationMode/mode")
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or(DEFAULT_COLLABORATION_MODE)
|
||||
.to_owned(),
|
||||
collaboration_mode_override: None,
|
||||
};
|
||||
s.fit_effort(models);
|
||||
s
|
||||
@@ -194,6 +206,13 @@ impl Settings {
|
||||
self.effort = Some(value.to_owned());
|
||||
}
|
||||
MODE => self.mode = Mode::parse(value).ok_or_else(|| format!("unknown mode {value}"))?,
|
||||
COLLABORATION_MODE => {
|
||||
if !matches!(value, DEFAULT_COLLABORATION_MODE | PLAN_COLLABORATION_MODE) {
|
||||
return Err(format!("unknown collaboration mode {value}"));
|
||||
}
|
||||
self.collaboration_mode = value.to_owned();
|
||||
self.collaboration_mode_override = Some(value.to_owned());
|
||||
}
|
||||
_ => return Err(format!("unknown setting {option}")),
|
||||
}
|
||||
Ok(())
|
||||
@@ -203,6 +222,9 @@ impl Settings {
|
||||
pub(super) const MODEL: &str = "model";
|
||||
pub(super) const EFFORT: &str = "reasoning_effort";
|
||||
pub(super) const MODE: &str = "mode";
|
||||
pub(super) const COLLABORATION_MODE: &str = "collaboration_mode";
|
||||
pub(super) const DEFAULT_COLLABORATION_MODE: &str = "default";
|
||||
pub(super) const PLAN_COLLABORATION_MODE: &str = "plan";
|
||||
|
||||
/// ACP `configOptions`: model, reasoning effort (for models that have it) and mode.
|
||||
pub(super) fn config_options(models: &[ModelInfo], s: &Settings) -> Value {
|
||||
@@ -235,9 +257,32 @@ pub(super) fn config_options(models: &[ModelInfo], s: &Settings) -> Value {
|
||||
"id": MODE, "name": "Mode", "category": "mode", "type": "select", "currentValue": s.mode.id(),
|
||||
"options": Mode::ALL.iter().map(|m| select_value(m.id(), m.name(), Some(m.description()))).collect::<Vec<_>>(),
|
||||
}));
|
||||
out.push(json!({
|
||||
"id": COLLABORATION_MODE,
|
||||
"name": "Collaboration mode",
|
||||
"category": "collaboration_mode",
|
||||
"type": "select",
|
||||
"currentValue": s.collaboration_mode,
|
||||
"options": [
|
||||
select_value(DEFAULT_COLLABORATION_MODE, "Default", Some("Execute changes directly")),
|
||||
select_value(PLAN_COLLABORATION_MODE, "Plan", Some("Plan before making changes")),
|
||||
],
|
||||
}));
|
||||
Value::Array(out)
|
||||
}
|
||||
|
||||
/// `turn/start.collaborationMode`: the preset plus the selected model settings.
|
||||
pub(super) fn collaboration_mode(settings: &Settings, models: &[ModelInfo]) -> Value {
|
||||
json!({
|
||||
"mode": settings.collaboration_mode_override.as_deref().unwrap_or(&settings.collaboration_mode),
|
||||
"settings": {
|
||||
"model": settings.model_slug(models),
|
||||
"reasoning_effort": settings.effort,
|
||||
"developer_instructions": null,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
fn select_value(value: &str, name: &str, description: Option<&str>) -> Value {
|
||||
let mut v = json!({ "value": value, "name": name });
|
||||
if let Some(d) = description {
|
||||
@@ -878,8 +923,18 @@ fn str_of(v: &Value, key: &str) -> Option<String> {
|
||||
|
||||
/// Session-scoped MCP configuration, carried in thread/start, resume and fork.
|
||||
pub(super) fn mcp_config(params: &Value) -> Option<Value> {
|
||||
let home = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(std::path::PathBuf::from);
|
||||
let cwd = params.get("cwd").and_then(Value::as_str).map_or_else(|| std::path::Path::new("."), std::path::Path::new);
|
||||
let external = crate::mcp::codex_external_server_names(home.as_deref(), cwd);
|
||||
mcp_config_with_external(params, &external)
|
||||
}
|
||||
|
||||
pub(super) fn mcp_config_with_external(
|
||||
params: &Value,
|
||||
external_names: &std::collections::BTreeSet<String>,
|
||||
) -> Option<Value> {
|
||||
let mut servers = serde_json::Map::new();
|
||||
for server in params.get("mcpServers")?.as_array()? {
|
||||
for server in params.get("mcpServers").and_then(Value::as_array).into_iter().flatten() {
|
||||
if server.get("type").and_then(Value::as_str).is_some_and(|t| t != "stdio") {
|
||||
continue;
|
||||
}
|
||||
@@ -901,5 +956,16 @@ pub(super) fn mcp_config(params: &Value) -> Option<Value> {
|
||||
"args":server.get("args").cloned().unwrap_or_else(||json!([])),"env":env}),
|
||||
);
|
||||
}
|
||||
for name in params
|
||||
.pointer("/_meta/openidea/mcpServersOff")
|
||||
.and_then(Value::as_array)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(Value::as_str)
|
||||
{
|
||||
if !servers.contains_key(name) && external_names.contains(name) {
|
||||
servers.insert(name.to_owned(), json!({ "enabled": false }));
|
||||
}
|
||||
}
|
||||
(!servers.is_empty()).then(|| json!({"mcp_servers":servers}))
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
//! A project trusted by the IDE may still be untrusted by Codex. Ask before changing
|
||||
//! Codex's own decision; only its config API writes the current project's trust entry.
|
||||
|
||||
use super::*;
|
||||
|
||||
fn disabled_project<'a>(config: &'a Value, cwd: &str) -> Option<&'a Value> {
|
||||
let folder = Path::new(cwd).join(".codex");
|
||||
config.get("layers")?.as_array()?.iter().find(|layer| {
|
||||
layer.pointer("/name/type").and_then(Value::as_str) == Some("project")
|
||||
&& layer
|
||||
.pointer("/name/dotCodexFolder")
|
||||
.and_then(Value::as_str)
|
||||
.is_some_and(|path| Path::new(path) == folder)
|
||||
&& layer.get("disabledReason").and_then(Value::as_str).is_some_and(|reason| !reason.trim().is_empty())
|
||||
})
|
||||
}
|
||||
|
||||
impl CodexShim {
|
||||
pub(super) async fn prepare_project_trust(&self, params: &Value) {
|
||||
let Some(cwd) = params.get("cwd").and_then(Value::as_str) else { return };
|
||||
if !self.state.lock().trust_checked.insert(cwd.to_owned()) {
|
||||
return;
|
||||
}
|
||||
// Old app-servers may not expose config layers. Their warnings still reach the UI.
|
||||
let Ok(Ok(config)) = tokio::time::timeout(
|
||||
Duration::from_secs(5),
|
||||
self.call("config/read", json!({ "cwd": cwd, "includeLayers": true })),
|
||||
)
|
||||
.await
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let Some(layer) = disabled_project(&config, cwd) else { return };
|
||||
let Some(client) = self.client.get() else { return };
|
||||
let title = format!(
|
||||
"Trust project in Codex: {cwd}? This saves trust in your Codex user configuration and allows \
|
||||
this project's MCP servers, hooks and exec policies to load."
|
||||
);
|
||||
let permission = json!({
|
||||
"sessionId": params.get("sessionId").and_then(Value::as_str).unwrap_or_default(),
|
||||
"toolCall": {
|
||||
"toolCallId": format!("codex-project-trust:{cwd}"),
|
||||
"title": title, "kind": "edit",
|
||||
"rawInput": { "project": cwd },
|
||||
},
|
||||
"options": [
|
||||
// Permanent trust must never be auto-approved by the task's allow-once bypass.
|
||||
{ "optionId": "codex-trust-project", "name": "Trust Project in Codex", "kind": "allow_always" },
|
||||
{ "optionId": "codex-keep-untrusted", "name": "Keep Untrusted", "kind": "reject_once" },
|
||||
],
|
||||
});
|
||||
let answer: Result<Value, RpcError> = client.request("session/request_permission", permission, None).await;
|
||||
let approved = answer.as_ref().is_ok_and(|answer| {
|
||||
answer.pointer("/outcome/outcome").and_then(Value::as_str) == Some("selected")
|
||||
&& answer.pointer("/outcome/optionId").and_then(Value::as_str) == Some("codex-trust-project")
|
||||
});
|
||||
if !approved {
|
||||
if let Some(reason) = layer.get("disabledReason").and_then(Value::as_str) {
|
||||
self.warning(reason);
|
||||
}
|
||||
return;
|
||||
}
|
||||
// Quote the path as one key segment: dots and Windows backslashes are literal.
|
||||
let mut write = json!({
|
||||
"keyPath": format!("projects.{}.trust_level", json!(cwd)),
|
||||
"value": "trusted", "mergeStrategy": "replace",
|
||||
});
|
||||
if let Some(version) = config["layers"]
|
||||
.as_array()
|
||||
.and_then(|layers| {
|
||||
layers.iter().find(|layer| {
|
||||
layer.pointer("/name/type").and_then(Value::as_str) == Some("user")
|
||||
&& layer.pointer("/name/profile").is_none_or(Value::is_null)
|
||||
})
|
||||
})
|
||||
.and_then(|layer| layer.get("version"))
|
||||
.filter(|version| version.is_string())
|
||||
{
|
||||
write["expectedVersion"] = version.clone();
|
||||
}
|
||||
match self.call("config/value/write", write).await {
|
||||
Err(error) => self.warning(format!("Codex could not save trust for {cwd}: {}", error.message)),
|
||||
Ok(reply) if reply["status"] == "okOverridden" => {
|
||||
self.warning(format!(
|
||||
"Codex saved trust for {cwd}, but a higher-priority configuration overrides it. \
|
||||
Project configuration may remain disabled; check the Codex configuration or contact your administrator."
|
||||
));
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
// start/resume/fork now load the updated config before creating the thread.
|
||||
}
|
||||
}
|
||||
@@ -19,6 +19,7 @@ mod translate;
|
||||
mod tests;
|
||||
|
||||
use super::Shim;
|
||||
use crate::BACKGROUND_TASKS_UPDATE;
|
||||
use crate::acp::AUTH_REQUIRED;
|
||||
use crate::provider::ProviderSpec;
|
||||
use ide_jsonrpc::{Framing, Handler, Peer, RpcError, codes};
|
||||
@@ -296,6 +297,25 @@ struct SessionEntry {
|
||||
prompt: Option<oneshot::Sender<TurnTerminal>>,
|
||||
early_cancel: Option<Instant>,
|
||||
temp_files: Vec<PathBuf>,
|
||||
/// Copilot's main agent loop is processing. It goes idle (`assistant.idle`) before the
|
||||
/// turn ends (`session.idle`) while background shells or agents it started still run.
|
||||
main_busy: bool,
|
||||
/// Counts `session.tasks.list` requests, so only the latest answer is reported.
|
||||
tasks_seq: u64,
|
||||
}
|
||||
|
||||
impl SessionEntry {
|
||||
fn new(settings: Settings) -> Self {
|
||||
Self {
|
||||
settings,
|
||||
translator: EventTranslator::default(),
|
||||
prompt: None,
|
||||
early_cancel: None,
|
||||
temp_files: Vec::new(),
|
||||
main_busy: false,
|
||||
tasks_seq: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct CopilotEvents(Weak<CopilotShim>);
|
||||
@@ -411,6 +431,7 @@ impl CopilotShim {
|
||||
"session/set_config_option" => self.set_config(¶ms).await,
|
||||
"session/prompt" => self.prompt(¶ms, false).await,
|
||||
"_openidea/steer" => self.prompt(¶ms, true).await,
|
||||
"_openidea/stop_task" => self.stop_task(¶ms).await,
|
||||
"session/close" => self.close_session(¶ms).await,
|
||||
_ => Err(error(codes::METHOD_NOT_FOUND, format!("unsupported method {method}"))),
|
||||
}
|
||||
@@ -425,7 +446,7 @@ impl CopilotShim {
|
||||
"promptCapabilities": { "image": true, "audio": false, "embeddedContext": true },
|
||||
"mcpCapabilities": { "http": true, "sse": true, "stdio": true },
|
||||
"sessionCapabilities": { "close": {}, "list": {} },
|
||||
"_meta": { "openidea": { "steer": true } },
|
||||
"_meta": { "openidea": { "steer": true, "backgroundTasks": true } },
|
||||
},
|
||||
"agentInfo": {
|
||||
"name": "copilot",
|
||||
@@ -471,6 +492,9 @@ impl CopilotShim {
|
||||
if let Some(mcp) = translate::wire_mcp_servers(params.get("mcpServers")) {
|
||||
req["mcpServers"] = mcp;
|
||||
}
|
||||
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
|
||||
req["disabledMcpServers"] = disabled;
|
||||
}
|
||||
|
||||
let created = self.call("session.create", req).await?;
|
||||
let session_id = created
|
||||
@@ -489,16 +513,7 @@ impl CopilotShim {
|
||||
}
|
||||
|
||||
let options = models::config_options(&catalog, &settings);
|
||||
self.state.lock().sessions.insert(
|
||||
session_id.clone(),
|
||||
SessionEntry {
|
||||
settings,
|
||||
translator: EventTranslator::default(),
|
||||
prompt: None,
|
||||
early_cancel: None,
|
||||
temp_files: Vec::new(),
|
||||
},
|
||||
);
|
||||
self.state.lock().sessions.insert(session_id.clone(), SessionEntry::new(settings));
|
||||
self.publish_commands(&session_id, cwd);
|
||||
Ok(json!({
|
||||
"sessionId": session_id,
|
||||
@@ -527,6 +542,9 @@ impl CopilotShim {
|
||||
if let Some(mcp) = translate::wire_mcp_servers(params.get("mcpServers")) {
|
||||
req["mcpServers"] = mcp;
|
||||
}
|
||||
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
|
||||
req["disabledMcpServers"] = disabled;
|
||||
}
|
||||
|
||||
let resumed = self.call("session.resume", req).await?;
|
||||
if let Ok(current) = self.call("session.model.getCurrent", json!({ "sessionId": session_id })).await {
|
||||
@@ -542,16 +560,7 @@ impl CopilotShim {
|
||||
}
|
||||
let actual_id = resumed.get("sessionId").and_then(Value::as_str).unwrap_or(&session_id).to_owned();
|
||||
let options = models::config_options(&catalog, &settings);
|
||||
self.state.lock().sessions.insert(
|
||||
actual_id.clone(),
|
||||
SessionEntry {
|
||||
settings,
|
||||
translator: EventTranslator::default(),
|
||||
prompt: None,
|
||||
early_cancel: None,
|
||||
temp_files: Vec::new(),
|
||||
},
|
||||
);
|
||||
self.state.lock().sessions.insert(actual_id.clone(), SessionEntry::new(settings));
|
||||
self.publish_commands(&actual_id, cwd);
|
||||
Ok(json!({
|
||||
"sessionId": actual_id,
|
||||
@@ -653,7 +662,11 @@ impl CopilotShim {
|
||||
let (text, attachments, temp_files) = build_prompt_payload(&session_id, blocks);
|
||||
|
||||
if steer {
|
||||
let is_running = self.state.lock().sessions.get(&session_id).is_some_and(|e| e.prompt.is_some());
|
||||
let (is_running, main_busy) = {
|
||||
let st = self.state.lock();
|
||||
let entry = st.sessions.get(&session_id);
|
||||
(entry.is_some_and(|e| e.prompt.is_some()), entry.is_some_and(|e| e.main_busy))
|
||||
};
|
||||
if !is_running {
|
||||
cleanup_files(&temp_files);
|
||||
return Err(error(codes::INVALID_PARAMS, "no turn running to steer"));
|
||||
@@ -661,14 +674,25 @@ impl CopilotShim {
|
||||
let mut send_req = json!({
|
||||
"sessionId": session_id,
|
||||
"prompt": text,
|
||||
"mode": "immediate",
|
||||
});
|
||||
// Joins the running loop; once it went idle (only background work is left), a plain
|
||||
// send starts the loop again with this message.
|
||||
if main_busy {
|
||||
send_req["mode"] = json!("immediate");
|
||||
}
|
||||
if !attachments.is_empty() {
|
||||
send_req["attachments"] = Value::Array(attachments);
|
||||
}
|
||||
if !main_busy && let Some(entry) = self.state.lock().sessions.get_mut(&session_id) {
|
||||
// Stop must abort the run this send starts, even before `assistant.turn_start`.
|
||||
entry.main_busy = true;
|
||||
}
|
||||
let res = self.call("session.send", send_req).await;
|
||||
if let Some(entry) = self.state.lock().sessions.get_mut(&session_id) {
|
||||
entry.temp_files.extend(temp_files);
|
||||
if res.is_err() && !main_busy {
|
||||
entry.main_busy = false;
|
||||
}
|
||||
}
|
||||
res?;
|
||||
return Ok(json!({}));
|
||||
@@ -685,6 +709,7 @@ impl CopilotShim {
|
||||
let mode = entry.settings.mode.wire();
|
||||
if !early {
|
||||
entry.prompt = Some(done_tx);
|
||||
entry.main_busy = true;
|
||||
}
|
||||
(mode, early)
|
||||
};
|
||||
@@ -734,19 +759,24 @@ impl CopilotShim {
|
||||
}
|
||||
|
||||
fn cancel(&self, session_id: &str) {
|
||||
let has_turn = {
|
||||
let (has_turn, ended) = {
|
||||
let mut st = self.state.lock();
|
||||
if let Some(entry) = st.sessions.get_mut(session_id) {
|
||||
if entry.prompt.is_none() {
|
||||
match st.sessions.get_mut(session_id) {
|
||||
Some(entry) if entry.prompt.is_none() => {
|
||||
entry.early_cancel = Some(Instant::now());
|
||||
false
|
||||
} else {
|
||||
true
|
||||
(false, None)
|
||||
}
|
||||
} else {
|
||||
false
|
||||
// The agent is done with the turn and only its background work runs, which
|
||||
// `session.idle` waits for: the turn ends now and that work keeps running
|
||||
// (it shows as background tasks, stoppable one by one).
|
||||
Some(entry) if !entry.main_busy => (false, entry.prompt.take()),
|
||||
Some(_) => (true, None),
|
||||
None => (false, None),
|
||||
}
|
||||
};
|
||||
if let Some(tx) = ended {
|
||||
let _ = tx.send(TurnTerminal::Idle { aborted: true });
|
||||
}
|
||||
if has_turn {
|
||||
let peer = self.copilot().clone();
|
||||
let sid = session_id.to_owned();
|
||||
@@ -790,10 +820,23 @@ impl CopilotShim {
|
||||
return;
|
||||
}
|
||||
|
||||
let main_agent = event.get("agentId").and_then(Value::as_str).is_none_or(str::is_empty);
|
||||
let event_type = event.get("type").and_then(Value::as_str).unwrap_or_default();
|
||||
if main_agent && event_type == "session.background_tasks_changed" {
|
||||
self.refresh_background_tasks(session_id);
|
||||
}
|
||||
|
||||
let catalog_snapshot = self.catalog.try_lock().ok().and_then(|g| g.clone());
|
||||
let (updates, done) = {
|
||||
let mut st = self.state.lock();
|
||||
let Some(entry) = st.sessions.get_mut(session_id) else { return };
|
||||
if main_agent {
|
||||
match event_type {
|
||||
"assistant.turn_start" => entry.main_busy = true,
|
||||
"assistant.idle" | "session.idle" | "session.error" => entry.main_busy = false,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
let fallback_limit =
|
||||
catalog_snapshot.as_deref().and_then(|models| entry.settings.active_context_tokens(models));
|
||||
let translated = entry.translator.translate(session_id, event, fallback_limit);
|
||||
@@ -803,11 +846,44 @@ impl CopilotShim {
|
||||
for (target_session, update) in updates {
|
||||
self.send_update(&target_session, update);
|
||||
}
|
||||
if main_agent && event_type == "session.idle" {
|
||||
// Nothing runs in the background any more.
|
||||
self.send_update(session_id, json!({ "sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": [] }));
|
||||
}
|
||||
if let Some((tx, outcome)) = done {
|
||||
let _ = tx.send(outcome);
|
||||
}
|
||||
}
|
||||
|
||||
/// Reports the session's running background shells and agents (`session.tasks.list`).
|
||||
fn refresh_background_tasks(self: &Arc<Self>, session_id: &str) {
|
||||
let seq = {
|
||||
let mut st = self.state.lock();
|
||||
let Some(entry) = st.sessions.get_mut(session_id) else { return };
|
||||
entry.tasks_seq += 1;
|
||||
entry.tasks_seq
|
||||
};
|
||||
let shim = self.clone();
|
||||
let sid = session_id.to_owned();
|
||||
self.runtime.spawn(async move {
|
||||
let Ok(list) = shim.call("session.tasks.list", json!({ "sessionId": sid })).await else { return };
|
||||
let latest = shim.state.lock().sessions.get(&sid).is_some_and(|e| e.tasks_seq == seq);
|
||||
if latest {
|
||||
let tasks = translate::background_tasks(&list);
|
||||
shim.send_update(&sid, json!({ "sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": tasks }));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Stops one background shell or agent (`session.tasks.cancel`).
|
||||
async fn stop_task(self: &Arc<Self>, params: &Value) -> Result<Value, ResponseError> {
|
||||
let session_id = str_param(params, "sessionId")?;
|
||||
let task_id = str_param(params, "taskId")?;
|
||||
self.call("session.tasks.cancel", json!({ "sessionId": session_id, "id": task_id })).await?;
|
||||
self.refresh_background_tasks(session_id);
|
||||
Ok(json!({}))
|
||||
}
|
||||
|
||||
fn handle_permission_event(self: &Arc<Self>, session_id: &str, event: &Value) {
|
||||
let data = &event["data"];
|
||||
if data.get("resolvedByHook").and_then(Value::as_bool) == Some(true) {
|
||||
|
||||
@@ -6,6 +6,7 @@ use ide_jsonrpc::{Framing, Handler, Peer, codes};
|
||||
use parking_lot::Mutex;
|
||||
use serde_json::{Value, json};
|
||||
use std::sync::{Arc, OnceLock};
|
||||
use std::time::Duration;
|
||||
|
||||
fn sample_models_list() -> Value {
|
||||
json!({
|
||||
@@ -340,6 +341,12 @@ fn headless_and_acp_args_roundtrip_while_preserving_user_flags() {
|
||||
struct FakeCopilotServer {
|
||||
peer: OnceLock<Peer>,
|
||||
calls: Mutex<Vec<(String, Value)>>,
|
||||
/// `session.send` leaves a shell running: the main loop goes idle but the session doesn't.
|
||||
background_shell: bool,
|
||||
}
|
||||
|
||||
fn copilot_event(sid: &str, event: Value) -> Value {
|
||||
json!({ "sessionId": sid, "event": event })
|
||||
}
|
||||
|
||||
impl Handler for FakeCopilotServer {
|
||||
@@ -355,12 +362,36 @@ impl Handler for FakeCopilotServer {
|
||||
"commands.list" => Ok(json!({ "commands": [{ "name": "compact", "description": "Compact context" }] })),
|
||||
"skills.discover" => Ok(json!({ "skills": [] })),
|
||||
"session.create" => Ok(json!({ "sessionId": "cop-sess-1" })),
|
||||
"session.resume" => Ok(json!({ "sessionId": params["sessionId"] })),
|
||||
"session.model.getCurrent" => Ok(json!({ "modelId": "gemini-4-carbon" })),
|
||||
"session.model.switchTo" => Ok(json!({ "modelId": params["modelId"] })),
|
||||
"session.mode.set" => Ok(json!({})),
|
||||
"session.permissions.setApproveAll" => {
|
||||
assert!(params.get("enabled").and_then(Value::as_bool).is_some());
|
||||
Ok(json!({ "success": true }))
|
||||
}
|
||||
"session.tasks.list" => Ok(json!({ "tasks": [
|
||||
{ "id": "shell-1", "type": "shell", "status": "running", "description": "",
|
||||
"command": "gh pr checks 3819 --watch", "attachmentMode": "attached" },
|
||||
{ "id": "shell-0", "type": "shell", "status": "completed", "description": "ls", "command": "ls" },
|
||||
] })),
|
||||
"session.tasks.cancel" => Ok(json!({ "cancelled": true })),
|
||||
"session.abort" => Ok(json!({})),
|
||||
"session.send" if self.background_shell => {
|
||||
if let Some(peer) = self.peer.get().cloned() {
|
||||
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
|
||||
std::thread::spawn(move || {
|
||||
for event in [
|
||||
json!({ "id": "b1", "type": "assistant.turn_start", "data": { "turnId": "t1" } }),
|
||||
json!({ "id": "b2", "type": "assistant.idle", "data": {} }),
|
||||
json!({ "id": "b3", "type": "session.background_tasks_changed", "data": {} }),
|
||||
] {
|
||||
let _ = peer.notify("session.event", copilot_event(&sid, event));
|
||||
}
|
||||
});
|
||||
}
|
||||
Ok(json!({ "messageId": "msg-1" }))
|
||||
}
|
||||
"session.send" => {
|
||||
if let Some(peer) = self.peer.get().cloned() {
|
||||
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
|
||||
@@ -423,7 +454,8 @@ impl Handler for CollectUpdates {
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_turns() {
|
||||
let server = Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()) });
|
||||
let server =
|
||||
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: false });
|
||||
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
|
||||
let server_clone = server.clone();
|
||||
let client = attach(updates.clone(), move |events| {
|
||||
@@ -538,3 +570,118 @@ async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_t
|
||||
.any(|u| u["sessionUpdate"] == "usage_update" && u["size"] == 200_000 && u["used"] == 42_000)
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn shim_forwards_disabled_mcp_servers_on_create_and_resume() {
|
||||
let server =
|
||||
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: false });
|
||||
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
|
||||
let server_clone = server.clone();
|
||||
let client = attach(updates, move |events| {
|
||||
let (a, b) = tokio::io::duplex(1 << 16);
|
||||
let (ar, aw) = tokio::io::split(a);
|
||||
let (br, bw) = tokio::io::split(b);
|
||||
let srv_peer = Peer::connect_framed(br, bw, server_clone.clone(), Framing::ContentLength);
|
||||
let _ = server_clone.peer.set(srv_peer);
|
||||
Ok(Peer::connect_framed(ar, aw, events, Framing::ContentLength))
|
||||
})
|
||||
.unwrap();
|
||||
|
||||
let _: Value = client.request("initialize", json!({}), None).await.unwrap();
|
||||
let disabled = json!(["datadog", "github-mcp-server", "linear", "playwright", "slack-official"]);
|
||||
let _: Value = client
|
||||
.request(
|
||||
"session/new",
|
||||
json!({
|
||||
"cwd": "/tmp",
|
||||
"mcpServers": [],
|
||||
"_meta": { "openidea": { "mcpServersOff": disabled } }
|
||||
}),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let _: Value = client
|
||||
.request(
|
||||
"session/load",
|
||||
json!({
|
||||
"sessionId": "cop-sess-1",
|
||||
"cwd": "/tmp",
|
||||
"mcpServers": [],
|
||||
"_meta": { "openidea": { "mcpServersOff": disabled } }
|
||||
}),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let calls = server.calls.lock();
|
||||
let (_, create_params) = calls.iter().find(|(m, _)| m == "session.create").unwrap();
|
||||
assert_eq!(create_params["disabledMcpServers"], disabled);
|
||||
let (_, resume_params) = calls.iter().find(|(m, _)| m == "session.resume").unwrap();
|
||||
assert_eq!(resume_params["disabledMcpServers"], disabled);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn stop_ends_a_turn_left_running_only_by_background_shells() {
|
||||
let server =
|
||||
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: true });
|
||||
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
|
||||
let server_clone = server.clone();
|
||||
let client = attach(updates.clone(), move |events| {
|
||||
let (a, b) = tokio::io::duplex(1 << 16);
|
||||
let (ar, aw) = tokio::io::split(a);
|
||||
let (br, bw) = tokio::io::split(b);
|
||||
let srv_peer = Peer::connect_framed(br, bw, server_clone.clone(), Framing::ContentLength);
|
||||
let _ = server_clone.peer.set(srv_peer);
|
||||
Ok(Peer::connect_framed(ar, aw, events, Framing::ContentLength))
|
||||
})
|
||||
.unwrap();
|
||||
let init: Value = client.request("initialize", json!({}), None).await.unwrap();
|
||||
assert_eq!(init["agentCapabilities"]["_meta"]["openidea"]["backgroundTasks"], true);
|
||||
let _: Value = client.request("session/new", json!({ "cwd": "/tmp", "mcpServers": [] }), None).await.unwrap();
|
||||
|
||||
let prompt_client = client.clone();
|
||||
let turn = tokio::spawn(async move {
|
||||
prompt_client
|
||||
.request::<_, Value>(
|
||||
"session/prompt",
|
||||
json!({ "sessionId": "cop-sess-1", "prompt": [{ "type": "text", "text": "watch CI" }] }),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
});
|
||||
|
||||
// The running shell shows as a background task.
|
||||
let mut shown = None;
|
||||
for _ in 0..500 {
|
||||
shown = updates.0.lock().iter().find(|u| u["sessionUpdate"] == crate::BACKGROUND_TASKS_UPDATE).cloned();
|
||||
if shown.is_some() {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
assert_eq!(
|
||||
shown.unwrap()["tasks"],
|
||||
json!([{ "task_id": "shell-1", "task_type": "local_bash", "description": "gh pr checks 3819 --watch" }])
|
||||
);
|
||||
|
||||
let _: Value = client
|
||||
.request("_openidea/stop_task", json!({ "sessionId": "cop-sess-1", "taskId": "shell-1" }), None)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(
|
||||
server
|
||||
.calls
|
||||
.lock()
|
||||
.iter()
|
||||
.any(|(m, p)| m == "session.tasks.cancel" && p["sessionId"] == "cop-sess-1" && p["id"] == "shell-1")
|
||||
);
|
||||
|
||||
// The main loop is idle, so Stop ends the turn even though `session.idle` never comes.
|
||||
assert!(!turn.is_finished());
|
||||
client.notify("session/cancel", json!({ "sessionId": "cop-sess-1" })).unwrap();
|
||||
let res = tokio::time::timeout(Duration::from_secs(5), turn).await.unwrap().unwrap().unwrap();
|
||||
assert_eq!(res["stopReason"], "cancelled");
|
||||
assert!(!server.calls.lock().iter().any(|(m, _)| m == "session.abort"));
|
||||
}
|
||||
@@ -522,6 +522,14 @@ pub(super) fn wire_mcp_servers(acp_servers: Option<&Value>) -> Option<Value> {
|
||||
(!out.is_empty()).then_some(Value::Object(out))
|
||||
}
|
||||
|
||||
/// Extracts `_meta.openidea.mcpServersOff` into Copilot's `disabledMcpServers` string array.
|
||||
pub(super) fn wire_disabled_mcp_servers(params: &Value) -> Option<Value> {
|
||||
let list = params.pointer("/_meta/openidea/mcpServersOff")?.as_array()?;
|
||||
let names: Vec<Value> =
|
||||
list.iter().filter_map(|v| v.as_str().map(str::trim).filter(|s| !s.is_empty()).map(|s| json!(s))).collect();
|
||||
(!names.is_empty()).then_some(Value::Array(names))
|
||||
}
|
||||
|
||||
/// Converts `commands.list` + `skills.discover` results into ACP `availableCommands`.
|
||||
pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Option<&Value>) -> Vec<Value> {
|
||||
let mut seen = HashSet::new();
|
||||
@@ -568,6 +576,28 @@ pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Optio
|
||||
out
|
||||
}
|
||||
|
||||
/// The running entries of a `session.tasks.list` result, in the background-task shape the
|
||||
/// app shows (`task_id`, `task_type`, `description`).
|
||||
pub(super) fn background_tasks(list: &Value) -> Vec<Value> {
|
||||
let tasks = list.get("tasks").and_then(Value::as_array).map(Vec::as_slice).unwrap_or_default();
|
||||
tasks
|
||||
.iter()
|
||||
.filter(|t| matches!(str_of(t, "status"), Some("running" | "idle")))
|
||||
.filter_map(|t| {
|
||||
let id = str_of(t, "id")?;
|
||||
let kind = str_of(t, "type").unwrap_or_default();
|
||||
let task_type = match kind {
|
||||
"shell" => "local_bash",
|
||||
"agent" => "local_agent",
|
||||
other => other,
|
||||
};
|
||||
let description =
|
||||
str_of(t, "description").filter(|d| !d.is_empty()).or_else(|| str_of(t, "command")).unwrap_or(kind);
|
||||
Some(json!({ "task_id": id, "task_type": task_type, "description": description }))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn trim_tail(text: &mut String) {
|
||||
if text.len() > MAX_OUTPUT {
|
||||
let mut cut = text.len() - MAX_OUTPUT;
|
||||
|
||||
@@ -56,6 +56,13 @@ const BUILTIN: &[(&str, &str, Driver, &[&str], &str)] = &[
|
||||
&["npx", "-y", "@agentclientprotocol/[email protected]"],
|
||||
"Run `codex login` in a terminal.",
|
||||
),
|
||||
(
|
||||
"deepseek-harness",
|
||||
"DeepSeek Harness",
|
||||
Driver::Acp,
|
||||
&["dsh", "--profile", "acp"],
|
||||
"Run `dsh` in a terminal and sign in.",
|
||||
),
|
||||
("gemini", "Gemini CLI", Driver::Acp, &["gemini", "--experimental-acp"], "Run `gemini` in a terminal and sign in."),
|
||||
(
|
||||
"copilot",
|
||||
|
||||
@@ -51,6 +51,7 @@ struct FakeAgent {
|
||||
/// Config options `session/new` reports after the model one (per-model efforts, say).
|
||||
extra_options: Mutex<Vec<Value>>,
|
||||
model_options: Mutex<HashMap<String, Vec<Value>>>,
|
||||
model_config_gate: Mutex<Option<std::sync::mpsc::Receiver<()>>>,
|
||||
/// Advertises steering as OMP does (`_meta.steering` at the top of `initialize`)
|
||||
/// instead of `_meta.openidea.steer`.
|
||||
session_steering: bool,
|
||||
@@ -231,6 +232,12 @@ impl Handler for FakeAgent {
|
||||
std::thread::sleep(self.delay_config);
|
||||
}
|
||||
self.calls.lock().push(format!("{method} {}", params.get("value").or(params.get("modeId")).unwrap()));
|
||||
if params["configId"] == "model" {
|
||||
let gate = self.model_config_gate.lock().take();
|
||||
if let Some(gate) = gate {
|
||||
gate.recv().unwrap();
|
||||
}
|
||||
}
|
||||
if params["configId"] == "model" && !self.model_options.lock().is_empty() {
|
||||
return Ok(json!({"configOptions": self.options_for(params["value"].as_str().unwrap())}));
|
||||
}
|
||||
@@ -590,6 +597,7 @@ for line in sys.stdin:
|
||||
assert_eq!(names, ["compact", "clear", "model", "context", "triage"]);
|
||||
assert_eq!(first[0].hint.as_deref(), Some("[instructions]"));
|
||||
let restored = manager(root, Arc::new(FakeAgent::default()));
|
||||
restored.set_builtin_command("claude", Some(script.to_string_lossy().into_owned())).unwrap();
|
||||
assert_eq!(first, restored.commands("claude", None).await.unwrap());
|
||||
// The same handshake lists the models, so the composer has them before any task.
|
||||
for mgr in [&mgr, &restored] {
|
||||
@@ -909,8 +917,23 @@ async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
|
||||
wait_for(&mgr_a, &task.id, AgentStatus::NeedsInput).await;
|
||||
assert_eq!(names(mgr_a.commands("claude", None).await.unwrap()), ["review", "triage"]);
|
||||
assert_eq!(names(mgr_a.commands("claude", Some(&task.id)).await.unwrap()), ["review", "triage"]);
|
||||
// Other agents get only what they offered.
|
||||
assert!(mgr_a.commands("codex", None).await.unwrap().is_empty());
|
||||
// Other agents get only what they offered, plus verified native builtins.
|
||||
assert_eq!(
|
||||
names(mgr_a.commands("codex", None).await.unwrap()),
|
||||
[
|
||||
"plan",
|
||||
"mcp",
|
||||
"skills",
|
||||
"status",
|
||||
"review",
|
||||
"review-branch",
|
||||
"review-commit",
|
||||
"compact",
|
||||
"goal",
|
||||
"rename",
|
||||
"logout",
|
||||
]
|
||||
);
|
||||
mgr_a.cancel(&task.id, None).unwrap();
|
||||
wait_for(&mgr_a, &task.id, AgentStatus::Ready).await;
|
||||
mgr_a.shutdown();
|
||||
@@ -930,9 +953,27 @@ async fn builtin_commands_only_fill_verified_gaps_and_preserve_advertised_metada
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager_at(tmp.path(), &tmp.path().join("models.json"), agent);
|
||||
for provider in ["claude", "claude-acp", "opencode2", "codex", "custom"] {
|
||||
for provider in ["claude", "claude-acp", "opencode2", "custom"] {
|
||||
assert!(mgr.commands(provider, None).await.unwrap().is_empty(), "{provider}");
|
||||
}
|
||||
let commands = mgr.commands("codex", None).await.unwrap();
|
||||
assert_eq!(
|
||||
commands.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(),
|
||||
[
|
||||
"plan",
|
||||
"mcp",
|
||||
"skills",
|
||||
"status",
|
||||
"review",
|
||||
"review-branch",
|
||||
"review-commit",
|
||||
"compact",
|
||||
"goal",
|
||||
"rename",
|
||||
"logout",
|
||||
]
|
||||
);
|
||||
assert_eq!(commands[1].hint.as_deref(), Some("[reconnect]"));
|
||||
let commands = mgr.commands("opencode", None).await.unwrap();
|
||||
assert_eq!(commands.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["compact"]);
|
||||
let task = mgr
|
||||
@@ -1173,25 +1214,15 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
|
||||
assert_eq!(queue.iter().map(|q| q.prompt.text.as_str()).collect::<Vec<_>>(), ["again"]);
|
||||
assert!(mgr.prompt(&task.id, text(" "), false).await.is_err());
|
||||
|
||||
mgr.send_queued_now(&task.id, &queue[0].id).unwrap();
|
||||
for _ in 0..500 {
|
||||
if mgr.entries(&task.id, None).unwrap().iter().any(|e| *e == AgentEntry::Agent { text: "second turn".into() }) {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let users: Vec<String> = mgr
|
||||
.entries(&task.id, None)
|
||||
.unwrap()
|
||||
.into_iter()
|
||||
.filter_map(|e| match e {
|
||||
AgentEntry::User { text, .. } => Some(text),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
assert_eq!(users, ["wait", "again"]);
|
||||
// Sending it now joins the running turn when the agent takes messages mid-turn.
|
||||
mgr.send_queued_now(&task.id, &queue[0].id).await.unwrap();
|
||||
assert!(agent.calls.lock().iter().any(|c| c == "_openidea/steer \"again\""));
|
||||
assert!(!agent.calls.lock().iter().any(|c| c == "session/cancel"));
|
||||
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
|
||||
let entries = mgr.entries(&task.id, None).unwrap();
|
||||
assert!(entries.iter().any(|e| matches!(e, AgentEntry::User { text, steered: true, .. } if text == "again")));
|
||||
mgr.cancel(&task.id, None).unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
|
||||
// Stopping a turn keeps the queue for later.
|
||||
mgr.prompt(&task.id, text("wait"), false).await.unwrap();
|
||||
@@ -1206,6 +1237,40 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
|
||||
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn send_now_interrupts_the_turn_when_steering_is_refused() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent { session_steering: true, ..FakeAgent::default() });
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("wait"),
|
||||
provider: "claude".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Running).await;
|
||||
mgr.prompt(&task.id, text("too late"), false).await.unwrap();
|
||||
let queued = mgr.task(&task.id).unwrap().state.lock().task.queue[0].id.clone();
|
||||
|
||||
mgr.send_queued_now(&task.id, &queued).await.unwrap();
|
||||
// The fake agent's next turn asks for permission.
|
||||
wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
|
||||
let calls = agent.calls.lock().clone();
|
||||
assert!(calls.contains(&"_session/steering \"too late\"".to_owned()), "{calls:?}");
|
||||
assert!(calls.contains(&"session/cancel".to_owned()), "{calls:?}");
|
||||
let entries = mgr.entries(&task.id, None).unwrap();
|
||||
assert!(entries.iter().any(|e| matches!(e, AgentEntry::User { text, steered: false, .. } if text == "too late")));
|
||||
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
|
||||
mgr.cancel(&task.id, None).unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn subagents_get_their_own_conversation() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -1270,6 +1335,25 @@ async fn subagents_get_their_own_conversation() {
|
||||
check(&manager(tmp.path(), Arc::new(FakeAgent::default())));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn image_blocks_declare_the_type_of_their_bytes() {
|
||||
let image = |mime: &str, data: &str| AgentImage { mime_type: mime.into(), data: data.into(), name: None };
|
||||
let cases = [
|
||||
// A browser's JPEG pasted as PNG.
|
||||
(image("image/png", "/9j/4AAQSkZJRgABAQ"), "image/jpeg"),
|
||||
(image("image/jpeg", "iVBORw0KGgoAAAANSUhEUg"), "image/png"),
|
||||
(image("image/png", "R0lGODlhAQABAIAAAP"), "image/gif"),
|
||||
(image("image/png", "UklGRiQAAABXRUJQVlA4"), "image/webp"),
|
||||
// Not recognised: as declared.
|
||||
(image("image/bmp", "Qk02AAAAAAAAADYAAA"), "image/bmp"),
|
||||
(image("image/png", "AAA"), "image/png"),
|
||||
];
|
||||
for (image, expected) in cases {
|
||||
let p = AgentPrompt { text: String::new(), files: vec![], images: vec![image] };
|
||||
assert_eq!(blocks(&p, &[])[0]["mimeType"], expected, "{:?}", p.images[0].data);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prompts_become_acp_content_blocks() {
|
||||
let p = AgentPrompt {
|
||||
@@ -1603,6 +1687,12 @@ async fn renamed_titles_survive_updates_forks_and_restart() {
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
// `/rename` reports an explicit title through the same update; later automatic names
|
||||
// must not replace it even though AgentManager.rename was not called.
|
||||
handle
|
||||
.on_update(None, &json!({"sessionUpdate": "session_info_update", "title": "Command title", "userNamed": true}));
|
||||
handle.on_update(None, &json!({"sessionUpdate": "session_info_update", "title": "Automatic title"}));
|
||||
assert_eq!(handle.state.lock().task.title, "Command title");
|
||||
assert!(mgr.rename(&task.id, " ").is_err());
|
||||
let initial = handle.state.lock().task.title.clone();
|
||||
for title in [initial, "My task".to_owned(), "名".repeat(205)] {
|
||||
@@ -1623,6 +1713,65 @@ async fn renamed_titles_survive_updates_forks_and_restart() {
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn startup_warnings_survive_replay_and_restart_without_failing_the_task() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask { provider: "claude".into(), prompt: text("again"), ..Default::default() })
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
handle.replaying.store(true, Ordering::Release);
|
||||
handle.turn_started.store(false, Ordering::Release);
|
||||
let client = Client { task: Arc::downgrade(&handle) };
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({"message": "Project MCP config is disabled until trusted."}));
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({"message": " "}));
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({}));
|
||||
assert_eq!(handle.state.lock().task.status, AgentStatus::Ready);
|
||||
assert!(!handle.turn_started.load(Ordering::Acquire));
|
||||
mgr.shutdown();
|
||||
let restored = manager(tmp.path(), agent);
|
||||
let handle = restored.task(&task.id).unwrap();
|
||||
assert_eq!(handle.state.lock().conversation.main.entries.iter().filter(|entry| matches!(entry, AgentEntry::Error {message} if message == "Project MCP config is disabled until trusted.")).count(), 1);
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn persistent_project_trust_needs_confirmation_even_with_bypass() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
.create(NewAgentTask { provider: "claude".into(), prompt: text("again"), ..Default::default() })
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
handle.state.lock().task.config = config::options_of(&json!({"configOptions": [{
|
||||
"id": "mode", "category": "mode", "type": "select", "currentValue": "full-access",
|
||||
"options": [{"value": "full-access", "name": "Full Access"}]
|
||||
}]}));
|
||||
assert!(config::bypass_approvals(&handle.state.lock().task.config));
|
||||
let params = json!({"toolCall": {"toolCallId": "trust", "kind": "edit", "title": "Trust Project in Codex"},
|
||||
"options": [
|
||||
{"optionId": "codex-trust-project", "name": "Trust Project in Codex", "kind": "allow_always"},
|
||||
{"optionId": "codex-keep-untrusted", "name": "Keep Untrusted", "kind": "reject_once"}
|
||||
]});
|
||||
let asking = {
|
||||
let handle = handle.clone();
|
||||
let params = params.clone();
|
||||
tokio::task::spawn_blocking(move || handle.ask_permission(¶ms))
|
||||
};
|
||||
wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
|
||||
assert!(!asking.is_finished());
|
||||
let id = *handle.permissions.lock().keys().next().unwrap();
|
||||
mgr.respond(&task.id, id, Some("codex-keep-untrusted".into())).unwrap();
|
||||
assert_eq!(asking.await.unwrap()["outcome"]["optionId"], "codex-keep-untrusted");
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn forks_rollbacks_and_steering() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -1833,8 +1982,7 @@ async fn thinking_levels_are_remembered_per_provider_and_model() {
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
|
||||
// After a model switch no session reported, picking that model again or changing
|
||||
// another setting must not record the task's effort-less copy as the model's levels.
|
||||
// Idle selections use cached model controls or discover them before the next prompt.
|
||||
for (option, value) in [("mode", "code"), ("model", "big")] {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
@@ -1847,7 +1995,7 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
provider: "claude-acp".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
@@ -1859,18 +2007,165 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
|
||||
mgr.shutdown();
|
||||
let restored = manager(tmp.path(), agent);
|
||||
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
|
||||
{
|
||||
let small = restored.task(&task.id).unwrap();
|
||||
let small = small.state.lock();
|
||||
let effort = small.task.config.iter().find(|option| option.id == "effort").unwrap();
|
||||
assert_eq!(
|
||||
effort.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(),
|
||||
["minimal", "medium"]
|
||||
);
|
||||
}
|
||||
restored.set_config(&task.id, "model", "big".into()).await.unwrap();
|
||||
restored.set_config(&task.id, option, value.into()).await.unwrap();
|
||||
let p = restored.providers().into_iter().find(|p| p.id == "claude").unwrap();
|
||||
let p = restored.providers().into_iter().find(|p| p.id == "claude-acp").unwrap();
|
||||
let big = p.thought_levels.get("big").and_then(|levels| levels.first());
|
||||
assert_eq!(big.map(|o| o.values.len()), Some(2), "{option}: {:?}", p.thought_levels);
|
||||
let saved: HashMap<String, Known> =
|
||||
serde_json::from_slice(&std::fs::read(&restored.shared.paths.models_file).unwrap()).unwrap();
|
||||
assert_eq!(saved["claude"].thought_levels, p.thought_levels, "{option}");
|
||||
assert_eq!(saved["claude-acp"].thought_levels, p.thought_levels, "{option}");
|
||||
restored.shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn idle_model_switches_discover_controls_and_no_control_models_without_another_prompt() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
*agent.model_options.lock() = HashMap::from([
|
||||
("big".into(), effort_options(&["low", "high"], "high")),
|
||||
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
|
||||
("plain".into(), vec![]),
|
||||
]);
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude-acp".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.shutdown();
|
||||
let restored = manager(tmp.path(), agent.clone());
|
||||
assert!(
|
||||
!restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp").thought_levels.contains_key("small")
|
||||
);
|
||||
agent.calls.lock().clear();
|
||||
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
|
||||
let current = restored.task(&task.id).unwrap();
|
||||
let config = current.state.lock().task.config.clone();
|
||||
let effort = config.iter().find(|option| option.id == "effort").unwrap();
|
||||
assert_eq!(effort.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(), ["minimal", "medium"]);
|
||||
restored.set_config(&task.id, "effort", "medium".into()).await.unwrap();
|
||||
restored.set_config(&task.id, "model", "plain".into()).await.unwrap();
|
||||
assert!(!current.state.lock().task.config.iter().any(config::is_per_model_option));
|
||||
let known = restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp");
|
||||
assert!(known.thought_levels["plain"].is_empty());
|
||||
assert_eq!(known.config.iter().find(|option| option.id == "model").unwrap().current.as_deref(), Some("big"));
|
||||
{
|
||||
let mut calls = agent.calls.lock();
|
||||
assert!(!calls.iter().any(|call| call == "session/prompt" || call == "session/load"));
|
||||
assert_eq!(calls.iter().filter(|call| *call == "session/new").count(), 2);
|
||||
calls.clear();
|
||||
}
|
||||
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
|
||||
assert!(agent.calls.lock().is_empty(), "a known model remains a cache-only selection");
|
||||
assert!(current.live.lock().is_none(), "discovery never mutates a task's live session");
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn idle_model_discovery_failure_restores_the_previous_choice_without_claiming_no_controls() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
*agent.extra_options.lock() = effort_options(&["low", "high"], "low");
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude-acp".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.shutdown();
|
||||
let restored = manager(tmp.path(), agent.clone());
|
||||
agent.calls.lock().clear();
|
||||
assert!(restored.set_config(&task.id, "model", "small".into()).await.is_err());
|
||||
let current = restored.task(&task.id).unwrap();
|
||||
assert_eq!(current.state.lock().task.model.as_deref(), Some("big"));
|
||||
assert!(current.state.lock().task.config.iter().any(|option| option.id == "effort"));
|
||||
assert!(
|
||||
!restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp").thought_levels.contains_key("small")
|
||||
);
|
||||
assert!(!agent.calls.lock().iter().any(|call| call == "session/prompt"));
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn rapid_idle_model_switches_share_discovery_and_never_apply_a_stale_completion() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
*agent.model_options.lock() = HashMap::from([
|
||||
("big".into(), effort_options(&["low", "high"], "high")),
|
||||
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
|
||||
("plain".into(), vec![]),
|
||||
]);
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude-acp".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.shutdown();
|
||||
let restored = Arc::new(manager(tmp.path(), agent.clone()));
|
||||
agent.calls.lock().clear();
|
||||
let (release, gate) = std::sync::mpsc::channel();
|
||||
*agent.model_config_gate.lock() = Some(gate);
|
||||
let first = tokio::spawn({
|
||||
let restored = restored.clone();
|
||||
let id = task.id.clone();
|
||||
async move { restored.set_config(&id, "model", "small".into()).await }
|
||||
});
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while agent.model_config_gate.lock().is_some() {
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let duplicate = restored.set_config(&task.id, "model", "small".into());
|
||||
tokio::pin!(duplicate);
|
||||
tokio::select! {
|
||||
biased;
|
||||
result = &mut duplicate => panic!("duplicate selection must join the pending discovery: {result:?}"),
|
||||
_ = tokio::task::yield_now() => {}
|
||||
}
|
||||
restored.set_config(&task.id, "model", "plain".into()).await.unwrap();
|
||||
release.send(()).unwrap();
|
||||
first.await.unwrap().unwrap();
|
||||
duplicate.await.unwrap();
|
||||
let current = restored.task(&task.id).unwrap();
|
||||
assert_eq!(current.state.lock().task.model.as_deref(), Some("plain"));
|
||||
assert!(!current.state.lock().task.config.iter().any(config::is_per_model_option));
|
||||
let catalog = restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp");
|
||||
assert!(catalog.thought_levels["plain"].is_empty());
|
||||
assert!(!catalog.thought_levels.contains_key("small"), "obsolete discovery cannot populate model settings");
|
||||
assert_eq!(agent.calls.lock().iter().filter(|call| *call == "session/new").count(), 2);
|
||||
assert!(!agent.calls.lock().iter().any(|call| call == "session/prompt"));
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn upfront_effort_is_validated_after_changing_model_before_the_prompt() {
|
||||
for (effort, applied) in [("medium", true), ("high", false)] {
|
||||
@@ -3493,199 +3788,6 @@ async fn security_policy_never_auto_approves_a_request_that_only_reads_like_a_co
|
||||
);
|
||||
}
|
||||
|
||||
/// A temporary side conversation is created ready, without starting its session and
|
||||
/// without writing anything to the store; a fresh subscriber (a reloaded page) sweeps
|
||||
/// it, and deleting it just drops it from memory.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn ephemeral_tasks_stay_in_memory_only() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let source = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("hello"),
|
||||
provider: "claude".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &source.id, AgentStatus::NeedsInput).await;
|
||||
let calls_before = agent.calls.lock().len();
|
||||
let task = mgr
|
||||
.create_ephemeral(
|
||||
NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("What changed in this file?"),
|
||||
provider: "claude".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
},
|
||||
&source.id,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
// Registering it starts nothing: the session waits for its first real message.
|
||||
assert_eq!(agent.calls.lock().len(), calls_before);
|
||||
assert_eq!(mgr.task(&task.id).unwrap().state.lock().task.status, AgentStatus::Ready);
|
||||
assert!(!tmp.path().join("store").join(format!("{}.json", task.id)).exists());
|
||||
|
||||
// Its first message starts the session like any task's, and still saves nothing: the
|
||||
// conversation records the question, not the context that rode along to the agent.
|
||||
// The fake agent's turn asks to change something, which a side conversation denies by
|
||||
// itself, so the turn ends without waiting for the user.
|
||||
mgr.prompt(&task.id, text("Why?"), false).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let entries = mgr.entries(&task.id, None).unwrap();
|
||||
let question = entries.iter().find_map(|e| match e {
|
||||
AgentEntry::User { text, .. } => Some(text.clone()),
|
||||
_ => None,
|
||||
});
|
||||
assert_eq!(question.as_deref(), Some("Why?"));
|
||||
assert!(
|
||||
entries.iter().any(|e| matches!(e, AgentEntry::Permission { chosen: Some(c), .. } if c.contains("read-only"))),
|
||||
"its `cargo test` request was denied: {entries:?}"
|
||||
);
|
||||
assert!(!tmp.path().join("store").join(format!("{}.json", task.id)).exists());
|
||||
|
||||
// A fresh subscriber (a reloaded page) sweeps it: it never reaches the task list.
|
||||
let events: Arc<Mutex<Vec<AgentEvent>>> = Arc::new(Mutex::new(Vec::new()));
|
||||
let sink_events = events.clone();
|
||||
let tasks = mgr.subscribe(Arc::new(move |e| sink_events.lock().push(e)));
|
||||
assert!(!tasks.iter().any(|t| t.id == task.id));
|
||||
assert!(mgr.task(&task.id).is_err());
|
||||
assert!(events.lock().iter().any(|e| matches!(e, AgentEvent::Removed { id } if *id == task.id)));
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
/// A side conversation's context stays within its budget: long tool outputs are cut to
|
||||
/// their head and tail, and entries that no longer fit are dropped oldest first.
|
||||
#[test]
|
||||
fn side_conversation_context_is_bounded() {
|
||||
let long_output = (0..400).map(|i| format!("line {i}")).collect::<Vec<_>>().join(
|
||||
"
|
||||
",
|
||||
);
|
||||
// Each reply alone is well inside the budget; together they are past it.
|
||||
let reply = |n: usize| AgentEntry::Agent { text: format!("reply {n} {}", "x".repeat(30_000)) };
|
||||
let entries = vec![
|
||||
AgentEntry::User {
|
||||
text: "oldest question".into(),
|
||||
attachments: vec![],
|
||||
images: vec![],
|
||||
sent_ms: None,
|
||||
done_ms: None,
|
||||
steered: false,
|
||||
},
|
||||
reply(1),
|
||||
reply(2),
|
||||
reply(3),
|
||||
reply(4),
|
||||
AgentEntry::Tool {
|
||||
id: "t1".into(),
|
||||
title: "grep".into(),
|
||||
kind: "search".into(),
|
||||
status: AgentToolStatus::Completed,
|
||||
locations: vec![],
|
||||
output: Some(long_output),
|
||||
diffs: vec![],
|
||||
},
|
||||
AgentEntry::User {
|
||||
text: "newest question".into(),
|
||||
attachments: vec![],
|
||||
images: vec![],
|
||||
sent_ms: None,
|
||||
done_ms: None,
|
||||
steered: false,
|
||||
},
|
||||
];
|
||||
let transcript = context_transcript(&entries);
|
||||
assert!(transcript.contains("newest question"), "the newest entry is always kept");
|
||||
assert!(transcript.contains("lines omitted"), "a long tool output is trimmed");
|
||||
assert!(transcript.contains("line 0") && transcript.contains("line 399"), "its head and tail stay");
|
||||
assert!(!transcript.contains("oldest question"), "entries past the budget are dropped oldest first");
|
||||
assert!(transcript.contains("oldest entries are omitted"));
|
||||
}
|
||||
|
||||
/// An ephemeral task denies a permission request that would change the project.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn ephemeral_tasks_deny_write_permissions() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let source = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("Something with a conversation to reuse"),
|
||||
provider: "claude".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &source.id, AgentStatus::NeedsInput).await;
|
||||
let pending = mgr
|
||||
.entries(&source.id, None)
|
||||
.unwrap()
|
||||
.iter()
|
||||
.find_map(|e| match e {
|
||||
AgentEntry::Permission { id, chosen: None, .. } => Some(*id),
|
||||
_ => None,
|
||||
})
|
||||
.unwrap_or_else(|| panic!("no pending permission request"));
|
||||
mgr.respond(&source.id, pending, Some("no".into())).unwrap();
|
||||
wait_for(&mgr, &source.id, AgentStatus::Ready).await;
|
||||
|
||||
let task = mgr
|
||||
.create_ephemeral(
|
||||
NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("What changed in this file?"),
|
||||
provider: "claude".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
},
|
||||
&source.id,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(mgr.task(&task.id).unwrap().state.lock().task.capabilities.read_only);
|
||||
|
||||
let answer = mgr
|
||||
.task(&task.id)
|
||||
.unwrap()
|
||||
.ask_permission(&json!({
|
||||
"sessionId": "c1",
|
||||
"toolCall": {"toolCallId": "c1-t2", "title": "Edit main.rs", "kind": "edit"},
|
||||
"options": [
|
||||
{"optionId": "yes", "name": "Allow", "kind": "allow_once"},
|
||||
{"optionId": "no", "name": "Reject", "kind": "reject_once"}
|
||||
]
|
||||
}))
|
||||
.pointer("/outcome/optionId")
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or("none")
|
||||
.to_owned();
|
||||
assert_eq!(answer, "no", "the write request is denied");
|
||||
let entries = mgr.entries(&task.id, None).unwrap();
|
||||
assert!(
|
||||
entries
|
||||
.iter()
|
||||
.any(|e| matches!(e, AgentEntry::Permission { chosen: Some(chosen), .. } if chosen.contains("read-only"))),
|
||||
"{entries:?}"
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
fn attention_reasons(events: &[AgentEvent]) -> Vec<AgentAttentionReason> {
|
||||
events
|
||||
.iter()
|
||||
@@ -4138,3 +4240,14 @@ done
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn session_params_name_the_servers_off() {
|
||||
let mcp = McpForSession { servers: vec![json!({ "name": "docs" })], off: vec!["github".into()] };
|
||||
let params = session_params("/p", &mcp);
|
||||
assert_eq!(params["cwd"], "/p");
|
||||
assert_eq!(params["mcpServers"][0]["name"], "docs");
|
||||
assert_eq!(params["_meta"]["openidea"]["mcpServersOff"], json!(["github"]));
|
||||
let none = McpForSession { servers: Vec::new(), off: Vec::new() };
|
||||
assert!(session_params("/p", &none).get("_meta").is_none());
|
||||
}
|
||||
@@ -47,13 +47,20 @@ pub fn plan(root: &Path, model: &BuildModel, module: &Path, cache: &Path) -> Ide
|
||||
fs::write(
|
||||
&script,
|
||||
format!(
|
||||
r#"gradle.projectsEvaluated {{
|
||||
r#"import org.gradle.util.GradleVersion
|
||||
|
||||
gradle.projectsEvaluated {{
|
||||
def p = gradle.rootProject.project({})
|
||||
def resources = p.tasks.named('processResources')
|
||||
p.tasks.register('openideaUpdateResources') {{
|
||||
dependsOn resources
|
||||
doLast {{ new File({}).setText(resources.get().destinationDir.absolutePath, 'UTF-8') }}
|
||||
def update = {{ t ->
|
||||
t.dependsOn 'processResources'
|
||||
// Resolved here so the action holds no task or project (configuration cache).
|
||||
def dir = p.tasks.getByName('processResources').destinationDir
|
||||
def manifest = new File({})
|
||||
t.doLast {{ manifest.setText(dir.absolutePath, 'UTF-8') }}
|
||||
}}
|
||||
// `register` is Gradle 4.9+.
|
||||
if (GradleVersion.current() >= GradleVersion.version('4.9')) p.tasks.register('openideaUpdateResources', update)
|
||||
else p.tasks.create('openideaUpdateResources', update)
|
||||
}}
|
||||
"#,
|
||||
literal(&p.path),
|
||||
@@ -172,7 +179,16 @@ mod tests {
|
||||
assert_eq!(gradle.command, "/tools/gradlew");
|
||||
assert_eq!(gradle.args.last().unwrap(), ":app:openideaUpdateResources");
|
||||
let script = fs::read_to_string(cache.join("resources.init.gradle")).unwrap();
|
||||
assert!(script.contains("processResources") && script.contains("destinationDir.absolutePath"));
|
||||
assert!(
|
||||
script.contains("processResources")
|
||||
&& script.contains(".destinationDir\n")
|
||||
&& script.contains("setText(dir.absolutePath")
|
||||
);
|
||||
// `register` is Gradle 4.9+ (#3864).
|
||||
assert!(script.contains("else p.tasks.create('openideaUpdateResources', update)"), "{script}");
|
||||
// The configuration cache can't serialize a task or project the action refers to.
|
||||
let action = &script[script.find("doLast").unwrap()..script.find("// `register`").unwrap()];
|
||||
assert!(!action.contains("p.") && !action.contains("tasks"), "{action}");
|
||||
assert!(!script.contains("build/resources/main")); // The task owns custom output locations.
|
||||
}
|
||||
|
||||
|
||||
@@ -548,7 +548,7 @@ impl PathMap {
|
||||
}
|
||||
|
||||
/// Removes `.` and resolvable `..` components without touching the file system.
|
||||
fn normalize(p: &Path) -> PathBuf {
|
||||
pub(crate) fn normalize(p: &Path) -> PathBuf {
|
||||
use std::path::Component;
|
||||
let mut out = PathBuf::new();
|
||||
for c in p.components() {
|
||||
|
||||
@@ -10,11 +10,14 @@ use std::process::Command as ProcCommand;
|
||||
|
||||
/// Output file of the `dependency:build-classpath` probe, relative to each module.
|
||||
const CP_FILE: &str = "target/ide-compile-cp.txt";
|
||||
// Older records include undeclared reactor test outputs even in runtime classpaths.
|
||||
const CLASSPATH_CACHE_VERSION: u32 = 1;
|
||||
|
||||
/// The resolved dependency classpath for one module and scope, tied to the same
|
||||
/// inputs as its launch build so POM, JDK, settings and profile changes invalidate it.
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
struct CachedClasspath {
|
||||
version: u32,
|
||||
fingerprint: LaunchFingerprint,
|
||||
classpath: String,
|
||||
}
|
||||
@@ -132,6 +135,7 @@ pub fn module_classpath(
|
||||
if let (Some(fingerprint), Some(path)) = (&fingerprint, &cache_path)
|
||||
&& let Ok(bytes) = fs::read(path)
|
||||
&& let Ok(cached) = serde_json::from_slice::<CachedClasspath>(&bytes)
|
||||
&& cached.version == CLASSPATH_CACHE_VERSION
|
||||
&& cached.fingerprint == *fingerprint
|
||||
&& classpath_entries_exist(root, &cached.classpath)
|
||||
{
|
||||
@@ -142,7 +146,7 @@ pub fn module_classpath(
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
if let (Some(fingerprint), Some(path)) = (fingerprint, cache_path) {
|
||||
let cached = CachedClasspath { fingerprint, classpath: classpath.clone() };
|
||||
let cached = CachedClasspath { version: CLASSPATH_CACHE_VERSION, fingerprint, classpath: classpath.clone() };
|
||||
if let Err(error) = cache_classpath(&path, &cached) {
|
||||
tracing::debug!(path = %path.display(), %error, "Cannot cache the Java launch classpath");
|
||||
}
|
||||
@@ -208,11 +212,11 @@ fn classpath(
|
||||
if dir == target.module {
|
||||
continue;
|
||||
}
|
||||
for classes in ["target/classes", "target/test-classes"] {
|
||||
let path = dir.join(classes);
|
||||
if path.is_dir() {
|
||||
entries.push(path.to_string_lossy().into_owned());
|
||||
}
|
||||
// A dependency's tests are not exported with its main artifact. Any explicitly
|
||||
// declared test artifact is supplied by Maven's resolved classpath below.
|
||||
let path = dir.join("target/classes");
|
||||
if path.is_dir() {
|
||||
entries.push(path.to_string_lossy().into_owned());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -337,13 +341,19 @@ mod tests {
|
||||
root,
|
||||
"pom.xml",
|
||||
r#"<project><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version>
|
||||
<packaging>pom</packaging><modules><module>lib</module><module>app</module></modules></project>"#,
|
||||
<packaging>pom</packaging><modules><module>shared</module><module>lib</module><module>app</module></modules></project>"#,
|
||||
);
|
||||
write(
|
||||
root,
|
||||
"lib/pom.xml",
|
||||
r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>
|
||||
<artifactId>lib</artifactId></project>"#,
|
||||
<artifactId>lib</artifactId><dependencies><dependency><groupId>demo</groupId><artifactId>shared</artifactId><version>1</version></dependency></dependencies></project>"#,
|
||||
);
|
||||
write(
|
||||
root,
|
||||
"shared/pom.xml",
|
||||
r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>
|
||||
<artifactId>shared</artifactId></project>"#,
|
||||
);
|
||||
write(
|
||||
root,
|
||||
@@ -354,6 +364,7 @@ mod tests {
|
||||
write(root, "app/src/main/java/demo/Main.java", "class Main {}");
|
||||
write(root, "app/src/test/java/demo/MainTest.java", "class MainTest {}");
|
||||
write(root, "lib/target/classes/Lib.class", "built");
|
||||
write(root, "shared/target/classes/Shared.class", "built");
|
||||
crate::load(root, &root.join("cache"), None)
|
||||
}
|
||||
|
||||
@@ -436,7 +447,9 @@ mod tests {
|
||||
let target = single_file_target(root, &model, &file).unwrap();
|
||||
assert!(target.top.command.ends_with("mvnw"));
|
||||
assert_eq!(target.pl, "app");
|
||||
fs::create_dir_all(root.join("lib/target/test-classes")).unwrap();
|
||||
let cp = single_file_classpath(root, &model, &target).unwrap();
|
||||
assert!(!std::env::split_paths(&cp).any(|p| p == root.join("lib/target/test-classes")), "{cp}");
|
||||
let separator = ':';
|
||||
// Reactor class directories first, so fresh outputs shadow installed snapshots.
|
||||
let lib = root.join("lib/target/classes").to_string_lossy().into_owned();
|
||||
@@ -451,9 +464,16 @@ mod tests {
|
||||
assert!(cp.split(separator).count() >= 3, "{cp}");
|
||||
let args = fs::read_to_string(root.join("args.txt")).unwrap();
|
||||
assert!(!args.lines().any(|a| a == "compile" || a == "package"), "{args}");
|
||||
fs::create_dir_all(root.join("app/target/test-classes")).unwrap();
|
||||
let target = single_file_target(root, &model, &root.join("app/src/test/java/demo/MainTest.java")).unwrap();
|
||||
let cp = single_file_classpath(root, &model, &target).unwrap();
|
||||
let paths: Vec<_> = std::env::split_paths(&cp).collect();
|
||||
assert_eq!(paths[0], root.join("app/target/test-classes"));
|
||||
assert!(paths.contains(&root.join("app/target/classes")), "{cp}");
|
||||
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{cp}");
|
||||
}
|
||||
|
||||
/// A launch uses runtime dependencies, while tests additionally see test-scope ones.
|
||||
/// Launches request Maven's matching scope without adding reactor test outputs.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn launch_module_classpath_uses_the_matching_dependency_scope() {
|
||||
@@ -465,15 +485,29 @@ mod tests {
|
||||
let script = root.join("mvnw");
|
||||
fs::write(
|
||||
&script,
|
||||
"#!/bin/sh\nprintf '%s\\n' \"$@\" > args.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/runtime.jar:/repo/test.jar' > \"$pl/target/ide-compile-cp.txt\"\n",
|
||||
"#!/bin/sh\nprintf '%s\\n' \"$@\" > args.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/runtime.jar:/repo/fixture-tests.jar:/repo/fixture/target/test-classes' > \"$pl/target/ide-compile-cp.txt\"\n",
|
||||
)
|
||||
.unwrap();
|
||||
fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
|
||||
let model = crate::load(root, &root.join("cache"), None);
|
||||
|
||||
for dir in
|
||||
["app/target/classes", "app/target/test-classes", "lib/target/test-classes", "shared/target/test-classes"]
|
||||
{
|
||||
fs::create_dir_all(root.join(dir)).unwrap();
|
||||
}
|
||||
let cache = root.join("cache");
|
||||
let runtime =
|
||||
module_classpath(root, &model, &root.join("app"), false, None, &cache, &CancellationToken::new()).unwrap();
|
||||
let paths: Vec<_> = std::env::split_paths(&runtime).collect();
|
||||
assert!(paths.contains(&root.join("app/target/classes")), "{runtime}");
|
||||
assert!(paths.contains(&root.join("lib/target/classes")), "{runtime}");
|
||||
assert!(!paths.contains(&root.join("app/target/test-classes")), "{runtime}");
|
||||
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{runtime}");
|
||||
assert!(paths.contains(&root.join("shared/target/classes")), "{runtime}");
|
||||
assert!(!paths.contains(&root.join("shared/target/test-classes")), "{runtime}");
|
||||
assert!(paths.contains(&PathBuf::from("/repo/fixture-tests.jar")), "{runtime}");
|
||||
assert!(paths.contains(&PathBuf::from("/repo/fixture/target/test-classes")), "{runtime}");
|
||||
assert!(runtime.contains("/repo/runtime.jar"), "{runtime}");
|
||||
let args = fs::read_to_string(root.join("args.txt")).unwrap();
|
||||
assert!(args.lines().any(|a| a == "compile"), "{args}");
|
||||
@@ -482,7 +516,15 @@ mod tests {
|
||||
|
||||
let test =
|
||||
module_classpath(root, &model, &root.join("app"), true, None, &cache, &CancellationToken::new()).unwrap();
|
||||
assert!(test.contains("/repo/test.jar"), "{test}");
|
||||
assert!(test.contains("/repo/fixture-tests.jar"), "{test}");
|
||||
let paths: Vec<_> = std::env::split_paths(&test).collect();
|
||||
assert!(paths.contains(&root.join("app/target/test-classes")), "{test}");
|
||||
assert!(paths.contains(&root.join("app/target/classes")), "{test}");
|
||||
assert!(paths.contains(&root.join("lib/target/classes")), "{test}");
|
||||
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{test}");
|
||||
assert!(paths.contains(&root.join("shared/target/classes")), "{test}");
|
||||
assert!(!paths.contains(&root.join("shared/target/test-classes")), "{test}");
|
||||
assert!(paths.contains(&PathBuf::from("/repo/fixture/target/test-classes")), "{test}");
|
||||
let args = fs::read_to_string(root.join("args.txt")).unwrap();
|
||||
assert!(args.lines().any(|a| a == "-Dmdep.includeScope=test"), "{args}");
|
||||
}
|
||||
@@ -491,7 +533,7 @@ mod tests {
|
||||
/// build input changes; the probe does not run packaging plugins.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn launch_classpath_cache_follows_the_runner_jdk() {
|
||||
fn launch_classpath_cache_follows_the_runner_jdk_and_format() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
@@ -513,6 +555,7 @@ mod tests {
|
||||
fs::write(home.join("release"), format!("JAVA_VERSION=\"{version}\"\n")).unwrap();
|
||||
fs::write(home.join("bin/java"), "").unwrap();
|
||||
}
|
||||
fs::create_dir_all(root.join("app/target/classes")).unwrap();
|
||||
let cache = root.join("classpath-cache");
|
||||
let cancel = CancellationToken::new();
|
||||
let jdk21 = root.join("jdk21");
|
||||
@@ -526,6 +569,30 @@ mod tests {
|
||||
assert_eq!(second, first);
|
||||
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), "x");
|
||||
|
||||
let record = classpath_cache_path(root, &cache, &root.join("app"), false).unwrap();
|
||||
let current: serde_json::Value = serde_json::from_slice(&fs::read(&record).unwrap()).unwrap();
|
||||
let test_output = root.join("lib/target/test-classes");
|
||||
fs::create_dir_all(&test_output).unwrap();
|
||||
let polluted = std::env::join_paths(std::env::split_paths(&first).chain([test_output])).unwrap();
|
||||
let mut calls = "x".to_owned();
|
||||
for version in [None, Some(0), Some(u32::MAX)] {
|
||||
let mut stale = current.clone();
|
||||
stale["classpath"] = polluted.to_string_lossy().as_ref().into();
|
||||
if let Some(version) = version {
|
||||
stale["version"] = version.into();
|
||||
} else {
|
||||
stale.as_object_mut().unwrap().remove("version");
|
||||
}
|
||||
fs::write(&record, serde_json::to_vec(&stale).unwrap()).unwrap();
|
||||
let rebuilt = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
|
||||
assert_eq!(rebuilt, first, "incompatible cache format {version:?} must be rebuilt");
|
||||
calls.push('x');
|
||||
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
|
||||
let reused = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
|
||||
assert_eq!(reused, rebuilt);
|
||||
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
|
||||
}
|
||||
|
||||
let jdk8 = root.join("jdk8");
|
||||
for project in &mut model.maven.as_mut().unwrap().projects {
|
||||
project.env.insert("JAVA_HOME".into(), jdk8.to_string_lossy().into_owned());
|
||||
@@ -533,6 +600,7 @@ mod tests {
|
||||
let switched = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
|
||||
assert!(switched.contains("jdk8/classpath/jdk.jar"), "{switched}");
|
||||
assert!(!switched.contains("jdk21/classpath/jdk.jar"), "{switched}");
|
||||
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), "xx");
|
||||
calls.push('x');
|
||||
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
|
||||
}
|
||||
}
|
||||
@@ -40,6 +40,18 @@ pub fn structure_outputs(root: &Path, ps: &ProjectStructureSettings) -> (PathBuf
|
||||
(main, test)
|
||||
}
|
||||
|
||||
/// Whether Rebuild may delete the output folder `dir`: never the project folder or one above
|
||||
/// it, nor a folder that holds or lies inside a source, test or resource root.
|
||||
fn deletable_output(dir: &Path, root: &Path, roots: &StructureRoots) -> bool {
|
||||
let dir = normalize(dir);
|
||||
let overlaps = |r: &PathBuf| {
|
||||
let r = normalize(r);
|
||||
r.starts_with(&dir) || dir.starts_with(&r)
|
||||
};
|
||||
!normalize(root).starts_with(&dir)
|
||||
&& !roots.sources.iter().chain(&roots.tests).chain(&roots.resources).chain(&roots.test_resources).any(overlaps)
|
||||
}
|
||||
|
||||
fn module_name(root: &Path) -> String {
|
||||
root.file_name().map_or_else(|| "project".to_owned(), |n| n.to_string_lossy().into_owned())
|
||||
}
|
||||
@@ -207,7 +219,11 @@ pub fn structure_plan(
|
||||
|
||||
let mut steps = Vec::new();
|
||||
if kind == BuildKind::Rebuild {
|
||||
steps.push(BuildStep::action(Action::Clean(vec![main_out.clone(), test_out.clone()]), root));
|
||||
let dirs: Vec<PathBuf> =
|
||||
[&main_out, &test_out].into_iter().filter(|d| deletable_output(d, root, roots)).cloned().collect();
|
||||
if !dirs.is_empty() {
|
||||
steps.push(BuildStep::action(Action::Clean(dirs), root));
|
||||
}
|
||||
}
|
||||
let main_cp = library_entries(root, ps, false);
|
||||
let compile = |name: &str, sources: &[PathBuf], out: &Path, cp: &[String]| -> IdeResult<BuildStep> {
|
||||
@@ -310,6 +326,8 @@ fn artifact_steps(
|
||||
.find(|f| f.module == artifact.module || f.module.is_empty() && artifact.module == ".")
|
||||
.or_else(|| ps.facets.iter().find(|f| f.kind == "web"));
|
||||
let staging = cache.join("artifacts").join(file_name(&artifact.name));
|
||||
// What the last build laid out in a folder the user chose, so the next one replaces only that.
|
||||
let record = cache.join("artifacts").join(format!("{}.files", file_name(&artifact.name)));
|
||||
let mut steps = Vec::new();
|
||||
match (artifact.kind, war) {
|
||||
(ArtifactKind::Jar, None) => {
|
||||
@@ -324,7 +342,11 @@ fn artifact_steps(
|
||||
manifest.push_str(&format!("Class-Path: {}\r\n", names.join(" ")));
|
||||
}
|
||||
steps.push(BuildStep::action(
|
||||
Action::Layout { into: staging.clone(), entries: vec![(classes.to_path_buf(), PathBuf::new())] },
|
||||
Action::Layout {
|
||||
into: staging.clone(),
|
||||
entries: vec![(classes.to_path_buf(), PathBuf::new())],
|
||||
record: None,
|
||||
},
|
||||
root,
|
||||
));
|
||||
// The jar's Class-Path names the libraries next to it.
|
||||
@@ -332,6 +354,7 @@ fn artifact_steps(
|
||||
Action::Layout {
|
||||
into: out.clone(),
|
||||
entries: libraries.iter().map(|l| (l.clone(), file_of(l))).collect(),
|
||||
record: Some(record),
|
||||
},
|
||||
root,
|
||||
));
|
||||
@@ -353,7 +376,9 @@ fn artifact_steps(
|
||||
for lib in &libraries {
|
||||
entries.push((lib.clone(), Path::new("WEB-INF/lib").join(file_of(lib))));
|
||||
}
|
||||
steps.push(BuildStep::action(Action::Layout { into: exploded.clone(), entries }, root));
|
||||
// The exploded output may be a folder the user chose; the staging folder is the IDE's own.
|
||||
let record = (exploded != staging).then_some(record);
|
||||
steps.push(BuildStep::action(Action::Layout { into: exploded.clone(), entries, record }, root));
|
||||
let archive = war
|
||||
.map(Path::to_path_buf)
|
||||
.or_else(|| (kind != ArtifactKind::WarExploded).then(|| artifact_file(root, artifact)));
|
||||
@@ -407,8 +432,10 @@ pub(crate) enum Action {
|
||||
/// relative paths; files that are already up to date are left alone.
|
||||
CopyResources { from: Vec<PathBuf>, to: PathBuf },
|
||||
/// Lays out an artifact in `into`: each folder's content or file goes to its relative
|
||||
/// place (`""` = the top). What is no longer laid out is removed.
|
||||
Layout { into: PathBuf, entries: Vec<(PathBuf, PathBuf)> },
|
||||
/// place (`""` = the top). What is no longer laid out is removed: without `record`, `into`
|
||||
/// is the IDE's own folder and is laid out afresh; with it, `into` is a folder the user chose
|
||||
/// and only the files the previous layout recorded there are removed, never anything else.
|
||||
Layout { into: PathBuf, entries: Vec<(PathBuf, PathBuf)>, record: Option<PathBuf> },
|
||||
/// Zips the folder `from` into the archive `to`, with this manifest first.
|
||||
Archive { from: PathBuf, to: PathBuf, manifest: Option<String> },
|
||||
}
|
||||
@@ -441,29 +468,39 @@ impl Action {
|
||||
}
|
||||
Ok(format!("{copied} resource file(s) copied"))
|
||||
}
|
||||
Action::Layout { into, entries } => {
|
||||
// A fresh layout: files dropped from the sources must not linger in the artifact.
|
||||
Action::Layout { into, entries, record } => {
|
||||
if entries.iter().any(|(from, _)| from.starts_with(into)) {
|
||||
return Err(IdeError::invalid(format!(
|
||||
"The artifact output folder {} holds files the artifact is made of",
|
||||
into.display()
|
||||
)));
|
||||
}
|
||||
if into.exists() {
|
||||
if record.is_none() && into.exists() {
|
||||
fs::remove_dir_all(into)
|
||||
.map_err(|e| IdeError::internal(format!("cannot delete {} ({e})", into.display())))?;
|
||||
}
|
||||
let mut copied = 0;
|
||||
let mut written = Vec::new();
|
||||
for (from, to) in entries {
|
||||
let target = into.join(to);
|
||||
// The folders of the output it goes into (and a folder entry's own) are
|
||||
// never links; a file in a link's place replaces the link.
|
||||
let mut at = into.to_path_buf();
|
||||
let folders = to.components().count().saturating_sub(usize::from(!from.is_dir()));
|
||||
for c in to.components().take(folders) {
|
||||
at.push(c);
|
||||
refuse_link(&at)?;
|
||||
}
|
||||
if from.is_dir() {
|
||||
copied += copy_tree(from, &target, cancel)?;
|
||||
copy_tree(from, &target, &mut written, cancel)?;
|
||||
} else if from.is_file() {
|
||||
copy_file(from, &target)?;
|
||||
copied += 1;
|
||||
written.push(target);
|
||||
}
|
||||
}
|
||||
Ok(format!("{copied} file(s) laid out"))
|
||||
if let Some(record) = record {
|
||||
replace_recorded(into, record, &written)?;
|
||||
}
|
||||
Ok(format!("{} file(s) laid out", written.len()))
|
||||
}
|
||||
Action::Archive { from, to, manifest } => {
|
||||
archive(from, to, manifest.as_deref(), cancel)?;
|
||||
@@ -474,6 +511,10 @@ impl Action {
|
||||
}
|
||||
|
||||
fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
|
||||
// A link in the artifact's place is replaced, not written through.
|
||||
if fs::symlink_metadata(to).is_ok_and(|m| m.file_type().is_symlink()) {
|
||||
fs::remove_file(to).map_err(|e| IdeError::internal(format!("cannot replace {} ({e})", to.display())))?;
|
||||
}
|
||||
if let Some(parent) = to.parent() {
|
||||
fs::create_dir_all(parent)
|
||||
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
|
||||
@@ -482,23 +523,80 @@ fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn copy_tree(from: &Path, to: &Path, cancel: &CancellationToken) -> IdeResult<usize> {
|
||||
fn refuse_link(folder: &Path) -> IdeResult<()> {
|
||||
if fs::symlink_metadata(folder).is_ok_and(|m| m.file_type().is_symlink()) {
|
||||
return Err(IdeError::invalid(format!(
|
||||
"{} links to another folder; the artifact is not laid out through it",
|
||||
folder.display()
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn copy_tree(from: &Path, to: &Path, written: &mut Vec<PathBuf>, cancel: &CancellationToken) -> IdeResult<()> {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let Ok(entries) = fs::read_dir(from) else { return Ok(0) };
|
||||
let mut copied = 0;
|
||||
let Ok(entries) = fs::read_dir(from) else { return Ok(()) };
|
||||
for e in entries.flatten() {
|
||||
let Ok(t) = e.file_type() else { continue };
|
||||
let target = to.join(e.file_name());
|
||||
if t.is_dir() {
|
||||
copied += copy_tree(&e.path(), &target, cancel)?;
|
||||
refuse_link(&target)?;
|
||||
copy_tree(&e.path(), &target, written, cancel)?;
|
||||
} else if t.is_file() {
|
||||
copy_file(&e.path(), &target)?;
|
||||
copied += 1;
|
||||
written.push(target);
|
||||
}
|
||||
}
|
||||
Ok(copied)
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Removes the files the previous layout recorded in `into` that this one didn't write
|
||||
/// (and the folders that leaves empty), then records `written` for the next layout.
|
||||
fn replace_recorded(into: &Path, record: &Path, written: &[PathBuf]) -> IdeResult<()> {
|
||||
let now: std::collections::HashSet<PathBuf> =
|
||||
written.iter().filter_map(|p| p.strip_prefix(into).ok().map(Path::to_path_buf)).collect();
|
||||
let before = fs::read_to_string(record).unwrap_or_default();
|
||||
let mut lines = before.lines();
|
||||
// The record names its folder first: one made for another output folder removes nothing.
|
||||
let same = lines.next().is_some_and(|dir| Path::new(dir) == into);
|
||||
for rel in lines.filter(|_| same).map(PathBuf::from) {
|
||||
// Only plain relative paths inside `into`: a damaged record must not reach elsewhere.
|
||||
if rel.as_os_str().is_empty()
|
||||
|| now.contains(&rel)
|
||||
|| rel.components().any(|c| !matches!(c, std::path::Component::Normal(_)))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let file = into.join(&rel);
|
||||
// Never through a link: a folder of the output that now links elsewhere (or a file that
|
||||
// is a link) leads out of what the layout wrote.
|
||||
let mut at = into.to_path_buf();
|
||||
let linked = rel.components().any(|c| {
|
||||
at.push(c);
|
||||
fs::symlink_metadata(&at).is_ok_and(|m| m.file_type().is_symlink())
|
||||
});
|
||||
if !linked && file.is_file() {
|
||||
let _ = fs::remove_file(&file);
|
||||
let mut dir = file.parent();
|
||||
while let Some(d) = dir.filter(|d| *d != into && d.starts_with(into)) {
|
||||
if fs::remove_dir(d).is_err() {
|
||||
break;
|
||||
}
|
||||
dir = d.parent();
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut list: Vec<String> = now.iter().map(|p| p.to_string_lossy().into_owned()).collect();
|
||||
list.sort();
|
||||
list.insert(0, into.to_string_lossy().into_owned());
|
||||
if let Some(parent) = record.parent() {
|
||||
fs::create_dir_all(parent)
|
||||
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
|
||||
}
|
||||
fs::write(record, list.join("\n"))
|
||||
.map_err(|e| IdeError::internal(format!("cannot write {} ({e})", record.display())))
|
||||
}
|
||||
|
||||
fn archive(from: &Path, to: &Path, manifest: Option<&str>, cancel: &CancellationToken) -> IdeResult<()> {
|
||||
@@ -698,6 +796,37 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rebuild_never_cleans_an_output_folder_over_the_project_or_its_sources() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().join("p");
|
||||
write(&root.join("src/A.java"), "class A {}");
|
||||
let roots = StructureRoots { sources: vec![root.join("src")], ..Default::default() };
|
||||
for (main, test) in [(".", "bin"), ("src", "src/../test-out"), ("src/classes", ".."), ("", "")] {
|
||||
let mut ps = ProjectStructureSettings::default();
|
||||
ps.modules.insert(
|
||||
".".into(),
|
||||
ModuleStructureSettings {
|
||||
compiler_output: main.into(),
|
||||
test_compiler_output: test.into(),
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
let plan = structure_plan(&root, &ps, &roots, None, "17", BuildKind::Rebuild, &tmp.path().join("c"))
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let clean: Vec<String> =
|
||||
plan.steps.iter().map(BuildStep::display).filter(|s| s.starts_with("Clean")).collect();
|
||||
let expected: &[&str] = match main {
|
||||
"." => &["Clean bin"],
|
||||
"src" => &["Clean src/../test-out"],
|
||||
"src/classes" => &[],
|
||||
_ => &["Clean out/production/p, out/test/p"],
|
||||
};
|
||||
assert_eq!(clean, expected, "{main} / {test}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_plan_without_java_sources() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -812,8 +941,71 @@ mod tests {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let web = tmp.path().join("WebRoot");
|
||||
write(&web.join("a.jsp"), "");
|
||||
let action = Action::Layout { into: tmp.path().to_path_buf(), entries: vec![(web.clone(), PathBuf::new())] };
|
||||
let action = Action::Layout {
|
||||
into: tmp.path().to_path_buf(),
|
||||
entries: vec![(web.clone(), PathBuf::new())],
|
||||
record: None,
|
||||
};
|
||||
assert!(action.run(&CancellationToken::new()).is_err());
|
||||
assert!(web.join("a.jsp").is_file());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_chosen_output_folder_keeps_what_the_artifact_did_not_put_there() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let project = tmp.path().join("project");
|
||||
write(&project.join("src/A.java"), "class A {}");
|
||||
write(&project.join(".git/HEAD"), "ref: refs/heads/main");
|
||||
let libs = tmp.path().join("libs");
|
||||
write(&libs.join("a.jar"), "a");
|
||||
write(&libs.join("b.jar"), "b");
|
||||
let record = tmp.path().join("cache/artifacts/app.files");
|
||||
let layout = |names: &[&str]| Action::Layout {
|
||||
into: project.clone(),
|
||||
entries: names.iter().map(|n| (libs.join(n), PathBuf::from(n))).collect(),
|
||||
record: Some(record.clone()),
|
||||
};
|
||||
layout(&["a.jar", "b.jar"]).run(&CancellationToken::new()).unwrap();
|
||||
assert!(project.join("a.jar").is_file() && project.join("b.jar").is_file());
|
||||
// A library dropped from the artifact goes; the project's own files stay.
|
||||
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
|
||||
assert!(project.join("a.jar").is_file() && !project.join("b.jar").exists());
|
||||
assert!(project.join("src/A.java").is_file() && project.join(".git/HEAD").is_file());
|
||||
// A damaged record never reaches outside the folder.
|
||||
write(&record, &format!("{}\n../outside.txt", project.display()));
|
||||
write(&tmp.path().join("outside.txt"), "x");
|
||||
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
|
||||
assert!(tmp.path().join("outside.txt").is_file());
|
||||
// Nor through a folder of the output that now links elsewhere.
|
||||
#[cfg(unix)]
|
||||
{
|
||||
write(&project.join("assets/x.txt"), "laid out");
|
||||
write(&record, &format!("{}\nassets/x.txt", project.display()));
|
||||
fs::remove_dir_all(project.join("assets")).unwrap();
|
||||
std::os::unix::fs::symlink(project.join("src"), project.join("assets")).unwrap();
|
||||
write(&project.join("src/x.txt"), "source");
|
||||
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
|
||||
assert!(project.join("src/x.txt").is_file());
|
||||
}
|
||||
// An entry's own folder that links elsewhere stops the layout instead of copying through it.
|
||||
#[cfg(unix)]
|
||||
{
|
||||
fs::remove_file(project.join("assets")).unwrap();
|
||||
std::os::unix::fs::symlink(project.join("src"), project.join("classes")).unwrap();
|
||||
write(&tmp.path().join("out/A.class"), "compiled");
|
||||
let into_link = Action::Layout {
|
||||
into: project.clone(),
|
||||
entries: vec![(tmp.path().join("out"), PathBuf::from("classes"))],
|
||||
record: Some(record.clone()),
|
||||
};
|
||||
assert!(into_link.run(&CancellationToken::new()).is_err());
|
||||
assert!(!project.join("src/A.class").exists());
|
||||
fs::remove_file(project.join("classes")).unwrap();
|
||||
}
|
||||
// Nor does one made for another output folder.
|
||||
write(&project.join("c.jar"), "mine");
|
||||
write(&record, "/elsewhere\nc.jar");
|
||||
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
|
||||
assert!(project.join("c.jar").is_file());
|
||||
}
|
||||
}
|
||||
@@ -30,7 +30,8 @@ def processedResources = { Project p, s ->
|
||||
def describe = { Project p ->
|
||||
def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
|
||||
if (p.gradle.parent != null) m.build = identity(p.rootProject)
|
||||
def sets = p.extensions.findByName('sourceSets')
|
||||
// Gradle 4.x has it as a convention property, not an extension.
|
||||
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
|
||||
if (sets != null) {
|
||||
// Test source sets as IDEA classifies them: `test`, test fixtures, JVM test suites,
|
||||
// and sets whose folders the `idea` plugin lists as test sources.
|
||||
@@ -51,9 +52,12 @@ def describe = { Project p ->
|
||||
}
|
||||
}
|
||||
try {
|
||||
// `java` is Gradle 4.10+ (a convention before), its toolchain 6.7+.
|
||||
def java = p.extensions.findByName('java')
|
||||
def lv = java?.toolchain?.languageVersion?.getOrNull()
|
||||
m.java = lv != null ? lv.asInt() : (java?.targetCompatibility?.majorVersion as Integer)
|
||||
def lv = null
|
||||
try { lv = java?.toolchain?.languageVersion?.getOrNull() } catch (ignored) {}
|
||||
def target = java != null ? java.targetCompatibility : p.findProperty('targetCompatibility')
|
||||
m.java = lv != null ? lv.asInt() : (target?.majorVersion as Integer)
|
||||
} catch (ignored) {}
|
||||
println '@openidea-model\t' + JsonOutput.toJson(m)
|
||||
}
|
||||
|
||||
@@ -1,13 +1,16 @@
|
||||
//! A Gradle project's resolved dependencies for the Dependency Analyzer:
|
||||
//! `gradle <project>:dependencies --configuration <name>`, parsed from its tree report.
|
||||
//! The reports it read are kept per build ([`save_gradle_report`]) until a build file
|
||||
//! changes, for readers that must not run Gradle themselves (plugins).
|
||||
|
||||
use crate::gradle;
|
||||
use crate::process;
|
||||
use crate::sync::{SyncOptions, error_summary};
|
||||
use crate::sync::{self, SyncOptions, error_summary};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::path::Path;
|
||||
use std::sync::Mutex;
|
||||
|
||||
/// One line of the report: an occurrence of a dependency where it is requested.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
@@ -158,6 +161,54 @@ pub fn gradle_dependencies(
|
||||
Ok(parse_report(&out.text))
|
||||
}
|
||||
|
||||
/// A `dependencies` report of one project of a build for one configuration.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub struct GradleReport {
|
||||
/// Gradle path of the project (`:`, `:app`).
|
||||
pub project: String,
|
||||
pub configuration: String,
|
||||
pub dependencies: Vec<GradleDependency>,
|
||||
}
|
||||
|
||||
#[derive(Default, Serialize, Deserialize)]
|
||||
struct ReportCache {
|
||||
/// The build files the reports were read with ([`sync::hash_gradle_files`]).
|
||||
hash: String,
|
||||
reports: Vec<GradleReport>,
|
||||
}
|
||||
|
||||
const REPORT_CACHE: &str = "gradle-dependencies.json";
|
||||
|
||||
/// Keeps `report` with the build's other reports (`cache_dir` is the build's cache
|
||||
/// directory), replacing an earlier one of the same project and configuration. Reports
|
||||
/// read before a build file changed are dropped.
|
||||
pub fn save_gradle_report(
|
||||
root: &Path,
|
||||
cache_dir: &Path,
|
||||
model: &gradle::GradleModel,
|
||||
report: &GradleReport,
|
||||
) -> IdeResult<()> {
|
||||
// Reports of several configurations may finish together: one read-modify-write at a time.
|
||||
static SAVING: Mutex<()> = Mutex::new(());
|
||||
let _saving = SAVING.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let hash = sync::hash_gradle_files(&gradle::build_files(root, model));
|
||||
let mut cache = sync::read_cache::<ReportCache>(cache_dir, REPORT_CACHE)
|
||||
.filter(|c| c.hash == hash)
|
||||
.unwrap_or_else(|| ReportCache { hash, reports: Vec::new() });
|
||||
cache.reports.retain(|r| (&r.project, &r.configuration) != (&report.project, &report.configuration));
|
||||
cache.reports.push(report.clone());
|
||||
sync::write_cache(cache_dir, REPORT_CACHE, &cache)
|
||||
}
|
||||
|
||||
/// The reports kept for the build, unless a build file changed since they were read.
|
||||
pub fn gradle_reports(root: &Path, cache_dir: &Path, model: &gradle::GradleModel) -> Vec<GradleReport> {
|
||||
let Some(cache) = sync::read_cache::<ReportCache>(cache_dir, REPORT_CACHE) else { return Vec::new() };
|
||||
if cache.hash != sync::hash_gradle_files(&gradle::build_files(root, model)) {
|
||||
return Vec::new();
|
||||
}
|
||||
cache.reports
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -234,6 +285,37 @@ runtimeClasspath - Runtime classpath of source set 'main'.
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reports_are_kept_per_project_and_configuration_until_a_build_file_changes() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path();
|
||||
let cache = root.join("cache");
|
||||
std::fs::write(root.join("settings.gradle"), "include 'app'").unwrap();
|
||||
std::fs::write(root.join("build.gradle"), "").unwrap();
|
||||
let model = gradle::load(root).unwrap();
|
||||
assert!(gradle_reports(root, &cache, &model).is_empty());
|
||||
let report = |project: &str, configuration: &str, version: &str| GradleReport {
|
||||
project: project.into(),
|
||||
configuration: configuration.into(),
|
||||
dependencies: vec![dep("org.a", "b", Some(version))],
|
||||
};
|
||||
save_gradle_report(root, &cache, &model, &report(":app", "runtimeClasspath", "1.0")).unwrap();
|
||||
save_gradle_report(root, &cache, &model, &report(":app", "compileClasspath", "1.0")).unwrap();
|
||||
// Reading a report again replaces what was read before.
|
||||
save_gradle_report(root, &cache, &model, &report(":app", "runtimeClasspath", "2.0")).unwrap();
|
||||
assert_eq!(
|
||||
gradle_reports(root, &cache, &model),
|
||||
[report(":app", "compileClasspath", "1.0"), report(":app", "runtimeClasspath", "2.0")]
|
||||
);
|
||||
// A comment changes nothing Gradle reads; a dependency does.
|
||||
std::fs::write(root.join("build.gradle"), "// notes").unwrap();
|
||||
assert_eq!(gradle_reports(root, &cache, &model).len(), 2);
|
||||
std::fs::write(root.join("build.gradle"), "dependencies { implementation 'org.a:b:3.0' }").unwrap();
|
||||
assert!(gradle_reports(root, &cache, &model).is_empty());
|
||||
save_gradle_report(root, &cache, &model, &report(":", "compileClasspath", "3.0")).unwrap();
|
||||
assert_eq!(gradle_reports(root, &cache, &model), [report(":", "compileClasspath", "3.0")]);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn runs_the_report_of_the_project_and_configuration() {
|
||||
|
||||
@@ -19,7 +19,7 @@ pub mod web;
|
||||
mod xml;
|
||||
|
||||
pub use gradle::{GradleModel, GradleProject, GradleTask};
|
||||
pub use gradle_deps::{GradleDependency, gradle_dependencies};
|
||||
pub use gradle_deps::{GradleDependency, GradleReport, gradle_dependencies, gradle_reports, save_gradle_report};
|
||||
pub use maven::{MavenDependency, MavenModel, MavenPlugin, MavenProfile, MavenProject, Omission};
|
||||
pub use sbt::{SbtBuild, SbtProject};
|
||||
pub use sync::{
|
||||
@@ -127,10 +127,22 @@ pub fn gradle_external_roots(
|
||||
gradle::external_roots(root, dirs.iter().map(String::as_str))
|
||||
}
|
||||
|
||||
/// Directories of Maven POMs linked from outside `root`, outermost only.
|
||||
/// Reads just those explicit paths (no POM parse and no directory walk).
|
||||
pub fn maven_external_roots(root: &Path, linked: &[String]) -> Vec<PathBuf> {
|
||||
let dirs = maven::external_pom_dirs(root, linked);
|
||||
/// Directories outside `root`, outermost only, of Maven POMs linked from there and, in a
|
||||
/// trusted project, of the modules its reactor lists there (`<module>../service-a</module>`):
|
||||
/// extra content roots, as IDEA imports such modules with content roots of their own.
|
||||
/// Linked POMs are read as explicit paths; the reactor's POMs are parsed, but not their
|
||||
/// parents, and nothing walks directories. `cache_dir` holds the profiles chosen at the last sync.
|
||||
pub fn maven_external_roots(
|
||||
root: &Path,
|
||||
cache_dir: &Path,
|
||||
settings: &ide_core::settings::MavenSettings,
|
||||
trusted: bool,
|
||||
) -> Vec<PathBuf> {
|
||||
let mut dirs = maven::external_pom_dirs(root, &settings.linked_projects);
|
||||
if trusted {
|
||||
let profiles = settings.profiles(&sync::maven_profiles(cache_dir));
|
||||
dirs.extend(maven::reactor_external_dirs(root, &profiles, &settings.unlinked_projects));
|
||||
}
|
||||
let owned: Vec<String> = dirs.iter().map(|dir| dir.to_string_lossy().into_owned()).collect();
|
||||
gradle::external_roots(root, owned.iter().map(String::as_str))
|
||||
}
|
||||
@@ -251,6 +263,59 @@ mod tests {
|
||||
assert!(gradle_external_roots(&root, &temp.path().join("cache"), &settings).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reactor_modules_outside_the_root_are_content_roots_of_a_trusted_project() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let root = base.join("workspace");
|
||||
let cache = base.join("cache");
|
||||
let write = |rel: &str, text: &str| {
|
||||
let path = base.join(rel).join("pom.xml");
|
||||
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
std::fs::write(path, format!("<project><artifactId>{rel}</artifactId>{text}</project>")).unwrap();
|
||||
};
|
||||
let reactor = |modules: &str| {
|
||||
format!(
|
||||
"<packaging>pom</packaging><modules>{modules}</modules>\
|
||||
<profiles><profile><id>extra</id><modules><module>../service-c</module></modules></profile></profiles>"
|
||||
)
|
||||
};
|
||||
let all = "<module>core</module><module>../service-a</module><module>..</module>";
|
||||
write("workspace", &reactor(all));
|
||||
write("workspace/core", "<modules><module>../../service-d</module></modules>");
|
||||
write("service-a", "<modules><module>impl</module><module>../service-e</module></modules>");
|
||||
for module in ["service-a/impl", "service-c", "service-d", "service-e", "unrelated"] {
|
||||
write(module, "");
|
||||
}
|
||||
// The folder holding the project is not a module beside it, nor are its other modules.
|
||||
write("", "<modules><module>workspace</module><module>unrelated</module></modules>");
|
||||
|
||||
let mut settings = ide_core::settings::MavenSettings::default();
|
||||
let roots = |settings: &ide_core::settings::MavenSettings, trusted| {
|
||||
maven_external_roots(&root, &cache, settings, trusted)
|
||||
};
|
||||
let (a, c, d, e) =
|
||||
(base.join("service-a"), base.join("service-c"), base.join("service-d"), base.join("service-e"));
|
||||
assert_eq!(roots(&settings, true), [a.clone(), d.clone(), e.clone()]);
|
||||
assert!(roots(&settings, false).is_empty(), "Restricted Mode does not widen the index");
|
||||
|
||||
settings.active_profiles = "extra".into();
|
||||
assert_eq!(roots(&settings, true), [a.clone(), c.clone(), d.clone(), e.clone()]);
|
||||
save_maven_profiles(&cache, &["!extra".into()]).unwrap();
|
||||
assert_eq!(roots(&settings, true), [a.clone(), d.clone(), e.clone()]);
|
||||
|
||||
settings.unlinked_projects = vec![a.join("pom.xml").to_string_lossy().replace('\\', "/")];
|
||||
assert_eq!(roots(&settings, true), std::slice::from_ref(&d));
|
||||
settings.unlinked_projects.clear();
|
||||
|
||||
write("workspace", &reactor("<module>core</module>"));
|
||||
assert_eq!(roots(&settings, true), std::slice::from_ref(&d));
|
||||
write("workspace/core", "");
|
||||
assert!(roots(&settings, true).is_empty());
|
||||
write("workspace", &reactor(all));
|
||||
assert_eq!(roots(&settings, true), [a, e]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn settings_profiles_and_checkbox_choices_control_modules_before_sync() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -1235,6 +1235,86 @@ pub fn external_pom_dirs(root: &Path, linked: &[String]) -> Vec<PathBuf> {
|
||||
out
|
||||
}
|
||||
|
||||
type FileStamp = Option<(Option<std::time::SystemTime>, u64)>;
|
||||
|
||||
fn file_stamp(path: &Path) -> FileStamp {
|
||||
std::fs::metadata(path).ok().map(|m| (m.modified().ok(), m.len()))
|
||||
}
|
||||
|
||||
/// The POM files a reactor walk read or looked for, and the module folders it found outside the root.
|
||||
struct ReactorScan {
|
||||
stamps: Vec<(PathBuf, FileStamp)>,
|
||||
dirs: Vec<PathBuf>,
|
||||
}
|
||||
|
||||
/// Folders of the modules that the reactor of `root/pom.xml` lists outside `root`
|
||||
/// (`<module>../service-a</module>`), with their own modules in turn, including those of
|
||||
/// the active `profiles`. An `unlinked` POM leaves out its modules too. A folder that
|
||||
/// holds `root` (`<module>..</module>`) is not a module beside the project and is skipped.
|
||||
/// Callers keep the outermost directory only. Memoized on the POMs' modification times and
|
||||
/// sizes: content roots are read on hot paths (every references search, Find in Files).
|
||||
pub fn reactor_external_dirs(root: &Path, profiles: &[String], unlinked: &[String]) -> Vec<PathBuf> {
|
||||
type Memo = HashMap<(PathBuf, Vec<String>, Vec<String>), ReactorScan>;
|
||||
static MEMO: std::sync::LazyLock<Mutex<Memo>> = std::sync::LazyLock::new(Default::default);
|
||||
let key = (root.to_path_buf(), profiles.to_vec(), unlinked.to_vec());
|
||||
if let Some(scan) = MEMO.lock().unwrap_or_else(|e| e.into_inner()).get(&key)
|
||||
&& scan.stamps.iter().all(|(path, stamp)| file_stamp(path) == *stamp)
|
||||
{
|
||||
return scan.dirs.clone();
|
||||
}
|
||||
let scan = scan_reactor(root, profiles, unlinked);
|
||||
let dirs = scan.dirs.clone();
|
||||
MEMO.lock().unwrap_or_else(|e| e.into_inner()).insert(key, scan);
|
||||
dirs
|
||||
}
|
||||
|
||||
/// Reads only the POMs the reactor lists (no parent resolution and no directory walk).
|
||||
fn scan_reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> ReactorScan {
|
||||
let canonical_root = dunce::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
|
||||
let chosen = Resolver::new(None, profiles);
|
||||
let unlinked: HashSet<String> = unlinked.iter().map(|p| normalized_pom(p.trim())).collect();
|
||||
let first = root.join("pom.xml");
|
||||
let mut scan = ReactorScan { stamps: vec![(first.clone(), file_stamp(&first))], dirs: Vec::new() };
|
||||
let mut seen: HashSet<PathBuf> = HashSet::new();
|
||||
let mut pending = vec![first];
|
||||
while let Some(path) = pending.pop() {
|
||||
if seen.len() >= MAX_PROJECTS {
|
||||
break;
|
||||
}
|
||||
let canonical = dunce::canonicalize(&path).unwrap_or_else(|_| path.clone());
|
||||
if !seen.insert(canonical.clone()) || unlinked.contains(&project_rel(&canonical_root, &canonical)) {
|
||||
continue;
|
||||
}
|
||||
let Some(pom) = xml::read_text(&path).as_deref().and_then(parse_pom) else { continue };
|
||||
let dir = path.parent().unwrap_or(root).to_path_buf();
|
||||
let dir_canon = dunce::canonicalize(&dir).unwrap_or_else(|_| dir.clone());
|
||||
if !dir_canon.starts_with(&canonical_root) {
|
||||
if canonical_root.starts_with(&dir_canon) {
|
||||
continue;
|
||||
}
|
||||
scan.dirs.push(dir_canon);
|
||||
}
|
||||
let active: Vec<&RawProfile> = chosen.active(&pom.profiles).collect();
|
||||
let props: HashMap<String, String> =
|
||||
pom.properties.iter().chain(active.iter().flat_map(|p| &p.properties)).cloned().collect();
|
||||
for module in pom.modules.iter().chain(active.iter().flat_map(|p| &p.modules)) {
|
||||
let module = interpolate(module, &props);
|
||||
if module.contains("${") {
|
||||
continue;
|
||||
}
|
||||
let mut mp = crate::gradle::normalize(&dir.join(module));
|
||||
if mp.is_dir() || mp.extension().is_none_or(|e| e != "xml") {
|
||||
mp.push("pom.xml");
|
||||
}
|
||||
scan.stamps.push((mp.clone(), file_stamp(&mp)));
|
||||
if mp.is_file() {
|
||||
pending.push(mp);
|
||||
}
|
||||
}
|
||||
}
|
||||
scan
|
||||
}
|
||||
|
||||
/// Whether `root` holds a Maven build or the settings link one inside it.
|
||||
pub fn has_projects(root: &Path, settings: &ide_core::settings::MavenSettings) -> bool {
|
||||
is_maven_project(root) || !linked_poms(root, &settings.linked_projects).is_empty()
|
||||
@@ -2479,8 +2559,12 @@ mod tests {
|
||||
assert_eq!(normalized[0], dunce::canonicalize(b.join("pom.xml")).unwrap().to_string_lossy().replace('\\', "/"));
|
||||
assert_eq!(normalized[1], "pom.xml");
|
||||
assert_eq!(normalized[2], "stub/pom.xml");
|
||||
assert_eq!(crate::maven_external_roots(&a, &normalized), vec![b.clone()]);
|
||||
assert_eq!(crate::maven_external_roots(&a, &stored), vec![b.clone()]);
|
||||
let external_roots = |linked: &[String]| {
|
||||
let settings = ide_core::settings::MavenSettings { linked_projects: linked.to_vec(), ..Default::default() };
|
||||
crate::maven_external_roots(&a, &base.join("cache"), &settings, true)
|
||||
};
|
||||
assert_eq!(external_roots(&normalized), vec![b.clone()]);
|
||||
assert_eq!(external_roots(&stored), vec![b.clone()]);
|
||||
|
||||
let removed = load_with_linked(&a, None, &[], &[]);
|
||||
assert!(removed.projects.iter().all(|p| p.artifact_id != "b"));
|
||||
|
||||
@@ -136,11 +136,11 @@ pub fn save_maven_profiles(cache_dir: &Path, profiles: &[String]) -> IdeResult<b
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
fn read_cache<T: DeserializeOwned>(dir: &Path, name: &str) -> Option<T> {
|
||||
pub(crate) fn read_cache<T: DeserializeOwned>(dir: &Path, name: &str) -> Option<T> {
|
||||
serde_json::from_slice(&std::fs::read(dir.join(name)).ok()?).ok()
|
||||
}
|
||||
|
||||
fn write_cache<T: Serialize>(dir: &Path, name: &str, value: &T) -> IdeResult<()> {
|
||||
pub(crate) fn write_cache<T: Serialize>(dir: &Path, name: &str, value: &T) -> IdeResult<()> {
|
||||
std::fs::create_dir_all(dir)?;
|
||||
let json = serde_json::to_vec(value).map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
let tmp = dir.join(format!("{name}.tmp"));
|
||||
@@ -156,7 +156,7 @@ fn hash_files(files: &[PathBuf]) -> String {
|
||||
|
||||
/// Like IDEA's auto-import CRC: editing a comment or reformatting a build script
|
||||
/// does not make the last sync stale.
|
||||
fn hash_gradle_files(files: &[PathBuf]) -> String {
|
||||
pub(crate) fn hash_gradle_files(files: &[PathBuf]) -> String {
|
||||
hash_contents(files, |f| {
|
||||
let text = std::fs::read_to_string(f).unwrap_or_default();
|
||||
let script = f.extension().is_some_and(|e| e == "gradle" || e == "kts");
|
||||
|
||||
@@ -172,13 +172,25 @@ pub fn build(root: &Path, model: &BuildModel, id: &str, cache: &Path) -> IdeResu
|
||||
fs::write(
|
||||
&script,
|
||||
format!(
|
||||
r#"gradle.projectsEvaluated {{
|
||||
r#"import org.gradle.util.GradleVersion
|
||||
|
||||
gradle.projectsEvaluated {{
|
||||
def p = gradle.rootProject.project({})
|
||||
def warTask = p.tasks.named('war')
|
||||
p.tasks.register('openideaTomcatArtifact') {{
|
||||
dependsOn warTask
|
||||
doLast {{ new File({}).setText(warTask.get().archiveFile.get().asFile.absolutePath, 'UTF-8') }}
|
||||
def artifact = {{ t ->
|
||||
t.dependsOn 'war'
|
||||
// Resolved here so the action holds no task or project (configuration cache).
|
||||
def war = p.tasks.getByName('war')
|
||||
// `archiveFile` is Gradle 5.1+, `archivePath` is gone in 8.0.
|
||||
def archive = war.hasProperty('archiveFile') ? war.archiveFile : war.archivePath
|
||||
def manifest = new File({})
|
||||
t.doLast {{
|
||||
def file = archive instanceof File ? archive : archive.get().asFile
|
||||
manifest.setText(file.absolutePath, 'UTF-8')
|
||||
}}
|
||||
}}
|
||||
// `register` is Gradle 4.9+.
|
||||
if (GradleVersion.current() >= GradleVersion.version('4.9')) p.tasks.register('openideaTomcatArtifact', artifact)
|
||||
else p.tasks.create('openideaTomcatArtifact', artifact)
|
||||
}}
|
||||
"#,
|
||||
groovy_literal(path),
|
||||
@@ -270,7 +282,7 @@ mod tests {
|
||||
assert_eq!(a.len(), 1);
|
||||
let plan = build(tmp.path(), &model, &a[0].id, &tmp.path().join("base")).unwrap();
|
||||
assert!(plan.args.contains(&":openideaTomcatArtifact".into()));
|
||||
assert!(fs::read_to_string(tmp.path().join("base/war.init.gradle")).unwrap().contains("archiveFile.get()"));
|
||||
assert!(fs::read_to_string(tmp.path().join("base/war.init.gradle")).unwrap().contains("? war.archiveFile :"));
|
||||
assert!(!crate::gradle::has_war_plugin("// plugins { war }"));
|
||||
}
|
||||
|
||||
@@ -297,7 +309,14 @@ mod tests {
|
||||
assert!(plan.args.contains(&format!("{}:openideaTomcatArtifact", module.trim_end_matches(':'))));
|
||||
let script = fs::read_to_string(cache.join("war.init.gradle")).unwrap();
|
||||
assert!(script.contains(&format!("rootProject.project('{}')", module)));
|
||||
assert!(script.contains("archiveFile.get().asFile.absolutePath, 'UTF-8'"));
|
||||
assert!(script.contains("manifest.setText(file.absolutePath, 'UTF-8')"));
|
||||
// `archiveFile` is Gradle 5.1+, `register` 4.9+ (#3864).
|
||||
assert!(
|
||||
script.contains(": war.archivePath") && script.contains("else p.tasks.create('openideaTomcatArtifact'")
|
||||
);
|
||||
// The configuration cache can't serialize a task or project the action refers to.
|
||||
let action = &script[script.find("doLast").unwrap()..script.find("// `register`").unwrap()];
|
||||
assert!(!action.contains("p.") && !action.contains("war."), "{action}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -348,6 +348,35 @@ mod imp {
|
||||
paths
|
||||
}
|
||||
|
||||
/// `Preferred DropEffect`: a `DWORD` saying whether the files were copied or cut.
|
||||
/// Explorer writes it with every file list, and paste targets that move files
|
||||
/// between machines (Remote Desktop's clipboard redirection, #3863) read it.
|
||||
fn drop_effect_format() -> u32 {
|
||||
let name: Vec<u16> = "Preferred DropEffect\0".encode_utf16().collect();
|
||||
unsafe { RegisterClipboardFormatW(name.as_ptr()) }
|
||||
}
|
||||
|
||||
/// `DROPEFFECT_COPY`.
|
||||
const DROPEFFECT_COPY: u32 = 1;
|
||||
|
||||
/// An `HGLOBAL` holding a copy of `bytes`. Null when the allocation failed.
|
||||
fn global_bytes(bytes: &[u8]) -> Handle {
|
||||
unsafe {
|
||||
let memory = GlobalAlloc(GMEM_MOVEABLE, bytes.len());
|
||||
if memory.is_null() {
|
||||
return ptr::null_mut();
|
||||
}
|
||||
let data = GlobalLock(memory);
|
||||
if data.is_null() {
|
||||
GlobalFree(memory);
|
||||
return ptr::null_mut();
|
||||
}
|
||||
ptr::copy_nonoverlapping(bytes.as_ptr(), data as *mut u8, bytes.len());
|
||||
GlobalUnlock(memory);
|
||||
memory
|
||||
}
|
||||
}
|
||||
|
||||
/// An `HGLOBAL` holding `text` as UTF-16 with a terminating NUL, and its
|
||||
/// byte size. Null when the allocation failed.
|
||||
fn global_text(text: &str) -> (Handle, usize) {
|
||||
@@ -430,6 +459,13 @@ mod imp {
|
||||
if !taken {
|
||||
GlobalFree(memory);
|
||||
}
|
||||
let effect = drop_effect_format();
|
||||
if effect != 0 {
|
||||
let effect_memory = global_bytes(&DROPEFFECT_COPY.to_le_bytes());
|
||||
if !effect_memory.is_null() && SetClipboardData(effect, effect_memory).is_null() {
|
||||
GlobalFree(effect_memory);
|
||||
}
|
||||
}
|
||||
let (text_memory, _) = global_text(&text);
|
||||
if !text_memory.is_null() {
|
||||
// The text alone still pastes somewhere useful.
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
[package]
|
||||
name = "ide-command"
|
||||
description = "Declares OpenIDEA's backend commands once and derives their adapters, trust class and placement"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[lib]
|
||||
proc-macro = true
|
||||
|
||||
[dependencies]
|
||||
heck.workspace = true
|
||||
proc-macro2.workspace = true
|
||||
quote.workspace = true
|
||||
syn.workspace = true
|
||||
|
||||
[dev-dependencies]
|
||||
serde.workspace = true
|
||||
@@ -0,0 +1,92 @@
|
||||
// Stand-in for the parts of `ide-host` that the code generated by `#[command]`, `domain!` and
|
||||
// `domains!` names; doctests `include!` it at their crate root.
|
||||
|
||||
pub type IdeResult<T> = Result<T, IdeError>;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct IdeError(pub String);
|
||||
|
||||
impl IdeError {
|
||||
pub fn unavailable(m: impl Into<String>) -> Self {
|
||||
Self(m.into())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Host;
|
||||
|
||||
impl Host {
|
||||
pub fn plugin_host(&self) -> Option<std::sync::Arc<plugins::PluginHost>> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
pub mod plugins {
|
||||
pub struct PluginHost;
|
||||
}
|
||||
|
||||
pub mod catalogue {
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum TrustClass {
|
||||
Always,
|
||||
OutsideRestricted,
|
||||
Trusted,
|
||||
}
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Placement {
|
||||
Desktop,
|
||||
ProjectHost,
|
||||
}
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Mode {
|
||||
Sync,
|
||||
Async,
|
||||
Spawn,
|
||||
}
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct Command {
|
||||
pub name: &'static str,
|
||||
pub trust: TrustClass,
|
||||
pub placement: Placement,
|
||||
pub bindings: bool,
|
||||
pub mode: Mode,
|
||||
}
|
||||
}
|
||||
|
||||
pub mod ops {
|
||||
pub struct Channel<T>(pub std::marker::PhantomData<T>);
|
||||
pub type Emit<T> = std::sync::Arc<dyn Fn(T) + Send + Sync>;
|
||||
}
|
||||
|
||||
pub mod rpc {
|
||||
use crate::catalogue::TrustClass;
|
||||
use crate::{IdeResult, ops::Channel};
|
||||
|
||||
pub struct Call {
|
||||
pub host: std::sync::Arc<crate::Host>,
|
||||
pub window: String,
|
||||
}
|
||||
|
||||
impl Call {
|
||||
pub fn arg<T: Default>(&self, _name: &str) -> IdeResult<T> {
|
||||
Ok(T::default())
|
||||
}
|
||||
pub fn sender<T>(&self, _name: &str) -> IdeResult<Channel<T>> {
|
||||
Ok(Channel(std::marker::PhantomData))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct Dispatcher(pub Vec<(&'static str, TrustClass)>);
|
||||
|
||||
impl Dispatcher {
|
||||
pub fn add<F, Fut, T>(&mut self, name: &'static str, trust: TrustClass, _f: F) -> &mut Self
|
||||
where
|
||||
F: Fn(Call) -> Fut + Send + Sync + 'static,
|
||||
Fut: Future<Output = IdeResult<T>> + Send + 'static,
|
||||
T: serde::Serialize,
|
||||
{
|
||||
self.0.push((name, trust));
|
||||
self
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,884 @@
|
||||
//! Declares OpenIDEA's backend commands once, on the fn that implements them.
|
||||
//!
|
||||
//! A command that runs on the project host is an `ide-host` fn with `#[command]`; its module
|
||||
//! lists it in `domain!`, and `ide-host` lists its domains in `domains!`. From that `src-tauri`
|
||||
//! derives the Tauri adapter and its bindings entry, and `ide-host` derives the JSON-RPC handler
|
||||
//! `openidea-server` answers. A command only the desktop runs keeps its hand-written Tauri fn,
|
||||
//! with `#[desktop_command]`, and its module lists it in `desktop_domain!`. Every command
|
||||
//! declares its trust class, and each declaration yields a `COMMAND`
|
||||
//! (`ide_host::catalogue::Command`): its name, trust class, placement, bindings entry and
|
||||
//! execution mode.
|
||||
//!
|
||||
//! The examples below build against a stand-in for `ide-host` (`src/doctest_host.rs`). Every
|
||||
//! `compile_fail` example differs from the example before it only by the mistake it names.
|
||||
|
||||
use heck::ToLowerCamelCase;
|
||||
use proc_macro::TokenStream;
|
||||
use proc_macro2::TokenStream as T2;
|
||||
use quote::{ToTokens, format_ident, quote};
|
||||
use syn::ext::IdentExt;
|
||||
use syn::parse::{Parse, ParseStream};
|
||||
use syn::punctuated::Punctuated;
|
||||
use syn::{FnArg, GenericArgument, Ident, ItemFn, Pat, PathArguments, ReturnType, Token, Type};
|
||||
|
||||
/// `#[command(trust = …)]` on a project-host command's implementation in `ide-host`.
|
||||
///
|
||||
/// The fn's name is the command's name and its `///` lines are the bindings' docs. Parameters
|
||||
/// of type `&Host` or `&Arc<Host>`, `window: &str` and `plugins: &Arc<PluginHost>` are injected;
|
||||
/// every other parameter is an argument, owned, whose key is its camelCase name, and
|
||||
/// `Channel<T>` streams values back. `async fn` gives an async Tauri adapter, `fn` a sync one.
|
||||
/// A result of type `IdeResult<T>` is returned as is; any other result is a success. A JSON-RPC
|
||||
/// request that leaves out an argument marked `#[default]` gets the type's default, so servers
|
||||
/// keep answering clients older than the argument.
|
||||
///
|
||||
/// Options:
|
||||
/// - `trust = always | outside_restricted | trusted` (required): where the command may run;
|
||||
/// `always` includes Restricted Mode, `outside_restricted` needs no project or a trusted
|
||||
/// one, `trusted` needs a trusted project.
|
||||
/// - `desktop_body = async | sync | spawn`: the Tauri adapter calls the hand-written fn of the
|
||||
/// same name in `src-tauri` instead of this one, which stays the server's implementation.
|
||||
/// `spawn` runs that sync body off the invoking thread.
|
||||
///
|
||||
/// ```
|
||||
/// # include!("doctest_host.rs");
|
||||
/// pub mod vcs {
|
||||
/// use crate::{Host, IdeResult, ops::Channel};
|
||||
/// use ide_command::command;
|
||||
///
|
||||
/// /// Renames a branch.
|
||||
/// #[command(trust = trusted)]
|
||||
/// pub async fn vcs_rename_branch(
|
||||
/// host: &Host,
|
||||
/// window: &str,
|
||||
/// from: String,
|
||||
/// to: String,
|
||||
/// unset_upstream: bool,
|
||||
/// ) -> IdeResult<()> {
|
||||
/// Ok(())
|
||||
/// }
|
||||
///
|
||||
/// #[command(trust = always)]
|
||||
/// pub fn vcs_watch(window: &str, #[default] depth: u32, on_event: Channel<u32>) -> bool {
|
||||
/// true
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domain!(vcs: vcs_rename_branch, vcs_watch);
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domains!(vcs: crate::vcs);
|
||||
///
|
||||
/// fn main() {
|
||||
/// use catalogue::{Mode, Placement, TrustClass};
|
||||
/// let mut d = rpc::Dispatcher::default();
|
||||
/// register_domains(&mut d);
|
||||
/// assert_eq!(d.0, [("vcs_rename_branch", TrustClass::Trusted), ("vcs_watch", TrustClass::Always)]);
|
||||
/// let watch = vcs::__cmd_vcs_watch::COMMAND;
|
||||
/// assert_eq!((watch.placement, watch.bindings, watch.mode), (Placement::ProjectHost, true, Mode::Sync));
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// A command without a trust class:
|
||||
///
|
||||
/// ```compile_fail
|
||||
/// # include!("doctest_host.rs");
|
||||
/// pub mod vcs {
|
||||
/// #[ide_command::command]
|
||||
/// pub fn vcs_watch(window: &str) -> bool {
|
||||
/// true
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domain!(vcs: vcs_watch);
|
||||
/// }
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
///
|
||||
/// A command its module doesn't list:
|
||||
///
|
||||
/// ```compile_fail,E0425
|
||||
/// # include!("doctest_host.rs");
|
||||
/// pub mod vcs {
|
||||
/// #[ide_command::command(trust = always)]
|
||||
/// pub fn vcs_watch(window: &str) -> bool {
|
||||
/// true
|
||||
/// }
|
||||
///
|
||||
/// #[ide_command::command(trust = always)]
|
||||
/// pub fn vcs_unwatch(window: &str) -> bool {
|
||||
/// true
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domain!(vcs: vcs_watch);
|
||||
/// }
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
///
|
||||
/// Two commands with one name, in different modules:
|
||||
///
|
||||
/// ```compile_fail,E0428
|
||||
/// # include!("doctest_host.rs");
|
||||
/// pub mod vcs {
|
||||
/// #[ide_command::command(trust = always)]
|
||||
/// pub fn vcs_watch(window: &str) -> bool {
|
||||
/// true
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domain!(vcs: vcs_watch);
|
||||
/// }
|
||||
///
|
||||
/// pub mod search {
|
||||
/// #[ide_command::command(trust = always)]
|
||||
/// pub fn vcs_watch(window: &str) -> bool {
|
||||
/// true
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domain!(search: vcs_watch);
|
||||
/// }
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
///
|
||||
/// A borrowed argument:
|
||||
///
|
||||
/// ```compile_fail
|
||||
/// # include!("doctest_host.rs");
|
||||
/// pub mod vcs {
|
||||
/// #[ide_command::command(trust = always)]
|
||||
/// pub fn vcs_watch(window: &str, path: &str) -> bool {
|
||||
/// true
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domain!(vcs: vcs_watch);
|
||||
/// }
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
///
|
||||
/// A stream that isn't a `Channel<T>`:
|
||||
///
|
||||
/// ```compile_fail
|
||||
/// # include!("doctest_host.rs");
|
||||
/// pub mod vcs {
|
||||
/// use crate::ops::Emit;
|
||||
///
|
||||
/// #[ide_command::command(trust = always)]
|
||||
/// pub fn vcs_watch(window: &str, on_event: Emit<u32>) -> bool {
|
||||
/// true
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domain!(vcs: vcs_watch);
|
||||
/// }
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
#[proc_macro_attribute]
|
||||
pub fn command(attr: TokenStream, item: TokenStream) -> TokenStream {
|
||||
let opts = syn::parse_macro_input!(attr as Opts);
|
||||
let f = syn::parse_macro_input!(item as ItemFn);
|
||||
expand_command(opts, f).unwrap_or_else(|e| e.to_compile_error()).into()
|
||||
}
|
||||
|
||||
fn expand_command(opts: Opts, mut f: ItemFn) -> syn::Result<T2> {
|
||||
opts.only(&["trust", "desktop_body"])?;
|
||||
let trust = opts.trust()?;
|
||||
// `#[default]` is read here and not emitted.
|
||||
let defaulted: Vec<bool> = f
|
||||
.sig
|
||||
.inputs
|
||||
.iter_mut()
|
||||
.map(|input| match input {
|
||||
FnArg::Typed(pt) => {
|
||||
let before = pt.attrs.len();
|
||||
pt.attrs.retain(|a| !a.path().is_ident("default"));
|
||||
pt.attrs.len() != before
|
||||
}
|
||||
FnArg::Receiver(_) => false,
|
||||
})
|
||||
.collect();
|
||||
let name = &f.sig.ident;
|
||||
if !f.sig.generics.params.is_empty() {
|
||||
return Err(syn::Error::new_spanned(&f.sig.generics, "a command is not generic"));
|
||||
}
|
||||
let is_async = f.sig.asyncness.is_some();
|
||||
let (run, body) = match opts.value("desktop_body") {
|
||||
None if is_async => (format_ident!("async"), quote!(derived)),
|
||||
None => (format_ident!("sync"), quote!(derived)),
|
||||
Some(Some(m)) if ["async", "sync", "spawn"].contains(&m.to_string().as_str()) => (m, quote!(desktop)),
|
||||
Some(v) => return Err(error(v.as_ref().unwrap_or(name), "`desktop_body = async | sync | spawn`")),
|
||||
};
|
||||
let mode = match run.to_string().as_str() {
|
||||
"async" => quote!(Async),
|
||||
"spawn" => quote!(Spawn),
|
||||
_ => quote!(Sync),
|
||||
};
|
||||
|
||||
let mut aliases = Vec::new(); // one type alias per argument, resolved in the fn's own scope
|
||||
let mut args = Vec::new(); // the arguments, for the Tauri adapter's signature
|
||||
let mut call = Vec::new(); // every parameter in declared order, for the Tauri adapter's call
|
||||
let mut rpc_call = Vec::new(); // the same, for the JSON-RPC handler
|
||||
let mut needs_plugins = false;
|
||||
for (input, defaulted) in f.sig.inputs.iter().zip(defaulted) {
|
||||
let FnArg::Typed(pt) = input else {
|
||||
return Err(error(input, "a command is a free fn"));
|
||||
};
|
||||
let Pat::Ident(pi) = &*pt.pat else {
|
||||
return Err(error(&pt.pat, "command parameters are plain identifiers"));
|
||||
};
|
||||
let ident = &pi.ident;
|
||||
let plain_only = || error(ident, "`#[default]` marks a plain argument");
|
||||
if defaulted && injected(ident, &pt.ty).is_some() {
|
||||
return Err(plain_only());
|
||||
}
|
||||
match injected(ident, &pt.ty) {
|
||||
Some(Injected::Host) => {
|
||||
call.push(quote!((inj host)));
|
||||
rpc_call.push(quote!(&c.host));
|
||||
continue;
|
||||
}
|
||||
Some(Injected::Window) => {
|
||||
call.push(quote!((inj window)));
|
||||
rpc_call.push(quote!(&c.window));
|
||||
continue;
|
||||
}
|
||||
Some(Injected::Plugins) => {
|
||||
needs_plugins = true;
|
||||
call.push(quote!((inj plugins)));
|
||||
rpc_call.push(quote!(&plugins));
|
||||
continue;
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
if matches!(&*pt.ty, Type::Reference(_)) {
|
||||
return Err(error(
|
||||
&pt.ty,
|
||||
"command arguments are owned; the injected references are `&Host`, `window: &str` and `plugins: &Arc<PluginHost>`",
|
||||
));
|
||||
}
|
||||
let seg = last_segment(&pt.ty);
|
||||
if seg.is_some_and(|s| s.ident == "Emit") {
|
||||
return Err(error(&pt.ty, "a command streams through `Channel<T>`, not `Emit<T>`"));
|
||||
}
|
||||
let key = ident.unraw().to_string().to_lower_camel_case();
|
||||
let alias = format_ident!("A{}", args.len());
|
||||
if let Some(inner) = seg.filter(|s| s.ident == "Channel").and_then(type_argument) {
|
||||
if defaulted {
|
||||
return Err(plain_only());
|
||||
}
|
||||
aliases.push(quote!(pub type #alias = #inner;));
|
||||
args.push(quote!((#ident channel #alias)));
|
||||
call.push(quote!((arg channel #ident)));
|
||||
rpc_call.push(quote!(c.sender(#key)?));
|
||||
} else {
|
||||
let ty = &pt.ty;
|
||||
aliases.push(quote!(pub type #alias = #ty;));
|
||||
args.push(quote!((#ident plain #alias)));
|
||||
call.push(quote!((arg plain #ident)));
|
||||
rpc_call.push(if defaulted {
|
||||
quote!(c.arg::<::core::option::Option<#ty>>(#key)?.unwrap_or_default())
|
||||
} else {
|
||||
quote!(c.arg(#key)?)
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
let ret: Type = match &f.sig.output {
|
||||
ReturnType::Default => syn::parse_quote!(()),
|
||||
ReturnType::Type(_, t) => (**t).clone(),
|
||||
};
|
||||
let fallible = last_segment(&ret).is_some_and(|s| s.ident == "IdeResult");
|
||||
// specta exports `fn f()` as `void` and `fn f() -> ()` as `null`: keep which one was written.
|
||||
let ret_alias = match &f.sig.output {
|
||||
ReturnType::Default => quote!(),
|
||||
ReturnType::Type(..) => quote!(Ret),
|
||||
};
|
||||
let shape = if fallible { quote!(fallible [#ret_alias]) } else { quote!(infallible [#ret_alias]) };
|
||||
let await_ = is_async.then(|| quote!(.await));
|
||||
let invoke = quote!(super::#name(#(#rpc_call),*) #await_);
|
||||
let invoke = if fallible { invoke } else { quote!(Ok(#invoke)) };
|
||||
let plugins = needs_plugins.then(|| {
|
||||
quote! {
|
||||
let plugins = c.host.plugin_host()
|
||||
.ok_or_else(|| crate::IdeError::unavailable("the plugin host has shut down"))?;
|
||||
}
|
||||
});
|
||||
let docs: Vec<_> = f.attrs.iter().filter(|a| a.path().is_ident("doc")).collect();
|
||||
let module = format_ident!("__cmd_{}", name);
|
||||
let tokens = format_ident!("__catalogue_{}", name);
|
||||
let name_str = name.unraw().to_string();
|
||||
|
||||
Ok(quote! {
|
||||
#f
|
||||
|
||||
// Resolves only if this module's `domain!` lists the command.
|
||||
const _: () = self::__listed::#name;
|
||||
|
||||
#[doc(hidden)]
|
||||
#[allow(non_snake_case)]
|
||||
pub mod #module {
|
||||
#[allow(unused_imports)]
|
||||
use super::*;
|
||||
#(#aliases)*
|
||||
pub type Ret = #ret;
|
||||
pub const COMMAND: crate::catalogue::Command = crate::catalogue::Command {
|
||||
name: #name_str,
|
||||
trust: crate::catalogue::TrustClass::#trust,
|
||||
placement: crate::catalogue::Placement::ProjectHost,
|
||||
bindings: true,
|
||||
mode: crate::catalogue::Mode::#mode,
|
||||
};
|
||||
/// The JSON-RPC handler.
|
||||
pub async fn rpc(c: crate::rpc::Call) -> crate::IdeResult<impl ::serde::Serialize + use<>> {
|
||||
#plugins
|
||||
#invoke
|
||||
}
|
||||
}
|
||||
|
||||
/// The command's signature, handed to `$cb!` for `src-tauri` to derive its Tauri adapter.
|
||||
#[doc(hidden)]
|
||||
#[macro_export]
|
||||
macro_rules! #tokens {
|
||||
([$($cb:tt)*] { $($ctx:tt)* }) => {
|
||||
$($cb)*! { { $($ctx)* } {
|
||||
name: #name,
|
||||
module: #module,
|
||||
docs: [ #(#docs)* ],
|
||||
run: #run,
|
||||
result: #shape,
|
||||
body: #body,
|
||||
args: [ #(#args)* ],
|
||||
call: [ #(#call)* ],
|
||||
} }
|
||||
};
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// `domain!(vcs: vcs_status, vcs_rename_branch, …)`: the commands one `ide-host` module
|
||||
/// declares with `#[command]`, in any order. It goes once at the end of that module and gives it
|
||||
/// the server's `register`; `domains!` names the domain.
|
||||
///
|
||||
/// ```
|
||||
/// # include!("doctest_host.rs");
|
||||
/// pub mod vcs {
|
||||
/// #[ide_command::command(trust = always)]
|
||||
/// pub fn vcs_watch(window: &str) -> bool {
|
||||
/// true
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domain!(vcs: vcs_watch);
|
||||
/// }
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
///
|
||||
/// A listed name that isn't a command:
|
||||
///
|
||||
/// ```compile_fail,E0433
|
||||
/// # include!("doctest_host.rs");
|
||||
/// pub mod vcs {
|
||||
/// #[ide_command::command(trust = always)]
|
||||
/// pub fn vcs_watch(window: &str) -> bool {
|
||||
/// true
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domain!(vcs: vcs_watch, vcs_unwatch);
|
||||
/// }
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
#[proc_macro]
|
||||
pub fn domain(input: TokenStream) -> TokenStream {
|
||||
let Domain { name, commands } = syn::parse_macro_input!(input as Domain);
|
||||
let modules: Vec<_> = commands.iter().map(|c| format_ident!("__cmd_{}", c)).collect();
|
||||
let tokens: Vec<_> = commands.iter().map(|c| format_ident!("__catalogue_{}", c)).collect();
|
||||
let list = format_ident!("__domain_{}", name);
|
||||
let names = commands.iter();
|
||||
let listed = commands.iter();
|
||||
let d = quote!($);
|
||||
quote! {
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals)]
|
||||
mod __listed {
|
||||
#( pub(super) const #listed: () = (); )*
|
||||
}
|
||||
|
||||
// Resolves only from the `domains!` entry that names this domain.
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals)]
|
||||
pub(crate) const #list: () = ();
|
||||
|
||||
/// Adds this module's commands to the server.
|
||||
pub(crate) fn register(d: &mut crate::rpc::Dispatcher) {
|
||||
#( d.add(#modules::COMMAND.name, #modules::COMMAND.trust, #modules::rpc); )*
|
||||
}
|
||||
|
||||
/// `@each`: each command's signature, in list order. `@names`: the list.
|
||||
#[doc(hidden)]
|
||||
#[macro_export]
|
||||
macro_rules! #list {
|
||||
(@each [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
|
||||
#( #d crate::#tokens!{ [#d (#d cb)*] { #d (#d ctx)* } } )*
|
||||
};
|
||||
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
|
||||
#d (#d cb)*! { { #d (#d ctx)* } [ #(#names)* ] }
|
||||
};
|
||||
}
|
||||
}
|
||||
.into()
|
||||
}
|
||||
|
||||
/// `domains!(vcs: crate::ops::vcs::commands, …)`, once in `ide-host`: every domain, by the name
|
||||
/// its `domain!` gives it and the crate path of its module. It gives the server
|
||||
/// `register_domains`, and hands `src-tauri` the list of domains through `__domains!`.
|
||||
///
|
||||
/// ```
|
||||
/// # include!("doctest_host.rs");
|
||||
/// pub mod vcs {
|
||||
/// #[ide_command::command(trust = always)]
|
||||
/// pub fn vcs_watch(window: &str) -> bool {
|
||||
/// true
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domain!(vcs: vcs_watch);
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domains!(vcs: crate::vcs);
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
///
|
||||
/// A domain under another name than its `domain!` gives it:
|
||||
///
|
||||
/// ```compile_fail,E0425
|
||||
/// # include!("doctest_host.rs");
|
||||
/// pub mod vcs {
|
||||
/// #[ide_command::command(trust = always)]
|
||||
/// pub fn vcs_watch(window: &str) -> bool {
|
||||
/// true
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domain!(vcs: vcs_watch);
|
||||
/// }
|
||||
///
|
||||
/// ide_command::domains!(git: crate::vcs);
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
#[proc_macro]
|
||||
pub fn domains(input: TokenStream) -> TokenStream {
|
||||
let entries = syn::parse_macro_input!(input with Punctuated::<DomainPath, Token![,]>::parse_terminated);
|
||||
let mut names = Vec::new();
|
||||
let mut paths = Vec::new();
|
||||
let mut from_crate = Vec::new();
|
||||
for DomainPath { name, path } in entries {
|
||||
let mut segments = path.segments.iter();
|
||||
if path.leading_colon.is_some() || segments.next().is_none_or(|s| s.ident != "crate") {
|
||||
return error(&path, "a domain's path starts with `crate::`").to_compile_error().into();
|
||||
}
|
||||
let rest: Vec<_> = segments.map(|s| &s.ident).collect();
|
||||
from_crate.push(quote!(#(#rest)::*));
|
||||
names.push(name);
|
||||
paths.push(path);
|
||||
}
|
||||
let lists: Vec<_> = names.iter().map(|n| format_ident!("__domain_{}", n)).collect();
|
||||
let d = quote!($);
|
||||
quote! {
|
||||
#( const _: () = #paths::#lists; )*
|
||||
|
||||
/// Adds every domain's commands to the server.
|
||||
pub(crate) fn register_domains(d: &mut crate::rpc::Dispatcher) {
|
||||
#( #paths::register(d); )*
|
||||
}
|
||||
|
||||
/// `@names`: each domain as `(name __domain_name { path })`.
|
||||
#[doc(hidden)]
|
||||
#[macro_export]
|
||||
macro_rules! __domains {
|
||||
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
|
||||
#d (#d cb)*! { { #d (#d ctx)* } [ #( (#names #lists { #d crate::#from_crate }) )* ] }
|
||||
};
|
||||
}
|
||||
}
|
||||
.into()
|
||||
}
|
||||
|
||||
/// `#[desktop_command(trust = …)]` on a command only the desktop runs, above its
|
||||
/// `#[tauri::command]` in `src-tauri`, whose `(async)` it reads. The fn is left as written.
|
||||
///
|
||||
/// Options: `trust` as for `#[command]` (required), and `bindings = none` for a command that is
|
||||
/// registered outside tauri-specta; such a command isn't listed in `desktop_domain!`.
|
||||
///
|
||||
/// ```
|
||||
/// # include!("doctest_host.rs");
|
||||
/// # extern crate self as ide_host;
|
||||
/// pub mod clipboard {
|
||||
/// #[ide_command::desktop_command(trust = always)]
|
||||
/// pub async fn clipboard_text() -> Option<String> {
|
||||
/// None
|
||||
/// }
|
||||
///
|
||||
/// ide_command::desktop_domain!(clipboard_text);
|
||||
/// }
|
||||
///
|
||||
/// fn main() {
|
||||
/// let text = clipboard::clipboard_text::COMMAND;
|
||||
/// assert_eq!((text.name, text.placement), ("clipboard_text", catalogue::Placement::Desktop));
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// A command without a trust class:
|
||||
///
|
||||
/// ```compile_fail
|
||||
/// # include!("doctest_host.rs");
|
||||
/// # extern crate self as ide_host;
|
||||
/// pub mod clipboard {
|
||||
/// #[ide_command::desktop_command]
|
||||
/// pub async fn clipboard_text() -> Option<String> {
|
||||
/// None
|
||||
/// }
|
||||
///
|
||||
/// ide_command::desktop_domain!(clipboard_text);
|
||||
/// }
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
///
|
||||
/// A command its module doesn't list:
|
||||
///
|
||||
/// ```compile_fail,E0425
|
||||
/// # include!("doctest_host.rs");
|
||||
/// # extern crate self as ide_host;
|
||||
/// pub mod clipboard {
|
||||
/// #[ide_command::desktop_command(trust = always)]
|
||||
/// pub async fn clipboard_text() -> Option<String> {
|
||||
/// None
|
||||
/// }
|
||||
///
|
||||
/// #[ide_command::desktop_command(trust = always)]
|
||||
/// pub async fn clipboard_html() -> Option<String> {
|
||||
/// None
|
||||
/// }
|
||||
///
|
||||
/// ide_command::desktop_domain!(clipboard_text);
|
||||
/// }
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
#[proc_macro_attribute]
|
||||
pub fn desktop_command(attr: TokenStream, item: TokenStream) -> TokenStream {
|
||||
let opts = syn::parse_macro_input!(attr as Opts);
|
||||
let f = syn::parse_macro_input!(item as ItemFn);
|
||||
expand_desktop_command(opts, f).unwrap_or_else(|e| e.to_compile_error()).into()
|
||||
}
|
||||
|
||||
fn expand_desktop_command(opts: Opts, f: ItemFn) -> syn::Result<T2> {
|
||||
opts.only(&["trust", "bindings"])?;
|
||||
let trust = opts.trust()?;
|
||||
let bindings = match opts.value("bindings") {
|
||||
None => true,
|
||||
Some(Some(v)) if v == "none" => false,
|
||||
Some(v) => return Err(error(v.as_ref().unwrap_or(&f.sig.ident), "`bindings = none`")),
|
||||
};
|
||||
// `#[tauri::command(async)]` runs a sync fn off the invoking thread.
|
||||
let spawned = f.attrs.iter().any(|a| {
|
||||
let path = a.path();
|
||||
path.segments.len() == 2
|
||||
&& path.segments[0].ident == "tauri"
|
||||
&& path.segments[1].ident == "command"
|
||||
&& a.parse_args::<Ident>().is_ok_and(|i| i == "async")
|
||||
});
|
||||
let mode = if f.sig.asyncness.is_some() {
|
||||
quote!(Async)
|
||||
} else if spawned {
|
||||
quote!(Spawn)
|
||||
} else {
|
||||
quote!(Sync)
|
||||
};
|
||||
let name = &f.sig.ident;
|
||||
let name_str = name.unraw().to_string();
|
||||
let listed = bindings.then(|| quote!(const _: () = self::__listed::#name;));
|
||||
Ok(quote! {
|
||||
#f
|
||||
|
||||
#listed
|
||||
|
||||
#[doc(hidden)]
|
||||
pub mod #name {
|
||||
pub const COMMAND: ::ide_host::catalogue::Command = ::ide_host::catalogue::Command {
|
||||
name: #name_str,
|
||||
trust: ::ide_host::catalogue::TrustClass::#trust,
|
||||
placement: ::ide_host::catalogue::Placement::Desktop,
|
||||
bindings: #bindings,
|
||||
mode: ::ide_host::catalogue::Mode::#mode,
|
||||
};
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// `desktop_domain!(clipboard_text, clipboard_write_text, …)`: the `#[desktop_command]`s of one
|
||||
/// `src-tauri` module that are in the bindings, in any order. It goes once at the end of that
|
||||
/// module and gives it `__desktop_domain!(@names …)`.
|
||||
#[proc_macro]
|
||||
pub fn desktop_domain(input: TokenStream) -> TokenStream {
|
||||
let commands = syn::parse_macro_input!(input with Punctuated::<Ident, Token![,]>::parse_terminated);
|
||||
let names = commands.iter();
|
||||
let listed = commands.iter();
|
||||
let d = quote!($);
|
||||
quote! {
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals)]
|
||||
mod __listed {
|
||||
#( pub(super) const #listed: () = (); )*
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
macro_rules! __desktop_domain {
|
||||
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
|
||||
#d (#d cb)*! { { #d (#d ctx)* } [ #(#names)* ] }
|
||||
};
|
||||
}
|
||||
#[allow(unused_imports)]
|
||||
pub(crate) use __desktop_domain;
|
||||
}
|
||||
.into()
|
||||
}
|
||||
|
||||
/// `sorted_catalogue!(bindings: a::x, b::y, …; raw: c::z, …)`, in `src-tauri`: every command,
|
||||
/// sorted by name, as `(collect_commands![…bindings…], [COMMAND, …every command…])`. Each path
|
||||
/// names a command fn and the module of the same name that holds its `COMMAND`.
|
||||
///
|
||||
/// ```
|
||||
/// # include!("doctest_host.rs");
|
||||
/// # extern crate self as ide_host;
|
||||
/// # extern crate self as tauri_specta;
|
||||
/// # #[macro_export]
|
||||
/// # macro_rules! collect_commands { ($($p:path),*) => { [$(stringify!($p)),*] } }
|
||||
/// pub mod clipboard {
|
||||
/// #[ide_command::desktop_command(trust = always)]
|
||||
/// pub async fn clipboard_text() -> Option<String> {
|
||||
/// None
|
||||
/// }
|
||||
///
|
||||
/// #[ide_command::desktop_command(trust = always)]
|
||||
/// pub fn clipboard_clear() {}
|
||||
///
|
||||
/// ide_command::desktop_domain!(clipboard_text, clipboard_clear);
|
||||
/// }
|
||||
///
|
||||
/// fn main() {
|
||||
/// let (commands, rows) = ide_command::sorted_catalogue!(
|
||||
/// bindings: clipboard::clipboard_text, clipboard::clipboard_clear;
|
||||
/// raw:
|
||||
/// );
|
||||
/// assert_eq!(commands, ["clipboard :: clipboard_clear", "clipboard :: clipboard_text"]);
|
||||
/// assert_eq!(rows.map(|c| c.name), ["clipboard_clear", "clipboard_text"]);
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// Two commands with one name:
|
||||
///
|
||||
/// ```compile_fail
|
||||
/// # include!("doctest_host.rs");
|
||||
/// # extern crate self as ide_host;
|
||||
/// # extern crate self as tauri_specta;
|
||||
/// # #[macro_export]
|
||||
/// # macro_rules! collect_commands { ($($p:path),*) => { [$(stringify!($p)),*] } }
|
||||
/// pub mod clipboard {
|
||||
/// #[ide_command::desktop_command(trust = always)]
|
||||
/// pub async fn clipboard_text() -> Option<String> {
|
||||
/// None
|
||||
/// }
|
||||
///
|
||||
/// #[ide_command::desktop_command(trust = always)]
|
||||
/// pub fn clipboard_clear() {}
|
||||
///
|
||||
/// ide_command::desktop_domain!(clipboard_text, clipboard_clear);
|
||||
/// }
|
||||
///
|
||||
/// pub mod editor {
|
||||
/// #[ide_command::desktop_command(trust = always)]
|
||||
/// pub fn clipboard_clear() {}
|
||||
///
|
||||
/// ide_command::desktop_domain!(clipboard_clear);
|
||||
/// }
|
||||
///
|
||||
/// fn main() {
|
||||
/// let (commands, rows) = ide_command::sorted_catalogue!(
|
||||
/// bindings: clipboard::clipboard_text, clipboard::clipboard_clear, editor::clipboard_clear;
|
||||
/// raw:
|
||||
/// );
|
||||
/// }
|
||||
/// ```
|
||||
#[proc_macro]
|
||||
pub fn sorted_catalogue(input: TokenStream) -> TokenStream {
|
||||
let Catalogue { bindings, raw } = syn::parse_macro_input!(input as Catalogue);
|
||||
let key = |p: &syn::Path| p.segments.last().map(|s| s.ident.unraw().to_string()).unwrap_or_default();
|
||||
let mut bindings: Vec<_> = bindings.into_iter().collect();
|
||||
bindings.sort_by_cached_key(key);
|
||||
let mut all: Vec<_> = bindings.iter().chain(&raw).collect();
|
||||
all.sort_by_cached_key(|p| key(p));
|
||||
for pair in all.windows(2) {
|
||||
if key(pair[0]) == key(pair[1]) {
|
||||
let (a, b) = (pair[0], pair[1]);
|
||||
let message = format!(
|
||||
"command `{}` is declared twice: `{}` and `{}`",
|
||||
key(b),
|
||||
a.to_token_stream(),
|
||||
b.to_token_stream()
|
||||
);
|
||||
return syn::Error::new_spanned(b, message).to_compile_error().into();
|
||||
}
|
||||
}
|
||||
quote! {
|
||||
(
|
||||
::tauri_specta::collect_commands![ #(#bindings),* ],
|
||||
[ #( #all::COMMAND ),* ],
|
||||
)
|
||||
}
|
||||
.into()
|
||||
}
|
||||
|
||||
struct Catalogue {
|
||||
bindings: Punctuated<syn::Path, Token![,]>,
|
||||
raw: Punctuated<syn::Path, Token![,]>,
|
||||
}
|
||||
|
||||
impl Parse for Catalogue {
|
||||
fn parse(input: ParseStream) -> syn::Result<Self> {
|
||||
let paths = |input: ParseStream, label: &str| -> syn::Result<Punctuated<syn::Path, Token![,]>> {
|
||||
let ident: Ident = input.parse()?;
|
||||
if ident != label {
|
||||
return Err(error(&ident, &format!("expected `{label}:`")));
|
||||
}
|
||||
input.parse::<Token![:]>()?;
|
||||
let mut out = Punctuated::new();
|
||||
while !input.is_empty() && !input.peek(Token![;]) {
|
||||
out.push_value(input.parse()?);
|
||||
if !input.peek(Token![,]) {
|
||||
break;
|
||||
}
|
||||
out.push_punct(input.parse()?);
|
||||
}
|
||||
Ok(out)
|
||||
};
|
||||
let bindings = paths(input, "bindings")?;
|
||||
input.parse::<Token![;]>()?;
|
||||
let raw = paths(input, "raw")?;
|
||||
let _ = input.parse::<Option<Token![;]>>()?;
|
||||
Ok(Self { bindings, raw })
|
||||
}
|
||||
}
|
||||
|
||||
enum Injected {
|
||||
Host,
|
||||
Window,
|
||||
Plugins,
|
||||
}
|
||||
|
||||
/// `&Host` or `&Arc<Host>` under any name, `window: &str`, `plugins: &Arc<PluginHost>`.
|
||||
fn injected(ident: &Ident, ty: &Type) -> Option<Injected> {
|
||||
let Type::Reference(r) = ty else { return None };
|
||||
if r.mutability.is_some() {
|
||||
return None;
|
||||
}
|
||||
let seg = last_segment(&r.elem)?;
|
||||
let arc_of =
|
||||
|name: &str| seg.ident == "Arc" && type_argument(seg).and_then(last_segment).is_some_and(|s| s.ident == name);
|
||||
if seg.ident == "Host" || arc_of("Host") {
|
||||
Some(Injected::Host)
|
||||
} else if ident == "window" && seg.ident == "str" {
|
||||
Some(Injected::Window)
|
||||
} else if ident == "plugins" && arc_of("PluginHost") {
|
||||
Some(Injected::Plugins)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
fn last_segment(ty: &Type) -> Option<&syn::PathSegment> {
|
||||
match ty {
|
||||
Type::Path(p) if p.qself.is_none() => p.path.segments.last(),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn type_argument(seg: &syn::PathSegment) -> Option<&Type> {
|
||||
match &seg.arguments {
|
||||
PathArguments::AngleBracketed(a) => a.args.iter().find_map(|g| match g {
|
||||
GenericArgument::Type(t) => Some(t),
|
||||
_ => None,
|
||||
}),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn error(span: impl ToTokens, message: &str) -> syn::Error {
|
||||
syn::Error::new_spanned(span, message)
|
||||
}
|
||||
|
||||
/// `name: a, b, …`
|
||||
struct Domain {
|
||||
name: Ident,
|
||||
commands: Punctuated<Ident, Token![,]>,
|
||||
}
|
||||
|
||||
impl Parse for Domain {
|
||||
fn parse(input: ParseStream) -> syn::Result<Self> {
|
||||
let name = input.parse()?;
|
||||
input.parse::<Token![:]>()?;
|
||||
Ok(Self { name, commands: Punctuated::parse_terminated(input)? })
|
||||
}
|
||||
}
|
||||
|
||||
/// `name: crate::path`
|
||||
struct DomainPath {
|
||||
name: Ident,
|
||||
path: syn::Path,
|
||||
}
|
||||
|
||||
impl Parse for DomainPath {
|
||||
fn parse(input: ParseStream) -> syn::Result<Self> {
|
||||
let name = input.parse()?;
|
||||
input.parse::<Token![:]>()?;
|
||||
Ok(Self { name, path: input.parse()? })
|
||||
}
|
||||
}
|
||||
|
||||
/// An attribute's options: `key = value` and bare `key`.
|
||||
struct Opts(Vec<(Ident, Option<Ident>)>);
|
||||
|
||||
impl Parse for Opts {
|
||||
fn parse(input: ParseStream) -> syn::Result<Self> {
|
||||
let mut out = Vec::new();
|
||||
while !input.is_empty() {
|
||||
let key: Ident = input.parse()?;
|
||||
let value = if input.peek(Token![=]) {
|
||||
input.parse::<Token![=]>()?;
|
||||
// `async` is a keyword.
|
||||
Some(Ident::parse_any(input)?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
out.push((key, value));
|
||||
if !input.is_empty() {
|
||||
input.parse::<Token![,]>()?;
|
||||
}
|
||||
}
|
||||
Ok(Self(out))
|
||||
}
|
||||
}
|
||||
|
||||
impl Opts {
|
||||
fn value(&self, key: &str) -> Option<Option<Ident>> {
|
||||
self.0.iter().find(|(k, _)| k == key).map(|(_, v)| v.clone())
|
||||
}
|
||||
|
||||
fn only(&self, known: &[&str]) -> syn::Result<()> {
|
||||
match self.0.iter().map(|(k, _)| k).find(|k| !known.iter().any(|n| *k == n)) {
|
||||
Some(k) => Err(error(k, &format!("unknown option; the options are {}", known.join(", ")))),
|
||||
None => Ok(()),
|
||||
}
|
||||
}
|
||||
|
||||
fn trust(&self) -> syn::Result<T2> {
|
||||
match self.value("trust").flatten().map(|t| t.to_string()).as_deref() {
|
||||
Some("always") => Ok(quote!(Always)),
|
||||
Some("outside_restricted") => Ok(quote!(OutsideRestricted)),
|
||||
Some("trusted") => Ok(quote!(Trusted)),
|
||||
_ => Err(syn::Error::new(
|
||||
proc_macro2::Span::call_site(),
|
||||
"every command declares its trust class: `trust = always | outside_restricted | trusted`",
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -343,6 +343,8 @@ pub struct InlayHintsSettings {
|
||||
/// Hints of other kinds (chaining, closing labels…).
|
||||
pub other: bool,
|
||||
pub disabled_languages: Vec<String>,
|
||||
/// Code vision as a whole (usages, author and language-server lenses); the switches below apply while it is on.
|
||||
pub code_vision: bool,
|
||||
/// Code vision: usages above declarations.
|
||||
pub code_vision_usages: bool,
|
||||
/// Code vision: last author of a declaration (VCS blame) beside its usages.
|
||||
@@ -373,6 +375,7 @@ impl Default for InlayHintsSettings {
|
||||
parameters: true,
|
||||
other: true,
|
||||
disabled_languages: Vec::new(),
|
||||
code_vision: true,
|
||||
code_vision_usages: true,
|
||||
code_vision_author: true,
|
||||
code_vision_no_usages: true,
|
||||
|
||||
@@ -38,6 +38,11 @@ pub enum IdeEvent {
|
||||
WindowGroupsChanged,
|
||||
/// A window entered or left full screen, itself or as a member of a full-screen window group.
|
||||
WindowFullscreenChanged,
|
||||
/// This remote window's connection to its host ended on its own (network loss, the host or
|
||||
/// its server went away); the window's project is unreachable until it reconnects.
|
||||
RemoteConnectionLost {
|
||||
host: String,
|
||||
},
|
||||
ProjectTrustChanged {
|
||||
root: crate::IpcPath,
|
||||
trusted: bool,
|
||||
@@ -142,6 +147,19 @@ pub enum IdeEvent {
|
||||
server: ServerId,
|
||||
kind: LspRefreshKind,
|
||||
},
|
||||
/// A language server asked the user to choose an action, e.g. Dart's
|
||||
/// "Renamed field will be invisible in …" warning during a rename. Answered
|
||||
/// with `lsp_message_request_answer`; the server cancels if we reply null.
|
||||
LspMessageRequest {
|
||||
id: u32,
|
||||
server: String,
|
||||
message: String,
|
||||
actions: Vec<String>,
|
||||
},
|
||||
/// The request was answered or timed out; every window drops its dialog.
|
||||
LspMessageRequestDone {
|
||||
id: u32,
|
||||
},
|
||||
TerminalExited {
|
||||
terminal: TerminalId,
|
||||
code: Option<i32>,
|
||||
|
||||
@@ -167,10 +167,11 @@ const GRADLE: &[&str] = &["gradle", "gradlew"];
|
||||
/// Gradle's own JVM and the compiler's source encoding are untouched.
|
||||
pub const GRADLE_FILE_ENCODING_SCRIPT: &str = "\
|
||||
// Written by OpenIDEA: a UTF-8 default charset for applications run by Gradle, as the Run console decodes UTF-8.
|
||||
import org.gradle.util.GradleVersion
|
||||
// `configureEach` (lazy) is Gradle 4.9+; older ones configure each task as it is added.
|
||||
def each = { tasks, Closure action -> GradleVersion.current() >= GradleVersion.version('4.9') ? tasks.configureEach(action) : tasks.all(action) }
|
||||
allprojects {
|
||||
tasks.withType(JavaExec).configureEach {
|
||||
defaultCharacterEncoding = 'UTF-8'
|
||||
}
|
||||
each(tasks.withType(JavaExec)) { t -> t.defaultCharacterEncoding = 'UTF-8' }
|
||||
}
|
||||
";
|
||||
|
||||
@@ -621,10 +622,12 @@ mod tests {
|
||||
#[test]
|
||||
fn gradle_script_respects_the_builds_own_file_encoding() {
|
||||
let s = GRADLE_FILE_ENCODING_SCRIPT;
|
||||
assert!(s.contains("tasks.withType(JavaExec).configureEach"), "{s}");
|
||||
assert!(s.contains("defaultCharacterEncoding = 'UTF-8'"), "{s}");
|
||||
assert!(s.contains("each(tasks.withType(JavaExec))"), "{s}");
|
||||
assert!(s.contains("t.defaultCharacterEncoding = 'UTF-8'"), "{s}");
|
||||
assert!(!s.contains("doFirst"), "the build must be able to override the default: {s}");
|
||||
assert!(!s.contains("withType(Test)") && !s.contains("JavaCompile"), "{s}");
|
||||
// Gradle before 4.9 has no `configureEach` (#3864).
|
||||
assert!(s.contains("? tasks.configureEach(action) : tasks.all(action)"), "{s}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1,3 +1,6 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
|
||||
/// The Windows OS build used by ConPTY; unavailable on other platforms or on query failure.
|
||||
#[cfg(windows)]
|
||||
pub fn windows_build_number() -> Option<u32> {
|
||||
@@ -16,6 +19,61 @@ pub fn windows_build_number() -> Option<u32> {
|
||||
None
|
||||
}
|
||||
|
||||
/// A caption button of a frameless window's title bar.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum WindowButton {
|
||||
Minimize,
|
||||
Maximize,
|
||||
Close,
|
||||
}
|
||||
|
||||
/// Which caption buttons the title bar shows on each side, in order from left to right.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct WindowButtonLayout {
|
||||
pub left: Vec<WindowButton>,
|
||||
pub right: Vec<WindowButton>,
|
||||
}
|
||||
|
||||
impl Default for WindowButtonLayout {
|
||||
/// Minimise, maximise, close on the right (Windows, and Linux when the desktop says nothing).
|
||||
fn default() -> Self {
|
||||
Self { left: Vec::new(), right: vec![WindowButton::Minimize, WindowButton::Maximize, WindowButton::Close] }
|
||||
}
|
||||
}
|
||||
|
||||
impl WindowButtonLayout {
|
||||
/// Reads GTK's `gtk-decoration-layout` (also GNOME's `button-layout`): button names separated
|
||||
/// by commas, the left side before the colon, e.g. `close,maximize,minimize:icon`. Names other
|
||||
/// than the three caption buttons (`icon`, `menu`, `appmenu`, `spacer`) are skipped, as are
|
||||
/// repeats. A value without any caption button is unusable for a frameless window: `None`.
|
||||
pub fn from_gtk_decoration_layout(layout: &str) -> Option<Self> {
|
||||
let mut seen = Vec::new();
|
||||
let mut side = |part: Option<&str>| {
|
||||
let mut buttons = Vec::new();
|
||||
for name in part.unwrap_or_default().split(',') {
|
||||
let button = match name.trim() {
|
||||
"minimize" => WindowButton::Minimize,
|
||||
"maximize" => WindowButton::Maximize,
|
||||
"close" => WindowButton::Close,
|
||||
_ => continue,
|
||||
};
|
||||
if !seen.contains(&button) {
|
||||
seen.push(button);
|
||||
buttons.push(button);
|
||||
}
|
||||
}
|
||||
buttons
|
||||
};
|
||||
// GTK splits at the first colon only; without one, every button is on the left.
|
||||
let mut parts = layout.splitn(2, ':');
|
||||
let left = side(parts.next());
|
||||
let right = side(parts.next());
|
||||
(!left.is_empty() || !right.is_empty()).then_some(Self { left, right })
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[test]
|
||||
@@ -26,4 +84,42 @@ mod tests {
|
||||
#[cfg(not(windows))]
|
||||
assert_eq!(build, None);
|
||||
}
|
||||
|
||||
use super::{WindowButton::*, WindowButtonLayout};
|
||||
|
||||
fn layout(left: &[super::WindowButton], right: &[super::WindowButton]) -> Option<WindowButtonLayout> {
|
||||
Some(WindowButtonLayout { left: left.to_vec(), right: right.to_vec() })
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_gtk_decoration_layouts() {
|
||||
let cases = [
|
||||
// KDE Plasma with `ButtonsOnLeft=XAIS` (#3794).
|
||||
("close,maximize,minimize:icon", layout(&[Close, Maximize, Minimize], &[])),
|
||||
("close,minimize,maximize:", layout(&[Close, Minimize, Maximize], &[])),
|
||||
(":minimize,maximize,close", layout(&[], &[Minimize, Maximize, Close])),
|
||||
// GNOME's default.
|
||||
("appmenu:close", layout(&[], &[Close])),
|
||||
("menu:minimize,close", layout(&[], &[Minimize, Close])),
|
||||
("icon,close:minimize,maximize", layout(&[Close], &[Minimize, Maximize])),
|
||||
(" close , spacer : minimize ", layout(&[Close], &[Minimize])),
|
||||
// No colon: GTK puts everything on the left.
|
||||
("close,minimize", layout(&[Close, Minimize], &[])),
|
||||
// Only the first colon separates the sides; a button appears once.
|
||||
("close:minimize:maximize", layout(&[Close], &[])),
|
||||
("close,close:close,minimize", layout(&[Close], &[Minimize])),
|
||||
("", None),
|
||||
(":", None),
|
||||
("appmenu:", None),
|
||||
("garbage", None),
|
||||
];
|
||||
for (value, expected) in cases {
|
||||
assert_eq!(WindowButtonLayout::from_gtk_decoration_layout(value), expected, "{value:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn default_layout_is_on_the_right() {
|
||||
assert_eq!(WindowButtonLayout::default(), layout(&[], &[Minimize, Maximize, Close]).unwrap());
|
||||
}
|
||||
}
|
||||
@@ -653,6 +653,10 @@ pub struct NotificationSettings {
|
||||
/// Mirror balloon notifications to the OS when no OpenIDEA window is focused.
|
||||
#[serde(default = "default_true")]
|
||||
pub system_notifications: bool,
|
||||
/// Terminal command completions (#3712): `off` | `longRunning` | `all`.
|
||||
pub terminal_completion: String,
|
||||
/// `longRunning`: the run time a finished command must reach, in seconds.
|
||||
pub terminal_threshold_seconds: u32,
|
||||
/// Group id → display; groups not listed use their default.
|
||||
pub groups: BTreeMap<String, NotificationGroupSettings>,
|
||||
}
|
||||
@@ -661,9 +665,24 @@ fn default_true() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn default_terminal_completion() -> String {
|
||||
"longRunning".to_owned()
|
||||
}
|
||||
|
||||
fn default_terminal_threshold_seconds() -> u32 {
|
||||
10
|
||||
}
|
||||
|
||||
impl Default for NotificationSettings {
|
||||
fn default() -> Self {
|
||||
Self { balloons: true, sound: false, system_notifications: true, groups: BTreeMap::new() }
|
||||
Self {
|
||||
balloons: true,
|
||||
sound: false,
|
||||
system_notifications: true,
|
||||
terminal_completion: default_terminal_completion(),
|
||||
terminal_threshold_seconds: default_terminal_threshold_seconds(),
|
||||
groups: BTreeMap::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -741,6 +760,9 @@ pub struct AppearanceSettings {
|
||||
pub main_menu_style: String,
|
||||
/// A lone Alt press focuses or opens the main menu (IDEA `ide.windows.main.menu.focus.on.alt`).
|
||||
pub main_menu_alt: bool,
|
||||
/// Settings open in a native window of their own (IDEA parity); off opens them
|
||||
/// as a dialog inside the project window, which needs no new webview.
|
||||
pub settings_in_separate_window: bool,
|
||||
/// `subpixel` | `greyscale` | `none`
|
||||
pub ide_antialiasing: String,
|
||||
pub editor_antialiasing: String,
|
||||
@@ -840,6 +862,7 @@ impl Default for AppearanceSettings {
|
||||
menu_icons: true,
|
||||
main_menu_style: "hamburger".into(),
|
||||
main_menu_alt: true,
|
||||
settings_in_separate_window: true,
|
||||
ide_antialiasing: "greyscale".into(),
|
||||
editor_antialiasing: "greyscale".into(),
|
||||
show_tool_window_bars: true,
|
||||
@@ -892,7 +915,13 @@ pub struct EditorSettings {
|
||||
pub docstring_format: String,
|
||||
/// Color Scheme › Language Defaults › Rainbow brackets: `()`, `[]`, `{}` coloured by depth.
|
||||
pub rainbow_brackets: bool,
|
||||
/// The bracket kinds rainbow brackets colour.
|
||||
pub rainbow_bracket_kinds: RainbowBracketKinds,
|
||||
/// Colours the rainbow bracket depth cycles through (2–5).
|
||||
pub rainbow_bracket_colors: u32,
|
||||
pub ligatures: bool,
|
||||
/// Editor › Font and Tools › Terminal › Font: the font pickers list only monospaced fonts.
|
||||
pub only_monospaced_fonts: bool,
|
||||
/// Fallback font for glyphs the main font lacks; empty = none.
|
||||
pub fallback_font: String,
|
||||
/// Typography Settings › Main font weight (CSS 100–900), as IDEA.
|
||||
@@ -936,7 +965,10 @@ impl Default for EditorSettings {
|
||||
semantic_highlighting: false,
|
||||
docstring_format: "rest".into(),
|
||||
rainbow_brackets: false,
|
||||
rainbow_bracket_kinds: RainbowBracketKinds::default(),
|
||||
rainbow_bracket_colors: 3,
|
||||
ligatures: false,
|
||||
only_monospaced_fonts: true,
|
||||
fallback_font: String::new(),
|
||||
font_weight: 400,
|
||||
bold_font_weight: 700,
|
||||
@@ -959,6 +991,23 @@ impl Default for EditorSettings {
|
||||
}
|
||||
}
|
||||
|
||||
/// Color Scheme › Language Defaults › Rainbow brackets: which delimiters are coloured.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct RainbowBracketKinds {
|
||||
pub round: bool,
|
||||
pub square: bool,
|
||||
pub curly: bool,
|
||||
/// Type argument / parameter delimiters and markup tags, where the syntax tree marks them.
|
||||
pub angle: bool,
|
||||
}
|
||||
|
||||
impl Default for RainbowBracketKinds {
|
||||
fn default() -> Self {
|
||||
Self { round: true, square: true, curly: true, angle: false }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct FileSettings {
|
||||
@@ -1751,6 +1800,41 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rainbow_bracket_options_default_and_round_trip() {
|
||||
let old: Settings = serde_json::from_str(r#"{"editor":{"rainbowBrackets":true}}"#).unwrap();
|
||||
assert!(old.editor.rainbow_brackets);
|
||||
assert_eq!(old.editor.rainbow_bracket_kinds, RainbowBracketKinds::default());
|
||||
assert_eq!(old.editor.rainbow_bracket_colors, 3);
|
||||
let defaults = Settings::default().editor;
|
||||
assert!(!defaults.rainbow_brackets);
|
||||
let kinds = defaults.rainbow_bracket_kinds;
|
||||
assert!(kinds.round && kinds.square && kinds.curly && !kinds.angle);
|
||||
|
||||
let mut settings = Settings::default();
|
||||
settings.editor.rainbow_bracket_kinds =
|
||||
RainbowBracketKinds { round: false, square: true, curly: true, angle: true };
|
||||
settings.editor.rainbow_bracket_colors = 5;
|
||||
let json = serde_json::to_value(&settings).unwrap();
|
||||
assert_eq!(json["editor"]["rainbowBracketKinds"]["angle"], true);
|
||||
assert_eq!(json["editor"]["rainbowBracketColors"], 5);
|
||||
let restored: Settings = serde_json::from_value(json).unwrap();
|
||||
assert_eq!(restored.editor.rainbow_bracket_kinds, settings.editor.rainbow_bracket_kinds);
|
||||
assert_eq!(restored.editor.rainbow_bracket_colors, 5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_monospaced_fonts_defaults_on_and_round_trips() {
|
||||
let old: Settings = serde_json::from_str(r#"{"editor":{"ligatures":true}}"#).unwrap();
|
||||
assert!(old.editor.only_monospaced_fonts);
|
||||
let mut settings = Settings::default();
|
||||
settings.editor.only_monospaced_fonts = false;
|
||||
let json = serde_json::to_value(&settings).unwrap();
|
||||
assert_eq!(json["editor"]["onlyMonospacedFonts"], false);
|
||||
let restored: Settings = serde_json::from_value(json).unwrap();
|
||||
assert!(!restored.editor.only_monospaced_fonts);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn docstring_format_defaults_and_round_trips() {
|
||||
let old: Settings = serde_json::from_str(r#"{"editor":{"semanticHighlighting":true}}"#).unwrap();
|
||||
@@ -1849,6 +1933,15 @@ mod tests {
|
||||
assert_eq!(serde_json::to_value(off).unwrap()["appearance"]["mainMenuAlt"], false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn settings_open_in_a_separate_window_unless_turned_off() {
|
||||
let old: Settings = serde_json::from_str(r#"{"appearance":{"compactMode":true}}"#).unwrap();
|
||||
assert!(old.appearance.settings_in_separate_window);
|
||||
let off: Settings = serde_json::from_str(r#"{"appearance":{"settingsInSeparateWindow":false}}"#).unwrap();
|
||||
assert!(!off.appearance.settings_in_separate_window);
|
||||
assert_eq!(serde_json::to_value(off).unwrap()["appearance"]["settingsInSeparateWindow"], false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn editor_font_weights_default_to_regular_and_bold() {
|
||||
let json = serde_json::to_value(Settings::default()).unwrap();
|
||||
|
||||
@@ -43,6 +43,9 @@ impl Default for VcsSettings {
|
||||
pub struct GitSettings {
|
||||
/// Show blame after the current editor line.
|
||||
pub inline_blame: bool,
|
||||
/// A click (or Enter / Space) on the inline blame label opens its commit; off, the
|
||||
/// label is plain text and a click on it places the caret as past the line end.
|
||||
pub inline_blame_clickable: bool,
|
||||
pub show_branch_in_project_view: bool,
|
||||
/// Path to the git executable; empty = auto-detect.
|
||||
pub executable: String,
|
||||
@@ -54,6 +57,8 @@ pub struct GitSettings {
|
||||
pub warn_detached_head: bool,
|
||||
/// Background check for incoming commits: `auto` | `always` | `never`.
|
||||
pub incoming_check: String,
|
||||
/// Minutes between background checks for incoming commits.
|
||||
pub incoming_check_interval: u32,
|
||||
/// Branch name globs, `;`/`,`-separated; force push to them is prohibited.
|
||||
pub protected_branches: String,
|
||||
/// Initial state of Commit Options › Sign-off Commit.
|
||||
@@ -78,6 +83,7 @@ impl Default for GitSettings {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
inline_blame: false,
|
||||
inline_blame_clickable: true,
|
||||
show_branch_in_project_view: false,
|
||||
executable: String::new(),
|
||||
update_method: "merge".into(),
|
||||
@@ -85,6 +91,7 @@ impl Default for GitSettings {
|
||||
warn_crlf: true,
|
||||
warn_detached_head: true,
|
||||
incoming_check: "auto".into(),
|
||||
incoming_check_interval: 15,
|
||||
protected_branches: "master; main".into(),
|
||||
sign_off: false,
|
||||
warn_large_files: true,
|
||||
@@ -128,6 +135,8 @@ pub struct CommitSettings {
|
||||
/// `Settings::default()`, or `SettingsStore::set` rejects the key as unknown.
|
||||
#[specta(optional)]
|
||||
pub double_click_opens_diff: Option<bool>,
|
||||
/// Team conventions for Generate Commit Message with Agent, added to its prompt.
|
||||
pub agent_instructions: String,
|
||||
}
|
||||
|
||||
impl Default for CommitSettings {
|
||||
@@ -149,6 +158,7 @@ impl Default for CommitSettings {
|
||||
wrap_at_margin: false,
|
||||
disabled_plugin_checks: Vec::new(),
|
||||
double_click_opens_diff: None,
|
||||
agent_instructions: String::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,11 +6,16 @@ use ide_run::wrap::{self, program_name};
|
||||
use std::path::Path;
|
||||
|
||||
const GRADLE_INIT: &str = r#"// Written by OpenIDEA for Run with Coverage.
|
||||
allprojects {
|
||||
plugins.withId('java') {
|
||||
apply plugin: 'jacoco'
|
||||
tasks.withType(Test).configureEach { t -> t.finalizedBy(tasks.named('jacocoTestReport')) }
|
||||
tasks.named('jacocoTestReport') { r -> r.reports { xml.required.set(true) } }
|
||||
import org.gradle.util.GradleVersion
|
||||
// `configureEach` (lazy) is Gradle 4.9+; older ones configure each task as it is added.
|
||||
def each = { tasks, Closure action -> GradleVersion.current() >= GradleVersion.version('4.9') ? tasks.configureEach(action) : tasks.all(action) }
|
||||
allprojects { p ->
|
||||
p.plugins.withId('java') {
|
||||
p.apply plugin: 'jacoco'
|
||||
each(p.tasks.withType(Test)) { t -> t.finalizedBy('jacocoTestReport') }
|
||||
def xml = p.tasks.getByName('jacocoTestReport').reports.xml
|
||||
// `Report.required` is Gradle 6.1+, `enabled` is gone in 8.0.
|
||||
if (xml.hasProperty('required')) xml.required.set(true) else xml.enabled = true
|
||||
}
|
||||
}
|
||||
"#;
|
||||
@@ -391,7 +396,10 @@ mod tests {
|
||||
let p = prepare(dir.path(), &cfg("gradle", "./gradlew", &[":app:test", "--tests", "*Calc"]), dir.path());
|
||||
let (l, report) = launch(&p);
|
||||
assert_eq!(l.args[0], "--init-script");
|
||||
assert!(std::fs::read_to_string(&l.args[1]).unwrap().contains("jacoco"));
|
||||
let script = std::fs::read_to_string(&l.args[1]).unwrap();
|
||||
assert!(script.contains("p.apply plugin: 'jacoco'"), "{script}");
|
||||
// `Report.required` is Gradle 6.1+, `configureEach` 4.9+ (#3864).
|
||||
assert!(script.contains("else xml.enabled = true") && script.contains(": tasks.all(action)"), "{script}");
|
||||
assert!(matches!(report, CoverageReportSpec::Jacoco { .. }));
|
||||
}
|
||||
|
||||
|
||||
@@ -216,6 +216,11 @@ fn settle<T>(result: Result<T, InspectError>) -> IdeResult<Result<T, JvmInspectU
|
||||
InspectError::TimedOut => U::TimedOut,
|
||||
InspectError::Closed => U::BackendClosed,
|
||||
InspectError::Failed(message) => return Err(IdeError::internal(format!("JVM inspector: {message}"))),
|
||||
// Only the stream trace commands answer these, never the memory view's.
|
||||
other @ (InspectError::NoSession
|
||||
| InspectError::NotAtChainStart(_)
|
||||
| InspectError::Busy
|
||||
| InspectError::NoTrace) => return Err(IdeError::internal(format!("JVM inspector: {other}"))),
|
||||
}))
|
||||
}
|
||||
|
||||
|
||||
@@ -23,7 +23,7 @@ use std::time::Duration;
|
||||
|
||||
pub use heap::*;
|
||||
pub use inspect::{JvmFieldsResult, JvmInspectUnavailable, JvmInstancesResult, JvmObjectRef, JvmReferrersResult};
|
||||
pub(crate) use inspect::{fields, instances, referrers, set_inspector, watch_link};
|
||||
pub(crate) use inspect::{fields, instances, referrers, set_inspector, vm_target, watch_link};
|
||||
#[cfg(all(test, unix))]
|
||||
pub(crate) use scan::watch_for_attached_jvm;
|
||||
pub(crate) use scan::{JvmFinder, attach_target, find_attached_jvm, find_local_jvm, local_jdwp_port};
|
||||
|
||||
@@ -19,6 +19,7 @@ mod jvm_memory;
|
||||
pub mod kotlin;
|
||||
pub mod kotlin_lsp;
|
||||
mod session;
|
||||
mod stream_trace;
|
||||
pub mod unity;
|
||||
|
||||
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
|
||||
@@ -39,6 +40,7 @@ use std::path::{Path, PathBuf};
|
||||
use std::sync::atomic::Ordering;
|
||||
use std::sync::{Arc, Weak};
|
||||
use std::time::Duration;
|
||||
pub use stream_trace::{TracePhase, TraceProgress, TraceRun, TraceUnavailable};
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -146,6 +148,9 @@ pub struct DebugCapabilities {
|
||||
pub js_page: bool,
|
||||
/// The adapter evaluates expressions while the program runs, without a stack frame.
|
||||
pub live_evaluate: bool,
|
||||
/// A stream chain can be traced while the program runs it ([`DebugManager::stream_trace`]).
|
||||
/// Can change during the session, like `jvm_instances`.
|
||||
pub stream_trace: bool,
|
||||
}
|
||||
|
||||
/// Result of [`DebugManager::redefine_classes`].
|
||||
@@ -602,6 +607,7 @@ pub(crate) fn capabilities_from(caps: &Value) -> DebugCapabilities {
|
||||
jvm_heap: false,
|
||||
js_page: false,
|
||||
live_evaluate: false,
|
||||
stream_trace: false,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -613,6 +619,7 @@ pub(crate) fn session_capabilities(session: &Session) -> DebugCapabilities {
|
||||
caps.jvm_heap = JVM_MEMORY_ADAPTERS.contains(&session.adapter.as_str());
|
||||
caps.js_page = js_debug::is_page(session);
|
||||
caps.live_evaluate = session.adapter == js_debug::ADAPTER;
|
||||
caps.stream_trace = stream_trace::available(session);
|
||||
caps
|
||||
}
|
||||
|
||||
@@ -1617,6 +1624,7 @@ impl DebugManager {
|
||||
// DAP: a response without the flag continued every thread.
|
||||
let all = body.get("allThreadsContinued").and_then(Value::as_bool).unwrap_or(true);
|
||||
session.suspended.resumed(ticket, thread_id, all);
|
||||
stream_trace::release_done(&session);
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: all });
|
||||
Ok(())
|
||||
}
|
||||
@@ -1665,6 +1673,7 @@ impl DebugManager {
|
||||
step_settled(&session, sent)?;
|
||||
// A step runs its thread; other threads stopped by their own events stay stopped.
|
||||
session.suspended.resumed(ticket, thread_id, false);
|
||||
stream_trace::release_done(&session);
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
|
||||
Ok(())
|
||||
}
|
||||
@@ -1776,6 +1785,7 @@ impl DebugManager {
|
||||
.await;
|
||||
step_settled(&session, sent)?;
|
||||
session.suspended.resumed(ticket, thread_id, false);
|
||||
stream_trace::release_done(&session);
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
|
||||
Ok(())
|
||||
}
|
||||
@@ -1873,6 +1883,42 @@ impl DebugManager {
|
||||
jvm_memory::referrers(&*self.session(s)?, object, limit).await
|
||||
}
|
||||
|
||||
/// Gives the session the backend for [`Self::stream_trace`] (used by java-debug sessions
|
||||
/// only); the UI is told to reload the session's capabilities.
|
||||
pub fn set_stream_tracer(
|
||||
&self,
|
||||
s: DebugSessionId,
|
||||
tracer: Arc<dyn ide_jvm_inspect::StreamTracer>,
|
||||
) -> IdeResult<()> {
|
||||
let session = self.session(s)?;
|
||||
if session.ended.is_cancelled() {
|
||||
return Err(no_session(s));
|
||||
}
|
||||
stream_trace::set_tracer(&session, tracer);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Traces the stream chain `plan` (the JSON of `ide_streams::RealRunPlan`) while the program
|
||||
/// runs it, from `thread_id` stopped where the chain starts. Leaves the thread stopped right
|
||||
/// after the chain's terminal operation. `cancel` stops keeping records; the program runs on.
|
||||
pub async fn stream_trace(
|
||||
&self,
|
||||
s: DebugSessionId,
|
||||
thread_id: i64,
|
||||
plan: Value,
|
||||
cancel: ide_core::CancellationToken,
|
||||
progress: impl Fn(TraceProgress) + Send + Sync,
|
||||
) -> IdeResult<TraceRun> {
|
||||
let session = self.session(s)?;
|
||||
Ok(stream_trace::run(self, &session, thread_id, &plan, &cancel, &progress).await)
|
||||
}
|
||||
|
||||
/// Ends the running terminal operation by interrupting its thread, then by throwing into it.
|
||||
/// `None` when no trace runs.
|
||||
pub async fn stream_trace_abort(&self, s: DebugSessionId) -> IdeResult<Option<ide_jvm_inspect::AbortState>> {
|
||||
stream_trace::abort(&*self.session(s)?).await
|
||||
}
|
||||
|
||||
/// HotSwap: reloads the classes compiled since the session started (or since the
|
||||
/// last reload) into the debuggee (java-debug `redefineClasses`).
|
||||
pub async fn redefine_classes(&self, s: DebugSessionId) -> IdeResult<HotSwapResult> {
|
||||
|
||||
@@ -114,6 +114,10 @@ pub(crate) struct Session {
|
||||
pub jvm_located: watch::Sender<bool>,
|
||||
pub kotlin_mirror: Mutex<Option<crate::kotlin::SourceMirror>>,
|
||||
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
|
||||
pub stream_tracer: parking_lot::Mutex<Option<Arc<dyn ide_jvm_inspect::StreamTracer>>>,
|
||||
pub(crate) stream_trace: parking_lot::Mutex<Option<crate::stream_trace::ActiveTrace>>,
|
||||
/// The last trace that finished, until the stop its records were read in ends.
|
||||
pub(crate) stream_trace_done: parking_lot::Mutex<Option<crate::stream_trace::DoneTrace>>,
|
||||
/// Used only by a kotlin-lsp session: see [`Session::kotlin_lsp_quirks`].
|
||||
pub(crate) quirks: kotlin_lsp::Quirks,
|
||||
pub(crate) unity_startup_activity: Mutex<Instant>,
|
||||
@@ -195,6 +199,13 @@ impl Suspension {
|
||||
self.0.lock().ticket
|
||||
}
|
||||
|
||||
/// The ticket of a stop of `thread` (its own or every thread's) taken after ticket `after`.
|
||||
pub fn stopped_since(&self, thread: i64, after: u64) -> Option<u64> {
|
||||
let stops = self.0.lock();
|
||||
let own = stops.threads.iter().find(|&&(id, _)| id == thread).map(|&(_, ticket)| ticket);
|
||||
own.max(stops.all).filter(|&ticket| ticket > after)
|
||||
}
|
||||
|
||||
/// After a successful resume-like request for `thread`; `all`: every thread ran.
|
||||
pub fn resumed(&self, ticket: u64, thread: i64, all: bool) {
|
||||
self.0.lock().release(Some(thread), all, ticket);
|
||||
@@ -270,6 +281,9 @@ impl Session {
|
||||
jvm_located: watch::channel(false).0,
|
||||
kotlin_mirror: Mutex::new(None),
|
||||
jvm_memory: tokio::sync::Mutex::default(),
|
||||
stream_tracer: parking_lot::Mutex::new(None),
|
||||
stream_trace: parking_lot::Mutex::new(None),
|
||||
stream_trace_done: parking_lot::Mutex::new(None),
|
||||
quirks: kotlin_lsp::Quirks::default(),
|
||||
unity_startup_activity: Mutex::new(Instant::now()),
|
||||
}
|
||||
@@ -741,6 +755,9 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
|
||||
}
|
||||
"stopped" => {
|
||||
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
|
||||
if crate::stream_trace::resume_traced_stop(s, int("threadId"), all) {
|
||||
return;
|
||||
}
|
||||
s.suspended.stopped(int("threadId"), all);
|
||||
let mut reason = str_("reason").unwrap_or_else(|| "pause".into());
|
||||
if let Some(quirks) = s.kotlin_lsp_quirks() {
|
||||
@@ -760,6 +777,7 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
|
||||
// DAP: an event without the flag continues its thread alone. The UI keeps treating
|
||||
// it as all threads; the suspension, which holds only threads that stopped, need not.
|
||||
s.suspended.continued(int("threadId"), all.unwrap_or(false));
|
||||
crate::stream_trace::release_done(s);
|
||||
s.emit(DebugEvent::Continued {
|
||||
thread_id: int("threadId").unwrap_or(0),
|
||||
all_threads_continued: all.unwrap_or(true),
|
||||
|
||||
@@ -0,0 +1,433 @@
|
||||
//! A stream chain traced while the program itself runs it. The JDT LS bundle arms the trace with
|
||||
//! the thread stopped where the chain starts; the program runs on `continue`, and the bundle holds
|
||||
//! the thread inside the terminal operation once it has run, until a `stepOut` brings java-debug
|
||||
//! to a stop of its own in which the records are read.
|
||||
|
||||
use crate::jvm_memory::vm_target;
|
||||
use crate::session::Session;
|
||||
use crate::{DebugManager, StepKind};
|
||||
use ide_core::event::DebugEvent;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use ide_jvm_inspect::{
|
||||
AbortState, InspectError, InspectFuture, StreamTracer, TraceCollected, TraceId, TraceState, VmTarget,
|
||||
};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
use specta::Type;
|
||||
use std::future::Future;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
/// Records the bundle keeps; later ones are only counted.
|
||||
const BUDGET: u32 = 50_000;
|
||||
const WAIT_MS: u32 = 500;
|
||||
const STOP_POLL: Duration = Duration::from_millis(20);
|
||||
const STOP_WAIT: Duration = Duration::from_secs(30);
|
||||
const RESUME_TIMEOUT: Duration = Duration::from_secs(30);
|
||||
/// The bundle reaches the JVM through java-debug's own session.
|
||||
const ADAPTER: &str = "java-debug";
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct TraceProgress {
|
||||
pub phase: TracePhase,
|
||||
pub records: u64,
|
||||
pub dropped: u64,
|
||||
/// Since the program started running the chain, as the bundle measures it.
|
||||
pub elapsed_ms: u64,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum TracePhase {
|
||||
Arming,
|
||||
Running,
|
||||
/// The terminal operation runs on, keeping no more records.
|
||||
RecordingStopped,
|
||||
Aborting,
|
||||
/// The terminal operation finished: stepping out of it and reading the records.
|
||||
Collecting,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub enum TraceRun {
|
||||
/// `generation`: the stop the records were read in, the only one their objects are valid in.
|
||||
Done {
|
||||
collected: TraceCollected,
|
||||
generation: u64,
|
||||
/// Stops of the traced thread while the program ran the chain, resumed unseen.
|
||||
resumed_stops: u32,
|
||||
},
|
||||
Unavailable {
|
||||
reason: TraceUnavailable,
|
||||
},
|
||||
Failed {
|
||||
detail: String,
|
||||
},
|
||||
/// Stop Recording or Abort Operation came before the terminal operation ran.
|
||||
Cancelled {
|
||||
detail: String,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
|
||||
pub enum TraceUnavailable {
|
||||
/// Not a java-debug session, or no JDT LS bundle behind it.
|
||||
NoBackend,
|
||||
NotSuspended,
|
||||
NotAtChainStart {
|
||||
detail: String,
|
||||
},
|
||||
/// A trace already runs in this session or its JVM.
|
||||
Busy,
|
||||
/// java-debug has no debug session for the JVM.
|
||||
NoSession,
|
||||
Unsupported {
|
||||
detail: String,
|
||||
},
|
||||
}
|
||||
|
||||
/// A trace that finished. Its records keep their objects from being collected until the stop they
|
||||
/// were read in ends; then the UI no longer shows them and [`release_done`] lets them go.
|
||||
pub(crate) struct DoneTrace {
|
||||
tracer: Arc<dyn StreamTracer>,
|
||||
target: VmTarget,
|
||||
id: TraceId,
|
||||
}
|
||||
|
||||
/// The stop a finished trace was read in ended (a resume, a step, a `continued` event).
|
||||
pub(crate) fn release_done(s: &Session) {
|
||||
let Some(done) = s.stream_trace_done.lock().take() else { return };
|
||||
let ended = s.ended.clone();
|
||||
let session = s.id.0;
|
||||
tokio::spawn(async move {
|
||||
tokio::select! {
|
||||
biased;
|
||||
() = ended.cancelled() => {}
|
||||
result = done.tracer.release(&done.target, done.id) => {
|
||||
if let Err(e) = result {
|
||||
tracing::debug!(session, trace = done.id, "releasing a finished stream trace: {e}");
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// The session's running trace; `id` is `None` until `arm` answers.
|
||||
pub(crate) struct ActiveTrace {
|
||||
tracer: Arc<dyn StreamTracer>,
|
||||
target: VmTarget,
|
||||
id: Option<TraceId>,
|
||||
aborting: bool,
|
||||
thread_id: i64,
|
||||
/// From the `continue` that runs the chain until the bundle holds the thread after it.
|
||||
running: bool,
|
||||
resumed_stops: u32,
|
||||
}
|
||||
|
||||
/// A stop of the traced thread while the program runs the chain is resumed instead of shown, as
|
||||
/// IntelliJ does (spec G5): the UI keeps Resume locked meanwhile, and a breakpoint java-debug set
|
||||
/// since the bundle last switched them off, hit inside the terminal's invoke, would hold that
|
||||
/// invoke forever. java-debug stops a breakpoint's thread alone; a stop of every thread is shown.
|
||||
/// `true` when the stop was taken.
|
||||
pub(crate) fn resume_traced_stop(s: &Arc<Session>, thread_id: Option<i64>, all: bool) -> bool {
|
||||
let Some(thread_id) = thread_id.filter(|_| !all) else { return false };
|
||||
{
|
||||
let mut slot = s.stream_trace.lock();
|
||||
let Some(active) = slot.as_mut().filter(|a| a.running && a.thread_id == thread_id) else { return false };
|
||||
active.resumed_stops += 1;
|
||||
}
|
||||
let s = s.clone();
|
||||
tokio::spawn(async move {
|
||||
let sent =
|
||||
s.conn.request_timeout("continue", serde_json::json!({ "threadId": thread_id }), RESUME_TIMEOUT).await;
|
||||
if let Err(e) = sent {
|
||||
tracing::warn!(session = s.id.0, thread_id, "resuming a stop inside a stream trace: {e}");
|
||||
}
|
||||
});
|
||||
true
|
||||
}
|
||||
|
||||
fn set_running(s: &Session, running: bool) {
|
||||
if let Some(active) = s.stream_trace.lock().as_mut() {
|
||||
active.running = running;
|
||||
}
|
||||
}
|
||||
|
||||
/// Frees the session for the next trace however this one ends, a dropped future included.
|
||||
struct Claim<'s>(&'s Session);
|
||||
|
||||
impl Drop for Claim<'_> {
|
||||
fn drop(&mut self) {
|
||||
self.0.stream_trace.lock().take();
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn set_tracer(s: &Session, tracer: Arc<dyn StreamTracer>) {
|
||||
*s.stream_tracer.lock() = Some(tracer);
|
||||
s.emit(DebugEvent::Capabilities);
|
||||
}
|
||||
|
||||
fn tracer(s: &Session) -> Option<Arc<dyn StreamTracer>> {
|
||||
s.stream_tracer.lock().clone().filter(|_| s.adapter == ADAPTER)
|
||||
}
|
||||
|
||||
pub(crate) fn available(s: &Session) -> bool {
|
||||
tracer(s).is_some()
|
||||
}
|
||||
|
||||
pub(crate) async fn run(
|
||||
mgr: &DebugManager,
|
||||
s: &Session,
|
||||
thread_id: i64,
|
||||
plan: &Value,
|
||||
cancel: &CancellationToken,
|
||||
progress: &(impl Fn(TraceProgress) + Send + Sync),
|
||||
) -> TraceRun {
|
||||
let unavailable = |reason| TraceRun::Unavailable { reason };
|
||||
let Some(tracer) = tracer(s) else { return unavailable(TraceUnavailable::NoBackend) };
|
||||
let target = vm_target(s);
|
||||
let _claim = {
|
||||
let mut slot = s.stream_trace.lock();
|
||||
if slot.is_some() {
|
||||
return unavailable(TraceUnavailable::Busy);
|
||||
}
|
||||
*slot = Some(ActiveTrace {
|
||||
tracer: tracer.clone(),
|
||||
target: target.clone(),
|
||||
id: None,
|
||||
aborting: false,
|
||||
thread_id,
|
||||
running: false,
|
||||
resumed_stops: 0,
|
||||
});
|
||||
Claim(s)
|
||||
};
|
||||
if !s.suspended.get() {
|
||||
return unavailable(TraceUnavailable::NotSuspended);
|
||||
}
|
||||
// The bundle releases the previous trace itself when this one arms.
|
||||
s.stream_trace_done.lock().take();
|
||||
static TOKENS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
|
||||
let token =
|
||||
format!("{}-{}-{}", std::process::id(), s.id.0, TOKENS.fetch_add(1, std::sync::atomic::Ordering::Relaxed));
|
||||
let mut trace = Trace {
|
||||
mgr,
|
||||
s,
|
||||
tracer: &*tracer,
|
||||
target: &target,
|
||||
thread_id,
|
||||
progress,
|
||||
token,
|
||||
arm_sent: false,
|
||||
id: None,
|
||||
last: Counts::default(),
|
||||
};
|
||||
match trace.drive(plan, cancel).await {
|
||||
Ok(run) => {
|
||||
if let (TraceRun::Done { .. }, Some(id)) = (&run, trace.id) {
|
||||
*s.stream_trace_done.lock() = Some(DoneTrace { tracer: tracer.clone(), target: target.clone(), id });
|
||||
}
|
||||
run
|
||||
}
|
||||
Err(run) => {
|
||||
// A stop from now on is the user's to see.
|
||||
set_running(s, false);
|
||||
trace.release().await;
|
||||
run
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `None` when no trace runs or it is still arming. The trace itself goes on to report how the
|
||||
/// abort ended it.
|
||||
pub(crate) async fn abort(s: &Session) -> IdeResult<Option<AbortState>> {
|
||||
let (tracer, target, id) = {
|
||||
let mut slot = s.stream_trace.lock();
|
||||
let Some(active) = slot.as_mut() else { return Ok(None) };
|
||||
let Some(id) = active.id else { return Ok(None) };
|
||||
active.aborting = true;
|
||||
(active.tracer.clone(), active.target.clone(), id)
|
||||
};
|
||||
let result = tokio::select! {
|
||||
biased;
|
||||
() = s.ended.cancelled() => return Ok(None),
|
||||
result = tracer.abort(&target, id) => result,
|
||||
};
|
||||
match result {
|
||||
Ok(state) => Ok(Some(state)),
|
||||
Err(InspectError::NoTrace) => Ok(None),
|
||||
Err(e) => Err(IdeError::internal(format!("cannot abort the stream trace: {e}"))),
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Counts {
|
||||
records: u64,
|
||||
dropped: u64,
|
||||
elapsed_ms: u64,
|
||||
}
|
||||
|
||||
struct Trace<'a, P> {
|
||||
mgr: &'a DebugManager,
|
||||
s: &'a Session,
|
||||
tracer: &'a dyn StreamTracer,
|
||||
/// The stop the trace was armed in.
|
||||
target: &'a VmTarget,
|
||||
thread_id: i64,
|
||||
progress: &'a P,
|
||||
/// Names the trace to the bundle before `arm` answers (see [`StreamTracer::release_armed`]).
|
||||
token: String,
|
||||
arm_sent: bool,
|
||||
/// Set once `arm` answers.
|
||||
id: Option<TraceId>,
|
||||
last: Counts,
|
||||
}
|
||||
|
||||
impl<P: Fn(TraceProgress) + Send + Sync> Trace<'_, P> {
|
||||
/// `Err` ends the trace early.
|
||||
async fn drive(&mut self, plan: &Value, cancel: &CancellationToken) -> Result<TraceRun, TraceRun> {
|
||||
let (s, tracer, target) = (self.s, self.tracer, self.target);
|
||||
self.report(TracePhase::Arming);
|
||||
self.arm_sent = true;
|
||||
let id = self
|
||||
.until_ended(tracer.arm(target, self.thread_id, plan, BUDGET, &self.token))
|
||||
.await?
|
||||
.map_err(|e| if s.ended.is_cancelled() { ended() } else { refused(e) })?;
|
||||
self.id = Some(id);
|
||||
if let Some(active) = s.stream_trace.lock().as_mut() {
|
||||
active.id = Some(id);
|
||||
}
|
||||
// Before the request: the thread can stop again before its reply arrives.
|
||||
set_running(s, true);
|
||||
self.dap(self.mgr.resume(s.id, self.thread_id)).await?;
|
||||
let mut stopped = false;
|
||||
loop {
|
||||
if cancel.is_cancelled() && !stopped {
|
||||
stopped = true;
|
||||
// Refused when the trace parked or failed just before: `wait` reports that.
|
||||
match self.until_ended(tracer.stop(target, id)).await? {
|
||||
Ok(records) => {
|
||||
self.last.records = records;
|
||||
self.report(TracePhase::RecordingStopped);
|
||||
}
|
||||
Err(e) => tracing::debug!(session = s.id.0, trace = id, "stream trace stop: {e}"),
|
||||
}
|
||||
}
|
||||
match self.inspect(tracer.wait(target, id, WAIT_MS)).await? {
|
||||
TraceState::Running { records, dropped, elapsed_ms } => {
|
||||
self.last = Counts { records, dropped, elapsed_ms };
|
||||
let aborting = s.stream_trace.lock().as_ref().is_some_and(|a| a.aborting);
|
||||
self.report(if aborting {
|
||||
TracePhase::Aborting
|
||||
} else if stopped {
|
||||
TracePhase::RecordingStopped
|
||||
} else {
|
||||
TracePhase::Running
|
||||
});
|
||||
}
|
||||
TraceState::Parked { records, dropped } => {
|
||||
set_running(s, false);
|
||||
self.last.records = records;
|
||||
self.last.dropped = dropped;
|
||||
break;
|
||||
}
|
||||
TraceState::Failed { detail } => return Err(TraceRun::Failed { detail }),
|
||||
TraceState::Cancelled { detail } => return Err(TraceRun::Cancelled { detail }),
|
||||
}
|
||||
}
|
||||
self.report(TracePhase::Collecting);
|
||||
let before = s.suspended.ticket();
|
||||
self.dap(self.mgr.step(s.id, self.thread_id, StepKind::Out)).await?;
|
||||
// Another thread's stop meanwhile is not this one: the traced thread would still be
|
||||
// inside the terminal operation.
|
||||
let stop = async {
|
||||
loop {
|
||||
if let Some(ticket) = s.suspended.stopped_since(self.thread_id, before) {
|
||||
return ticket;
|
||||
}
|
||||
tokio::time::sleep(STOP_POLL).await;
|
||||
}
|
||||
};
|
||||
let Ok(generation) = self.until_ended(tokio::time::timeout(STOP_WAIT, stop)).await? else {
|
||||
// Collecting in the old stop would only be refused as stale.
|
||||
return Err(TraceRun::Failed { detail: step_out_timeout() });
|
||||
};
|
||||
let stopped_in = VmTarget { generation, ..vm_target(s) };
|
||||
let collected = self.inspect(tracer.collect(&stopped_in, id, self.last.records)).await?;
|
||||
let resumed_stops = s.stream_trace.lock().as_ref().map_or(0, |a| a.resumed_stops);
|
||||
Ok(TraceRun::Done { collected, generation, resumed_stops })
|
||||
}
|
||||
|
||||
/// After a trace that ended early. Left to the bundle, an armed trace would keep every
|
||||
/// breakpoint off and a parked one its thread suspended behind java-debug's back; the bundle
|
||||
/// undoes either, or does so once a terminal still running returns. Not after a finished
|
||||
/// trace: the records it unpins are the values the result shows ([`release_done`] does, once
|
||||
/// that stop ends). An `arm` that never answered (it timed out) may still have armed: released
|
||||
/// by its token.
|
||||
async fn release(&self) {
|
||||
if self.s.ended.is_cancelled() {
|
||||
return;
|
||||
}
|
||||
let work = match self.id {
|
||||
Some(id) => self.tracer.release(self.target, id),
|
||||
None if self.arm_sent => self.tracer.release_armed(self.target, &self.token),
|
||||
None => return,
|
||||
};
|
||||
if let Ok(Err(e)) = self.until_ended(work).await {
|
||||
tracing::debug!(session = self.s.id.0, trace = ?self.id, "stream trace release: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
fn report(&self, phase: TracePhase) {
|
||||
let Counts { records, dropped, elapsed_ms } = self.last;
|
||||
(self.progress)(TraceProgress { phase, records, dropped, elapsed_ms });
|
||||
}
|
||||
|
||||
/// A reply may never come once the session ends.
|
||||
async fn until_ended<T>(&self, work: impl Future<Output = T>) -> Result<T, TraceRun> {
|
||||
tokio::select! {
|
||||
biased;
|
||||
() = self.s.ended.cancelled() => Err(ended()),
|
||||
value = work => Ok(value),
|
||||
}
|
||||
}
|
||||
|
||||
async fn inspect<T>(&self, work: InspectFuture<'_, T>) -> Result<T, TraceRun> {
|
||||
self.until_ended(work).await?.map_err(|e| self.failed(e.to_string()))
|
||||
}
|
||||
|
||||
async fn dap(&self, work: impl Future<Output = IdeResult<()>>) -> Result<(), TraceRun> {
|
||||
self.until_ended(work).await?.map_err(|e| self.failed(e.message))
|
||||
}
|
||||
|
||||
/// A request that failed because the session was ending says so.
|
||||
fn failed(&self, detail: String) -> TraceRun {
|
||||
if self.s.ended.is_cancelled() { ended() } else { TraceRun::Failed { detail } }
|
||||
}
|
||||
}
|
||||
|
||||
fn step_out_timeout() -> String {
|
||||
format!(
|
||||
"java-debug reported no stop within {} s of stepping out of the stream's terminal operation",
|
||||
STOP_WAIT.as_secs()
|
||||
)
|
||||
}
|
||||
|
||||
fn ended() -> TraceRun {
|
||||
TraceRun::Failed { detail: "the debug session ended".into() }
|
||||
}
|
||||
|
||||
fn refused(e: InspectError) -> TraceRun {
|
||||
use TraceUnavailable as U;
|
||||
let reason = match e {
|
||||
InspectError::NotSuspended => U::NotSuspended,
|
||||
InspectError::Busy => U::Busy,
|
||||
InspectError::NoSession => U::NoSession,
|
||||
InspectError::Unsupported(detail) => U::Unsupported { detail },
|
||||
InspectError::NotAtChainStart(detail) => U::NotAtChainStart { detail },
|
||||
other => return TraceRun::Failed { detail: other.to_string() },
|
||||
};
|
||||
TraceRun::Unavailable { reason }
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
//! Protocol flow against an in-memory fake adapter.
|
||||
|
||||
mod jvm_inspect;
|
||||
mod stream_trace;
|
||||
|
||||
use super::*;
|
||||
use crate::adapter::{AdapterIo, LaunchFuture};
|
||||
@@ -71,10 +72,21 @@ async fn windows_stop_releases_the_debuggees_port_before_returning() {
|
||||
.unwrap();
|
||||
let pid = child.0.id();
|
||||
child.1 = Some(ide_core::process::ProcessTree::capture(pid));
|
||||
let h = harness(Script { debuggee_pid: Some(pid), supports_terminate, ..Default::default() });
|
||||
// A running program: one suspended at a breakpoint is killed at once (#3658), without the
|
||||
// wait for its tree this test is about.
|
||||
let h = harness(Script {
|
||||
debuggee_pid: Some(pid),
|
||||
supports_terminate,
|
||||
continued_after_stop: true,
|
||||
..Default::default()
|
||||
});
|
||||
let id = h.start(config()).await.unwrap();
|
||||
let session = h.manager.session(id).unwrap();
|
||||
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid) {
|
||||
// The pid, then the stop at launch and the `continued` that ends it.
|
||||
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid)
|
||||
|| session.suspended.ticket() == 0
|
||||
|| session.suspended.get()
|
||||
{
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
let stop = tokio::spawn({
|
||||
@@ -132,6 +144,16 @@ struct Script {
|
||||
continue_reply: Option<Value>,
|
||||
/// Answer `continue` and stop at a breakpoint again, instead of letting the program exit.
|
||||
stop_after_continue: bool,
|
||||
/// Answer `stepOut` and stop these threads one after the other, 100 ms apart (java-debug
|
||||
/// stops the stepping thread right after the call returns).
|
||||
step_out_stops: &'static [i64],
|
||||
/// Refuse `stepOut`.
|
||||
refuse_step_out: bool,
|
||||
/// Refuse `continue`.
|
||||
refuse_continue: bool,
|
||||
/// Stop thread 1 alone at a breakpoint right after each of the first this many `continue`s
|
||||
/// that `continue_reply` answers.
|
||||
breakpoints_after_continue: usize,
|
||||
/// The `reason` of the stop a `next` ends with (`step` when unset; kotlin-lsp says `breakpoint`).
|
||||
step_reason: Option<&'static str>,
|
||||
/// Refuse `next`, then stop at a breakpoint (one the program hit meanwhile).
|
||||
@@ -185,6 +207,10 @@ impl Default for Script {
|
||||
hang_up_after_stop: false,
|
||||
continue_reply: None,
|
||||
stop_after_continue: false,
|
||||
step_out_stops: &[],
|
||||
refuse_step_out: false,
|
||||
refuse_continue: false,
|
||||
breakpoints_after_continue: 0,
|
||||
step_reason: None,
|
||||
refuse_next: false,
|
||||
invalidated_after_stop: false,
|
||||
@@ -248,6 +274,7 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
let mut running = false;
|
||||
let mut thread_requests = 0;
|
||||
let mut unity = false;
|
||||
let mut breakpoints_left = script.breakpoints_after_continue;
|
||||
macro_rules! send {
|
||||
($v:expr) => {{
|
||||
let mut v: Value = $v;
|
||||
@@ -494,7 +521,21 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
{"label": ""},
|
||||
]})
|
||||
),
|
||||
"continue" if script.continue_reply.is_some() => ok!(msg, script.continue_reply.clone().unwrap()),
|
||||
"continue" if script.refuse_continue => send!(
|
||||
json!({"type": "response", "request_seq": msg["seq"], "command": "continue", "success": false, "message": "Thread is not suspended"})
|
||||
),
|
||||
"continue" if script.continue_reply.is_some() => {
|
||||
ok!(msg, script.continue_reply.clone().unwrap());
|
||||
if breakpoints_left > 0 {
|
||||
breakpoints_left -= 1;
|
||||
send!(
|
||||
json!({"type": "event", "event": "stopped", "body": {"reason": "breakpoint", "threadId": 1}})
|
||||
);
|
||||
}
|
||||
}
|
||||
"stepOut" if script.refuse_step_out => send!(
|
||||
json!({"type": "response", "request_seq": msg["seq"], "command": "stepOut", "success": false, "message": "Thread is not suspended"})
|
||||
),
|
||||
"continue" if script.stop_after_continue => {
|
||||
ok!(msg, json!({"allThreadsContinued": true}));
|
||||
send!(
|
||||
@@ -507,6 +548,16 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
send!(json!({"type": "event", "event": "terminated"}));
|
||||
}
|
||||
"pause" if script.hang_up_on_pause => break,
|
||||
"stepOut" if !script.step_out_stops.is_empty() => {
|
||||
ok!(msg, Value::Null);
|
||||
for (i, thread) in script.step_out_stops.iter().enumerate() {
|
||||
if i > 0 {
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
let reason = if i + 1 == script.step_out_stops.len() { "step" } else { "breakpoint" };
|
||||
send!(json!({"type": "event", "event": "stopped", "body": {"reason": reason, "threadId": thread}}));
|
||||
}
|
||||
}
|
||||
"stepIn" | "stepOut" | "pause" => ok!(msg, Value::Null),
|
||||
"redefineClasses" => {
|
||||
send!(
|
||||
@@ -1871,6 +1922,7 @@ fn godot_registry(port: u16, command: &str, args: &[&str]) -> Arc<LanguageRegist
|
||||
framework_files: Vec::new(),
|
||||
formatter: None,
|
||||
scratch_template: None,
|
||||
rainbow_brackets: Default::default(),
|
||||
tree_sitter: None,
|
||||
language_servers: vec![],
|
||||
debugger: Some(ide_language::DebuggerConfig {
|
||||
|
||||
@@ -0,0 +1,558 @@
|
||||
//! A stream chain traced while the program runs it, through a session's stream tracer.
|
||||
|
||||
use super::*;
|
||||
use ide_core::CancellationToken;
|
||||
use ide_jvm_inspect::{
|
||||
AbortState, CollectedTerminal, InspectError, InspectFuture, JvmValue, StreamTracer, TraceCollected, TraceId,
|
||||
TraceState, VmTarget,
|
||||
};
|
||||
use std::collections::VecDeque;
|
||||
use tokio::sync::Notify;
|
||||
|
||||
const TRACE: TraceId = 7;
|
||||
|
||||
#[derive(Default)]
|
||||
struct FakeTracer {
|
||||
/// Answers to `wait`, in order. Once they run out, `wait` signals `waiting` and answers only
|
||||
/// after more are pushed and `more` is notified.
|
||||
waits: Mutex<VecDeque<Result<TraceState, InspectError>>>,
|
||||
arm_error: Mutex<Option<InspectError>>,
|
||||
stop_error: Mutex<Option<InspectError>>,
|
||||
collect_error: Mutex<Option<InspectError>>,
|
||||
/// The record count each `collect` was given.
|
||||
collect_records: Mutex<Vec<u64>>,
|
||||
calls: Mutex<Vec<(&'static str, VmTarget)>>,
|
||||
waiting: Notify,
|
||||
more: Notify,
|
||||
}
|
||||
|
||||
impl FakeTracer {
|
||||
fn scripted(waits: impl IntoIterator<Item = TraceState>) -> Arc<Self> {
|
||||
Self::answering(waits.into_iter().map(Ok))
|
||||
}
|
||||
|
||||
fn answering(waits: impl IntoIterator<Item = Result<TraceState, InspectError>>) -> Arc<Self> {
|
||||
Arc::new(Self { waits: Mutex::new(waits.into_iter().collect()), ..Self::default() })
|
||||
}
|
||||
|
||||
fn record(&self, name: &'static str, target: &VmTarget) {
|
||||
self.calls.lock().push((name, target.clone()));
|
||||
}
|
||||
|
||||
fn names(&self) -> Vec<&'static str> {
|
||||
self.calls.lock().iter().map(|(name, _)| *name).collect()
|
||||
}
|
||||
|
||||
fn target_of(&self, name: &str) -> VmTarget {
|
||||
self.calls.lock().iter().find(|(n, _)| *n == name).map(|(_, t)| t.clone()).unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
impl StreamTracer for FakeTracer {
|
||||
fn arm<'a>(
|
||||
&'a self,
|
||||
target: &'a VmTarget,
|
||||
_thread_id: i64,
|
||||
_plan: &'a Value,
|
||||
_budget: u32,
|
||||
_token: &'a str,
|
||||
) -> InspectFuture<'a, TraceId> {
|
||||
self.record("arm", target);
|
||||
let error = self.arm_error.lock().clone();
|
||||
Box::pin(async move { error.map_or(Ok(TRACE), Err) })
|
||||
}
|
||||
|
||||
fn wait<'a>(&'a self, target: &'a VmTarget, _trace: TraceId, _ms: u32) -> InspectFuture<'a, TraceState> {
|
||||
self.record("wait", target);
|
||||
Box::pin(async move {
|
||||
loop {
|
||||
if let Some(state) = self.waits.lock().pop_front() {
|
||||
return state;
|
||||
}
|
||||
self.waiting.notify_one();
|
||||
self.more.notified().await;
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fn stop<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, u64> {
|
||||
self.record("stop", target);
|
||||
let error = self.stop_error.lock().clone();
|
||||
Box::pin(async move { error.map_or(Ok(3), Err) })
|
||||
}
|
||||
|
||||
fn abort<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, AbortState> {
|
||||
self.record("abort", target);
|
||||
Box::pin(async { Ok(AbortState::Interrupted) })
|
||||
}
|
||||
|
||||
fn collect<'a>(&'a self, target: &'a VmTarget, _trace: TraceId, records: u64) -> InspectFuture<'a, TraceCollected> {
|
||||
self.record("collect", target);
|
||||
self.collect_records.lock().push(records);
|
||||
let error = self.collect_error.lock().clone();
|
||||
Box::pin(async move { error.map_or_else(|| Ok(collected()), Err) })
|
||||
}
|
||||
|
||||
fn release<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, ()> {
|
||||
self.record("release", target);
|
||||
Box::pin(async { Ok(()) })
|
||||
}
|
||||
|
||||
fn release_armed<'a>(&'a self, target: &'a VmTarget, _token: &'a str) -> InspectFuture<'a, ()> {
|
||||
self.record("releaseArmed", target);
|
||||
Box::pin(async { Ok(()) })
|
||||
}
|
||||
}
|
||||
|
||||
fn collected() -> TraceCollected {
|
||||
TraceCollected {
|
||||
records: vec![(0, JvmValue::Primitive { type_name: "int".into(), text: "1".into() })],
|
||||
dropped: 0,
|
||||
terminal: CollectedTerminal::Void,
|
||||
skipped_breakpoints: 0,
|
||||
sequentialized: false,
|
||||
}
|
||||
}
|
||||
|
||||
fn running(records: u64) -> TraceState {
|
||||
TraceState::Running { records, dropped: 0, elapsed_ms: 5 }
|
||||
}
|
||||
|
||||
fn parked() -> TraceState {
|
||||
TraceState::Parked { records: 10, dropped: 0 }
|
||||
}
|
||||
|
||||
/// java-debug keeps the program running after `continue` and stops right after a `stepOut`.
|
||||
fn java_debug() -> Script {
|
||||
Script { continue_reply: Some(json!({"allThreadsContinued": true})), step_out_stops: &[1], ..Script::default() }
|
||||
}
|
||||
|
||||
async fn stopped_java(h: &Harness, tracer: &Arc<FakeTracer>) -> DebugSessionId {
|
||||
let id = h.start(java_config("launch")).await.unwrap();
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
|
||||
h.manager.set_stream_tracer(id, tracer.clone()).unwrap();
|
||||
id
|
||||
}
|
||||
|
||||
async fn trace(h: &Harness, id: DebugSessionId) -> IdeResult<TraceRun> {
|
||||
let run = h.manager.stream_trace(id, 1, json!({"steps": []}), CancellationToken::new(), |_| {});
|
||||
tokio::time::timeout(Duration::from_secs(10), run).await.expect("the trace did not end")
|
||||
}
|
||||
|
||||
/// A trace in its own task, returned once it waits for the answers its tracer has not got.
|
||||
async fn hanging_trace(
|
||||
h: &Harness,
|
||||
id: DebugSessionId,
|
||||
tracer: &FakeTracer,
|
||||
) -> tokio::task::JoinHandle<IdeResult<TraceRun>> {
|
||||
hanging_trace_with(h, id, tracer, |_| {}).await
|
||||
}
|
||||
|
||||
async fn hanging_trace_with(
|
||||
h: &Harness,
|
||||
id: DebugSessionId,
|
||||
tracer: &FakeTracer,
|
||||
progress: impl Fn(TraceProgress) + Send + Sync + 'static,
|
||||
) -> tokio::task::JoinHandle<IdeResult<TraceRun>> {
|
||||
let manager = h.manager.clone();
|
||||
let task = tokio::spawn(async move {
|
||||
manager.stream_trace(id, 1, json!({"steps": []}), CancellationToken::new(), progress).await
|
||||
});
|
||||
tokio::time::timeout(Duration::from_secs(5), tracer.waiting.notified()).await.expect("the trace did not wait");
|
||||
task
|
||||
}
|
||||
|
||||
fn phases(seen: &Mutex<Vec<TraceProgress>>) -> Vec<TracePhase> {
|
||||
seen.lock().iter().map(|p| p.phase).collect()
|
||||
}
|
||||
|
||||
fn progress(phase: TracePhase, records: u64, elapsed_ms: u64) -> TraceProgress {
|
||||
TraceProgress { phase, records, dropped: 0, elapsed_ms }
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn trace_runs_continue_then_step_out() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([running(10), parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let start = h.manager.session(id).unwrap().suspended.ticket();
|
||||
|
||||
let run = trace(&h, id).await.unwrap();
|
||||
|
||||
let TraceRun::Done { collected: got, generation, resumed_stops } = run else { panic!("not done: {run:?}") };
|
||||
assert_eq!(got, collected());
|
||||
assert_eq!(resumed_stops, 0);
|
||||
assert!(generation > start, "collected in the stop of the trace ({start}), not after it ({generation})");
|
||||
let commands = h.commands();
|
||||
let resumed = commands.iter().position(|c| c == "continue").expect("no continue");
|
||||
let stepped = commands.iter().position(|c| c == "stepOut").expect("no stepOut");
|
||||
assert!(resumed < stepped, "{commands:?}");
|
||||
assert_eq!(h.request("continue")["arguments"]["threadId"], 1);
|
||||
assert_eq!(h.request("stepOut")["arguments"]["threadId"], 1);
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "wait", "collect"]);
|
||||
assert_eq!(*tracer.collect_records.lock(), [10], "collect is told how many records the trace parked with");
|
||||
assert_eq!(tracer.target_of("arm").generation, start);
|
||||
assert_eq!(tracer.target_of("collect").generation, generation);
|
||||
assert!(h.manager.session(id).unwrap().suspended.get());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn trace_reports_progress() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([running(10), parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
|
||||
let sink = seen.clone();
|
||||
|
||||
let run = h.manager.stream_trace(id, 1, json!({}), CancellationToken::new(), move |p| sink.lock().push(p)).await;
|
||||
|
||||
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
|
||||
assert_eq!(
|
||||
*seen.lock(),
|
||||
[
|
||||
progress(TracePhase::Arming, 0, 0),
|
||||
progress(TracePhase::Running, 10, 5),
|
||||
progress(TracePhase::Collecting, 10, 5),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn cancel_stops_recording_once() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([running(10), running(12), parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let cancel = CancellationToken::new();
|
||||
let on_running = cancel.clone();
|
||||
let seen: Arc<Mutex<Vec<TracePhase>>> = Arc::default();
|
||||
let sink = seen.clone();
|
||||
|
||||
let run = h
|
||||
.manager
|
||||
.stream_trace(id, 1, json!({}), cancel, move |p| {
|
||||
if p.phase == TracePhase::Running {
|
||||
on_running.cancel();
|
||||
}
|
||||
sink.lock().push(p.phase);
|
||||
})
|
||||
.await;
|
||||
|
||||
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "stop", "wait", "wait", "collect"]);
|
||||
assert_eq!(
|
||||
*seen.lock(),
|
||||
[
|
||||
TracePhase::Arming,
|
||||
TracePhase::Running,
|
||||
TracePhase::RecordingStopped,
|
||||
TracePhase::RecordingStopped,
|
||||
TracePhase::Collecting
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn second_trace_is_busy() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let first = hanging_trace(&h, id, &tracer).await;
|
||||
|
||||
let second = trace(&h, id).await.unwrap();
|
||||
|
||||
assert_eq!(second, TraceRun::Unavailable { reason: TraceUnavailable::Busy });
|
||||
assert_eq!(tracer.names().iter().filter(|n| **n == "arm").count(), 1);
|
||||
first.abort();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn trace_ends_when_session_ends() {
|
||||
// The fake adapter lets the program exit on `continue`.
|
||||
let h = harness(Script::default());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let session = h.manager.session(id).unwrap();
|
||||
|
||||
let run = trace(&h, id).await.unwrap();
|
||||
|
||||
assert_eq!(run, TraceRun::Failed { detail: "the debug session ended".into() });
|
||||
assert!(session.stream_trace.lock().is_none());
|
||||
let next = trace(&h, id).await;
|
||||
assert!(!matches!(next, Ok(TraceRun::Unavailable { reason: TraceUnavailable::Busy })), "{next:?}");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn dropping_the_trace_frees_the_session() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let first = hanging_trace(&h, id, &tracer).await;
|
||||
|
||||
first.abort();
|
||||
assert!(first.await.unwrap_err().is_cancelled());
|
||||
|
||||
let session = h.manager.session(id).unwrap();
|
||||
assert!(session.stream_trace.lock().is_none());
|
||||
// The first trace resumed the thread.
|
||||
session.suspended.stopped(Some(1), false);
|
||||
let again = hanging_trace(&h, id, &tracer).await;
|
||||
assert_eq!(tracer.names().iter().filter(|n| **n == "arm").count(), 2);
|
||||
again.abort();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn arm_errors_map_to_unavailable_or_failed() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
*tracer.arm_error.lock() = Some(InspectError::NotAtChainStart("the stop is on line 4".into()));
|
||||
assert_eq!(
|
||||
trace(&h, id).await.unwrap(),
|
||||
TraceRun::Unavailable { reason: TraceUnavailable::NotAtChainStart { detail: "the stop is on line 4".into() } }
|
||||
);
|
||||
*tracer.arm_error.lock() = Some(InspectError::TimedOut);
|
||||
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: InspectError::TimedOut.to_string() });
|
||||
assert!(!h.commands().iter().any(|c| c == "continue"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn abort_reaches_the_running_trace() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
assert_eq!(h.manager.stream_trace_abort(id).await.unwrap(), None);
|
||||
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
|
||||
let sink = seen.clone();
|
||||
let task = hanging_trace_with(&h, id, &tracer, move |p| sink.lock().push(p)).await;
|
||||
|
||||
assert_eq!(h.manager.stream_trace_abort(id).await.unwrap(), Some(AbortState::Interrupted));
|
||||
assert_eq!(tracer.target_of("abort"), tracer.target_of("arm"));
|
||||
|
||||
let thrown = "java.lang.RuntimeException: oi-cancel:1";
|
||||
tracer.waits.lock().extend([Ok(running(4)), Ok(TraceState::Failed { detail: thrown.into() })]);
|
||||
tracer.more.notify_one();
|
||||
let run = tokio::time::timeout(Duration::from_secs(5), task).await.unwrap().unwrap().unwrap();
|
||||
assert_eq!(run, TraceRun::Failed { detail: thrown.into() });
|
||||
assert_eq!(phases(&seen), [TracePhase::Arming, TracePhase::Aborting]);
|
||||
assert_eq!(tracer.names().last(), Some(&"release"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn failed_wait_passes_its_detail_through() {
|
||||
let h = harness(java_debug());
|
||||
let detail = "the program began to exit while the stream ran: stop the debug session";
|
||||
let tracer = FakeTracer::scripted([running(1), TraceState::Failed { detail: detail.into() }]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: detail.into() });
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "wait", "release"]);
|
||||
assert!(!h.commands().iter().any(|c| c == "stepOut"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_trace_cancelled_before_its_terminal_says_so() {
|
||||
let detail = "cancelled before the terminal ran";
|
||||
let tracer = FakeTracer::scripted([TraceState::Cancelled { detail: detail.into() }]);
|
||||
let h = harness(java_debug());
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Cancelled { detail: detail.into() });
|
||||
assert!(!h.commands().iter().any(|c| c == "stepOut"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_wait_that_errs_releases_the_trace() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::answering([Ok(running(1)), Err(InspectError::TimedOut)]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: InspectError::TimedOut.to_string() });
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "wait", "release"]);
|
||||
assert_eq!(tracer.target_of("release"), tracer.target_of("arm"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_refused_step_out_releases_the_trace() {
|
||||
let h = harness(Script { refuse_step_out: true, ..java_debug() });
|
||||
let tracer = FakeTracer::scripted([parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
let run = trace(&h, id).await.unwrap();
|
||||
|
||||
assert!(matches!(&run, TraceRun::Failed { detail } if detail.contains("not suspended")), "{run:?}");
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "release"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_refused_continue_releases_the_trace() {
|
||||
let h = harness(Script { refuse_continue: true, ..java_debug() });
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
let run = trace(&h, id).await.unwrap();
|
||||
|
||||
assert!(matches!(&run, TraceRun::Failed { .. }), "{run:?}");
|
||||
assert_eq!(tracer.names(), ["arm", "release"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_failed_collect_releases_the_trace() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([parked()]);
|
||||
*tracer.collect_error.lock() = Some(InspectError::Stale);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Failed { .. }));
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "collect", "release"]);
|
||||
}
|
||||
|
||||
fn stops(h: &Harness) -> usize {
|
||||
h.events.lock().iter().filter(|e| matches!(e, IdeEvent::Debug { event: DebugEvent::Stopped { .. }, .. })).count()
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_stop_of_the_traced_thread_while_the_chain_runs_is_resumed_unseen() {
|
||||
// A breakpoint java-debug set meanwhile, hit inside the terminal's invoke before the bundle
|
||||
// switched it off: held there, the invoke would never return.
|
||||
let h = harness(Script { breakpoints_after_continue: 1, ..java_debug() });
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let shown = stops(&h);
|
||||
let task = hanging_trace(&h, id, &tracer).await;
|
||||
|
||||
for _ in 0..200 {
|
||||
if h.commands().iter().filter(|c| *c == "continue").count() == 2 {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
assert_eq!(h.commands().iter().filter(|c| *c == "continue").count(), 2, "{:?}", h.commands());
|
||||
assert_eq!(h.log.lock().iter().rfind(|m| m["command"] == "continue").unwrap()["arguments"]["threadId"], 1);
|
||||
tracer.waits.lock().push_back(Ok(parked()));
|
||||
tracer.more.notify_one();
|
||||
let run = tokio::time::timeout(Duration::from_secs(5), task).await.unwrap().unwrap().unwrap();
|
||||
|
||||
let TraceRun::Done { resumed_stops, .. } = run else { panic!("not done: {run:?}") };
|
||||
assert_eq!(resumed_stops, 1);
|
||||
assert_eq!(stops(&h), shown + 1, "only the step-out stop is shown, after the trace parked");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_finished_trace_is_not_released() {
|
||||
// Releasing unpins the records, which the result's values still show until the program runs on.
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Done { .. }));
|
||||
assert!(!tracer.names().contains(&"release"), "{:?}", tracer.names());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_finished_trace_is_released_once_the_program_runs_on() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Done { .. }));
|
||||
|
||||
h.manager.resume(id, 1).await.unwrap();
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while !tracer.names().contains(&"release") {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.expect("the finished trace was not released");
|
||||
assert_eq!(tracer.names().iter().filter(|n| **n == "release").count(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn an_arm_without_a_reply_is_released_by_its_token() {
|
||||
// The bundle may still finish arming after the reply timed out: its breakpoints would stay off.
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
*tracer.arm_error.lock() = Some(InspectError::TimedOut);
|
||||
|
||||
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Failed { .. }));
|
||||
assert_eq!(tracer.names(), ["arm", "releaseArmed"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn refused_stop_leaves_the_outcome_to_wait() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([running(10), parked()]);
|
||||
*tracer.stop_error.lock() = Some(InspectError::NoTrace);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let cancel = CancellationToken::new();
|
||||
let on_running = cancel.clone();
|
||||
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
|
||||
let sink = seen.clone();
|
||||
|
||||
let run = h
|
||||
.manager
|
||||
.stream_trace(id, 1, json!({}), cancel, move |p| {
|
||||
if p.phase == TracePhase::Running {
|
||||
on_running.cancel();
|
||||
}
|
||||
sink.lock().push(p);
|
||||
})
|
||||
.await;
|
||||
|
||||
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "stop", "wait", "collect"]);
|
||||
assert_eq!(phases(&seen), [TracePhase::Arming, TracePhase::Running, TracePhase::Collecting]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn another_threads_stop_is_not_the_step_out() {
|
||||
// Thread 2 stops at a breakpoint 100 ms before the traced thread's step out ends.
|
||||
let h = harness(Script { step_out_stops: &[2, 1], ..java_debug() });
|
||||
let tracer = FakeTracer::scripted([parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let start = h.manager.session(id).unwrap().suspended.ticket();
|
||||
|
||||
let run = trace(&h, id).await.unwrap();
|
||||
|
||||
let TraceRun::Done { generation, .. } = run else { panic!("not done: {run:?}") };
|
||||
assert_eq!(
|
||||
generation,
|
||||
start + 2,
|
||||
"collected in thread 2's stop, not in the traced thread's step-out stop after it"
|
||||
);
|
||||
assert_eq!(tracer.target_of("collect").generation, generation);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn step_out_without_a_stop_times_out() {
|
||||
let h = harness(Script { step_out_stops: &[], ..java_debug() });
|
||||
let tracer = FakeTracer::scripted([parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
tokio::time::pause();
|
||||
|
||||
let run = h.manager.stream_trace(id, 1, json!({}), CancellationToken::new(), |_| {}).await.unwrap();
|
||||
|
||||
assert_eq!(
|
||||
run,
|
||||
TraceRun::Failed {
|
||||
detail: "java-debug reported no stop within 30 s of stepping out of the stream's terminal operation".into()
|
||||
}
|
||||
);
|
||||
assert!(h.commands().iter().any(|c| c == "stepOut"));
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "release"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn capability_only_for_java_debug() {
|
||||
let h = harness(Script::default());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let java = h.start(java_config("launch")).await.unwrap();
|
||||
assert!(!h.manager.capabilities(java).unwrap().stream_trace);
|
||||
h.manager.set_stream_tracer(java, tracer.clone()).unwrap();
|
||||
assert!(h.manager.capabilities(java).unwrap().stream_trace);
|
||||
|
||||
let other = h.start(config()).await.unwrap();
|
||||
h.manager.set_stream_tracer(other, tracer.clone()).unwrap();
|
||||
assert!(!h.manager.capabilities(other).unwrap().stream_trace);
|
||||
}
|
||||
@@ -14,6 +14,7 @@ mod snowflake;
|
||||
pub mod source;
|
||||
pub mod split;
|
||||
pub mod sql;
|
||||
pub mod tools;
|
||||
mod watch;
|
||||
pub use watch::SourcesWatch;
|
||||
|
||||
@@ -787,6 +788,56 @@ impl DbManager {
|
||||
Ok(v.unwrap_or_else(|| "Connected".into()))
|
||||
}
|
||||
|
||||
/// Runs `job` with the client tool at `executable` against target `id`, connected like the
|
||||
/// data source (through its SSH tunnel, with its SSL settings and password), until it exits
|
||||
/// or `cancel` fires. Connects first, so a missing password fails the way it does for a
|
||||
/// console. Returns the exit code.
|
||||
pub async fn run_tool(
|
||||
&self,
|
||||
id: &str,
|
||||
executable: &std::path::Path,
|
||||
job: &tools::DbToolJob,
|
||||
cancel: &CancellationToken,
|
||||
on_output: impl FnMut(Vec<tools::ToolLine>),
|
||||
) -> IdeResult<Option<i32>> {
|
||||
let tool = job.tool();
|
||||
if !tool.is_program(executable) {
|
||||
return Err(IdeError::invalid(format!("{} is not {}", executable.display(), tool.program())));
|
||||
}
|
||||
let source = self.source(id)?;
|
||||
if source.driver != tool.driver() {
|
||||
return Err(IdeError::invalid(format!("{} cannot connect to {}", tool.program(), source.name)));
|
||||
}
|
||||
self.pool(id).await?;
|
||||
let password = self.password(&source).await;
|
||||
// Holding the tunnel keeps it open while the tool runs, even if the tree disconnects.
|
||||
let (target, _tunnel) = self.endpoint(&source, None, true).await?;
|
||||
let prepared = tools::prepare(job, &target, password.as_deref());
|
||||
tools::run(executable, &prepared.args, &prepared.env, cancel, on_output).await
|
||||
}
|
||||
|
||||
/// The command [`DbManager::run_tool`] would run, for the dialogs' preview: the data source's
|
||||
/// own host and port (not a tunnel's local end), and no password.
|
||||
pub fn tool_preview(&self, id: &str, executable: &std::path::Path, job: &tools::DbToolJob) -> IdeResult<String> {
|
||||
let source = self.source(id)?;
|
||||
let prepared = tools::prepare(job, &source, None);
|
||||
Ok(tools::command_line(executable, &prepared.args))
|
||||
}
|
||||
|
||||
/// The PostgreSQL server's `server_version_num` (`150013` for 15.13).
|
||||
pub async fn server_version(&self, id: &str) -> IdeResult<u32> {
|
||||
let pool = self.pool(id).await?;
|
||||
if pool.driver() != DbDriver::Postgres {
|
||||
return Err(IdeError::invalid("not a PostgreSQL data source"));
|
||||
}
|
||||
let rows = pool.rows("SHOW server_version_num", 1).await?;
|
||||
rows.into_iter()
|
||||
.next()
|
||||
.and_then(|r| r.into_iter().next().flatten())
|
||||
.and_then(|v| v.trim().parse().ok())
|
||||
.ok_or_else(|| IdeError::internal("no server version"))
|
||||
}
|
||||
|
||||
pub fn is_connected(&self, id: &str) -> bool {
|
||||
self.pools.lock().contains_key(id)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,341 @@
|
||||
//! What a dump or restore dialog asks for, as typed options, and the arguments that do it.
|
||||
//! The connection arguments come from [`super::connection`]; these are the rest.
|
||||
|
||||
use super::DbTool;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::path::Path;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum DbDumpFormat {
|
||||
/// SQL text, restored with `psql`.
|
||||
Plain,
|
||||
Custom,
|
||||
/// A directory of files; the only format `pg_dump` writes in parallel.
|
||||
Directory,
|
||||
Tar,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum DbDumpStatements {
|
||||
Copy,
|
||||
Inserts,
|
||||
ColumnInserts,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum DbDumpContent {
|
||||
All,
|
||||
SchemaOnly,
|
||||
DataOnly,
|
||||
}
|
||||
|
||||
/// Name lists hold `pg_dump` patterns (`*`, `?`, quoted names).
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct DbPgDumpOptions {
|
||||
pub format: DbDumpFormat,
|
||||
pub statements: DbDumpStatements,
|
||||
pub content: DbDumpContent,
|
||||
pub schemas: Vec<String>,
|
||||
pub tables: Vec<String>,
|
||||
pub exclude_tables: Vec<String>,
|
||||
/// Plain format only: archives get DROP / CREATE at restore.
|
||||
pub clean: bool,
|
||||
pub if_exists: bool,
|
||||
pub create: bool,
|
||||
pub no_owner: bool,
|
||||
pub no_privileges: bool,
|
||||
/// Directory format only.
|
||||
pub jobs: u32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct DbPgRestoreOptions {
|
||||
pub content: DbDumpContent,
|
||||
pub schemas: Vec<String>,
|
||||
pub clean: bool,
|
||||
pub if_exists: bool,
|
||||
pub no_owner: bool,
|
||||
pub no_privileges: bool,
|
||||
pub single_transaction: bool,
|
||||
pub exit_on_error: bool,
|
||||
/// Ignored with a single transaction, which `pg_restore` cannot split.
|
||||
pub jobs: u32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct DbPsqlOptions {
|
||||
pub single_transaction: bool,
|
||||
pub stop_on_error: bool,
|
||||
}
|
||||
|
||||
/// A run of a client tool: which one, the file it writes or reads, and its options.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "tool", rename_all = "camelCase")]
|
||||
pub enum DbToolJob {
|
||||
PgDump {
|
||||
file: String,
|
||||
options: DbPgDumpOptions,
|
||||
},
|
||||
/// `file`: an archive, or a directory archive.
|
||||
PgRestore {
|
||||
file: String,
|
||||
options: DbPgRestoreOptions,
|
||||
},
|
||||
Psql {
|
||||
file: String,
|
||||
options: DbPsqlOptions,
|
||||
},
|
||||
}
|
||||
|
||||
impl DbToolJob {
|
||||
pub fn tool(&self) -> DbTool {
|
||||
match self {
|
||||
DbToolJob::PgDump { .. } => DbTool::PgDump,
|
||||
DbToolJob::PgRestore { .. } => DbTool::PgRestore,
|
||||
DbToolJob::Psql { .. } => DbTool::Psql,
|
||||
}
|
||||
}
|
||||
|
||||
/// The arguments after the connection ones.
|
||||
pub fn args(&self) -> Vec<String> {
|
||||
match self {
|
||||
DbToolJob::PgDump { file, options } => pg_dump(options, file),
|
||||
DbToolJob::PgRestore { file, options } => pg_restore(options, file),
|
||||
DbToolJob::Psql { file, options } => psql(options, file),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn flag(on: bool, flag: &str) -> Option<String> {
|
||||
on.then(|| flag.to_owned())
|
||||
}
|
||||
|
||||
fn content(c: DbDumpContent) -> Option<String> {
|
||||
match c {
|
||||
DbDumpContent::All => None,
|
||||
DbDumpContent::SchemaOnly => Some("--schema-only".into()),
|
||||
DbDumpContent::DataOnly => Some("--data-only".into()),
|
||||
}
|
||||
}
|
||||
|
||||
fn each(names: &[String], option: &str) -> impl Iterator<Item = String> {
|
||||
names.iter().map(|n| n.trim()).filter(|n| !n.is_empty()).map(move |n| format!("--{option}={n}"))
|
||||
}
|
||||
|
||||
fn pg_dump(o: &DbPgDumpOptions, file: &str) -> Vec<String> {
|
||||
let plain = o.format == DbDumpFormat::Plain;
|
||||
let format = match o.format {
|
||||
DbDumpFormat::Plain => "p",
|
||||
DbDumpFormat::Custom => "c",
|
||||
DbDumpFormat::Directory => "d",
|
||||
DbDumpFormat::Tar => "t",
|
||||
};
|
||||
let mut args = vec![format!("--format={format}"), format!("--file={file}")];
|
||||
args.extend(match o.statements {
|
||||
DbDumpStatements::Copy => None,
|
||||
DbDumpStatements::Inserts => Some("--inserts".to_owned()),
|
||||
DbDumpStatements::ColumnInserts => Some("--column-inserts".to_owned()),
|
||||
});
|
||||
args.extend(content(o.content));
|
||||
args.extend(each(&o.schemas, "schema"));
|
||||
args.extend(each(&o.tables, "table"));
|
||||
args.extend(each(&o.exclude_tables, "exclude-table"));
|
||||
args.extend(flag(plain && o.clean, "--clean"));
|
||||
args.extend(flag(plain && o.clean && o.if_exists, "--if-exists"));
|
||||
args.extend(flag(plain && o.create, "--create"));
|
||||
args.extend(flag(o.no_owner, "--no-owner"));
|
||||
args.extend(flag(o.no_privileges, "--no-privileges"));
|
||||
if o.format == DbDumpFormat::Directory && o.jobs > 1 {
|
||||
args.push(format!("--jobs={}", o.jobs));
|
||||
}
|
||||
args.push("--verbose".into());
|
||||
args
|
||||
}
|
||||
|
||||
fn pg_restore(o: &DbPgRestoreOptions, file: &str) -> Vec<String> {
|
||||
let mut args: Vec<String> = content(o.content).into_iter().collect();
|
||||
args.extend(each(&o.schemas, "schema"));
|
||||
args.extend(flag(o.clean, "--clean"));
|
||||
args.extend(flag(o.clean && o.if_exists, "--if-exists"));
|
||||
args.extend(flag(o.no_owner, "--no-owner"));
|
||||
args.extend(flag(o.no_privileges, "--no-privileges"));
|
||||
args.extend(flag(o.single_transaction, "--single-transaction"));
|
||||
args.extend(flag(o.exit_on_error, "--exit-on-error"));
|
||||
if o.jobs > 1 && !o.single_transaction {
|
||||
args.push(format!("--jobs={}", o.jobs));
|
||||
}
|
||||
args.push("--verbose".into());
|
||||
if !file.is_empty() {
|
||||
args.push(file.to_owned());
|
||||
}
|
||||
args
|
||||
}
|
||||
|
||||
fn psql(o: &DbPsqlOptions, file: &str) -> Vec<String> {
|
||||
// `~/.psqlrc` could switch databases or change settings before the dump runs.
|
||||
let mut args = vec!["--no-psqlrc".to_owned()];
|
||||
args.extend((!file.is_empty()).then(|| format!("--file={file}")));
|
||||
args.extend(flag(o.single_transaction, "--single-transaction"));
|
||||
args.extend(flag(o.stop_on_error, "--set=ON_ERROR_STOP=1"));
|
||||
args
|
||||
}
|
||||
|
||||
/// The command as a shell would need it typed: the dialogs' preview.
|
||||
pub fn command_line(program: &Path, args: &[String]) -> String {
|
||||
let quote = |s: &str| {
|
||||
if !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || "@%+=:,./-_".contains(c)) {
|
||||
s.to_owned()
|
||||
} else {
|
||||
format!("'{}'", s.replace('\'', "'\\''"))
|
||||
}
|
||||
};
|
||||
std::iter::once(program.to_string_lossy().into_owned())
|
||||
.chain(args.iter().cloned())
|
||||
.map(|a| quote(&a))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn dump() -> DbPgDumpOptions {
|
||||
DbPgDumpOptions {
|
||||
format: DbDumpFormat::Plain,
|
||||
statements: DbDumpStatements::Copy,
|
||||
content: DbDumpContent::All,
|
||||
schemas: vec![],
|
||||
tables: vec![],
|
||||
exclude_tables: vec![],
|
||||
clean: false,
|
||||
if_exists: false,
|
||||
create: false,
|
||||
no_owner: false,
|
||||
no_privileges: false,
|
||||
jobs: 1,
|
||||
}
|
||||
}
|
||||
|
||||
fn restore() -> DbPgRestoreOptions {
|
||||
DbPgRestoreOptions {
|
||||
content: DbDumpContent::All,
|
||||
schemas: vec![],
|
||||
clean: false,
|
||||
if_exists: false,
|
||||
no_owner: false,
|
||||
no_privileges: false,
|
||||
single_transaction: false,
|
||||
exit_on_error: true,
|
||||
jobs: 1,
|
||||
}
|
||||
}
|
||||
|
||||
fn args(job: DbToolJob) -> Vec<String> {
|
||||
job.args()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dumps_plain_sql_with_copy_by_default() {
|
||||
let job = DbToolJob::PgDump { file: "/tmp/shop.sql".into(), options: dump() };
|
||||
assert_eq!(args(job), ["--format=p", "--file=/tmp/shop.sql", "--verbose"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn turns_lists_and_switches_into_flags() {
|
||||
let options = DbPgDumpOptions {
|
||||
statements: DbDumpStatements::ColumnInserts,
|
||||
content: DbDumpContent::DataOnly,
|
||||
schemas: vec!["public".into(), "audit".into()],
|
||||
tables: vec!["public.orders".into()],
|
||||
exclude_tables: vec!["public.log_*".into()],
|
||||
clean: true,
|
||||
if_exists: true,
|
||||
create: true,
|
||||
no_owner: true,
|
||||
..dump()
|
||||
};
|
||||
assert_eq!(
|
||||
args(DbToolJob::PgDump { file: "/tmp/x.sql".into(), options }),
|
||||
[
|
||||
"--format=p",
|
||||
"--file=/tmp/x.sql",
|
||||
"--column-inserts",
|
||||
"--data-only",
|
||||
"--schema=public",
|
||||
"--schema=audit",
|
||||
"--table=public.orders",
|
||||
"--exclude-table=public.log_*",
|
||||
"--clean",
|
||||
"--if-exists",
|
||||
"--create",
|
||||
"--no-owner",
|
||||
"--verbose",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn leaves_drop_and_create_to_the_restore_of_an_archive() {
|
||||
let options = DbPgDumpOptions { format: DbDumpFormat::Custom, clean: true, create: true, ..dump() };
|
||||
let a = args(DbToolJob::PgDump { file: "/tmp/x.dump".into(), options });
|
||||
assert!(!a.iter().any(|a| a == "--clean" || a == "--create"), "{a:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn runs_parallel_jobs_only_where_the_tool_can() {
|
||||
let dir = DbPgDumpOptions { format: DbDumpFormat::Directory, jobs: 4, ..dump() };
|
||||
assert!(args(DbToolJob::PgDump { file: "/tmp/d".into(), options: dir.clone() }).contains(&"--jobs=4".into()));
|
||||
let custom = DbPgDumpOptions { format: DbDumpFormat::Custom, ..dir };
|
||||
assert!(!args(DbToolJob::PgDump { file: "/tmp/d".into(), options: custom }).contains(&"--jobs=4".into()));
|
||||
let single = DbPgRestoreOptions { jobs: 4, single_transaction: true, ..restore() };
|
||||
let a = args(DbToolJob::PgRestore { file: "/tmp/x".into(), options: single });
|
||||
assert!(a.contains(&"--single-transaction".into()) && !a.iter().any(|a| a.starts_with("--jobs")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn restores_the_archive_named_last_and_stops_on_the_first_error() {
|
||||
assert_eq!(
|
||||
args(DbToolJob::PgRestore { file: "/tmp/shop.dump".into(), options: restore() }),
|
||||
["--exit-on-error", "--verbose", "/tmp/shop.dump"]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn leaves_out_an_archive_not_chosen_yet() {
|
||||
let a = args(DbToolJob::PgRestore { file: String::new(), options: restore() });
|
||||
assert_eq!(a, ["--exit-on-error", "--verbose"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn runs_a_sql_file_in_one_transaction_that_stops_on_error() {
|
||||
let options = DbPsqlOptions { single_transaction: true, stop_on_error: true };
|
||||
assert_eq!(
|
||||
args(DbToolJob::Psql { file: "/tmp/shop.sql".into(), options }),
|
||||
["--no-psqlrc", "--file=/tmp/shop.sql", "--single-transaction", "--set=ON_ERROR_STOP=1"]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn quotes_what_a_shell_would_split() {
|
||||
let line = command_line(
|
||||
Path::new("/usr/bin/pg_dump"),
|
||||
&["--port=5432".into(), "--file=/tmp/my dump.sql".into(), "--table=it's".into()],
|
||||
);
|
||||
assert_eq!(line, r#"/usr/bin/pg_dump --port=5432 '--file=/tmp/my dump.sql' '--table=it'\''s'"#);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_the_job_the_dialog_sends() {
|
||||
let json = r#"{"tool":"psql","file":"/tmp/a.sql","options":{"singleTransaction":true,"stopOnError":false}}"#;
|
||||
let job: DbToolJob = serde_json::from_str(json).unwrap();
|
||||
assert_eq!(job.tool(), DbTool::Psql);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,558 @@
|
||||
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`): finding installed copies, the
|
||||
//! arguments and environment that connect them like the data source, and running them.
|
||||
|
||||
mod jobs;
|
||||
pub use jobs::*;
|
||||
|
||||
use crate::source::{DataSource, DbDriver, DbSslMode};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::ffi::OsStr;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Stdio;
|
||||
use std::time::Duration;
|
||||
use tokio::io::{AsyncBufReadExt, AsyncRead, BufReader};
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum DbTool {
|
||||
PgDump,
|
||||
PgRestore,
|
||||
Psql,
|
||||
}
|
||||
|
||||
impl DbTool {
|
||||
pub fn program(self) -> &'static str {
|
||||
self.programs()[0]
|
||||
}
|
||||
|
||||
/// Executable names.
|
||||
pub fn programs(self) -> &'static [&'static str] {
|
||||
match self {
|
||||
DbTool::PgDump => &["pg_dump"],
|
||||
DbTool::PgRestore => &["pg_restore"],
|
||||
DbTool::Psql => &["psql"],
|
||||
}
|
||||
}
|
||||
|
||||
pub fn driver(self) -> DbDriver {
|
||||
DbDriver::Postgres
|
||||
}
|
||||
|
||||
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`…).
|
||||
/// The data source's password is handed only to such a program.
|
||||
pub fn is_program(self, path: &Path) -> bool {
|
||||
let Some(stem) = path.file_stem().and_then(OsStr::to_str) else { return false };
|
||||
self.programs().iter().any(|p| {
|
||||
stem.strip_prefix(p).is_some_and(|rest| {
|
||||
let digits = rest.strip_prefix(['-', '.', '_']).unwrap_or(rest);
|
||||
digits.chars().all(|c| c.is_ascii_digit())
|
||||
})
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// An installed copy of a tool.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase", rename = "DbToolInstall")]
|
||||
pub struct ToolInstall {
|
||||
pub path: String,
|
||||
/// First line of `--version`, e.g. `pg_dump (PostgreSQL) 17.2`.
|
||||
pub version: String,
|
||||
}
|
||||
|
||||
/// A line the tool wrote.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase", rename = "DbToolLine")]
|
||||
pub struct ToolLine {
|
||||
pub stderr: bool,
|
||||
pub text: String,
|
||||
}
|
||||
|
||||
/// Directories holding the tools that are often missing from `PATH`, by platform.
|
||||
fn known_dirs() -> Vec<PathBuf> {
|
||||
let mut dirs = Vec::new();
|
||||
if cfg!(target_os = "macos") {
|
||||
for prefix in ["/opt/homebrew", "/usr/local"] {
|
||||
dirs.push(PathBuf::from(format!("{prefix}/bin")));
|
||||
let opt = PathBuf::from(format!("{prefix}/opt"));
|
||||
for keg in ["libpq", "postgresql"] {
|
||||
dirs.extend(children(&opt, keg).into_iter().map(|d| d.join("bin")));
|
||||
}
|
||||
}
|
||||
dirs.extend(
|
||||
children(Path::new("/Applications/Postgres.app/Contents/Versions"), "").into_iter().map(|d| d.join("bin")),
|
||||
);
|
||||
} else if cfg!(windows) {
|
||||
for var in ["ProgramFiles", "ProgramFiles(x86)"] {
|
||||
if let Some(base) = std::env::var_os(var) {
|
||||
let root = PathBuf::from(base).join("PostgreSQL");
|
||||
dirs.extend(children(&root, "").into_iter().map(|d| d.join("bin")));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
dirs.extend(children(Path::new("/usr/lib/postgresql"), "").into_iter().map(|d| d.join("bin")));
|
||||
dirs.extend(children(Path::new("/usr"), "pgsql-").into_iter().map(|d| d.join("bin")));
|
||||
}
|
||||
dirs
|
||||
}
|
||||
|
||||
/// Subdirectories of `parent` whose name starts with `prefix`, newest version first.
|
||||
fn children(parent: &Path, prefix: &str) -> Vec<PathBuf> {
|
||||
let Ok(entries) = std::fs::read_dir(parent) else { return Vec::new() };
|
||||
let mut dirs: Vec<PathBuf> = entries
|
||||
.flatten()
|
||||
.filter(|e| e.file_name().to_str().is_some_and(|n| n.starts_with(prefix)))
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.is_dir())
|
||||
.collect();
|
||||
dirs.sort_by_key(|p| std::cmp::Reverse(version_key(&p.to_string_lossy())));
|
||||
dirs
|
||||
}
|
||||
|
||||
/// The numbers in `text`, for comparing versions (`17.2` after `9.6`).
|
||||
fn version_key(text: &str) -> Vec<u32> {
|
||||
text.split(|c: char| !c.is_ascii_digit()).filter_map(|n| n.parse().ok()).collect()
|
||||
}
|
||||
|
||||
/// The installed copies of `tool` on `PATH` and in the usual install directories, newest first.
|
||||
/// Blocking: runs each one's `--version`.
|
||||
pub fn find_installs(tool: DbTool) -> Vec<ToolInstall> {
|
||||
let path = ide_core::process::host_var_os("PATH").unwrap_or_default();
|
||||
let mut dirs: Vec<PathBuf> = std::env::split_paths(&path).collect();
|
||||
dirs.extend(known_dirs());
|
||||
let mut seen = Vec::new();
|
||||
let mut out = Vec::new();
|
||||
for dir in dirs {
|
||||
for program in tool.programs() {
|
||||
let Some(found) = ide_core::process::find_executable(program, dir.as_os_str()) else { continue };
|
||||
let real = dunce::canonicalize(&found).unwrap_or_else(|_| found.clone());
|
||||
if seen.contains(&real) {
|
||||
continue;
|
||||
}
|
||||
seen.push(real);
|
||||
if let Ok(version) = version_of(&found) {
|
||||
out.push(ToolInstall { path: found.to_string_lossy().into_owned(), version });
|
||||
}
|
||||
}
|
||||
}
|
||||
out.sort_by_key(|i| std::cmp::Reverse(version_key(&i.version)));
|
||||
out
|
||||
}
|
||||
|
||||
/// The first line `path --version` prints. Blocking.
|
||||
pub fn version_of(path: &Path) -> IdeResult<String> {
|
||||
let (ok, text) = capture(path, "--version")?;
|
||||
match text.lines().next().map(str::trim).filter(|l| !l.is_empty()) {
|
||||
Some(line) if ok => Ok(line.to_owned()),
|
||||
_ => Err(IdeError::invalid(format!("{} is not a working executable", path.display()))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs `path arg` for at most five seconds; whether it succeeded, and its standard output.
|
||||
fn capture(path: &Path, arg: &str) -> IdeResult<(bool, String)> {
|
||||
if !path.is_file() {
|
||||
return Err(IdeError::not_found(format!("{} does not exist", path.display())));
|
||||
}
|
||||
let mut cmd = std::process::Command::new(path);
|
||||
cmd.arg(arg).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
|
||||
ide_core::process::prepare(&mut cmd);
|
||||
let mut child = cmd.spawn().map_err(|e| IdeError::invalid(format!("cannot run {}: {e}", path.display())))?;
|
||||
let mut stdout = child.stdout.take().expect("piped");
|
||||
let reader = std::thread::spawn(move || {
|
||||
let mut buf = Vec::new();
|
||||
let _ = std::io::Read::read_to_end(&mut stdout, &mut buf);
|
||||
buf
|
||||
});
|
||||
let deadline = std::time::Instant::now() + Duration::from_secs(5);
|
||||
let status = loop {
|
||||
if let Some(status) = child.try_wait()? {
|
||||
break status;
|
||||
}
|
||||
if std::time::Instant::now() > deadline {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
return Err(IdeError::invalid(format!("{} {arg} did not finish", path.display())));
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
};
|
||||
let out = reader.join().unwrap_or_default();
|
||||
Ok((status.success(), String::from_utf8_lossy(&out).into_owned()))
|
||||
}
|
||||
|
||||
/// What made a dump, read from its first bytes (a directory: its `toc.dat`).
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum DbDumpKind {
|
||||
/// `pg_dump` custom or tar archive, or a directory archive: `pg_restore`.
|
||||
PostgresArchive,
|
||||
/// Plain SQL from `pg_dump`: `psql`.
|
||||
PostgresSql,
|
||||
/// `mysqldump` / `mariadb-dump`: not for the PostgreSQL tools.
|
||||
MysqlSql,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
/// Blocking: reads at most the first 4 KiB.
|
||||
pub fn dump_kind(path: &Path) -> IdeResult<DbDumpKind> {
|
||||
use std::io::Read;
|
||||
if path.is_dir() {
|
||||
return Ok(if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown });
|
||||
}
|
||||
let mut head = Vec::with_capacity(4096);
|
||||
std::fs::File::open(path)
|
||||
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?
|
||||
.take(4096)
|
||||
.read_to_end(&mut head)?;
|
||||
Ok(kind_of(&head))
|
||||
}
|
||||
|
||||
fn kind_of(head: &[u8]) -> DbDumpKind {
|
||||
// A tar archive keeps `toc.dat` first; its name starts the 512-byte header.
|
||||
if head.starts_with(b"PGDMP") || head.starts_with(b"toc.dat\0") {
|
||||
return DbDumpKind::PostgresArchive;
|
||||
}
|
||||
let text = String::from_utf8_lossy(head);
|
||||
let comments: Vec<&str> = text.lines().take(20).filter(|l| l.starts_with("--")).collect();
|
||||
if comments.iter().any(|l| l.contains("PostgreSQL database dump")) {
|
||||
DbDumpKind::PostgresSql
|
||||
} else if comments.iter().any(|l| l.starts_with("-- MySQL dump") || l.starts_with("-- MariaDB dump")) {
|
||||
DbDumpKind::MysqlSql
|
||||
} else {
|
||||
DbDumpKind::Unknown
|
||||
}
|
||||
}
|
||||
|
||||
/// Arguments and environment that connect `tool` to `source` (already resolved, through its
|
||||
/// tunnel when it has one). The password is left to [`prepare`].
|
||||
pub fn connection(tool: DbTool, source: &DataSource) -> (Vec<String>, Vec<(String, String)>) {
|
||||
let mut args = Vec::new();
|
||||
let host = source.host.trim();
|
||||
if !host.is_empty() {
|
||||
args.push(format!("--host={host}"));
|
||||
}
|
||||
args.push(format!("--port={}", source.port.or(source.driver.default_port()).unwrap_or(5432)));
|
||||
if !source.user.trim().is_empty() {
|
||||
args.push(format!("--username={}", source.user.trim()));
|
||||
}
|
||||
if !source.database.is_empty() {
|
||||
args.push(format!("--dbname={}", dbname_arg(&source.database)));
|
||||
}
|
||||
// Without a terminal a password prompt would wait forever: fail instead.
|
||||
args.push("--no-password".into());
|
||||
|
||||
let mut env = vec![
|
||||
("PGAPPNAME".to_owned(), format!("OpenIDEA {}", tool.program())),
|
||||
(
|
||||
"PGSSLMODE".to_owned(),
|
||||
match source.ssl {
|
||||
DbSslMode::Disable => "disable",
|
||||
DbSslMode::Prefer => "prefer",
|
||||
DbSslMode::Require => "require",
|
||||
DbSslMode::VerifyCa => "verify-ca",
|
||||
DbSslMode::VerifyFull => "verify-full",
|
||||
}
|
||||
.to_owned(),
|
||||
),
|
||||
];
|
||||
for (var, file) in [
|
||||
("PGSSLROOTCERT", &source.ssl_ca_file),
|
||||
("PGSSLCERT", &source.ssl_cert_file),
|
||||
("PGSSLKEY", &source.ssl_key_file),
|
||||
] {
|
||||
if !file.trim().is_empty() {
|
||||
env.push((var.to_owned(), ide_ssh::expand(file.trim()).to_string_lossy().into_owned()));
|
||||
}
|
||||
}
|
||||
if source.read_only {
|
||||
env.push(("PGOPTIONS".to_owned(), "-c default_transaction_read_only=on".to_owned()));
|
||||
}
|
||||
(args, env)
|
||||
}
|
||||
|
||||
/// `--dbname` reads a connection string or URI as connection parameters: such a database name
|
||||
/// goes in quoted as the string's `dbname`, so it cannot pick another host or credentials.
|
||||
fn dbname_arg(name: &str) -> String {
|
||||
if name.contains('=') || name.starts_with("postgresql://") || name.starts_with("postgres://") {
|
||||
format!("dbname='{}'", name.replace('\\', "\\\\").replace('\'', "\\'"))
|
||||
} else {
|
||||
name.to_owned()
|
||||
}
|
||||
}
|
||||
|
||||
/// How a tool is started: connection arguments, then the job's, and the environment.
|
||||
pub struct Prepared {
|
||||
pub args: Vec<String>,
|
||||
pub env: Vec<(String, String)>,
|
||||
}
|
||||
|
||||
/// The command for `job` against `source`. The password goes in `PGPASSWORD`, never in the
|
||||
/// arguments, which other users of the machine can read in the process list.
|
||||
pub fn prepare(job: &DbToolJob, source: &DataSource, password: Option<&str>) -> Prepared {
|
||||
let (mut args, mut env) = connection(job.tool(), source);
|
||||
args.extend(job.args());
|
||||
if let Some(p) = password.filter(|p| !p.is_empty()) {
|
||||
env.push(("PGPASSWORD".into(), p.to_owned()));
|
||||
}
|
||||
Prepared { args, env }
|
||||
}
|
||||
|
||||
/// Runs `program` until it exits, passing its output in batches. Returns the exit code
|
||||
/// (`None`: ended by a signal). Cancelling kills it and everything it started.
|
||||
pub async fn run(
|
||||
program: &Path,
|
||||
args: &[String],
|
||||
env: &[(String, String)],
|
||||
cancel: &CancellationToken,
|
||||
mut on_output: impl FnMut(Vec<ToolLine>),
|
||||
) -> IdeResult<Option<i32>> {
|
||||
let mut cmd = tokio::process::Command::new(program);
|
||||
cmd.args(args)
|
||||
.envs(env.iter().map(|(k, v)| (k, v)))
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.kill_on_drop(true);
|
||||
ide_core::process::prepare(cmd.as_std_mut());
|
||||
ide_core::process::own_group(cmd.as_std_mut());
|
||||
let mut child = cmd.spawn().map_err(|e| IdeError::invalid(format!("cannot start {}: {e}", program.display())))?;
|
||||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
if let Some(out) = child.stdout.take() {
|
||||
forward(out, false, tx.clone());
|
||||
}
|
||||
if let Some(err) = child.stderr.take() {
|
||||
forward(err, true, tx);
|
||||
}
|
||||
|
||||
let mut batch = Vec::new();
|
||||
let mut tick = tokio::time::interval(Duration::from_millis(100));
|
||||
loop {
|
||||
tokio::select! {
|
||||
line = rx.recv() => match line {
|
||||
Some(line) => {
|
||||
batch.push(line);
|
||||
if batch.len() >= 500 {
|
||||
on_output(std::mem::take(&mut batch));
|
||||
}
|
||||
}
|
||||
None => break,
|
||||
},
|
||||
_ = tick.tick() => {
|
||||
if !batch.is_empty() {
|
||||
on_output(std::mem::take(&mut batch));
|
||||
}
|
||||
}
|
||||
_ = cancel.cancelled() => {
|
||||
if let Some(pid) = child.id() {
|
||||
ide_core::process::kill_tree_of(pid);
|
||||
}
|
||||
let _ = child.kill().await;
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
}
|
||||
}
|
||||
if !batch.is_empty() {
|
||||
on_output(batch);
|
||||
}
|
||||
let status = tokio::select! {
|
||||
status = child.wait() => status?,
|
||||
_ = cancel.cancelled() => {
|
||||
if let Some(pid) = child.id() {
|
||||
ide_core::process::kill_tree_of(pid);
|
||||
}
|
||||
let _ = child.kill().await;
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
};
|
||||
Ok(status.code())
|
||||
}
|
||||
|
||||
fn forward(
|
||||
pipe: impl AsyncRead + Unpin + Send + 'static,
|
||||
stderr: bool,
|
||||
tx: tokio::sync::mpsc::UnboundedSender<ToolLine>,
|
||||
) {
|
||||
tokio::spawn(async move {
|
||||
let mut reader = BufReader::new(pipe);
|
||||
let mut buf = Vec::new();
|
||||
loop {
|
||||
buf.clear();
|
||||
match reader.read_until(b'\n', &mut buf).await {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(_) => {
|
||||
let text = String::from_utf8_lossy(&buf).trim_end_matches(['\r', '\n']).to_owned();
|
||||
if tx.send(ToolLine { stderr, text }).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn pg() -> DataSource {
|
||||
DataSource {
|
||||
driver: DbDriver::Postgres,
|
||||
host: "db.example.test".into(),
|
||||
port: Some(6543),
|
||||
user: "app".into(),
|
||||
database: "shop".into(),
|
||||
..DataSource::default()
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn connects_like_the_data_source_without_prompting() {
|
||||
let (args, env) = connection(DbTool::PgDump, &pg());
|
||||
assert_eq!(args, ["--host=db.example.test", "--port=6543", "--username=app", "--dbname=shop", "--no-password"]);
|
||||
assert!(env.contains(&("PGSSLMODE".into(), "prefer".into())));
|
||||
assert!(!env.iter().any(|(k, _)| k == "PGPASSWORD" || k == "PGOPTIONS"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_database_named_like_connection_parameters_stays_a_name() {
|
||||
for (name, arg) in [
|
||||
("host=evil.example dbname=p", r"--dbname=dbname='host=evil.example dbname=p'"),
|
||||
(r"it's=\x", r"--dbname=dbname='it\'s=\\x'"),
|
||||
("postgresql://evil.example/p", "--dbname=dbname='postgresql://evil.example/p'"),
|
||||
] {
|
||||
let (args, _) = connection(DbTool::PgDump, &DataSource { database: name.into(), ..pg() });
|
||||
assert!(args.contains(&arg.to_owned()), "{args:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn default_port_and_optional_fields() {
|
||||
let source = DataSource { port: None, user: String::new(), database: String::new(), ..pg() };
|
||||
let (args, _) = connection(DbTool::Psql, &source);
|
||||
assert_eq!(args, ["--host=db.example.test", "--port=5432", "--no-password"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_only_sources_refuse_writes() {
|
||||
let source = DataSource { read_only: true, ssl: DbSslMode::VerifyFull, ..pg() };
|
||||
let (_, env) = connection(DbTool::PgRestore, &source);
|
||||
assert!(env.contains(&("PGOPTIONS".into(), "-c default_transaction_read_only=on".into())));
|
||||
assert!(env.contains(&("PGSSLMODE".into(), "verify-full".into())));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_the_tool_itself_is_accepted() {
|
||||
for ok in ["/usr/bin/pg_dump", "/pg/bin/pg_dump.exe", "/usr/bin/pg_dump-17", "/opt/pg_dump17"] {
|
||||
assert!(DbTool::PgDump.is_program(Path::new(ok)), "{ok}");
|
||||
}
|
||||
for bad in ["/usr/bin/pg_dumpall", "/bin/sh", "/usr/bin/pg_restore", "/tmp/evil"] {
|
||||
assert!(!DbTool::PgDump.is_program(Path::new(bad)), "{bad}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tells_dumps_apart_by_their_header() {
|
||||
assert_eq!(kind_of(b"PGDMP\x01\x0f"), DbDumpKind::PostgresArchive);
|
||||
assert_eq!(kind_of(b"toc.dat\0\0\0"), DbDumpKind::PostgresArchive);
|
||||
assert_eq!(kind_of(b"--\n-- PostgreSQL database dump\n--\n"), DbDumpKind::PostgresSql);
|
||||
assert_eq!(kind_of(b"-- MySQL dump 10.13 Distrib 8.4.6\n--\n"), DbDumpKind::MysqlSql);
|
||||
assert_eq!(kind_of(b"-- MariaDB dump 10.19 Distrib 11.4.2\n"), DbDumpKind::MysqlSql);
|
||||
assert_eq!(kind_of(b"CREATE TABLE t (id int);\n"), DbDumpKind::Unknown);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn newer_versions_sort_first() {
|
||||
assert!(version_key("pg_dump (PostgreSQL) 17.2") > version_key("pg_dump (PostgreSQL) 9.6.24"));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn streams_both_pipes_and_reports_the_exit_code() {
|
||||
let mut lines = Vec::new();
|
||||
let code = run(
|
||||
Path::new("/bin/sh"),
|
||||
&["-c".into(), "echo out; echo err >&2; exit 3".into()],
|
||||
&[],
|
||||
&CancellationToken::new(),
|
||||
|batch| lines.extend(batch),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(code, Some(3));
|
||||
assert!(lines.contains(&ToolLine { stderr: false, text: "out".into() }));
|
||||
assert!(lines.contains(&ToolLine { stderr: true, text: "err".into() }));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn cancelling_stops_the_process() {
|
||||
let cancel = CancellationToken::new();
|
||||
let stop = cancel.clone();
|
||||
tokio::spawn(async move {
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
stop.cancel();
|
||||
});
|
||||
let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], &cancel, |_| {}).await;
|
||||
assert!(result.is_err());
|
||||
}
|
||||
|
||||
/// A stand-in for `tool` that prints each argument on a line, then whether `PGPASSWORD`
|
||||
/// holds the expected password.
|
||||
#[cfg(unix)]
|
||||
fn echo_tool(dir: &Path, tool: DbTool) -> PathBuf {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let path = dir.join(tool.program());
|
||||
std::fs::write(
|
||||
&path,
|
||||
"#!/bin/sh\nfor a in \"$@\"; do echo \"arg:$a\"; done\necho \"env:${PGPASSWORD:+set}\"\n",
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
path
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn the_password_never_reaches_the_arguments() {
|
||||
const SECRET: &str = "s3cret-pass-do-not-leak";
|
||||
let dir = std::env::temp_dir().join(format!("openidea-tools-{}", uuid::Uuid::new_v4()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let file = dir.join("out.sql").to_string_lossy().into_owned();
|
||||
let jobs = [
|
||||
DbToolJob::PgDump {
|
||||
file: file.clone(),
|
||||
options: DbPgDumpOptions {
|
||||
format: DbDumpFormat::Plain,
|
||||
statements: DbDumpStatements::Copy,
|
||||
content: DbDumpContent::All,
|
||||
schemas: vec!["public".into()],
|
||||
tables: vec![],
|
||||
exclude_tables: vec![],
|
||||
clean: true,
|
||||
if_exists: true,
|
||||
create: false,
|
||||
no_owner: false,
|
||||
no_privileges: false,
|
||||
jobs: 1,
|
||||
},
|
||||
},
|
||||
DbToolJob::Psql {
|
||||
file: file.clone(),
|
||||
options: DbPsqlOptions { single_transaction: true, stop_on_error: true },
|
||||
},
|
||||
];
|
||||
for job in jobs {
|
||||
let program = echo_tool(&dir, job.tool());
|
||||
let prepared = prepare(&job, &pg(), Some(SECRET));
|
||||
assert!(!prepared.args.iter().any(|a| a.contains(SECRET)), "{:?}", prepared.args);
|
||||
let mut lines = Vec::new();
|
||||
run(&program, &prepared.args, &prepared.env, &CancellationToken::new(), |b| lines.extend(b)).await.unwrap();
|
||||
let text: Vec<&str> = lines.iter().map(|l| l.text.as_str()).collect();
|
||||
assert!(text.contains(&"arg:--dbname=shop"), "{text:?}");
|
||||
assert!(!text.iter().any(|l| l.contains(SECRET)), "{text:?}");
|
||||
assert!(text.contains(&"env:set"), "the tool gets the password from PGPASSWORD: {text:?}");
|
||||
}
|
||||
std::fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -228,3 +228,78 @@ async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
|
||||
db.execute("p", "DROP SCHEMA oi_keys CASCADE", 10, &c).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Runs `job` with the newest installed copy of its tool, the way the dialogs do.
|
||||
async fn run_tool(db: &DbManager, target: &str, job: ide_db::tools::DbToolJob) -> IdeResult<()> {
|
||||
let install = ide_db::tools::find_installs(job.tool()).into_iter().next().expect("installed");
|
||||
let mut lines = Vec::new();
|
||||
let code = db.run_tool(target, install.path.as_ref(), &job, &CancellationToken::new(), |b| lines.extend(b)).await?;
|
||||
assert_eq!(code, Some(0), "{} failed: {lines:?}", job.tool().program());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
|
||||
use ide_db::tools::{
|
||||
DbDumpContent, DbDumpFormat, DbDumpStatements, DbPgDumpOptions, DbPgRestoreOptions, DbPsqlOptions, DbTool,
|
||||
DbToolJob, find_installs,
|
||||
};
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let Some(db) = manager(&tmp).await else { return Ok(()) };
|
||||
let server = db.server_version("p").await? / 10000;
|
||||
let major = |t: DbTool| {
|
||||
find_installs(t).first().and_then(|i| i.version.split(' ').nth(2)?.split('.').next()?.parse::<u32>().ok())
|
||||
};
|
||||
// Other major versions write or refuse what this server needs; the dialogs warn about that instead.
|
||||
if [DbTool::PgDump, DbTool::PgRestore, DbTool::Psql].into_iter().any(|t| major(t) != Some(server)) {
|
||||
return Ok(());
|
||||
}
|
||||
create_schemas(&db).await;
|
||||
let c = CancellationToken::new();
|
||||
db.execute("p", "DROP DATABASE IF EXISTS oi_restore", 1, &c).await?;
|
||||
db.execute("p", "CREATE DATABASE oi_restore", 1, &c).await?;
|
||||
let file = |name: &str| tmp.path().join(name).to_string_lossy().into_owned();
|
||||
|
||||
let dump = |format, file: String, schema: &str| DbToolJob::PgDump {
|
||||
file,
|
||||
options: DbPgDumpOptions {
|
||||
format,
|
||||
statements: DbDumpStatements::Copy,
|
||||
content: DbDumpContent::All,
|
||||
schemas: vec![schema.into()],
|
||||
tables: vec![],
|
||||
exclude_tables: vec![],
|
||||
clean: false,
|
||||
if_exists: false,
|
||||
create: false,
|
||||
no_owner: false,
|
||||
no_privileges: false,
|
||||
jobs: 1,
|
||||
},
|
||||
};
|
||||
let archive = file("a.dump");
|
||||
run_tool(&db, "p", dump(DbDumpFormat::Custom, archive.clone(), "oi_a")).await?;
|
||||
let restore = DbPgRestoreOptions {
|
||||
content: DbDumpContent::All,
|
||||
schemas: vec![],
|
||||
clean: false,
|
||||
if_exists: false,
|
||||
no_owner: false,
|
||||
no_privileges: false,
|
||||
single_transaction: false,
|
||||
exit_on_error: true,
|
||||
jobs: 1,
|
||||
};
|
||||
run_tool(&db, "p:oi_restore", DbToolJob::PgRestore { file: archive, options: restore }).await?;
|
||||
|
||||
let script = file("b.sql");
|
||||
run_tool(&db, "p", dump(DbDumpFormat::Plain, script.clone(), "oi_b")).await?;
|
||||
let psql = DbPsqlOptions { single_transaction: true, stop_on_error: true };
|
||||
run_tool(&db, "p:oi_restore", DbToolJob::Psql { file: script, options: psql }).await?;
|
||||
|
||||
let r = db.execute("p:oi_restore", "SELECT a.tag || ', ' || b.tag FROM oi_a.items a, oi_b.items b", 1, &c).await?;
|
||||
assert_eq!(r.rows[0][0].as_deref(), Some("from a, from b"));
|
||||
db.disconnect("p:oi_restore").await;
|
||||
db.execute("p", "DROP DATABASE oi_restore", 1, &c).await?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -24,6 +24,16 @@ pub enum DockerEndpoint {
|
||||
Tcp { host: String, tls_cert_dir: Option<String> },
|
||||
/// A named `docker context`.
|
||||
Context { name: String },
|
||||
/// A daemon on the host of an SSH configuration (Settings › Tools › SSH Configurations),
|
||||
/// reached with the IDE's own SSH client and its saved credentials. The host resolves it to
|
||||
/// a local [`DockerEndpoint::Tcp`] tunnel before running docker; unresolved, the CLI is
|
||||
/// pointed at an address it rejects rather than at another daemon.
|
||||
Ssh { config: String },
|
||||
}
|
||||
|
||||
/// What an unresolved [`DockerEndpoint::Ssh`] gives the CLI: an error, never a fallback daemon.
|
||||
fn unresolved_ssh(config: &str) -> String {
|
||||
format!("ssh-configuration://{}", config.trim())
|
||||
}
|
||||
|
||||
impl DockerEndpoint {
|
||||
@@ -55,6 +65,7 @@ impl DockerEndpoint {
|
||||
args
|
||||
}
|
||||
Self::Context { name } => vec!["--context".into(), name.trim().to_owned()],
|
||||
Self::Ssh { config } => vec!["--host".into(), unresolved_ssh(config)],
|
||||
}
|
||||
}
|
||||
|
||||
@@ -101,6 +112,11 @@ impl DockerEndpoint {
|
||||
set("DOCKER_HOST", String::new());
|
||||
set("DOCKER_TLS_VERIFY", String::new());
|
||||
}
|
||||
Self::Ssh { config } => {
|
||||
set("DOCKER_HOST", unresolved_ssh(config));
|
||||
set("DOCKER_CONTEXT", String::new());
|
||||
set("DOCKER_TLS_VERIFY", String::new());
|
||||
}
|
||||
}
|
||||
env
|
||||
}
|
||||
@@ -111,8 +127,13 @@ impl DockerEndpoint {
|
||||
Self::Socket { path } => path.trim().is_empty(),
|
||||
Self::Tcp { host, .. } => host.trim().is_empty(),
|
||||
Self::Context { name } => name.trim().is_empty() || name.trim().starts_with('-'),
|
||||
Self::Ssh { config } => config.trim().is_empty(),
|
||||
};
|
||||
if empty { Err(IdeError::invalid("the Docker connection needs a socket, host or context")) } else { Ok(()) }
|
||||
if empty {
|
||||
Err(IdeError::invalid("the Docker connection needs a socket, host, context or SSH configuration"))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -325,6 +346,17 @@ fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn an_unresolved_ssh_endpoint_never_falls_back_to_another_daemon() {
|
||||
let ssh = DockerEndpoint::Ssh { config: "box".into() };
|
||||
assert_eq!(ssh.global_args(), ["--host", "ssh-configuration://box"]);
|
||||
let env = ssh.env_vars();
|
||||
assert_eq!((env["DOCKER_HOST"].as_str(), env["DOCKER_CONTEXT"].as_str()), ("ssh-configuration://box", ""));
|
||||
assert!(ssh.validate().is_ok());
|
||||
assert!(DockerEndpoint::Ssh { config: " ".into() }.validate().is_err());
|
||||
assert!(!crate::endpoint_is_local(&ssh).unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn endpoint_args() {
|
||||
assert!(DockerEndpoint::Default.global_args().is_empty());
|
||||
|
||||
@@ -142,7 +142,7 @@ pub fn snapshot(ep: &DockerEndpoint) -> DockerSnapshot {
|
||||
}
|
||||
const FMT: &str = "{{json .}}";
|
||||
let (containers, images, volumes, networks) = std::thread::scope(|s| {
|
||||
let c = s.spawn(|| run(ep, &["ps", "--all", "--no-trunc", "--format", FMT], QUICK));
|
||||
let c = s.spawn(|| run(ep, &["ps", "--all", "--no-trunc", "--format", PS_FORMAT], QUICK));
|
||||
let i = s.spawn(|| run(ep, &["image", "ls", "--no-trunc", "--format", FMT], QUICK));
|
||||
let v = s.spawn(|| run(ep, &["volume", "ls", "--format", FMT], QUICK));
|
||||
let n = s.spawn(|| run(ep, &["network", "ls", "--no-trunc", "--format", FMT], QUICK));
|
||||
@@ -483,6 +483,7 @@ pub fn endpoint_is_local(ep: &DockerEndpoint) -> IdeResult<bool> {
|
||||
|name| context_host(&DockerEndpoint::Default, name),
|
||||
)?,
|
||||
DockerEndpoint::Context { name } => context_host(&DockerEndpoint::Default, Some(name.trim()))?,
|
||||
DockerEndpoint::Ssh { .. } => return Ok(false),
|
||||
};
|
||||
Ok(daemon_url_is_local(&url))
|
||||
}
|
||||
|
||||
@@ -226,6 +226,16 @@ fn lines<T: for<'de> Deserialize<'de>>(text: &str) -> impl Iterator<Item = T> +
|
||||
})
|
||||
}
|
||||
|
||||
/// The `docker ps --format` template: only the fields [`RawContainer`] reads. `{{json .}}`
|
||||
/// would also include `Size`, which makes the daemon compute every container's writable
|
||||
/// layer and can take tens of seconds.
|
||||
pub const PS_FORMAT: &str = concat!(
|
||||
r#"{"ID":{{json .ID}},"Names":{{json .Names}},"Image":{{json .Image}},"#,
|
||||
r#""Command":{{json .Command}},"State":{{json .State}},"Status":{{json .Status}},"#,
|
||||
r#""Ports":{{json .Ports}},"CreatedAt":{{json .CreatedAt}},"Labels":{{json .Labels}},"#,
|
||||
r#""Mounts":{{json .Mounts}},"Networks":{{json .Networks}}}"#,
|
||||
);
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct RawContainer {
|
||||
@@ -247,7 +257,7 @@ fn split_csv(raw: &str) -> Vec<String> {
|
||||
raw.split(',').map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned).collect()
|
||||
}
|
||||
|
||||
/// `docker ps -a --no-trunc --format '{{json .}}'`.
|
||||
/// `docker ps -a --no-trunc --format` [`PS_FORMAT`] (or `'{{json .}}'`).
|
||||
pub fn parse_containers(text: &str) -> Vec<DockerContainer> {
|
||||
let mut out: Vec<DockerContainer> = lines::<RawContainer>(text)
|
||||
.map(|r| {
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
//! Parsing of recorded `docker … --format '{{json .}}'` output.
|
||||
|
||||
use ide_docker::{
|
||||
parse_container_stats, parse_container_top, parse_containers, parse_image_history, parse_images, parse_networks,
|
||||
parse_volumes,
|
||||
PS_FORMAT, parse_container_stats, parse_container_top, parse_containers, parse_image_history, parse_images,
|
||||
parse_networks, parse_volumes,
|
||||
};
|
||||
|
||||
const PS: &str = include_str!("fixtures/ps.jsonl");
|
||||
@@ -10,6 +10,27 @@ const IMAGES: &str = include_str!("fixtures/images.jsonl");
|
||||
const VOLUMES: &str = include_str!("fixtures/volumes.jsonl");
|
||||
const NETWORKS: &str = include_str!("fixtures/networks.jsonl");
|
||||
|
||||
/// Fills `{{json .Field}}` placeholders of a `--format` template from a `{{json .}}` line.
|
||||
fn render(template: &str, line: &str) -> String {
|
||||
let fields: serde_json::Map<String, serde_json::Value> = serde_json::from_str(line).unwrap();
|
||||
let mut out = template.to_owned();
|
||||
while let Some(start) = out.find("{{json .") {
|
||||
let end = start + out[start..].find("}}").unwrap() + 2;
|
||||
let key = &out[start + "{{json .".len()..end - 2];
|
||||
let value = fields.get(key).unwrap_or_else(|| panic!("fixture lacks {key}"));
|
||||
out.replace_range(start..end, &value.to_string());
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ps_format_carries_everything_the_parser_reads_but_size() {
|
||||
assert!(!PS_FORMAT.contains("Size"), "Size makes the daemon compute container sizes");
|
||||
let rendered: Vec<String> = PS.lines().filter(|l| l.starts_with('{')).map(|l| render(PS_FORMAT, l)).collect();
|
||||
assert_eq!(rendered.len(), 2);
|
||||
assert_eq!(parse_containers(&rendered.join("\n")), parse_containers(PS));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn containers_with_compose_labels() {
|
||||
let c = parse_containers(PS);
|
||||
|
||||
@@ -26,6 +26,8 @@ pub enum Capability {
|
||||
DatabaseSources,
|
||||
VcsRead,
|
||||
VcsWrite,
|
||||
/// The Maven / Gradle dependency graph the IDE resolved.
|
||||
BuildRead,
|
||||
/// The plugin's own key-value store and data directory.
|
||||
Storage,
|
||||
/// The plugin's own secrets (kept in the client's OS keychain).
|
||||
@@ -55,6 +57,9 @@ pub enum Capability {
|
||||
FsRead(String),
|
||||
/// Write files outside the project under one path.
|
||||
FsWrite(String),
|
||||
/// Load the plugin's Java agent into the JVMs of Java run configurations. Never
|
||||
/// declared: it comes from `[[contributes.javaAgents]]`.
|
||||
JavaAgent,
|
||||
}
|
||||
|
||||
/// How a grant is presented (plan 4.2).
|
||||
@@ -72,7 +77,9 @@ pub enum Risk {
|
||||
impl Capability {
|
||||
pub fn risk(&self) -> Risk {
|
||||
match self {
|
||||
Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead => Risk::Low,
|
||||
Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead | Self::BuildRead => {
|
||||
Risk::Low
|
||||
}
|
||||
Self::EditorWrite
|
||||
| Self::DatabaseSources
|
||||
| Self::VcsWrite
|
||||
@@ -90,7 +97,8 @@ impl Capability {
|
||||
| Self::Process(_)
|
||||
| Self::Lsp(_)
|
||||
| Self::FsRead(_)
|
||||
| Self::FsWrite(_) => Risk::High,
|
||||
| Self::FsWrite(_)
|
||||
| Self::JavaAgent => Risk::High,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -111,6 +119,7 @@ impl Capability {
|
||||
Self::IdeCommands => "Run any IDE action or other plugins' commands as if you chose them, including running programs, committing and pushing".into(),
|
||||
Self::VcsRead => "Read version control state".into(),
|
||||
Self::VcsWrite => "Change version control state (commit, fetch, checkout)".into(),
|
||||
Self::BuildRead => "Read the project's resolved Maven and Gradle dependencies".into(),
|
||||
Self::Storage => "Store its own data".into(),
|
||||
Self::Secrets => "Store secrets in the system keychain".into(),
|
||||
Self::Events => "Observe editor, filesystem and version control events".into(),
|
||||
@@ -135,6 +144,7 @@ impl Capability {
|
||||
}
|
||||
Self::FsRead(path) => format!("Read files under {path}, outside the project"),
|
||||
Self::FsWrite(path) => format!("Change files under {path}, outside the project"),
|
||||
Self::JavaAgent => "Run code inside the Java applications you start".into(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -246,6 +256,7 @@ impl fmt::Display for Capability {
|
||||
Self::DatabaseSources => f.write_str("database.sources"),
|
||||
Self::VcsRead => f.write_str("vcs.read"),
|
||||
Self::VcsWrite => f.write_str("vcs.write"),
|
||||
Self::BuildRead => f.write_str("build.read"),
|
||||
Self::Storage => f.write_str("storage"),
|
||||
Self::Secrets => f.write_str("secrets"),
|
||||
Self::Events => f.write_str("events"),
|
||||
@@ -259,6 +270,7 @@ impl fmt::Display for Capability {
|
||||
Self::Lsp(s) => write!(f, "lsp:{s}"),
|
||||
Self::FsRead(p) => write!(f, "fs.read:{p}"),
|
||||
Self::FsWrite(p) => write!(f, "fs.write:{p}"),
|
||||
Self::JavaAgent => f.write_str("java.agent"),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -330,11 +342,13 @@ impl FromStr for Capability {
|
||||
"database.sources" => Self::DatabaseSources,
|
||||
"vcs.read" => Self::VcsRead,
|
||||
"vcs.write" => Self::VcsWrite,
|
||||
"build.read" => Self::BuildRead,
|
||||
"storage" => Self::Storage,
|
||||
"secrets" => Self::Secrets,
|
||||
"events" => Self::Events,
|
||||
"events.input" => Self::InputEvents,
|
||||
"clipboard" => Self::Clipboard,
|
||||
"java.agent" => Self::JavaAgent,
|
||||
_ => return Err(format!("unknown capability {s:?}")),
|
||||
})
|
||||
}
|
||||
@@ -383,6 +397,7 @@ mod tests {
|
||||
"editor.write",
|
||||
"project.write",
|
||||
"vcs.write",
|
||||
"build.read",
|
||||
"storage",
|
||||
"secrets",
|
||||
"events",
|
||||
@@ -392,6 +407,7 @@ mod tests {
|
||||
"process:cargo",
|
||||
"lsp:phoxite",
|
||||
"lsp:rust-analyzer",
|
||||
"java.agent",
|
||||
] {
|
||||
assert_eq!(s.parse::<Capability>().unwrap().to_string(), s);
|
||||
}
|
||||
@@ -425,8 +441,11 @@ mod tests {
|
||||
assert_eq!(Capability::Clipboard.risk(), Risk::Medium);
|
||||
assert_eq!(Capability::Process("cargo".into()).risk(), Risk::High);
|
||||
assert_eq!(Capability::Lsp("phoxite".into()).risk(), Risk::High);
|
||||
assert_eq!(Capability::BuildRead.risk(), Risk::Low);
|
||||
assert!(!Capability::Lsp("phoxite".into()).covers(&Capability::Lsp("intelephense".into())));
|
||||
assert!(Capability::Storage.auto_migrates() && !Capability::EditorWrite.auto_migrates());
|
||||
assert_eq!(Capability::JavaAgent.risk(), Risk::High);
|
||||
assert!(!Capability::JavaAgent.auto_migrates());
|
||||
}
|
||||
|
||||
/// A trusted project's files name programs the IDE starts by itself: the git and language
|
||||
|
||||
@@ -10,6 +10,8 @@
|
||||
//! - `process:<program>` grants record the program's absolute path and file
|
||||
//! hash at grant time. Calls use that path, never a `PATH` lookup, and fail
|
||||
//! when the file changed (re-confirmation needed).
|
||||
//! - `java.agent` grants record the agent jar's path and hash the same way;
|
||||
//! a launch adds the agent only while the jar still has that hash.
|
||||
|
||||
use crate::capability::{Capability, Risk};
|
||||
use serde::{Deserialize, Serialize};
|
||||
@@ -267,7 +269,7 @@ impl Ledger {
|
||||
if cap == &Capability::NetAsk {
|
||||
grant.net_hosts.clear();
|
||||
}
|
||||
if let Capability::Process(_) = cap {
|
||||
if let Capability::Process(_) | Capability::JavaAgent = cap {
|
||||
grant.binaries.remove(&s);
|
||||
for binaries in grant.project_binaries.values_mut() {
|
||||
binaries.remove(&s);
|
||||
@@ -290,7 +292,7 @@ impl Ledger {
|
||||
self.grants.get_mut(subject).is_some_and(|g| g.net_hosts.remove(host))
|
||||
}
|
||||
|
||||
/// Records the program approved for a `process:` grant.
|
||||
/// Records the program approved for a `process:` grant (or the jar of a `java.agent` one).
|
||||
pub fn set_binary(&mut self, subject: &Subject, cap: &Capability, binary: BinaryGrant) {
|
||||
if let Some(grant) = self.grants.get_mut(subject) {
|
||||
grant.binaries.insert(cap.to_string(), binary);
|
||||
@@ -675,6 +677,21 @@ mod tests {
|
||||
assert!(l.check_binary(&r.subject, &cap).unwrap_err().contains("changed"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn revoking_java_agent_forgets_its_jar() {
|
||||
let mut l = Ledger::in_memory();
|
||||
let r = req("1.0.0", "h", &[], &["java.agent"]);
|
||||
let cap = Capability::JavaAgent;
|
||||
let jar = BinaryGrant { path: "/plugins/p/agent.jar".into(), hash: "abc".into() };
|
||||
l.confirm(&r, std::slice::from_ref(&cap), [(cap.to_string(), jar.clone())].into());
|
||||
assert_eq!(l.pinned_binary(&r.subject, &cap), Some(jar.clone()));
|
||||
l.set(&r.subject, &cap, false);
|
||||
assert_eq!(l.pinned_binary(&r.subject, &cap), None);
|
||||
// Granting again without a new hash does not bring the old one back.
|
||||
l.set(&r.subject, &cap, true);
|
||||
assert_eq!(l.pinned_binary(&r.subject, &cap), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hashes_and_grouping() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -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.9.0";
|
||||
pub const ENGINE_VERSION: &str = "1.10.0";
|
||||
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
|
||||
pub const LEGACY_API: &str = "0.1";
|
||||
/// Marketplace categories, in the order they are shown.
|
||||
@@ -360,6 +360,14 @@ impl Manifest {
|
||||
if matches!(cap, Capability::Lsp(_)) {
|
||||
self.needs_api(&format!("capability `{cap}`"), 9)?;
|
||||
}
|
||||
if matches!(cap, Capability::BuildRead) {
|
||||
self.needs_api(&format!("capability `{cap}`"), 10)?;
|
||||
}
|
||||
if matches!(cap, Capability::JavaAgent) {
|
||||
return Err(
|
||||
"`java.agent` comes from `[[contributes.javaAgents]]`: remove it from [capabilities]".into()
|
||||
);
|
||||
}
|
||||
}
|
||||
if let Some(dark) = &self.icon_dark {
|
||||
if self.icon.is_none() {
|
||||
@@ -730,6 +738,22 @@ required = [\"lsp:phoxite\"]
|
||||
assert_eq!(m.capabilities.required, [Capability::Lsp("phoxite".into())]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_build_capability_needs_api_1_10() {
|
||||
let caps = "[capabilities]\noptional = [\"build.read\"]\n";
|
||||
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.9"))).contains("new in plugin API 1.10"));
|
||||
let m = Manifest::parse(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).unwrap();
|
||||
assert_eq!(m.capabilities.optional, [Capability::BuildRead]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn java_agent_capability_is_not_declared() {
|
||||
for list in ["required", "optional"] {
|
||||
let caps = format!("[capabilities]\n{list} = [\"java.agent\"]\n");
|
||||
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).contains("contributes.javaAgents"));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_icons() {
|
||||
let m = Manifest::parse(&format!("{BASE}icon = \"icon.svg\"\nicon-dark = \"icon_dark.svg\"\n")).unwrap();
|
||||
|
||||
@@ -11,6 +11,7 @@ path = "src/bin/server.rs"
|
||||
|
||||
[dependencies]
|
||||
encoding_rs.workspace = true
|
||||
ide-command.workspace = true
|
||||
ide-core.workspace = true
|
||||
ide-mcp.workspace = true
|
||||
futures.workspace = true
|
||||
@@ -30,6 +31,8 @@ ide-vcs.workspace = true
|
||||
ide-dap.workspace = true
|
||||
ide-heap.workspace = true
|
||||
ide-jvm-attach.workspace = true
|
||||
ide-jvm-inspect.workspace = true
|
||||
ide-streams.workspace = true
|
||||
ide-build.workspace = true
|
||||
ide-analysis.workspace = true
|
||||
ide-coverage.workspace = true
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
//! `openidea-server --stdio`: the IDE backend for remote development, serving
|
||||
//! one desktop client over stdin / stdout (started by the client over SSH).
|
||||
|
||||
use ide_host::catalogue::TrustClass;
|
||||
use ide_host::plugins::remote::{RemotePluginLanguages, SYNC_COMMAND};
|
||||
use ide_host::plugins::remote_host::RemotePlugins;
|
||||
use ide_host::rpc::{self, Dispatcher};
|
||||
@@ -102,7 +103,7 @@ async fn run(base: PathBuf) -> i32 {
|
||||
if let Some(plugins) = &plugins {
|
||||
plugins.register(&mut dispatcher);
|
||||
}
|
||||
dispatcher.add(SYNC_COMMAND, move |c| {
|
||||
dispatcher.add(SYNC_COMMAND, TrustClass::Trusted, move |c| {
|
||||
let remote = plugin_languages.clone();
|
||||
async move {
|
||||
let report = remote.sync(c.arg("languages")?);
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
//! What every command declares: its trust class, where it runs, and how Tauri runs it.
|
||||
//! `#[ide_command::command]` and `#[ide_command::desktop_command]` give each command a
|
||||
//! [`Command`].
|
||||
|
||||
/// Where a command may run, from the trust decision of the window's project.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||||
pub enum TrustClass {
|
||||
/// Everywhere, including Restricted Mode.
|
||||
Always,
|
||||
/// With no project open, or in a trusted project.
|
||||
OutsideRestricted,
|
||||
/// Only in a trusted project.
|
||||
Trusted,
|
||||
}
|
||||
|
||||
/// Which backend runs a command for a remote window.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||||
pub enum Placement {
|
||||
Desktop,
|
||||
ProjectHost,
|
||||
}
|
||||
|
||||
/// How Tauri runs the command: on the invoking thread, as a future, or on its thread pool.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||||
pub enum Mode {
|
||||
Sync,
|
||||
Async,
|
||||
Spawn,
|
||||
}
|
||||
|
||||
/// One command's declaration.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||||
pub struct Command {
|
||||
pub name: &'static str,
|
||||
pub trust: TrustClass,
|
||||
pub placement: Placement,
|
||||
/// In `bindings.ts`; a command registered outside tauri-specta isn't.
|
||||
pub bindings: bool,
|
||||
pub mode: Mode,
|
||||
}
|
||||
@@ -4,6 +4,7 @@
|
||||
//! runs one on a remote machine and serves it over JSON-RPC ([`rpc`]).
|
||||
|
||||
pub mod agent_secrets;
|
||||
pub mod catalogue;
|
||||
pub mod data_dirs;
|
||||
pub mod diagnostics_store;
|
||||
pub mod environment;
|
||||
@@ -23,7 +24,7 @@ pub mod rpc;
|
||||
pub mod shell_env;
|
||||
pub mod trust;
|
||||
|
||||
pub use project::{Project, apply_git_executable, apply_workspace_edit, history_retention};
|
||||
pub use project::{Project, apply_git_executable, history_retention};
|
||||
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, RequestId, SharedSink};
|
||||
use ide_language::{LanguageRegistry, Syntax};
|
||||
@@ -91,6 +92,8 @@ pub struct Host {
|
||||
pub ssh: Arc<ide_ssh::SshManager>,
|
||||
/// SFTP deployment, remote file editing and runs on run targets.
|
||||
pub remote: Arc<ide_remote::RemoteService>,
|
||||
/// Tunnels of Docker connections made through an SSH configuration.
|
||||
pub docker_tunnels: ops::docker::DockerTunnels,
|
||||
/// What child processes get beyond this process's environment (Reload Environment, `remoteEnv`).
|
||||
pub environment: environment::Environment,
|
||||
/// The built-in web server (Open In › Browser, the editor's browser bar). On a remote host the
|
||||
@@ -161,6 +164,7 @@ impl Host {
|
||||
agent_secrets: Arc::new(agent_secrets::AgentSecrets::new(&data_dir)),
|
||||
remote: Arc::new(ide_remote::RemoteService::new(ssh.clone(), data_dir.join("remote"))),
|
||||
ssh,
|
||||
docker_tunnels: Default::default(),
|
||||
environment: environment::Environment::new(project_environment, local_data_dir.clone()),
|
||||
web: ide_web::WebServer::new(),
|
||||
global_settings,
|
||||
@@ -191,6 +195,12 @@ impl Host {
|
||||
};
|
||||
host.apply_proxy();
|
||||
host.apply_added_jdks();
|
||||
// Before any project starts jdtls; the deleting itself can take a while.
|
||||
let unused =
|
||||
ide_sdk::jdtls_workspaces::take_unused(&host.local_data_dir, ide_sdk::jdtls_workspaces::UNUSED_FOR);
|
||||
if !unused.is_empty() {
|
||||
std::thread::spawn(move || ide_sdk::jdtls_workspaces::remove(unused));
|
||||
}
|
||||
ops::agent::move_user_mcp_values(&host);
|
||||
host
|
||||
}
|
||||
|
||||
@@ -331,7 +331,7 @@ targetIndex, or narrow the call with a contextSnippet that shows the one you mea
|
||||
FileEdit::Rename { from, to } => vec![from, to],
|
||||
};
|
||||
for p in paths {
|
||||
if let Err(e) = super::super::tool::ensure_inside(call.root(), p) {
|
||||
if let Err(e) = call.ensure_writable_place(p) {
|
||||
let hint = format!(
|
||||
"{}. Nothing was renamed. A rename that must change a file outside the project cannot run here.",
|
||||
e.message
|
||||
@@ -873,15 +873,15 @@ async fn occurrences(
|
||||
let host = call.host();
|
||||
let request = crate::mcp::tool::request_id();
|
||||
let files = Arc::new(Mutex::new(Vec::new()));
|
||||
let emit: crate::ops::Emit<SearchEvent> = {
|
||||
let emit = {
|
||||
let files = files.clone();
|
||||
Arc::new(move |event| {
|
||||
crate::ops::Channel::new(move |event: SearchEvent| {
|
||||
if let SearchEvent::File { file } = event {
|
||||
files.lock().push(file);
|
||||
}
|
||||
})
|
||||
};
|
||||
let search = crate::ops::search::start(&host, call.window(), request, query, emit);
|
||||
let search = crate::ops::search::search_start(&host, call.window(), request, query, emit);
|
||||
tokio::pin!(search);
|
||||
tokio::select! {
|
||||
r = &mut search => r?,
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
use super::page::{OFFSET, Page};
|
||||
use super::scope::{self, Scope};
|
||||
use super::tool::{Call, Output, Param, ParamType, Tool};
|
||||
use ide_core::{Diagnostic, IdeResult, Severity};
|
||||
use serde_json::{Map, Value, json};
|
||||
@@ -14,7 +15,8 @@ pub fn tools() -> Vec<Tool> {
|
||||
|
||||
Use this tool to explore current open editors.",
|
||||
open_editors,
|
||||
),
|
||||
)
|
||||
.param(scope::param()),
|
||||
Tool::new(
|
||||
"get_current_file",
|
||||
"Returns the focused editor's file and selection reported by the IDE.
|
||||
@@ -43,18 +45,20 @@ Lines and UTF-16 columns are 1-based.",
|
||||
project_problems,
|
||||
)
|
||||
.param(Param::optional("errorsOnly", ParamType::Boolean, "Only errors (default) or warnings too"))
|
||||
.param(scope::param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Problems to return at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET)),
|
||||
]
|
||||
}
|
||||
|
||||
async fn open_editors(call: Call) -> IdeResult<Output> {
|
||||
let dir = Scope::of(&call)?;
|
||||
let windows = call.host.mcp_windows(call.root());
|
||||
let open = call.host.mcp_reports.editors(&windows);
|
||||
let active = call.host.mcp_reports.focused(call.window());
|
||||
let active = call.host.mcp_reports.focused(call.window()).filter(|e| dir.contains(&e.path.0));
|
||||
Output::json(json!({
|
||||
"activeFilePath": active.map(|e| call.display(&e.path.0)),
|
||||
"openFiles": open.iter().map(|p| call.display(p)).collect::<Vec<_>>(),
|
||||
"openFiles": open.iter().filter(|p| dir.contains(p)).map(|p| call.display(p)).collect::<Vec<_>>(),
|
||||
}))
|
||||
}
|
||||
|
||||
@@ -99,9 +103,11 @@ async fn file_problems(call: Call) -> IdeResult<Output> {
|
||||
async fn project_problems(call: Call) -> IdeResult<Output> {
|
||||
let page = Page::of(&call, PROBLEMS_LIMIT)?;
|
||||
let errors_only = call.flag("errorsOnly", true)?;
|
||||
let dir = Scope::of(&call)?;
|
||||
let files = call.host.mcp_reports.problems(&call.host.mcp_windows(call.root()));
|
||||
let problems: Vec<(String, Value)> = files
|
||||
.into_iter()
|
||||
.filter(|f| dir.contains(&f.path.0))
|
||||
.flat_map(|f| {
|
||||
let path = call.display(&f.path.0);
|
||||
let wanted = f.items.into_iter().filter(|d| !errors_only || d.severity == Severity::Error);
|
||||
|
||||
@@ -57,7 +57,7 @@ The maximum accepted limit is 5000 lines.",
|
||||
probe.size
|
||||
)));
|
||||
}
|
||||
let text = crate::ops::fs::read_text(&call.host(), call.window(), path).await?;
|
||||
let text = crate::ops::fs::fs_read_text(&call.host(), call.window(), path).await?;
|
||||
Ok(Output::text(render_slice(&text, offset as usize, limit as usize, window)?))
|
||||
},
|
||||
)
|
||||
|
||||
@@ -37,7 +37,7 @@ Returns each request's 0-based `index`, optional `name`, `method`, URL as writte
|
||||
Use `http_run_request` with the same `path` and an `index` to send one.",
|
||||
|call| async move {
|
||||
let path = resolve_http_file(&call, &call.str("path")?).await?;
|
||||
let text = crate::ops::fs::read_text(&call.host(), call.window(), path).await?;
|
||||
let text = crate::ops::fs::fs_read_text(&call.host(), call.window(), path).await?;
|
||||
let requests: Vec<_> = ide_http::parse::requests(&text)
|
||||
.into_iter()
|
||||
.map(|b| {
|
||||
@@ -139,7 +139,7 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
|
||||
}
|
||||
let index = index as u32;
|
||||
let env = call.opt_str("env")?;
|
||||
let text = crate::ops::fs::read_text(&call.host(), call.window(), path.clone()).await?;
|
||||
let text = crate::ops::fs::fs_read_text(&call.host(), call.window(), path.clone()).await?;
|
||||
let blocks = ide_http::parse::requests(&text);
|
||||
let block =
|
||||
blocks.get(index as usize).ok_or_else(|| IdeError::not_found(format!("no request #{}", index + 1)))?;
|
||||
@@ -167,7 +167,10 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
|
||||
}
|
||||
call.confirm(&subject, Some(detail)).await?;
|
||||
|
||||
let exchange = ide_http::run(input, &call.cancel).await?;
|
||||
// Exactly the request the user approved: preparing it again would read the
|
||||
// environment files again, which may name another destination by now.
|
||||
let redact_url = prepared.url.clone();
|
||||
let exchange = ide_http::send(prepared, Some(&path), &call.cancel).await?;
|
||||
let history = call.project().http_history.clone();
|
||||
let saved = exchange.clone();
|
||||
let _ = call.host().blocking(move || history.add(&saved)).await;
|
||||
@@ -188,7 +191,7 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
|
||||
"status": response.map(|r| r.status),
|
||||
"statusText": response.map(|r| r.status_text.clone()),
|
||||
"totalMs": response.map(|r| r.total_ms).or(exchange.entry.total_ms),
|
||||
"error": redact_transport_error(exchange.entry.error.clone(), &prepared.url),
|
||||
"error": redact_transport_error(exchange.entry.error.clone(), &redact_url),
|
||||
"body": body,
|
||||
"bodyTruncated": body_truncated,
|
||||
}))
|
||||
|
||||
@@ -9,7 +9,8 @@ pub use requests::Requests;
|
||||
mod files;
|
||||
mod http;
|
||||
mod page;
|
||||
mod reports;
|
||||
pub mod reports;
|
||||
mod scope;
|
||||
mod search;
|
||||
mod symbols;
|
||||
mod tool;
|
||||
@@ -18,7 +19,9 @@ mod util;
|
||||
use crate::Host;
|
||||
use ide_core::{CancellationToken, IdeError};
|
||||
use ide_mcp::{ToolCallError, ToolRegistry};
|
||||
pub use reports::{FileProblems, FocusedEditor, Reports};
|
||||
pub use reports::{
|
||||
FileProblems, FocusedEditor, Reports, mcp_report_problems, mcp_set_focused_editor, mcp_set_open_editors,
|
||||
};
|
||||
pub use run::agent::{AGENT_PARAM, AgentRun, AgentRuns, NAME_PREFIX, SHELL_PARAM};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
@@ -54,14 +57,17 @@ impl Registry {
|
||||
if self.0.mcp_reports.remote_roots().iter().any(|p| p == root) {
|
||||
return Err("not supported for remote projects yet".into());
|
||||
}
|
||||
let mut windows: Vec<_> = self
|
||||
.0
|
||||
.projects
|
||||
.read()
|
||||
.iter()
|
||||
.filter(|(_, p)| p.root == root && !p.light)
|
||||
.map(|(w, p)| (w.clone(), p.clone()))
|
||||
.collect();
|
||||
let projects = self.0.projects.read();
|
||||
let open = || projects.iter().filter(|(_, p)| !p.light);
|
||||
let mut windows: Vec<_> = open().filter(|(_, p)| p.root == root).map(|(w, p)| (w.clone(), p.clone())).collect();
|
||||
if windows.is_empty() {
|
||||
// A project attached to an open one: the window it is attached in.
|
||||
windows = open()
|
||||
.filter(|(_, p)| tool::attached_projects(&p.root).iter().any(|a| a == root))
|
||||
.map(|(w, p)| (w.clone(), p.clone()))
|
||||
.collect();
|
||||
}
|
||||
drop(projects);
|
||||
let focused = self.0.mcp_reports.focused_window();
|
||||
windows.sort_by(|a, b| {
|
||||
(Some(&b.0) == focused.as_ref()).cmp(&(Some(&a.0) == focused.as_ref())).then(a.0.cmp(&b.0))
|
||||
@@ -71,13 +77,10 @@ impl Registry {
|
||||
}
|
||||
impl ToolRegistry for Registry {
|
||||
fn projects(&self) -> Vec<PathBuf> {
|
||||
self.0
|
||||
.projects()
|
||||
.into_iter()
|
||||
.filter(|p| !p.light)
|
||||
.map(|p| p.root.clone())
|
||||
.chain(self.0.mcp_reports.remote_roots())
|
||||
.collect()
|
||||
let open: Vec<_> = self.0.projects().into_iter().filter(|p| !p.light).collect();
|
||||
// Attached projects are listed too, so a `projectPath` inside one names it.
|
||||
let attached: Vec<_> = open.iter().flat_map(|p| tool::attached_projects(&p.root)).collect();
|
||||
open.into_iter().map(|p| p.root.clone()).chain(attached).chain(self.0.mcp_reports.remote_roots()).collect()
|
||||
}
|
||||
fn tools(&self, root: &Path) -> Result<Vec<ide_mcp::Tool>, String> {
|
||||
let (_, project) = self.target(root)?;
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
//! Window-owned snapshots. A project close drops every report from that window.
|
||||
use ide_command::command;
|
||||
use ide_core::{Diagnostic, IpcPath, Range};
|
||||
use parking_lot::RwLock;
|
||||
use serde::{Deserialize, Serialize};
|
||||
@@ -134,6 +135,37 @@ impl Reports {
|
||||
}
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub fn mcp_set_open_editors(host: &crate::Host, window: &str, paths: Vec<IpcPath>) -> ide_core::IdeResult<()> {
|
||||
host.project(window)?;
|
||||
host.mcp_reports.set_open_editors(window, paths.into_iter().map(PathBuf::from).collect());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub fn mcp_set_focused_editor(
|
||||
host: &crate::Host,
|
||||
window: &str,
|
||||
editor: Option<FocusedEditor>,
|
||||
focused: bool,
|
||||
) -> ide_core::IdeResult<()> {
|
||||
host.project(window)?;
|
||||
host.mcp_reports.set_focused_editor(window, editor, focused);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub fn mcp_report_problems(
|
||||
host: &crate::Host,
|
||||
window: &str,
|
||||
reset: bool,
|
||||
files: Vec<FileProblems>,
|
||||
) -> ide_core::IdeResult<()> {
|
||||
host.project(window)?;
|
||||
host.mcp_reports.report_problems(window, reset, files);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -154,3 +186,10 @@ mod tests {
|
||||
assert_eq!(windows, ["a", "b", "never", "c"]);
|
||||
}
|
||||
}
|
||||
|
||||
ide_command::domain!(
|
||||
mcp_reports:
|
||||
mcp_report_problems,
|
||||
mcp_set_focused_editor,
|
||||
mcp_set_open_editors,
|
||||
);
|
||||
@@ -305,6 +305,7 @@ pub fn list_runs() -> Tool {
|
||||
start of the command, exit code and times. `get_run_status` gives a tab's whole status.",
|
||||
|call| async move {
|
||||
let page = Page::of(&call, LIST_LIMIT)?;
|
||||
let dir = crate::mcp::scope::Scope::of(&call)?;
|
||||
let wanted = call.opt_str("state")?.filter(|s| s != "all");
|
||||
let states = match wanted.as_deref() {
|
||||
None => None,
|
||||
@@ -325,6 +326,8 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
|
||||
.iter()
|
||||
.rev()
|
||||
.map(|r| r.status())
|
||||
// A tab belongs where its command runs.
|
||||
.filter(|s| dir.contains_shown(call.root(), s["workingDirectory"].as_str().unwrap_or_default()))
|
||||
.filter(|s| {
|
||||
states.as_ref().is_none_or(|states| s["state"].as_str().is_some_and(|v| states.contains(&v)))
|
||||
})
|
||||
@@ -341,6 +344,7 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
|
||||
ParamType::String,
|
||||
"all (default), running, idle (not running), error (failed, crashed, startFailed), or one state",
|
||||
))
|
||||
.param(crate::mcp::scope::param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Tabs to return at most (default 10)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
}
|
||||
@@ -414,10 +418,10 @@ input). Terminal keys (arrows, Escape, Backspace, Ctrl+Z…) are refused. To ans
|
||||
host.processes.write_stdin(id, &std::mem::take(&mut data))?;
|
||||
}
|
||||
if key == Key::EndOfInput {
|
||||
crate::ops::run::close_stdin(&host, id)?;
|
||||
crate::ops::run::run_close_stdin(&host, id)?;
|
||||
} else {
|
||||
run.agent_stopping();
|
||||
crate::ops::run::stop(&host, &run.window(), id)?;
|
||||
crate::ops::run::run_stop(&host, &run.window(), id)?;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -451,10 +455,10 @@ keeps `stopping`: call again with `force`. The tab stays open with its output."
|
||||
let deadline = deadline(&call, STOP_TIMEOUT_MS)?;
|
||||
let host = call.host();
|
||||
run.agent_stopping();
|
||||
crate::ops::run::stop(&host, &run.window(), id)?;
|
||||
crate::ops::run::run_stop(&host, &run.window(), id)?;
|
||||
if force {
|
||||
// A second Stop kills the tree.
|
||||
crate::ops::run::stop(&host, &run.window(), id)?;
|
||||
crate::ops::run::run_stop(&host, &run.window(), id)?;
|
||||
}
|
||||
let end = run.wait(deadline, None, run.log_len(), &call.cancel).await?;
|
||||
let mut extra = Map::new();
|
||||
|
||||
@@ -139,8 +139,13 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
|
||||
}
|
||||
let page = Page::of(&call, CONFIGURATIONS_LIMIT)?;
|
||||
let query = call.opt_str("query")?.map(|q| q.to_lowercase());
|
||||
let dir = crate::mcp::scope::Scope::of(&call)?;
|
||||
let list: Vec<Value> = configs
|
||||
.iter()
|
||||
// A configuration belongs where it runs.
|
||||
.filter(|c| {
|
||||
dir.contains(&c.cwd.as_deref().map_or_else(|| call.root().to_path_buf(), |d| call.root().join(d)))
|
||||
})
|
||||
.filter(|c| {
|
||||
query.as_ref().is_none_or(|q| {
|
||||
[c.name.as_str(), c.kind.as_str(), command_line(c).as_str()]
|
||||
@@ -164,6 +169,7 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
|
||||
in the file instead of project-wide run configurations.",
|
||||
))
|
||||
.param(Param::optional("query", ParamType::String, "Only configurations whose name, type or command contains it"))
|
||||
.param(crate::mcp::scope::param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Configurations to return at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
}
|
||||
@@ -277,7 +283,7 @@ fn run_exit(host: &crate::Host, id: RunId) -> Option<Option<i32>> {
|
||||
match host.processes.exit_code(id) {
|
||||
Ok(exit) => exit,
|
||||
// Remote (SSH) runs, or a finished run already forgotten: the run list knows whether it runs.
|
||||
Err(_) => match crate::ops::run::list(host).into_iter().find(|r| r.id == id) {
|
||||
Err(_) => match crate::ops::run::run_list(host).into_iter().find(|r| r.id == id) {
|
||||
Some(r) if r.running => None,
|
||||
_ => Some(None),
|
||||
},
|
||||
@@ -298,7 +304,7 @@ async fn wait_exit(call: &Call, id: RunId, deadline: Option<Instant>) -> IdeResu
|
||||
tokio::select! {
|
||||
_ = tokio::time::sleep(Duration::from_millis(50)) => {}
|
||||
_ = call.cancel.cancelled() => {
|
||||
let _ = crate::ops::run::stop(&host, call.window(), id);
|
||||
let _ = crate::ops::run::run_stop(&host, call.window(), id);
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
}
|
||||
@@ -307,9 +313,9 @@ async fn wait_exit(call: &Call, id: RunId, deadline: Option<Instant>) -> IdeResu
|
||||
|
||||
/// An output callback that skips the IDE's own lines (`Process finished…`), as JetBrains
|
||||
/// skips `ProcessOutputType.SYSTEM`.
|
||||
fn process_output(mut f: impl FnMut(&str) + Send + 'static) -> crate::ops::Emit<OutputChunk> {
|
||||
fn process_output(mut f: impl FnMut(&str) + Send + 'static) -> crate::ops::Channel<OutputChunk> {
|
||||
let f = Mutex::new(move |t: &str| f(t));
|
||||
Arc::new(move |chunk: OutputChunk| match &chunk {
|
||||
crate::ops::Channel::new(move |chunk: OutputChunk| match &chunk {
|
||||
OutputChunk::Stdout { text } | OutputChunk::Stderr { text } => (f.lock())(text),
|
||||
OutputChunk::System { .. } => {}
|
||||
})
|
||||
@@ -350,7 +356,7 @@ async fn run_to_end(call: &Call, config: RunConfig, errors: &mut BuildErrors) ->
|
||||
t.drain(..cut);
|
||||
}
|
||||
});
|
||||
let info = crate::ops::run::start(&call.host(), call.window(), config, emit).await?;
|
||||
let info = crate::ops::run::run_start(&call.host(), call.window(), config, emit, None).await?;
|
||||
let exit = wait_exit(call, info.id, None).await?.flatten();
|
||||
if exit == Some(0) {
|
||||
return Ok(true);
|
||||
@@ -606,7 +612,7 @@ one by one",
|
||||
let output_path = collector.lock().path.clone();
|
||||
let sink = collector.clone();
|
||||
let emit = process_output(move |text| sink.lock().append(text));
|
||||
let info = match crate::ops::run::start(&call.host(), call.window(), config, emit).await {
|
||||
let info = match crate::ops::run::run_start(&call.host(), call.window(), config, emit, None).await {
|
||||
Ok(info) => info,
|
||||
Err(e) => {
|
||||
let _ = std::fs::remove_file(&output_path);
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
//! The `scope` argument of the query tools: the directory their results are limited to, a
|
||||
//! folder of the project or a project attached to it.
|
||||
|
||||
use crate::mcp::tool::{Call, Param, ParamType};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
pub fn param() -> Param {
|
||||
Param::optional(
|
||||
"scope",
|
||||
ParamType::String,
|
||||
"Directory to limit results to: relative to the project root, or absolute",
|
||||
)
|
||||
}
|
||||
|
||||
/// No `scope`: everything.
|
||||
pub struct Scope(Option<PathBuf>);
|
||||
|
||||
impl Scope {
|
||||
pub fn of(call: &Call) -> IdeResult<Self> {
|
||||
let Some(raw) = call.opt_str("scope")?.filter(|s| !s.trim().is_empty()) else { return Ok(Self(None)) };
|
||||
let given = Path::new(raw.trim());
|
||||
let path = crate::mcp::tool::normalize(&if given.is_absolute() {
|
||||
given.to_path_buf()
|
||||
} else {
|
||||
call.root().join(given)
|
||||
});
|
||||
let roots: Vec<PathBuf> =
|
||||
std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots()).collect();
|
||||
// Before touching the file system: on Windows, resolving `\\host\share` signs in to that host.
|
||||
if !ide_vfs::content_path_allowed(&path, &roots) {
|
||||
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
|
||||
}
|
||||
let path = dunce::canonicalize(&path).unwrap_or(path);
|
||||
if !path.is_dir() {
|
||||
return Err(IdeError::not_found(format!("scope {raw} is not a directory")));
|
||||
}
|
||||
if !roots.iter().any(|root| path.starts_with(root)) {
|
||||
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
|
||||
}
|
||||
Ok(Self(Some(path)))
|
||||
}
|
||||
|
||||
pub fn dir(&self) -> Option<&Path> {
|
||||
self.0.as_deref()
|
||||
}
|
||||
|
||||
pub fn contains(&self, path: &Path) -> bool {
|
||||
self.0.as_ref().is_none_or(|dir| path.starts_with(dir))
|
||||
}
|
||||
|
||||
/// For a path the tools return: project-relative with `/`, or absolute.
|
||||
pub fn contains_shown(&self, root: &Path, path: &str) -> bool {
|
||||
self.0.is_none() || self.contains(&root.join(path))
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@
|
||||
//! the editor (one per character except emoji and other astral characters).
|
||||
|
||||
use crate::mcp::page::{OFFSET, Page};
|
||||
use crate::mcp::scope::{self, Scope};
|
||||
use crate::mcp::tool::{Call, Output, Param, ParamType, Tool};
|
||||
use crate::mcp::util::{INDEXING_PARTIAL_RESULT_REASON, MEDIUM_TIMEOUT};
|
||||
use crate::ops::search::SearchEvent;
|
||||
@@ -67,6 +68,7 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|
||||
|call| async move { text_search(call, false).await },
|
||||
)
|
||||
.param(Param::required("q", ParamType::String, "Text to search for"))
|
||||
.param(scope::param())
|
||||
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
|
||||
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
@@ -89,6 +91,7 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|
||||
|call| async move { text_search(call, true).await },
|
||||
)
|
||||
.param(Param::required("q", ParamType::String, "Regex pattern to search for"))
|
||||
.param(scope::param())
|
||||
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
|
||||
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
@@ -110,6 +113,7 @@ If you don't find a suitable result, try again with include_external=true to sea
|
||||
|call| async move { symbol_search(call).await },
|
||||
)
|
||||
.param(Param::required("q", ParamType::String, "Symbol query text"))
|
||||
.param(scope::param())
|
||||
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
|
||||
.param(Param::optional(
|
||||
"include_external",
|
||||
@@ -136,6 +140,7 @@ Paths are optional additional glob filters relative to the project root.",
|
||||
|call| async move { file_search(call).await },
|
||||
)
|
||||
.param(Param::required("q", ParamType::String, "Glob pattern to search for"))
|
||||
.param(scope::param())
|
||||
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
|
||||
.param(Param::optional(
|
||||
"includeExcluded",
|
||||
@@ -312,7 +317,7 @@ async fn fill_lines(
|
||||
for item in items {
|
||||
let (Some(path), Some(line)) = (absolute(item), item.start_line) else { continue };
|
||||
if current.as_ref().is_none_or(|(p, _)| p != &path) {
|
||||
let text = crate::ops::fs::read_text(&host, call.window(), path.clone()).await.ok();
|
||||
let text = crate::ops::fs::fs_read_text(&host, call.window(), path.clone()).await.ok();
|
||||
let lines = text.map(|t| t.split('\n').map(|l| l.strip_suffix('\r').unwrap_or(l).to_owned()).collect());
|
||||
current = Some((path, lines));
|
||||
}
|
||||
@@ -539,6 +544,7 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
|
||||
let pattern = query(&call, if is_regex { "Regex pattern is empty" } else { "Search text is empty" })?;
|
||||
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
|
||||
let around = context(&call)?;
|
||||
let dir = Scope::of(&call)?;
|
||||
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
|
||||
// Globs Find in Files cannot take are applied afterwards, so the engine must not
|
||||
// stop at `limit` matches the filter may drop.
|
||||
@@ -559,7 +565,8 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
|
||||
whole_word: false,
|
||||
include,
|
||||
exclude,
|
||||
scope: SearchScope::Project,
|
||||
// Only `scope` is walked.
|
||||
scope: dir.dir().map_or(SearchScope::Project, |d| SearchScope::Directory { path: d.to_path_buf().into() }),
|
||||
max_matches,
|
||||
context: Default::default(),
|
||||
};
|
||||
@@ -568,8 +575,12 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
|
||||
}
|
||||
let (files, summary, timed_out) = run_search(&call, query.clone()).await?;
|
||||
// Content roots outside the project are reported by absolute path.
|
||||
let mut files: Vec<(String, FileMatches)> =
|
||||
files.into_iter().map(|f| (call.display(&f.path.0), f)).filter(|(path, _)| scope.matches(path)).collect();
|
||||
let mut files: Vec<(String, FileMatches)> = files
|
||||
.into_iter()
|
||||
.filter(|f| dir.contains(&f.path.0))
|
||||
.map(|f| (call.display(&f.path.0), f))
|
||||
.filter(|(path, _)| scope.matches(path))
|
||||
.collect();
|
||||
files.sort_by(|a, b| a.0.cmp(&b.0));
|
||||
// Only these can match a line break.
|
||||
let may_span = is_regex || pattern.contains('\n');
|
||||
@@ -584,7 +595,7 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
|
||||
// such lines are matched again in the file's whole text.
|
||||
let long = |m: &ide_search::LineMatch| m.text_offset > 0 || m.text.encode_utf16().count() + 1 >= LINE_WINDOW;
|
||||
let whole = if file.matches.iter().any(long) {
|
||||
crate::ops::fs::read_text(&host, call.window(), file.path.0.clone())
|
||||
crate::ops::fs::fs_read_text(&host, call.window(), file.path.0.clone())
|
||||
.await
|
||||
.ok()
|
||||
.and_then(|text| Some((ide_search::match_ranges(&text, &query).ok()?, text)))
|
||||
@@ -667,7 +678,7 @@ async fn extend_spanning(call: &Call, query: &SearchQuery, hits: &mut [TextHit],
|
||||
let mut current: Option<FileText> = None;
|
||||
for (i, path) in spanning {
|
||||
if current.as_ref().is_none_or(|(p, ..)| p != &path) {
|
||||
let Ok(text) = crate::ops::fs::read_text(&host, call.window(), path.clone()).await else { continue };
|
||||
let Ok(text) = crate::ops::fs::fs_read_text(&host, call.window(), path.clone()).await else { continue };
|
||||
let Ok(ranges) = ide_search::match_ranges(&text, query) else { continue };
|
||||
let starts = std::iter::once(0).chain(text.match_indices('\n').map(|(i, _)| i + 1)).collect();
|
||||
current = Some((path, text, starts, ranges));
|
||||
@@ -703,14 +714,14 @@ async fn run_search(call: &Call, query: SearchQuery) -> IdeResult<(Vec<FileMatch
|
||||
let request = crate::mcp::tool::request_id();
|
||||
let files = Arc::new(Mutex::new(Vec::new()));
|
||||
let done = Arc::new(Mutex::new(None));
|
||||
let emit: crate::ops::Emit<SearchEvent> = {
|
||||
let emit = {
|
||||
let (files, done) = (files.clone(), done.clone());
|
||||
Arc::new(move |event| match event {
|
||||
crate::ops::Channel::new(move |event: SearchEvent| match event {
|
||||
SearchEvent::File { file } => files.lock().push(file),
|
||||
SearchEvent::Done { summary } => *done.lock() = Some(summary),
|
||||
})
|
||||
};
|
||||
let search = crate::ops::search::start(&host, call.window(), request, query, emit);
|
||||
let search = crate::ops::search::search_start(&host, call.window(), request, query, emit);
|
||||
tokio::pin!(search);
|
||||
let mut timed_out = false;
|
||||
tokio::select! {
|
||||
@@ -739,6 +750,7 @@ async fn run_search(call: &Call, query: SearchQuery) -> IdeResult<(Vec<FileMatch
|
||||
async fn file_search(call: Call) -> IdeResult<Output> {
|
||||
let q = query(&call, "Glob pattern is empty")?;
|
||||
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
|
||||
let dir = Scope::of(&call)?;
|
||||
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
|
||||
let include_excluded = call.flag("includeExcluded", false)?;
|
||||
let glob = GlobSetBuilder::new()
|
||||
@@ -748,16 +760,19 @@ async fn file_search(call: Call) -> IdeResult<Output> {
|
||||
// Ignored names and "Exclude files" patterns, which `read_dir` does not flag.
|
||||
let excludes = if include_excluded { None } else { Some(FileMask::new(&[], &call.project().search_excludes())?) };
|
||||
let root = call.root().to_path_buf();
|
||||
// The project folder and the content roots its walk does not cover: those outside it and
|
||||
// those inside it that it skips as ignored.
|
||||
let roots: Vec<PathBuf> = std::iter::once(root.clone())
|
||||
.chain(
|
||||
call.project()
|
||||
.content_roots()
|
||||
.into_iter()
|
||||
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r)),
|
||||
)
|
||||
.collect();
|
||||
// `scope`, or the project folder and the content roots its walk does not cover: those
|
||||
// outside it and those inside it that it skips as ignored.
|
||||
let roots: Vec<PathBuf> = match dir.dir() {
|
||||
Some(dir) => vec![dir.to_path_buf()],
|
||||
None => std::iter::once(root.clone())
|
||||
.chain(
|
||||
call.project()
|
||||
.content_roots()
|
||||
.into_iter()
|
||||
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r)),
|
||||
)
|
||||
.collect(),
|
||||
};
|
||||
let host = call.host();
|
||||
let walk = Walk {
|
||||
host: host.clone(),
|
||||
@@ -807,7 +822,7 @@ impl Walk {
|
||||
/// Collects matching files under `dir` (inside the walked root `base`) depth first in
|
||||
/// name order; true when it stopped early: more than `limit` match or the time ran out.
|
||||
fn dir(&self, dir: &Path, base: &Path, found: &mut Vec<String>) -> bool {
|
||||
let Ok(mut entries) = tokio::runtime::Handle::current().block_on(crate::ops::fs::read_dir(
|
||||
let Ok(mut entries) = tokio::runtime::Handle::current().block_on(crate::ops::fs::fs_read_dir(
|
||||
&self.host,
|
||||
&self.window,
|
||||
dir.to_path_buf(),
|
||||
@@ -838,9 +853,9 @@ impl Walk {
|
||||
}
|
||||
}
|
||||
EntryKind::File => {
|
||||
// Files of content roots outside the project go by absolute path.
|
||||
// Files of content roots outside the project go by absolute path, with `/` as elsewhere.
|
||||
let path = relative_to_root(&self.root, &entry.path)
|
||||
.unwrap_or_else(|| entry.path.to_string_lossy().into_owned());
|
||||
.unwrap_or_else(|| entry.path.to_string_lossy().replace('\\', "/"));
|
||||
if self.glob.is_match(&path) && self.scope.matches(&path) {
|
||||
if found.len() == self.limit {
|
||||
return true;
|
||||
@@ -862,6 +877,7 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
|
||||
let q = query(&call, "Search query is empty")?;
|
||||
let (page, limit) = page(&call, SYMBOL_SEARCH_DEFAULT_LIMIT)?;
|
||||
let around = context(&call)?;
|
||||
let dir = Scope::of(&call)?;
|
||||
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
|
||||
let external = call.flag("include_external", false)?;
|
||||
let host = call.host();
|
||||
@@ -869,16 +885,30 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
|
||||
let indexing_before = project.index.status().indexing;
|
||||
let pool = if scope.is_all() { limit + 1 } else { ((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL) };
|
||||
let found = {
|
||||
let (project, q) = (project.clone(), q.clone());
|
||||
host.blocking(move || Ok(project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool))).await?
|
||||
let (project, q, dir) = (project.clone(), q.clone(), dir.dir().map(Path::to_path_buf));
|
||||
host.blocking(move || {
|
||||
Ok(match dir {
|
||||
// Filtered in the index: a pool cut before the filter could miss every match.
|
||||
Some(dir) => project
|
||||
.index
|
||||
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| p.starts_with(&dir), &|| false)
|
||||
.unwrap_or_default(),
|
||||
None => project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool),
|
||||
})
|
||||
})
|
||||
.await?
|
||||
};
|
||||
let mut items: Vec<SearchItem> = found
|
||||
.into_iter()
|
||||
.filter(|s| scope.matches(&s.rel_path))
|
||||
.map(|s| SearchItem {
|
||||
// By the path the other tools give: the index shows a root outside the project by its
|
||||
// folder name, which is no path to read.
|
||||
.filter(|s| dir.contains(&s.path.0))
|
||||
.map(|s| (call.display(&s.path.0), s))
|
||||
.filter(|(path, _)| scope.matches(path))
|
||||
.map(|(path, s)| SearchItem {
|
||||
name: Some(s.name),
|
||||
container: s.container.filter(|c| !c.is_empty()),
|
||||
..SearchItem::at(s.rel_path, s.range)
|
||||
..SearchItem::at(path, s.range)
|
||||
})
|
||||
.collect();
|
||||
let mut timed_out = false;
|
||||
@@ -886,11 +916,15 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
|
||||
let budget = MEDIUM_TIMEOUT.saturating_sub(started.elapsed());
|
||||
let (symbols, out_of_time) = workspace_symbols(&call, &q, budget).await;
|
||||
timed_out = out_of_time;
|
||||
let mut roots = project.content_roots();
|
||||
roots.extend(crate::mcp::tool::attached_projects(call.root()));
|
||||
for (name, container, location) in symbols {
|
||||
let path = location.uri.clone().unwrap_or_else(|| call.display(&location.path));
|
||||
// Project files obey `paths`; library symbols are what was asked for.
|
||||
let inside = location.uri.is_none() && !Path::new(&path).is_absolute();
|
||||
if inside && !scope.matches(&path) {
|
||||
// Project files (attached projects' too) obey `scope` and `paths`; library symbols
|
||||
// are what was asked for.
|
||||
let inside = location.uri.is_none()
|
||||
&& (!Path::new(&path).is_absolute() || roots.iter().any(|r| location.path.starts_with(r)));
|
||||
if inside && !(dir.contains_shown(call.root(), &path) && scope.matches(&path)) {
|
||||
continue;
|
||||
}
|
||||
let item = SearchItem {
|
||||
|
||||
@@ -211,6 +211,7 @@ pub fn find_references() -> Tool {
|
||||
Tool::new("find_references", "Find references using the language service and the IDE's project index. Positions are 1-based UTF-16. Reports incomplete results when analysis is still running.", |call| async move {
|
||||
let path = call.resolve_readable(&call.str("filePath")?).await?;
|
||||
let page = super::page::Page::of(&call, REFERENCES_LIMIT)?;
|
||||
let dir = super::scope::Scope::of(&call)?;
|
||||
let line = call.opt_i64("line")?.ok_or_else(|| IdeError::invalid("missing line"))?;
|
||||
let column = call.opt_i64("column")?.ok_or_else(|| IdeError::invalid("missing column"))?;
|
||||
let project = call.project.clone();
|
||||
@@ -248,7 +249,12 @@ pub fn find_references() -> Tool {
|
||||
// `classified`, when there, goes with `locations` one to one.
|
||||
if let serde_json::Value::Object(map) = &mut value {
|
||||
let mut list = |key: &str| match map.remove(key) { Some(serde_json::Value::Array(items)) => items, _ => Vec::new() };
|
||||
let (locations, classified) = (list("locations"), list("classified"));
|
||||
let (mut locations, mut classified) = (list("locations"), list("classified"));
|
||||
if dir.dir().is_some() {
|
||||
let inside = |l: &serde_json::Value| l["path"].as_str().is_some_and(|p| dir.contains(std::path::Path::new(p)));
|
||||
locations.retain(inside);
|
||||
classified.retain(|c| inside(&c["location"]));
|
||||
}
|
||||
let classified = page.take(classified, &mut serde_json::Map::new());
|
||||
let locations = page.take(locations, map);
|
||||
map.insert("locations".into(), locations.into());
|
||||
@@ -260,6 +266,7 @@ pub fn find_references() -> Tool {
|
||||
.param(Param::required("line", ParamType::Integer, "1-based line"))
|
||||
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
|
||||
.param(Param::optional("includeDeclaration", ParamType::Boolean, "Include declarations (default true)"))
|
||||
.param(super::scope::param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "References to return at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
|
||||
}
|
||||
|
||||
@@ -37,7 +37,12 @@ impl Call {
|
||||
.collect()
|
||||
}
|
||||
pub fn resolve_inside(&self, path: &str) -> IdeResult<PathBuf> {
|
||||
resolve_inside(self.root(), path)
|
||||
resolve_inside(self.root(), path).or_else(|e| {
|
||||
// An absolute path may name a trusted attached project, wherever it is.
|
||||
let absolute = path.starts_with("file://") || Path::new(path).is_absolute();
|
||||
let attached = if absolute { self.trusted_attachments() } else { Vec::new() };
|
||||
attached.iter().find_map(|root| resolve_inside(root, path).ok()).ok_or(e)
|
||||
})
|
||||
}
|
||||
pub async fn resolve_writable(&self, path: &str) -> IdeResult<PathBuf> {
|
||||
let path = self.resolve_inside(path)?;
|
||||
@@ -46,7 +51,24 @@ impl Call {
|
||||
}
|
||||
pub async fn check_writable(&self, path: &Path) -> IdeResult<()> {
|
||||
self.project.require_trust()?;
|
||||
ensure_inside(self.root(), path)
|
||||
self.ensure_writable_place(path)
|
||||
}
|
||||
/// `path` is inside the project or a trusted project attached to it.
|
||||
pub fn ensure_writable_place(&self, path: &Path) -> IdeResult<()> {
|
||||
ensure_inside(self.root(), path).or_else(|e| {
|
||||
if self.trusted_attachments().iter().any(|root| ensure_inside(root, path).is_ok()) {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(e)
|
||||
}
|
||||
})
|
||||
}
|
||||
/// The projects attached to this one that the user trusts (each is trusted on its own).
|
||||
fn trusted_attachments(&self) -> Vec<PathBuf> {
|
||||
attached_projects(self.root())
|
||||
.into_iter()
|
||||
.filter(|root| self.host.trust.trusted(root).unwrap_or(false))
|
||||
.collect()
|
||||
}
|
||||
pub async fn ask(&self, request: ide_core::event::McpUiRequest) -> IdeResult<()> {
|
||||
self.host.mcp_requests.ask(self, request).await
|
||||
@@ -300,3 +322,12 @@ pub fn resolve_inside(root: &Path, raw: &str) -> IdeResult<PathBuf> {
|
||||
pub fn ensure_inside(root: &Path, path: &Path) -> IdeResult<()> {
|
||||
resolve_inside(root, &path.to_string_lossy()).map(|_| ())
|
||||
}
|
||||
|
||||
/// The projects attached to the one at `root` (its workspace members), `root` itself left out.
|
||||
pub(crate) fn attached_projects(root: &Path) -> Vec<PathBuf> {
|
||||
ide_workspace::workspace::Workspace::load(root)
|
||||
.ok()
|
||||
.flatten()
|
||||
.map(|w| w.projects.into_iter().filter(|p| p != root).collect())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
@@ -29,7 +29,7 @@ fn relative_to(root: &Path, path: &Path) -> String {
|
||||
};
|
||||
match rel {
|
||||
Some(rel) => rel.to_string_lossy().replace('\\', "/"),
|
||||
None => path.to_string_lossy().into_owned(),
|
||||
None => path.to_string_lossy().replace('\\', "/"),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -266,11 +266,16 @@ By default all Git repositories are returned.",
|
||||
.map(|r| (r.root.into_path_buf(), r.head))
|
||||
.collect();
|
||||
let wanted = call.opt_str("repositoryPathRelativeToProject")?;
|
||||
let scope = super::scope::Scope::of(&call)?;
|
||||
let git = git_executable(&call);
|
||||
let mut roots: Vec<(PathBuf, Option<String>)> = match &wanted {
|
||||
// A repository asked for, or the one holding `scope`.
|
||||
let target = match &wanted {
|
||||
Some(wanted) => Some(call.resolve_inside(wanted)?),
|
||||
None => scope.dir().map(Path::to_path_buf),
|
||||
};
|
||||
let mut roots: Vec<(PathBuf, Option<String>)> = match target {
|
||||
None => repos,
|
||||
Some(wanted) => {
|
||||
let path = call.resolve_inside(wanted)?;
|
||||
Some(path) => {
|
||||
// The innermost repository containing the path.
|
||||
match innermost_repo(repos, &path) {
|
||||
Some(repo) => vec![repo],
|
||||
@@ -282,7 +287,8 @@ By default all Git repositories are returned.",
|
||||
vec![(root, branch)]
|
||||
}
|
||||
None => {
|
||||
return Err(IdeError::not_found(format!("No git repository found for path: {wanted}")));
|
||||
let shown = wanted.unwrap_or_else(|| call.display(&path));
|
||||
return Err(IdeError::not_found(format!("No git repository found for path: {shown}")));
|
||||
}
|
||||
},
|
||||
}
|
||||
@@ -293,12 +299,13 @@ By default all Git repositories are returned.",
|
||||
for (root, branch) in roots {
|
||||
let rel = relative_to_project(&call, &root);
|
||||
let (git, dir) = (git.clone(), root.clone());
|
||||
let entries = host
|
||||
let mut entries = host
|
||||
.blocking(move || read_status(&git, &dir, include_untracked, include_ignored))
|
||||
.await
|
||||
.map_err(|e| {
|
||||
IdeError::internal(format!("Failed to get git status for repository '{rel}': {}", e.message))
|
||||
})?;
|
||||
entries.retain(|e| scope.contains(&root.join(e.path.trim_end_matches('/'))));
|
||||
let count = |f: fn(&StatusEntry) -> bool| entries.iter().filter(|e| f(e)).count();
|
||||
let listed: Vec<Value> = entries
|
||||
.iter()
|
||||
@@ -345,6 +352,7 @@ By default all Git repositories are returned.",
|
||||
))
|
||||
.param(Param::optional("includeUntracked", ParamType::Boolean, "Whether to include untracked files"))
|
||||
.param(Param::optional("includeIgnored", ParamType::Boolean, "Whether to include ignored files"))
|
||||
.param(super::scope::param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Entries to return per repository at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
}
|
||||
|
||||
@@ -1,9 +1,8 @@
|
||||
//! Agents tool window: coding agent tasks of the project (over ACP). In a remote
|
||||
//! window they run on the host, next to the project they work on.
|
||||
use super::{Channel, Emit};
|
||||
use super::Channel;
|
||||
use crate::Host;
|
||||
use crate::agent_secrets::{AgentSecrets, Kept};
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_agent::registry::{AgentRegistry, RegistryPaths};
|
||||
use ide_agent::{
|
||||
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentEntry,
|
||||
@@ -11,6 +10,7 @@ use ide_agent::{
|
||||
ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput,
|
||||
McpTransport, NewAgentTask,
|
||||
};
|
||||
use ide_command::command;
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::{IdeError, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
|
||||
use ide_tools::InstallEvent;
|
||||
@@ -18,32 +18,47 @@ use std::collections::HashSet;
|
||||
use std::sync::{LazyLock, Mutex};
|
||||
|
||||
/// Streams the project's agent events to this window; returns every task.
|
||||
pub fn subscribe(host: &Host, window: &str, on_event: Emit<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
|
||||
Ok(host.project(window)?.agents.subscribe(on_event))
|
||||
#[command(trust = always)]
|
||||
pub fn agent_subscribe(host: &Host, window: &str, on_event: Channel<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
|
||||
Ok(host.project(window)?.agents.subscribe(std::sync::Arc::new(move |e| {
|
||||
let _ = on_event.send(e);
|
||||
})))
|
||||
}
|
||||
|
||||
pub fn providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn agent_providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
|
||||
host.require_trust(window)?;
|
||||
let mut providers = host.project(window)?.agents.providers();
|
||||
ide_agent::registry::mark_updates(®istry_paths(host), &mut providers);
|
||||
Ok(providers)
|
||||
}
|
||||
|
||||
/// Refreshes the selected agent's model catalog without sending a prompt.
|
||||
pub fn refresh_models(host: &Host, window: &str, provider: String, force: bool) -> IdeResult<AgentModelCatalog> {
|
||||
/// Refreshes the model catalog; force bypasses freshness, not the cooldown.
|
||||
#[command(trust = trusted)]
|
||||
pub fn agent_refresh_models(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
force: bool,
|
||||
model: Option<String>,
|
||||
) -> IdeResult<AgentModelCatalog> {
|
||||
// Refreshes the selected agent's model catalog without sending a prompt.
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.refresh_models(&provider, force)
|
||||
host.project(window)?.agents.refresh_models(&provider, force, model.as_deref())
|
||||
}
|
||||
|
||||
/// Overrides built-in agent `id`'s command with `command` (its agent file keeps the
|
||||
/// built-in's driver and arguments), or returns it to auto-detection with `None`.
|
||||
pub fn set_command(host: &Host, window: &str, id: String, command: Option<String>) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn agent_set_command(host: &Host, window: &str, id: String, command: Option<String>) -> IdeResult<()> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.set_builtin_command(&id, command)
|
||||
}
|
||||
|
||||
/// Environment variables built-in agent `id` starts with; empty clears them.
|
||||
pub fn set_env(
|
||||
/// Environment variables built-in agent `id` starts with (saved in its agent file);
|
||||
/// an empty map clears them.
|
||||
#[command(trust = trusted)]
|
||||
pub fn agent_set_env(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: String,
|
||||
@@ -82,7 +97,8 @@ fn join_err(e: impl std::fmt::Display) -> IdeError {
|
||||
|
||||
/// Agents of the ACP Registry this machine can run, with what is installed; the list
|
||||
/// saved earlier when the registry is unreachable. Cancel with `cancel_request(request)`.
|
||||
pub async fn registry_list(host: &Host, _window: &str, request: RequestId) -> IdeResult<AgentRegistry> {
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_registry_list(host: &Host, request: RequestId) -> IdeResult<AgentRegistry> {
|
||||
let paths = registry_paths(host);
|
||||
let cancel = host.begin_request(request);
|
||||
let result =
|
||||
@@ -124,15 +140,15 @@ impl Drop for Installing {
|
||||
}
|
||||
|
||||
/// Installs the registry's current version of agent `id` (also to update it), streaming
|
||||
/// progress through `on_event`; the agent then shows in `agent_providers`. Cancel with
|
||||
/// `cancel_request(request)`.
|
||||
pub async fn registry_install(
|
||||
/// progress through `on_event`. Cancel with `cancel_request(request)`.
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_registry_install(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
id: String,
|
||||
request: RequestId,
|
||||
on_event: Channel<InstallEvent>,
|
||||
) -> IdeResult<()> {
|
||||
// The agent then shows in `agent_providers`.
|
||||
let paths = registry_paths(host);
|
||||
let installing = Installing::begin(&id)?;
|
||||
let cancel = host.begin_request(request);
|
||||
@@ -183,7 +199,8 @@ pub async fn registry_install(
|
||||
}
|
||||
|
||||
/// Removes a registry agent: its agent file and installed files.
|
||||
pub async fn registry_remove(host: &Host, _window: &str, id: String) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_registry_remove(host: &Host, id: String) -> IdeResult<()> {
|
||||
let paths = registry_paths(host);
|
||||
tokio::task::spawn_blocking(move || ide_agent::registry::remove(&paths, &id)).await.map_err(join_err)??;
|
||||
for project in host.projects() {
|
||||
@@ -194,7 +211,8 @@ pub async fn registry_remove(host: &Host, _window: &str, id: String) -> IdeResul
|
||||
|
||||
/// Slash commands to complete for `provider` in `task`'s directory, or in the project
|
||||
/// before a task exists (skills and custom commands on disk included).
|
||||
pub async fn commands(
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_commands(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
@@ -204,26 +222,36 @@ pub async fn commands(
|
||||
}
|
||||
|
||||
/// Entries of `task`'s conversation, or of its subagent `subagent`'s.
|
||||
pub fn entries(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<Vec<AgentEntry>> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_entries(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<Vec<AgentEntry>> {
|
||||
host.project(window)?.agents.entries(&task, subagent)
|
||||
}
|
||||
|
||||
/// Sessions of the project on this machine that no task holds yet, newest first. Reads
|
||||
/// transcripts from disk on the blocking pool.
|
||||
pub async fn external_sessions(host: &Host, window: &str) -> IdeResult<Vec<ExternalSession>> {
|
||||
/// Sessions of the project on this machine that no task holds yet, newest first.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_external_sessions(host: &Host, window: &str) -> IdeResult<Vec<ExternalSession>> {
|
||||
// Reads transcripts from disk on the blocking pool.
|
||||
let agents = host.project(window)?.agents.clone();
|
||||
tokio::task::spawn_blocking(move || agents.external_sessions()).await.map_err(join_err)
|
||||
}
|
||||
|
||||
/// Imports an external session as a task: its first turn loads and replays it.
|
||||
pub async fn import_session(host: &Host, window: &str, provider: String, session_id: String) -> IdeResult<AgentTask> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_import_session(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
session_id: String,
|
||||
) -> IdeResult<AgentTask> {
|
||||
host.require_trust(window)?;
|
||||
let agents = host.project(window)?.agents.clone();
|
||||
tokio::task::spawn_blocking(move || agents.import_session(&provider, &session_id)).await.map_err(join_err)?
|
||||
}
|
||||
|
||||
pub async fn create(host: &Host, window: &str, mut request: NewAgentTask) -> IdeResult<AgentTask> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_create(host: &Host, window: &str, request: NewAgentTask) -> IdeResult<AgentTask> {
|
||||
host.require_trust(window)?;
|
||||
let mut request = request;
|
||||
let project = host.project(window)?;
|
||||
let root = project.root.clone();
|
||||
let requested = request.project_root.take();
|
||||
@@ -234,110 +262,123 @@ pub async fn create(host: &Host, window: &str, mut request: NewAgentTask) -> Ide
|
||||
}
|
||||
|
||||
/// Sends a message; while the agent works it is queued, or with `now` it interrupts the turn.
|
||||
pub async fn prompt(host: &Host, window: &str, task: String, prompt: AgentPrompt, now: bool) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_prompt(host: &Host, window: &str, task: String, prompt: AgentPrompt, now: bool) -> IdeResult<()> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.prompt(&task, prompt, now).await
|
||||
}
|
||||
|
||||
/// Drops a queued message and returns it (to edit it).
|
||||
pub fn unqueue(host: &Host, window: &str, task: String, queued: String) -> IdeResult<AgentQueued> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_unqueue(host: &Host, window: &str, task: String, queued: String) -> IdeResult<AgentQueued> {
|
||||
host.project(window)?.agents.unqueue(&task, &queued)
|
||||
}
|
||||
|
||||
/// Sends a queued message now, interrupting the current turn.
|
||||
pub fn send_queued_now(host: &Host, window: &str, task: String, queued: String) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_send_queued_now(host: &Host, window: &str, task: String, queued: String) -> IdeResult<()> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.send_queued_now(&task, &queued)
|
||||
host.project(window)?.agents.send_queued_now(&task, &queued).await
|
||||
}
|
||||
|
||||
/// Changes a session setting (model, mode, thinking effort…).
|
||||
pub async fn set_config(host: &Host, window: &str, task: String, option: String, value: String) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_set_config(host: &Host, window: &str, task: String, option: String, value: String) -> IdeResult<()> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.set_config(&task, &option, value).await
|
||||
}
|
||||
|
||||
/// Copies the task's conversation into a new task, up to its first `turns` turns (all when `None`).
|
||||
pub async fn fork(host: &Host, window: &str, task: String, turns: Option<u32>) -> IdeResult<AgentTask> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_fork(host: &Host, window: &str, task: String, turns: Option<u32>) -> IdeResult<AgentTask> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.fork(&task, turns).await
|
||||
}
|
||||
|
||||
/// Creates a temporary side conversation of `source`: lives in memory only, never
|
||||
/// persisted, not listed.
|
||||
pub async fn create_ephemeral(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: NewAgentTask,
|
||||
source: String,
|
||||
) -> IdeResult<AgentTask> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.create_ephemeral(request, &source).await
|
||||
}
|
||||
|
||||
/// Drops the task's turns after its first `turns`; returns the message of the first dropped one.
|
||||
pub async fn rollback(host: &Host, window: &str, task: String, turns: u32) -> IdeResult<Option<AgentPrompt>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_rollback(host: &Host, window: &str, task: String, turns: u32) -> IdeResult<Option<AgentPrompt>> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.rollback(&task, turns).await
|
||||
}
|
||||
|
||||
/// What the agent reports about itself when it starts, without opening a session.
|
||||
pub async fn probe(host: &Host, window: &str, provider: String, refresh: bool) -> IdeResult<AgentProbe> {
|
||||
/// What the agent reports about itself when it starts (no session: no MCP servers, hooks
|
||||
/// or sign-in run). Remembered until `refresh`.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_probe(host: &Host, window: &str, provider: String, refresh: bool) -> IdeResult<AgentProbe> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.probe(&provider, refresh).await
|
||||
}
|
||||
|
||||
/// Stops the task's current turn, or with `subagent` only that subagent's work.
|
||||
pub fn cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
|
||||
host.project(window)?.agents.cancel(&task, subagent)
|
||||
}
|
||||
|
||||
/// Stops one of the task's background tasks.
|
||||
pub async fn stop_background(host: &Host, window: &str, task: String, background: String) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_stop_background(host: &Host, window: &str, task: String, background: String) -> IdeResult<()> {
|
||||
host.project(window)?.agents.stop_background(&task, &background).await
|
||||
}
|
||||
|
||||
/// Answers a permission request; `option: None` cancels it.
|
||||
pub fn respond(host: &Host, window: &str, task: String, permission: u32, option: Option<String>) -> IdeResult<()> {
|
||||
/// Answers a permission request; `option: null` cancels it.
|
||||
#[command(trust = trusted)]
|
||||
pub fn agent_respond(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
permission: u32,
|
||||
option: Option<String>,
|
||||
) -> IdeResult<()> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.respond(&task, permission, option)
|
||||
}
|
||||
|
||||
pub fn archive(host: &Host, window: &str, task: String) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_archive(host: &Host, window: &str, task: String) -> IdeResult<()> {
|
||||
host.project(window)?.agents.archive(&task)
|
||||
}
|
||||
|
||||
pub fn unarchive(host: &Host, window: &str, task: String) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_unarchive(host: &Host, window: &str, task: String) -> IdeResult<()> {
|
||||
host.project(window)?.agents.unarchive(&task)
|
||||
}
|
||||
|
||||
pub fn rename(host: &Host, window: &str, task: String, title: String) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn agent_rename(host: &Host, window: &str, task: String, title: String) -> IdeResult<()> {
|
||||
host.project(window)?.agents.rename(&task, &title)
|
||||
}
|
||||
|
||||
pub async fn delete(host: &Host, window: &str, task: String, remove_worktree: bool) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_delete(host: &Host, window: &str, task: String, remove_worktree: bool) -> IdeResult<()> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.delete(&task, remove_worktree).await
|
||||
}
|
||||
|
||||
pub async fn changes(host: &Host, window: &str, task: String) -> IdeResult<Vec<AgentChange>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_changes(host: &Host, window: &str, task: String) -> IdeResult<Vec<AgentChange>> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.changes(&task).await
|
||||
}
|
||||
|
||||
/// The task's uncommitted changes and the commits made since it started.
|
||||
pub async fn grouped_changes(host: &Host, window: &str, task: String) -> IdeResult<AgentChanges> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_grouped_changes(host: &Host, window: &str, task: String) -> IdeResult<AgentChanges> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.grouped_changes(&task).await
|
||||
}
|
||||
|
||||
/// Content of `path` when the task started (left side of its diff).
|
||||
pub async fn base_text(host: &Host, window: &str, task: String, path: IpcPath) -> IdeResult<Option<String>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_base_text(host: &Host, window: &str, task: String, path: IpcPath) -> IdeResult<Option<String>> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.base_text(&task, path.into_path_buf()).await
|
||||
}
|
||||
|
||||
/// Rollback: the task's changed files among `paths` (all without) back as `view` compares them.
|
||||
pub async fn rollback_changes(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_rollback_changes(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
@@ -350,7 +391,8 @@ pub async fn rollback_changes(
|
||||
|
||||
/// Accept: copies a worktree task's changed files among `paths` (all without) into the
|
||||
/// local checkout, uncommitted; files the checkout changed itself are left alone and reported.
|
||||
pub async fn accept_changes(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_accept_changes(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
@@ -463,6 +505,7 @@ fn persist_mcp_map(
|
||||
host.global_settings.set(ide_workspace::settings::SettingsScope::Global, "agents.mcpServers", value)?;
|
||||
for p in host.projects() {
|
||||
p.settings.reload();
|
||||
p.agents.notify_mcp_servers_changed();
|
||||
p.sink.emit(event.clone());
|
||||
if kept == Kept::LocalFile {
|
||||
host.agent_secrets.notify_kept_locally(&p.sink);
|
||||
@@ -472,6 +515,7 @@ fn persist_mcp_map(
|
||||
McpScope::Workspace => {
|
||||
let p = project.ok_or_else(|| IdeError::invalid("Open a project to configure workspace MCP servers"))?;
|
||||
p.settings.set(ide_workspace::settings::SettingsScope::Project, "agents.mcpServers", value)?;
|
||||
p.agents.notify_mcp_servers_changed();
|
||||
p.sink.emit(event);
|
||||
}
|
||||
}
|
||||
@@ -539,20 +583,31 @@ pub(crate) fn session_mcp_servers(
|
||||
use ide_workspace::settings::SettingsScope;
|
||||
let mut user = settings.layer(SettingsScope::Global).agents.mcp_servers;
|
||||
fill_mcp_values(secrets, &mut user);
|
||||
let mut workspace = settings.layer(SettingsScope::Project).agents.mcp_servers;
|
||||
workspace.retain(|name, srv| approvals.approved(root, name, srv));
|
||||
ide_agent::mcp::servers_from_settings(&user, &workspace)
|
||||
let raw_workspace = settings.layer(SettingsScope::Project).agents.mcp_servers;
|
||||
let workspace = approvals.apply(root, raw_workspace.clone());
|
||||
let mut out = ide_agent::mcp::servers_from_settings(&user, &workspace);
|
||||
for srv in &mut out {
|
||||
if srv.scope == McpScope::Workspace
|
||||
&& let Some(raw) = raw_workspace.get(&srv.name)
|
||||
{
|
||||
srv.unapproved = !approvals.approved(root, &srv.name, raw);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Lists configured MCP servers across User (`settings.toml`) and Workspace (`.openidea/settings.toml`) scopes.
|
||||
pub fn mcp_list(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
|
||||
/// Lists configured and discovered MCP servers across User, Workspace, Plugin, and Built-In scopes.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_mcp_list(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
|
||||
// Configured servers of the User (`settings.toml`) and Workspace (`.openidea/settings.toml`) scopes.
|
||||
let (user, workspace, project) = mcp_maps(host, window);
|
||||
Ok(listed(host, project.as_ref(), &user, workspace))
|
||||
}
|
||||
|
||||
/// Creates or updates a User or Workspace MCP server and returns the updated list. A Workspace
|
||||
/// server saved here is one the user turned on.
|
||||
pub fn mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<Vec<McpServer>> {
|
||||
/// Creates or updates a User or Workspace MCP server and returns the updated list.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<Vec<McpServer>> {
|
||||
// A Workspace server saved here is one the user turned on.
|
||||
let approve: Vec<String> =
|
||||
(input.scope == McpScope::Workspace).then(|| input.name.trim().to_owned()).into_iter().collect();
|
||||
update_mcp_maps(host, window, &approve, |user, workspace, project_root| {
|
||||
@@ -561,8 +616,9 @@ pub fn mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<V
|
||||
}
|
||||
|
||||
/// Parses and saves one or more MCP servers from a pasted JSON snippet (`{"mcpServers": {...}}` or
|
||||
/// single server object). Workspace servers explicitly saved here by the user are approved.
|
||||
pub fn mcp_save_json(
|
||||
/// single server object).
|
||||
#[command(trust = always)]
|
||||
pub fn agent_mcp_save_json(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
scope: McpScope,
|
||||
@@ -570,6 +626,7 @@ pub fn mcp_save_json(
|
||||
fallback_name: Option<String>,
|
||||
agents: Vec<String>,
|
||||
) -> IdeResult<Vec<McpServer>> {
|
||||
// Workspace servers explicitly saved here by the user are approved.
|
||||
update_mcp_maps(host, window, &[], |user, workspace, project_root| {
|
||||
let saved = ide_agent::mcp::apply_save_json(
|
||||
user,
|
||||
@@ -585,7 +642,8 @@ pub fn mcp_save_json(
|
||||
}
|
||||
|
||||
/// Enables or disables an MCP server and returns the updated list.
|
||||
pub fn mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) -> IdeResult<Vec<McpServer>> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) -> IdeResult<Vec<McpServer>> {
|
||||
let approve: Vec<String> = ide_agent::mcp::parse_server_id(&id)
|
||||
.filter(|(scope, _)| enabled && *scope == McpScope::Workspace)
|
||||
.map(|(_, name)| name.to_owned())
|
||||
@@ -597,15 +655,17 @@ pub fn mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) ->
|
||||
}
|
||||
|
||||
/// Removes a User or Workspace MCP server and returns the updated list.
|
||||
pub fn mcp_remove(host: &Host, window: &str, id: String) -> IdeResult<Vec<McpServer>> {
|
||||
#[command(trust = always)]
|
||||
pub fn agent_mcp_remove(host: &Host, window: &str, id: String) -> IdeResult<Vec<McpServer>> {
|
||||
update_mcp_maps(host, window, &[], |user, workspace, _| {
|
||||
ide_agent::mcp::apply_remove(user, workspace, &id).map(|_| Vec::new())
|
||||
})
|
||||
}
|
||||
|
||||
/// Copies MCP servers from `.mcp.json` and `.vscode/mcp.json` into the workspace settings once;
|
||||
/// they stay off until the user turns them on.
|
||||
pub fn mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
|
||||
/// Copies MCP servers from `.mcp.json` and `.vscode/mcp.json` into the workspace settings once.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
|
||||
// They stay off until the user turns them on.
|
||||
update_mcp_maps(host, window, &[], |_, workspace, project_root| {
|
||||
let root = project_root.ok_or_else(|| "Open a project to import workspace MCP servers".to_string())?;
|
||||
ide_agent::mcp::apply_import(workspace, root);
|
||||
@@ -614,7 +674,8 @@ pub fn mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
|
||||
}
|
||||
|
||||
/// Discovers external MCP configuration files on disk (CLI user configs + workspace `.mcp.json`).
|
||||
pub async fn mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<McpExternalSource>> {
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<McpExternalSource>> {
|
||||
let project_root = host.project(window).ok().filter(|p| !p.light).map(|p| p.root.clone());
|
||||
let home = dirs::home_dir();
|
||||
tokio::task::spawn_blocking(move || {
|
||||
@@ -625,14 +686,15 @@ pub async fn mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<Mc
|
||||
}
|
||||
|
||||
/// Imports selected servers from discovered external MCP configuration files into User or Workspace scope.
|
||||
/// Imported Workspace entries remain unapproved (disabled) until the user explicitly enables them.
|
||||
pub async fn mcp_import_selected(
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_mcp_import_selected(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
scope: McpScope,
|
||||
selections: Vec<McpImportSelection>,
|
||||
overwrite: bool,
|
||||
) -> IdeResult<Vec<McpServer>> {
|
||||
// Imported Workspace entries remain unapproved (disabled) until the user explicitly enables them.
|
||||
let home = dirs::home_dir();
|
||||
update_mcp_maps(host, window, &[], move |user, workspace, project_root| {
|
||||
ide_agent::mcp::apply_import_selected(
|
||||
@@ -649,7 +711,8 @@ pub async fn mcp_import_selected(
|
||||
}
|
||||
|
||||
/// Tests an MCP server by connecting (`initialize`) and listing its tools (`tools/list`).
|
||||
pub async fn mcp_test(host: &Host, window: &str, id: String) -> IdeResult<McpProbeResult> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_mcp_test(host: &Host, window: &str, id: String) -> IdeResult<McpProbeResult> {
|
||||
host.require_trust(window)?;
|
||||
let (user, workspace, project) = mcp_maps(host, window);
|
||||
let (scope, name) = ide_agent::mcp::parse_server_id(&id)
|
||||
@@ -724,7 +787,10 @@ async fn probe_http_mcp_server(server: &ide_core::settings::AgentMcpServer) -> M
|
||||
if let Some(sid) = session_id.as_deref() {
|
||||
req = req.header("Mcp-Session-Id", sid);
|
||||
}
|
||||
let resp = req.send().await.map_err(|e| format!("Request to `{url}` failed: {e}"))?;
|
||||
let resp = req
|
||||
.send()
|
||||
.await
|
||||
.map_err(|e| format!("Request to `{url}` failed: {}", ide_http::client::describe(&e.without_url())))?;
|
||||
let status = resp.status();
|
||||
let next_session =
|
||||
resp.headers().get("mcp-session-id").and_then(|v| v.to_str().ok()).map(str::to_owned).or(session_id);
|
||||
@@ -826,8 +892,9 @@ fn parse_mcp_http_response(body: &str) -> Result<serde_json::Value, String> {
|
||||
Err("Unexpected non-JSON MCP response".into())
|
||||
}
|
||||
|
||||
/// Updates per-session MCP server enable/disable overrides on task `task`.
|
||||
pub fn set_mcp_overrides(
|
||||
/// Updates per-session MCP server enable/disable overrides on `task`.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_set_mcp_overrides(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
@@ -836,85 +903,6 @@ pub fn set_mcp_overrides(
|
||||
host.project(window)?.agents.set_mcp_overrides(&task, overrides)
|
||||
}
|
||||
|
||||
/// Commands of this module the remote server answers.
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("agent_subscribe", |c| async move { subscribe(&c.host, &c.window, c.channel("onEvent")?) });
|
||||
d.add("agent_providers", |c| async move { providers(&c.host, &c.window) });
|
||||
d.add("agent_refresh_models", |c| async move {
|
||||
refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?)
|
||||
});
|
||||
d.add("agent_set_command", |c| async move { set_command(&c.host, &c.window, c.arg("id")?, c.arg("command")?) });
|
||||
d.add("agent_set_env", |c| async move { set_env(&c.host, &c.window, c.arg("id")?, c.arg("env")?) });
|
||||
d.add("agent_registry_list", |c| async move { registry_list(&c.host, &c.window, c.arg("request")?).await });
|
||||
d.add("agent_registry_install", |c| async move {
|
||||
registry_install(&c.host, &c.window, c.arg("id")?, c.arg("request")?, c.sender("onEvent")?).await
|
||||
});
|
||||
d.add("agent_registry_remove", |c| async move { registry_remove(&c.host, &c.window, c.arg("id")?).await });
|
||||
d.add("agent_mcp_list", |c| async move { mcp_list(&c.host, &c.window) });
|
||||
d.add("agent_mcp_save", |c| async move { mcp_save(&c.host, &c.window, c.arg("input")?) });
|
||||
d.add("agent_mcp_save_json", |c| async move {
|
||||
mcp_save_json(&c.host, &c.window, c.arg("scope")?, c.arg("rawJson")?, c.arg("fallbackName")?, c.arg("agents")?)
|
||||
});
|
||||
d.add(
|
||||
"agent_mcp_set_enabled",
|
||||
|c| async move { mcp_set_enabled(&c.host, &c.window, c.arg("id")?, c.arg("enabled")?) },
|
||||
);
|
||||
d.add("agent_mcp_remove", |c| async move { mcp_remove(&c.host, &c.window, c.arg("id")?) });
|
||||
d.add("agent_mcp_import", |c| async move { mcp_import(&c.host, &c.window) });
|
||||
d.add("agent_mcp_discover_sources", |c| async move { mcp_discover_sources(&c.host, &c.window).await });
|
||||
d.add("agent_mcp_import_selected", |c| async move {
|
||||
mcp_import_selected(&c.host, &c.window, c.arg("scope")?, c.arg("selections")?, c.arg("overwrite")?).await
|
||||
});
|
||||
d.add("agent_mcp_test", |c| async move { mcp_test(&c.host, &c.window, c.arg("id")?).await });
|
||||
d.add("agent_set_mcp_overrides", |c| async move {
|
||||
set_mcp_overrides(&c.host, &c.window, c.arg("task")?, c.arg("overrides")?)
|
||||
});
|
||||
d.add("agent_commands", |c| async move { commands(&c.host, &c.window, c.arg("provider")?, c.arg("task")?).await });
|
||||
d.add("agent_entries", |c| async move { entries(&c.host, &c.window, c.arg("task")?, c.arg("subagent")?) });
|
||||
d.add("agent_create", |c| async move { create(&c.host, &c.window, c.arg("request")?).await });
|
||||
d.add("agent_external_sessions", |c| async move { external_sessions(&c.host, &c.window).await });
|
||||
d.add("agent_import_session", |c| async move {
|
||||
import_session(&c.host, &c.window, c.arg("provider")?, c.arg("sessionId")?).await
|
||||
});
|
||||
d.add("agent_prompt", |c| async move {
|
||||
prompt(&c.host, &c.window, c.arg("task")?, c.arg("prompt")?, c.arg("now")?).await
|
||||
});
|
||||
d.add("agent_unqueue", |c| async move { unqueue(&c.host, &c.window, c.arg("task")?, c.arg("queued")?) });
|
||||
d.add(
|
||||
"agent_send_queued_now",
|
||||
|c| async move { send_queued_now(&c.host, &c.window, c.arg("task")?, c.arg("queued")?) },
|
||||
);
|
||||
d.add("agent_set_config", |c| async move {
|
||||
set_config(&c.host, &c.window, c.arg("task")?, c.arg("option")?, c.arg("value")?).await
|
||||
});
|
||||
d.add("agent_fork", |c| async move { fork(&c.host, &c.window, c.arg("task")?, c.arg("turns")?).await });
|
||||
d.add("agent_rollback", |c| async move { rollback(&c.host, &c.window, c.arg("task")?, c.arg("turns")?).await });
|
||||
d.add("agent_probe", |c| async move { probe(&c.host, &c.window, c.arg("provider")?, c.arg("refresh")?).await });
|
||||
d.add("agent_cancel", |c| async move { cancel(&c.host, &c.window, c.arg("task")?, c.arg("subagent")?) });
|
||||
d.add("agent_stop_background", |call| async move {
|
||||
stop_background(&call.host, &call.window, call.arg("task")?, call.arg("background")?).await
|
||||
});
|
||||
d.add("agent_respond", |c| async move {
|
||||
respond(&c.host, &c.window, c.arg("task")?, c.arg("permission")?, c.arg("option")?)
|
||||
});
|
||||
d.add("agent_unarchive", |c| async move { unarchive(&c.host, &c.window, c.arg("task")?) });
|
||||
d.add("agent_rename", |c| async move { rename(&c.host, &c.window, c.arg("task")?, c.arg("title")?) });
|
||||
d.add("agent_archive", |c| async move { archive(&c.host, &c.window, c.arg("task")?) });
|
||||
d.add(
|
||||
"agent_delete",
|
||||
|c| async move { delete(&c.host, &c.window, c.arg("task")?, c.arg("removeWorktree")?).await },
|
||||
);
|
||||
d.add("agent_changes", |c| async move { changes(&c.host, &c.window, c.arg("task")?).await });
|
||||
d.add("agent_grouped_changes", |c| async move { grouped_changes(&c.host, &c.window, c.arg("task")?).await });
|
||||
d.add("agent_base_text", |c| async move { base_text(&c.host, &c.window, c.arg("task")?, c.arg("path")?).await });
|
||||
d.add("agent_rollback_changes", |c| async move {
|
||||
rollback_changes(&c.host, &c.window, c.arg("task")?, c.arg("paths")?, c.arg("view")?).await
|
||||
});
|
||||
d.add("agent_accept_changes", |c| async move {
|
||||
accept_changes(&c.host, &c.window, c.arg("task")?, c.arg("paths")?).await
|
||||
});
|
||||
}
|
||||
|
||||
fn validate_project_root(root: &std::path::Path, requested: Option<&std::path::Path>) -> IdeResult<std::path::PathBuf> {
|
||||
let Some(requested) = requested else {
|
||||
return Ok(root.to_path_buf());
|
||||
@@ -1023,3 +1011,49 @@ mod tests {
|
||||
assert!(!reloaded.approved(&tmp.path().join("other"), "extra", &extra));
|
||||
}
|
||||
}
|
||||
|
||||
ide_command::domain!(
|
||||
agent:
|
||||
agent_accept_changes,
|
||||
agent_archive,
|
||||
agent_base_text,
|
||||
agent_cancel,
|
||||
agent_changes,
|
||||
agent_commands,
|
||||
agent_create,
|
||||
agent_delete,
|
||||
agent_entries,
|
||||
agent_external_sessions,
|
||||
agent_fork,
|
||||
agent_grouped_changes,
|
||||
agent_import_session,
|
||||
agent_mcp_discover_sources,
|
||||
agent_mcp_import,
|
||||
agent_mcp_import_selected,
|
||||
agent_mcp_list,
|
||||
agent_mcp_remove,
|
||||
agent_mcp_save,
|
||||
agent_mcp_save_json,
|
||||
agent_mcp_set_enabled,
|
||||
agent_mcp_test,
|
||||
agent_probe,
|
||||
agent_prompt,
|
||||
agent_providers,
|
||||
agent_refresh_models,
|
||||
agent_registry_install,
|
||||
agent_registry_list,
|
||||
agent_registry_remove,
|
||||
agent_rename,
|
||||
agent_respond,
|
||||
agent_rollback,
|
||||
agent_rollback_changes,
|
||||
agent_send_queued_now,
|
||||
agent_set_command,
|
||||
agent_set_config,
|
||||
agent_set_env,
|
||||
agent_set_mcp_overrides,
|
||||
agent_stop_background,
|
||||
agent_subscribe,
|
||||
agent_unarchive,
|
||||
agent_unqueue,
|
||||
);
|
||||
@@ -6,7 +6,7 @@
|
||||
use crate::Host;
|
||||
use crate::Project;
|
||||
use crate::ops::Channel;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
use super::doc::blocking;
|
||||
use ide_analysis::{
|
||||
@@ -122,6 +122,7 @@ pub struct StructuralLanguage {
|
||||
|
||||
/// Inspect Code: diagnostics of every file in `scope` that a language server
|
||||
/// serves. Files stream through `on_event` as they finish; ends with `Done`.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn inspect_code(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -195,6 +196,7 @@ pub async fn inspect_code(
|
||||
}
|
||||
|
||||
/// Locate Duplicates over the files of `scope`.
|
||||
#[command(trust = always)]
|
||||
pub async fn analysis_locate_duplicates(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -217,7 +219,8 @@ pub async fn analysis_locate_duplicates(
|
||||
}
|
||||
|
||||
/// Languages Search Structurally supports (those with a bundled grammar).
|
||||
pub async fn structural_languages(host: &Host, _window: &str) -> IdeResult<Vec<StructuralLanguage>> {
|
||||
#[command(trust = always)]
|
||||
pub async fn structural_languages(host: &Host) -> IdeResult<Vec<StructuralLanguage>> {
|
||||
let syntax = host.syntax();
|
||||
let mut out: Vec<StructuralLanguage> = host
|
||||
.languages
|
||||
@@ -231,7 +234,8 @@ pub async fn structural_languages(host: &Host, _window: &str) -> IdeResult<Vec<S
|
||||
}
|
||||
|
||||
/// Checks a structural search template (and language) while the user types.
|
||||
pub async fn structural_validate(host: &Host, _window: &str, query: StructuralQuery) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn structural_validate(host: &Host, query: StructuralQuery) -> IdeResult<()> {
|
||||
let syntax = host.syntax();
|
||||
blocking(move || ide_analysis::validate_structural(&syntax, &query)).await
|
||||
}
|
||||
@@ -239,6 +243,7 @@ pub async fn structural_validate(host: &Host, _window: &str, query: StructuralQu
|
||||
/// Search Structurally over `scope`; files with matches stream through
|
||||
/// `on_event`, ending with `Done`. With a replacement, matches carry their
|
||||
/// replacement text (applied by the UI as a workspace edit).
|
||||
#[command(trust = always)]
|
||||
pub async fn structural_search(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -265,18 +270,11 @@ pub async fn structural_search(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Commands of this module the remote server answers.
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("inspect_code", |c| async move {
|
||||
inspect_code(&c.host, &c.window, c.arg("request")?, c.arg("scope")?, c.sender("onEvent")?).await
|
||||
});
|
||||
d.add("analysis_locate_duplicates", |c| async move {
|
||||
analysis_locate_duplicates(&c.host, &c.window, c.arg("request")?, c.arg("scope")?, c.arg("options")?).await
|
||||
});
|
||||
d.add("structural_languages", |c| async move { structural_languages(&c.host, &c.window).await });
|
||||
d.add("structural_validate", |c| async move { structural_validate(&c.host, &c.window, c.arg("query")?).await });
|
||||
d.add("structural_search", |c| async move {
|
||||
structural_search(&c.host, &c.window, c.arg("request")?, c.arg("scope")?, c.arg("query")?, c.sender("onEvent")?)
|
||||
.await
|
||||
});
|
||||
}
|
||||
ide_command::domain!(
|
||||
analysis:
|
||||
analysis_locate_duplicates,
|
||||
inspect_code,
|
||||
structural_languages,
|
||||
structural_search,
|
||||
structural_validate,
|
||||
);
|
||||
@@ -4,8 +4,8 @@ mod workspace;
|
||||
|
||||
use super::dependencies::{MavenCentralArtifacts, MavenCentralGroups, MavenCentralVersions};
|
||||
use crate::ops::Channel;
|
||||
use crate::rpc::Dispatcher;
|
||||
use crate::{Host, Project, apply_workspace_edit};
|
||||
use crate::{Host, Project};
|
||||
use ide_command::command;
|
||||
|
||||
use ide_build::compile::{self, BuildEvent, BuildKind, BuildResult};
|
||||
use ide_build::maven::PomGoto;
|
||||
@@ -126,6 +126,7 @@ fn with_profiles(mut model: BuildModel, cache: &Path) -> BuildModel {
|
||||
}
|
||||
|
||||
/// Maven and Gradle projects of the window's project, from the build files plus the last sync.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn build_model(host: &Host, window: &str) -> IdeResult<BuildModel> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
@@ -202,13 +203,15 @@ async fn set_gradle_projects(host: &Host, window: &str, paths: Vec<String>, link
|
||||
.map_err(join_err)?
|
||||
}
|
||||
|
||||
/// Links independent builds without changing their Gradle scripts.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn gradle_link_projects(host: &Host, window: &str, paths: Vec<String>) -> IdeResult<BuildModel> {
|
||||
// Links independent builds without changing their Gradle scripts.
|
||||
set_gradle_projects(host, window, paths, true).await
|
||||
}
|
||||
|
||||
/// Stops importing the selected independent builds; files and saved run configurations stay intact.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn gradle_unlink_projects(host: &Host, window: &str, paths: Vec<String>) -> IdeResult<BuildModel> {
|
||||
// Stops importing the selected independent builds; files and saved run configurations stay intact.
|
||||
set_gradle_projects(host, window, paths, false).await
|
||||
}
|
||||
|
||||
@@ -216,6 +219,7 @@ pub async fn gradle_unlink_projects(host: &Host, window: &str, paths: Vec<String
|
||||
/// background, reporting progress on `on_progress`; cancellable with `cancel_request(request)`.
|
||||
/// Returns the refreshed model; a failed build is reported in its `syncError`.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn build_sync(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -311,12 +315,11 @@ pub async fn build_sync(
|
||||
if completion_token.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
if tool == BuildTool::Gradle {
|
||||
// The sync may report project folders outside the project (`includeFlat`): index and list them.
|
||||
project.refresh_index_scope();
|
||||
let p = project.clone();
|
||||
tokio::task::spawn_blocking(move || p.refresh_repositories());
|
||||
}
|
||||
// Gradle may report project folders outside the project (`includeFlat`), and a Maven
|
||||
// reactor may have gained or dropped modules beside it: index and list them.
|
||||
project.refresh_index_scope();
|
||||
let p = project.clone();
|
||||
tokio::task::spawn_blocking(move || p.refresh_repositories());
|
||||
// New source folders and dependency versions: the Project view and External Libraries reload.
|
||||
project.sink.emit(ide_core::IdeEvent::ProjectRootsChanged { root: project.root.clone().into() });
|
||||
if tool == BuildTool::Maven
|
||||
@@ -420,7 +423,8 @@ fn declaring_pom(
|
||||
}
|
||||
|
||||
/// The `.toml` of a version catalog the build imports as `group:artifact:version`, once a
|
||||
/// build has downloaded it (`ide_sdk::libraries::published_version_catalog`).
|
||||
/// build has downloaded it.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn gradle_published_catalog(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -435,8 +439,8 @@ pub async fn gradle_published_catalog(
|
||||
.map_err(join_err)
|
||||
}
|
||||
|
||||
/// The resolved dependency tree of the Gradle project `gradle_path` (`:`, `:app`) for
|
||||
/// `configuration`, from Gradle's `dependencies` report; cancellable with `cancel_request(request)`.
|
||||
/// The resolved dependency tree of a Gradle project for one configuration (Dependency Analyzer).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn gradle_dependencies(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -446,6 +450,7 @@ pub async fn gradle_dependencies(
|
||||
request: RequestId,
|
||||
build_dir: Option<String>,
|
||||
) -> IdeResult<Vec<ide_build::GradleDependency>> {
|
||||
// `gradle_path` is `:`, `:app`…; the tree comes from Gradle's `dependencies` report.
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
let config = host.config_dir.clone();
|
||||
@@ -468,7 +473,15 @@ pub async fn gradle_dependencies(
|
||||
gradle_command: Some(gradle.command.clone()),
|
||||
..Default::default()
|
||||
};
|
||||
ide_build::gradle_dependencies(&scope.root, gradle, &options, &gradle_path, &configuration, &token)
|
||||
let dependencies =
|
||||
ide_build::gradle_dependencies(&scope.root, gradle, &options, &gradle_path, &configuration, &token)?;
|
||||
// What plugins read of the build (`build.dependencies`) instead of running Gradle.
|
||||
let report = ide_build::GradleReport { project: gradle_path, configuration, dependencies };
|
||||
let cache = ide_build::gradle::cache_dir(&scope.cache, &gradle.dir);
|
||||
if let Err(e) = ide_build::save_gradle_report(&scope.root, &cache, gradle, &report) {
|
||||
tracing::debug!("keeping the dependencies report of {}: {e}", report.project);
|
||||
}
|
||||
Ok(report.dependencies)
|
||||
})
|
||||
.await
|
||||
.map_err(join_err);
|
||||
@@ -476,7 +489,42 @@ pub async fn gradle_dependencies(
|
||||
result?
|
||||
}
|
||||
|
||||
/// What the Dependency Analyzer has of the builds of `project` at `root` (the project, or one
|
||||
/// of its workspace members), without running a build tool: the Maven modules as last synced
|
||||
/// and the Gradle reports read since the build files last changed.
|
||||
pub(crate) fn analyzed_dependencies(
|
||||
project: &Project,
|
||||
config: &Path,
|
||||
root: &Path,
|
||||
) -> IdeResult<crate::plugins::BuildGraph> {
|
||||
let mut graph = crate::plugins::BuildGraph::default();
|
||||
for scope in workspace::scopes(project, config)?.iter().filter(|s| root == project.root || s.root == root) {
|
||||
let settings = &scope.settings;
|
||||
let model = ide_build::load_linked(
|
||||
&scope.root,
|
||||
&scope.cache,
|
||||
ide_sdk::apply::maven_local_repository(&scope.root, settings),
|
||||
&settings.languages.java.maven,
|
||||
&settings.languages.java.gradle,
|
||||
);
|
||||
graph.maven.extend(model.maven.into_iter().flat_map(|m| m.projects));
|
||||
for build in &model.gradle {
|
||||
let reports =
|
||||
ide_build::gradle_reports(&scope.root, &ide_build::gradle::cache_dir(&scope.cache, &build.dir), build);
|
||||
// buildSrc can't be analyzed from the build, as in the Dependency Analyzer.
|
||||
for p in build.projects.iter().filter(|p| !p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc"))) {
|
||||
graph.gradle.push(crate::plugins::GradleModule {
|
||||
path: p.path.clone(),
|
||||
reports: reports.iter().filter(|r| r.project == p.path).cloned().collect(),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(graph)
|
||||
}
|
||||
|
||||
/// Where the direct dependency `dependency` of the Maven module `pom` is declared.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn maven_dependency_declaration(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -493,14 +541,15 @@ pub async fn maven_dependency_declaration(
|
||||
.map_err(join_err)?
|
||||
}
|
||||
|
||||
/// The go-to-declaration target at `pos` of the Maven POM `pom` (project-relative, or
|
||||
/// absolute for a parent POM opened from the local repository): the definition of the
|
||||
/// The go-to-declaration target at `pos` of a Maven POM: the definition of the
|
||||
/// `${property}` at the caret, or the `<dependencyManagement>` / `<pluginManagement>`
|
||||
/// entry providing the dependency's / plugin's version, along the parent chain (into
|
||||
/// the local repository when a parent is not in the project), else the artifact's own
|
||||
/// POM (a project module's, or the local repository's). `None` when nothing
|
||||
/// resolvable is under the caret.
|
||||
/// entry providing the dependency's / plugin's version, along the parent chain.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos: Pos) -> IdeResult<Option<PomGoto>> {
|
||||
// `pom` is project-relative, or absolute for a parent POM opened from the local repository.
|
||||
// The parent chain reaches into the local repository when a parent is not in the project;
|
||||
// without a managed version the target is the artifact's own POM (a project module's, or the
|
||||
// local repository's). `None` when nothing resolvable is under the caret.
|
||||
let project = host.project(window)?;
|
||||
tokio::task::spawn_blocking(move || {
|
||||
let given = Path::new(&pom);
|
||||
@@ -531,12 +580,8 @@ pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos:
|
||||
const CENTRAL_WAIT: std::time::Duration = std::time::Duration::from_secs(1);
|
||||
|
||||
/// Completion of the `<dependency>` coordinate the caret (`offset`, UTF-16) sits
|
||||
/// in the value of in the POM `doc`: the coordinates installed in the local
|
||||
/// repository (Settings › Maven's, else `~/.m2/repository`) — group ids,
|
||||
/// the chosen group's artifacts, the chosen artifact's versions — topped up
|
||||
/// with Maven Central's (the search endpoint's popular coordinates, the
|
||||
/// published version metadata), which the shared version cache keeps for the
|
||||
/// session. `None` when the caret is not in a `<dependency>` coordinate element.
|
||||
/// in the value of in the POM `doc`, from the local repository and Maven Central.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn maven_dependency_completion(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -544,6 +589,10 @@ pub async fn maven_dependency_completion(
|
||||
offset: u32,
|
||||
request: RequestId,
|
||||
) -> IdeResult<Option<PomCompletion>> {
|
||||
// The local repository is Settings › Maven's, else `~/.m2/repository` (group ids, the chosen
|
||||
// group's artifacts, the chosen artifact's versions), topped up with Maven Central's (the search
|
||||
// endpoint's popular coordinates, the published version metadata), which the shared version
|
||||
// cache keeps for the session. `None` when the caret is not in a `<dependency>` coordinate element.
|
||||
use ide_build::maven::completion::{PomCompletionKind, local_options};
|
||||
let project = host.project(window)?;
|
||||
let cache = host.dependency_versions.clone();
|
||||
@@ -613,6 +662,7 @@ pub async fn maven_dependency_completion(
|
||||
/// Adds an `<exclusion>` of `exclusion` to the declaration of the direct dependency
|
||||
/// `dependency` of the Maven module `pom`, through the open document when there is one
|
||||
/// (saved). Returns the declaration; nothing changes when it already excludes it.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn maven_exclude_dependency(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -630,7 +680,7 @@ pub async fn maven_exclude_dependency(
|
||||
files: vec![FileEdit::Edit { path: path.clone().into(), edits: vec![edit], version: None }],
|
||||
..Default::default()
|
||||
};
|
||||
apply_workspace_edit(&project.documents, &edit)?;
|
||||
project.documents.apply_workspace_edit(&edit)?;
|
||||
}
|
||||
Some(Exclusion::Present) => {}
|
||||
None => return Err(IdeError::not_found(format!("{dependency} is not declared in {}", path.display()))),
|
||||
@@ -737,6 +787,7 @@ fn cmake_plan(root: &Path, kind: BuildKind, configs: &[ide_run::RunConfig], id:
|
||||
/// with `cancel_request(request)`. Diagnostics of `clear` (the files of the previous build)
|
||||
/// are cleared first; the new messages are published as `build` diagnostics.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn build_run(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -835,12 +886,19 @@ pub async fn build_run(
|
||||
for (path, items) in compile::diagnostics(&result.messages) {
|
||||
sink.emit(IdeEvent::Diagnostics { path: path.into(), source: compile::DIAGNOSTICS_SOURCE.into(), items });
|
||||
}
|
||||
Ok(result)
|
||||
Ok::<_, IdeError>(result)
|
||||
})
|
||||
.await
|
||||
.map_err(join_err);
|
||||
host.end_request(request);
|
||||
result?
|
||||
let outcome = result??;
|
||||
// Maven generated sources (protobuf, gRPC) stay invisible to jdtls until the
|
||||
// folders the build wrote are attached. An up-to-date build skips Maven and
|
||||
// still needs this: the classes can already be on disk.
|
||||
if outcome.system == ide_build::compile::BuildSystem::Maven {
|
||||
project.lsp.sync_maven_generated_sources(&project.root).await;
|
||||
}
|
||||
Ok(outcome)
|
||||
}
|
||||
|
||||
/// Build › Compile File: compiles one Java source of a linked Maven module with
|
||||
@@ -848,6 +906,7 @@ pub async fn build_run(
|
||||
/// `cancel_request(request)`. Diagnostics of `clear` (the files of the previous
|
||||
/// build) are cleared first; the new messages are published as `build`
|
||||
/// diagnostics.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn build_compile_file(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -876,79 +935,16 @@ pub async fn build_compile_file(
|
||||
for (path, items) in compile::diagnostics(&result.messages) {
|
||||
sink.emit(IdeEvent::Diagnostics { path: path.into(), source: compile::DIAGNOSTICS_SOURCE.into(), items });
|
||||
}
|
||||
Ok(result)
|
||||
Ok::<_, IdeError>(result)
|
||||
})
|
||||
.await
|
||||
.map_err(join_err);
|
||||
host.end_request(request);
|
||||
result?
|
||||
}
|
||||
|
||||
/// Commands of this module the remote server answers.
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("build_model", |c| async move { build_model(&c.host, &c.window).await });
|
||||
d.add("gradle_link_projects", |c| async move { gradle_link_projects(&c.host, &c.window, c.arg("paths")?).await });
|
||||
d.add(
|
||||
"gradle_unlink_projects",
|
||||
|c| async move { gradle_unlink_projects(&c.host, &c.window, c.arg("paths")?).await },
|
||||
);
|
||||
d.add("build_sync", |c| async move {
|
||||
build_sync(
|
||||
&c.host,
|
||||
&c.window,
|
||||
c.arg("tool")?,
|
||||
c.arg("request")?,
|
||||
c.arg("offline")?,
|
||||
c.arg("profiles")?,
|
||||
c.arg("buildDir")?,
|
||||
c.sender("onProgress")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("gradle_published_catalog", |c| async move {
|
||||
gradle_published_catalog(&c.host, &c.window, c.arg("coordinates")?).await
|
||||
});
|
||||
d.add("gradle_dependencies", |c| async move {
|
||||
gradle_dependencies(
|
||||
&c.host,
|
||||
&c.window,
|
||||
c.arg("gradlePath")?,
|
||||
c.arg("configuration")?,
|
||||
c.arg("offline")?,
|
||||
c.arg("request")?,
|
||||
c.arg("buildDir")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("maven_dependency_declaration", |c| async move {
|
||||
maven_dependency_declaration(&c.host, &c.window, c.arg("pom")?, c.arg("dependency")?).await
|
||||
});
|
||||
d.add("maven_goto_declaration", |c| async move {
|
||||
maven_goto_declaration(&c.host, &c.window, c.arg("pom")?, c.arg("pos")?).await
|
||||
});
|
||||
d.add("maven_dependency_completion", |c| async move {
|
||||
maven_dependency_completion(&c.host, &c.window, c.arg("doc")?, c.arg("offset")?, c.arg("request")?).await
|
||||
});
|
||||
d.add("maven_exclude_dependency", |c| async move {
|
||||
maven_exclude_dependency(&c.host, &c.window, c.arg("pom")?, c.arg("dependency")?, c.arg("exclusion")?).await
|
||||
});
|
||||
d.add("build_run", |c| async move {
|
||||
build_run(
|
||||
&c.host,
|
||||
&c.window,
|
||||
c.arg("kind")?,
|
||||
c.arg("file")?,
|
||||
c.arg("cmake")?,
|
||||
c.arg("request")?,
|
||||
c.arg("clear")?,
|
||||
c.sender("onEvent")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("build_compile_file", |c| async move {
|
||||
build_compile_file(&c.host, &c.window, c.arg("file")?, c.arg("request")?, c.arg("clear")?, c.sender("onEvent")?)
|
||||
.await
|
||||
});
|
||||
let outcome = result??;
|
||||
if outcome.system == ide_build::compile::BuildSystem::Maven {
|
||||
project.lsp.sync_maven_generated_sources(&project.root).await;
|
||||
}
|
||||
Ok(outcome)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -1275,3 +1271,19 @@ mod maven_completion_tests {
|
||||
host.close_project("main");
|
||||
}
|
||||
}
|
||||
|
||||
ide_command::domain!(
|
||||
build:
|
||||
build_compile_file,
|
||||
build_model,
|
||||
build_run,
|
||||
build_sync,
|
||||
gradle_dependencies,
|
||||
gradle_link_projects,
|
||||
gradle_published_catalog,
|
||||
gradle_unlink_projects,
|
||||
maven_dependency_completion,
|
||||
maven_dependency_declaration,
|
||||
maven_exclude_dependency,
|
||||
maven_goto_declaration,
|
||||
);
|
||||
@@ -1,6 +1,6 @@
|
||||
//! Raw file bytes for the image viewer and hex view (see `ide_vfs::bytes`).
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
use crate::ops::doc::blocking;
|
||||
use ide_core::IdeResult;
|
||||
@@ -8,27 +8,24 @@ use ide_vfs::{ByteRange, FileProbe};
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// Size and text/binary classification, from the file's head only.
|
||||
pub async fn fs_probe(_host: &Host, _window: &str, path: PathBuf) -> IdeResult<FileProbe> {
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_probe(path: PathBuf) -> IdeResult<FileProbe> {
|
||||
blocking(move || ide_vfs::probe(&path)).await
|
||||
}
|
||||
|
||||
/// Up to `len` bytes from `offset` (capped per call), base64-encoded.
|
||||
pub async fn fs_read_range(_host: &Host, _window: &str, path: PathBuf, offset: u64, len: u32) -> IdeResult<ByteRange> {
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_read_range(path: PathBuf, offset: u64, len: u32) -> IdeResult<ByteRange> {
|
||||
blocking(move || ide_vfs::read_range(&path, offset, len)).await
|
||||
}
|
||||
|
||||
/// An image file as a `data:` URL. A network path is read only from a share an open project is
|
||||
/// on: the path may come from Markdown, and opening a share signs in to its server.
|
||||
pub async fn fs_read_image(host: &Host, _window: &str, path: PathBuf) -> IdeResult<String> {
|
||||
/// An image file as a `data:` URL.
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_read_image(host: &Host, path: PathBuf) -> IdeResult<String> {
|
||||
// A network path is read only from a share an open project is on: the path may come from
|
||||
// Markdown, and opening a share signs in to its server.
|
||||
let opened: Vec<PathBuf> = host.projects().iter().map(|project| project.root.clone()).collect();
|
||||
blocking(move || ide_vfs::read_data_url(&path, &opened)).await
|
||||
}
|
||||
|
||||
/// Commands of this module the remote server answers.
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("fs_probe", |c| async move { fs_probe(&c.host, &c.window, c.arg("path")?).await });
|
||||
d.add("fs_read_range", |c| async move {
|
||||
fs_read_range(&c.host, &c.window, c.arg("path")?, c.arg("offset")?, c.arg("len")?).await
|
||||
});
|
||||
d.add("fs_read_image", |c| async move { fs_read_image(&c.host, &c.window, c.arg("path")?).await });
|
||||
}
|
||||
ide_command::domain!(bytes: fs_probe, fs_read_image, fs_read_range);
|
||||
@@ -1,6 +1,6 @@
|
||||
//! Run with Coverage: launch plans and coverage reports.
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
|
||||
use ide_core::{IdeError, IdeResult, IpcPath};
|
||||
use ide_coverage::{CoveragePrepared, CoverageReportSpec, CoverageSuite};
|
||||
@@ -15,6 +15,7 @@ pub async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send
|
||||
|
||||
/// How to run `config` with coverage: the command to launch and where its report will be,
|
||||
/// or which tool is missing.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn coverage_prepare(host: &Host, window: &str, config: RunConfig) -> IdeResult<CoveragePrepared> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
@@ -27,21 +28,19 @@ pub async fn coverage_prepare(host: &Host, window: &str, config: RunConfig) -> I
|
||||
}
|
||||
|
||||
/// Reads the report a coverage run left behind.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn coverage_collect(host: &Host, window: &str, report: CoverageReportSpec) -> IdeResult<CoverageSuite> {
|
||||
host.require_trust(window)?;
|
||||
blocking(move || ide_coverage::collect(&report)).await
|
||||
}
|
||||
|
||||
/// Reads a report collected elsewhere (CI): lcov, a Go cover profile, JaCoCo XML or a SimpleCov resultset,
|
||||
/// Reads a report collected elsewhere (CI): lcov, a Go cover profile or JaCoCo XML,
|
||||
/// with paths mapped into this project.
|
||||
#[command(trust = always)]
|
||||
pub async fn coverage_import(host: &Host, window: &str, path: IpcPath) -> IdeResult<CoverageSuite> {
|
||||
// Also reads a SimpleCov resultset.
|
||||
let root = host.project(window)?.root.clone();
|
||||
blocking(move || ide_coverage::import(&path, &root)).await
|
||||
}
|
||||
|
||||
/// Commands of this module the remote server answers.
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("coverage_prepare", |c| async move { coverage_prepare(&c.host, &c.window, c.arg("config")?).await });
|
||||
d.add("coverage_collect", |c| async move { coverage_collect(&c.host, &c.window, c.arg("report")?).await });
|
||||
d.add("coverage_import", |c| async move { coverage_import(&c.host, &c.window, c.arg("path")?).await });
|
||||
}
|
||||
ide_command::domain!(coverage: coverage_collect, coverage_import, coverage_prepare);
|
||||
@@ -3,7 +3,7 @@
|
||||
//! shell: its path comes from a local save dialog, so the export must land
|
||||
//! on the user's machine, not the side the project runs on.
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
|
||||
use ide_db::split::SqlStatement;
|
||||
use ide_db::{
|
||||
@@ -24,172 +24,15 @@ pub struct StatementOutcome {
|
||||
pub error: Option<String>,
|
||||
}
|
||||
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("db_sources", |c| async move { sources(&c.host, &c.window) });
|
||||
d.add("db_save_sources", |c| async move {
|
||||
let sources = c.arg("sources")?;
|
||||
save_sources(&c.host, &c.window, sources).await
|
||||
});
|
||||
d.add("db_set_password", |c| async move {
|
||||
let (id, password, save) =
|
||||
(c.arg::<String>("id")?, c.arg::<Option<String>>("password")?, c.arg::<bool>("save")?);
|
||||
set_password(&c.host, &c.window, &id, password, save).await
|
||||
});
|
||||
d.add("db_test", |c| async move {
|
||||
let (source, password, ssh_secret) = (
|
||||
c.arg::<DataSource>("source")?,
|
||||
c.arg::<Option<String>>("password")?,
|
||||
c.arg::<Option<String>>("sshSecret")?,
|
||||
);
|
||||
test(&c.host, &c.window, source, password, ssh_secret).await
|
||||
});
|
||||
d.add("db_test_tunnel", |c| async move {
|
||||
let (source, ssh_secret) = (c.arg::<DataSource>("source")?, c.arg::<Option<String>>("sshSecret")?);
|
||||
test_tunnel(&c.host, &c.window, source, ssh_secret).await
|
||||
});
|
||||
d.add("db_set_ssh_secret", |c| async move {
|
||||
let (id, secret, save) = (c.arg::<String>("id")?, c.arg::<Option<String>>("secret")?, c.arg::<bool>("save")?);
|
||||
set_ssh_secret(&c.host, &c.window, &id, secret, save).await
|
||||
});
|
||||
d.add("db_trust_ssh_host", |c| async move {
|
||||
let id = c.arg::<String>("id")?;
|
||||
trust_ssh_host(&c.host, &c.window, &id).await
|
||||
});
|
||||
d.add("db_connected", |c| async move { connected(&c.host, &c.window) });
|
||||
d.add("db_connect", |c| async move {
|
||||
let id = c.arg::<String>("id")?;
|
||||
connect(&c.host, &c.window, &id).await
|
||||
});
|
||||
d.add("db_set_manual_commit", |c| async move {
|
||||
let (id, manual) = (c.arg::<String>("id")?, c.arg::<bool>("manual")?);
|
||||
set_manual_commit(&c.host, &c.window, &id, manual).await
|
||||
});
|
||||
d.add("db_finish_transaction", |c| async move {
|
||||
let (id, commit) = (c.arg::<String>("id")?, c.arg::<bool>("commit")?);
|
||||
finish_transaction(&c.host, &c.window, &id, commit).await
|
||||
});
|
||||
d.add("db_disconnect", |c| async move {
|
||||
let id = c.arg::<String>("id")?;
|
||||
disconnect(&c.host, &c.window, &id).await
|
||||
});
|
||||
d.add("db_databases", |c| async move {
|
||||
let id = c.arg::<String>("id")?;
|
||||
databases(&c.host, &c.window, &id).await
|
||||
});
|
||||
d.add("db_database_catalog", |c| async move {
|
||||
let (id, database) = (c.arg::<String>("id")?, c.arg::<String>("database")?);
|
||||
database_catalog(&c.host, &c.window, &id, &database).await
|
||||
});
|
||||
d.add("db_saved_catalog", |c| async move {
|
||||
let id = c.arg::<String>("id")?;
|
||||
saved_catalog(&c.host, &c.window, &id).await
|
||||
});
|
||||
d.add("db_retain_catalog", |c| async move {
|
||||
let (id, databases) = (c.arg::<String>("id")?, c.arg::<Vec<String>>("databases")?);
|
||||
retain_catalog(&c.host, &c.window, &id, databases).await
|
||||
});
|
||||
d.add("db_session_context", |c| async move {
|
||||
let id = c.arg::<String>("id")?;
|
||||
session_context(&c.host, &c.window, &id).await
|
||||
});
|
||||
d.add("db_schemas", |c| async move {
|
||||
let id = c.arg::<String>("id")?;
|
||||
schemas(&c.host, &c.window, &id).await
|
||||
});
|
||||
d.add("db_tables", |c| async move {
|
||||
let (id, schema) = (c.arg::<String>("id")?, c.arg::<String>("schema")?);
|
||||
tables(&c.host, &c.window, &id, &schema).await
|
||||
});
|
||||
d.add("db_table_details", |c| async move {
|
||||
let (id, schema, table) = (c.arg::<String>("id")?, c.arg::<String>("schema")?, c.arg::<String>("table")?);
|
||||
table_details(&c.host, &c.window, &id, &schema, &table).await
|
||||
});
|
||||
d.add("db_ddl", |c| async move {
|
||||
let (id, schema, table) = (c.arg::<String>("id")?, c.arg::<String>("schema")?, c.arg::<String>("table")?);
|
||||
ddl(&c.host, &c.window, &id, &schema, &table).await
|
||||
});
|
||||
d.add("db_schema_objects", |c| async move {
|
||||
let (id, schema) = (c.arg::<String>("id")?, c.arg::<String>("schema")?);
|
||||
schema_objects(&c.host, &c.window, &id, &schema).await
|
||||
});
|
||||
d.add("db_object_ddl", |c| async move {
|
||||
let (id, schema, kind, name) = (
|
||||
c.arg::<String>("id")?,
|
||||
c.arg::<String>("schema")?,
|
||||
c.arg::<DbObjectKind>("kind")?,
|
||||
c.arg::<String>("name")?,
|
||||
);
|
||||
object_ddl(&c.host, &c.window, &id, &schema, kind, &name).await
|
||||
});
|
||||
d.add("db_explain", |c| async move {
|
||||
let (request, id, statement) =
|
||||
(c.arg::<RequestId>("request")?, c.arg::<String>("id")?, c.arg::<String>("statement")?);
|
||||
let schema = c.arg::<Option<String>>("schema")?;
|
||||
explain(&c.host, &c.window, request, &id, &statement, schema.as_deref()).await
|
||||
});
|
||||
d.add("db_history", |c| async move {
|
||||
let id = c.arg::<String>("id")?;
|
||||
history(&c.host, &c.window, &id).await
|
||||
});
|
||||
d.add("db_remove_history", |c| async move {
|
||||
let (id, texts) = (c.arg::<String>("id")?, c.arg::<Option<Vec<String>>>("texts")?);
|
||||
remove_history(&c.host, &c.window, &id, texts).await
|
||||
});
|
||||
d.add("db_completion", |c| async move {
|
||||
let id = c.arg::<String>("id")?;
|
||||
completion(&c.host, &c.window, &id).await
|
||||
});
|
||||
d.add("db_statements", |c| async move {
|
||||
let (id, text, from, to) =
|
||||
(c.arg::<String>("id")?, c.arg::<String>("text")?, c.arg::<u32>("from")?, c.arg::<u32>("to")?);
|
||||
statements(&c.host, &c.window, &id, &text, from, to)
|
||||
});
|
||||
d.add("db_execute", |c| async move {
|
||||
let (request, id, statements, skip, max_rows) = (
|
||||
c.arg::<RequestId>("request")?,
|
||||
c.arg::<String>("id")?,
|
||||
c.arg::<Vec<SqlStatement>>("statements")?,
|
||||
c.arg::<Option<u32>>("skip")?.unwrap_or(0),
|
||||
c.arg::<u32>("maxRows")?,
|
||||
);
|
||||
let schema = c.arg::<Option<String>>("schema")?;
|
||||
execute(&c.host, &c.window, request, &id, statements, skip, max_rows, schema.as_deref()).await
|
||||
});
|
||||
d.add("db_table_page", |c| async move {
|
||||
let (request, id, schema, table) = (
|
||||
c.arg::<RequestId>("request")?,
|
||||
c.arg::<String>("id")?,
|
||||
c.arg::<String>("schema")?,
|
||||
c.arg::<String>("table")?,
|
||||
);
|
||||
let (filter, sort, offset, limit) = (
|
||||
c.arg::<Option<String>>("filter")?,
|
||||
c.arg::<Vec<SortKey>>("sort")?,
|
||||
c.arg::<u32>("offset")?,
|
||||
c.arg::<u32>("limit")?,
|
||||
);
|
||||
table_page(&c.host, &c.window, request, &id, &schema, &table, filter, sort, offset, limit).await
|
||||
});
|
||||
d.add("db_apply_edits", |c| async move {
|
||||
let (id, schema, table, edits) = (
|
||||
c.arg::<String>("id")?,
|
||||
c.arg::<String>("schema")?,
|
||||
c.arg::<String>("table")?,
|
||||
c.arg::<Vec<DbRowEdit>>("edits")?,
|
||||
);
|
||||
apply_edits(&c.host, &c.window, &id, &schema, &table, edits).await
|
||||
});
|
||||
d.add("db_console_path", |c| async move { console_path(&c.host, &c.arg::<String>("id")?) });
|
||||
d.add("db_consoles", |c| async move { consoles(&c.host, &c.arg::<String>("id")?, c.arg("create")?) });
|
||||
}
|
||||
|
||||
/// The data sources configured for the project (the tree's roots).
|
||||
pub fn sources(host: &Host, window: &str) -> IdeResult<Vec<DataSource>> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn db_sources(host: &Host, window: &str) -> IdeResult<Vec<DataSource>> {
|
||||
// The data sources configured for the project (the tree's roots).
|
||||
host.project(window)?.db.sources()
|
||||
}
|
||||
|
||||
/// Replaces the project's data sources with `sources`.
|
||||
pub async fn save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -> IdeResult<()> {
|
||||
// Replaces the project's data sources with `sources`.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.save_sources(sources).await?;
|
||||
let root = host.project(window)?.root.clone();
|
||||
@@ -199,222 +42,279 @@ pub async fn save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Remembers the password of data source `id` for the session, and in the OS
|
||||
/// saved passwords when `save` (`None` forgets it).
|
||||
pub async fn set_password(host: &Host, window: &str, id: &str, password: Option<String>, save: bool) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_set_password(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: String,
|
||||
password: Option<String>,
|
||||
save: bool,
|
||||
) -> IdeResult<()> {
|
||||
// Remembers the password of data source `id` for the session, and in the OS
|
||||
// saved passwords when `save` (`None` forgets it).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.set_password(id, password, save).await
|
||||
db.set_password(&id, password, save).await
|
||||
}
|
||||
|
||||
/// Test Connection: connects with unsaved settings and returns the server version.
|
||||
pub async fn test(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_test(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
source: DataSource,
|
||||
password: Option<String>,
|
||||
ssh_secret: Option<String>,
|
||||
) -> IdeResult<String> {
|
||||
// Test Connection: connects with unsaved settings and returns the server version.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.test(&source, password, ssh_secret).await
|
||||
}
|
||||
|
||||
/// Checks the SSH tunnel of `source` alone: SSH login and the SSH host reaching the database.
|
||||
pub async fn test_tunnel(
|
||||
/// Data Source › SSH/SSL › Test SSH Tunnel.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_test_tunnel(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
source: DataSource,
|
||||
ssh_secret: Option<String>,
|
||||
) -> IdeResult<String> {
|
||||
// Checks the SSH tunnel of `source` alone: SSH login and the SSH host reaching the database.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.test_tunnel(&source, ssh_secret).await
|
||||
}
|
||||
|
||||
/// Remembers the SSH password / key passphrase of a data source (see `set_password`).
|
||||
pub async fn set_ssh_secret(host: &Host, window: &str, id: &str, secret: Option<String>, save: bool) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_set_ssh_secret(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: String,
|
||||
secret: Option<String>,
|
||||
save: bool,
|
||||
) -> IdeResult<()> {
|
||||
// Remembers the SSH password / key passphrase of a data source (see `db_set_password`).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.set_ssh_secret(id, secret, save).await
|
||||
db.set_ssh_secret(&id, secret, save).await
|
||||
}
|
||||
|
||||
/// Trusts the SSH host key that made the last connection of `id` fail with
|
||||
/// "Unknown SSH host key" (records it in `~/.ssh/known_hosts`).
|
||||
pub async fn trust_ssh_host(host: &Host, window: &str, id: &str) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_trust_ssh_host(host: &Host, window: &str, id: String) -> IdeResult<()> {
|
||||
// Trusts the SSH host key that made the last connection of `id` fail with
|
||||
// "Unknown SSH host key" (records it in `~/.ssh/known_hosts`).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.trust_ssh_host(id).await
|
||||
db.trust_ssh_host(&id).await
|
||||
}
|
||||
|
||||
/// The data sources with an open connection.
|
||||
pub fn connected(host: &Host, window: &str) -> IdeResult<Vec<String>> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn db_connected(host: &Host, window: &str) -> IdeResult<Vec<String>> {
|
||||
// The data sources with an open connection.
|
||||
Ok(host.project(window)?.db.connected())
|
||||
}
|
||||
|
||||
/// Connects (fails with `permissionDenied` when the password is missing or wrong).
|
||||
pub async fn connect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_connect(host: &Host, window: &str, id: String) -> IdeResult<()> {
|
||||
// Connects (fails with `permissionDenied` when the password is missing or wrong).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.pool(id).await.map(|_| ())
|
||||
db.pool(&id).await.map(|_| ())
|
||||
}
|
||||
|
||||
/// Switches a data source between auto-commit and manual commit (leaving
|
||||
/// manual mode rolls back what was not committed).
|
||||
pub async fn set_manual_commit(host: &Host, window: &str, id: &str, manual: bool) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_set_manual_commit(host: &Host, window: &str, id: String, manual: bool) -> IdeResult<()> {
|
||||
// Switches a data source between auto-commit and manual commit (leaving
|
||||
// manual mode rolls back what was not committed).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.set_manual_commit(id, manual).await
|
||||
db.set_manual_commit(&id, manual).await
|
||||
}
|
||||
|
||||
/// Commits or rolls back the open transaction of a manual-commit data source.
|
||||
pub async fn finish_transaction(host: &Host, window: &str, id: &str, commit: bool) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_finish_transaction(host: &Host, window: &str, id: String, commit: bool) -> IdeResult<()> {
|
||||
// Commits or rolls back the open transaction of a manual-commit data source.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.finish_transaction(id, commit).await
|
||||
db.finish_transaction(&id, commit).await
|
||||
}
|
||||
|
||||
/// Closes the connection of data source `id`.
|
||||
pub async fn disconnect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_disconnect(host: &Host, window: &str, id: String) -> IdeResult<()> {
|
||||
// Closes the connection of data source `id`.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.disconnect(id).await;
|
||||
db.disconnect(&id).await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
|
||||
pub async fn databases(host: &Host, window: &str, id: &str) -> IdeResult<Databases> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_databases(host: &Host, window: &str, id: String) -> IdeResult<Databases> {
|
||||
// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.databases(id).await
|
||||
db.databases(&id).await
|
||||
}
|
||||
|
||||
/// The schemas of `database` of Snowflake data source `id` with their tables and views.
|
||||
pub async fn database_catalog(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_database_catalog(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: &str,
|
||||
database: &str,
|
||||
id: String,
|
||||
database: String,
|
||||
) -> IdeResult<Vec<ide_db::CatalogSchema>> {
|
||||
// The schemas of `database` of Snowflake data source `id` with their tables and views.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.database_catalog(id, database).await
|
||||
db.database_catalog(&id, &database).await
|
||||
}
|
||||
|
||||
/// What earlier introspection of data source `id` saved; the data source is not connected to.
|
||||
pub async fn saved_catalog(host: &Host, window: &str, id: &str) -> IdeResult<Option<ide_db::SourceCatalog>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_saved_catalog(host: &Host, window: &str, id: String) -> IdeResult<Option<ide_db::SourceCatalog>> {
|
||||
// What earlier introspection of data source `id` saved; the data source is not connected to.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.saved_catalog(id).await
|
||||
db.saved_catalog(&id).await
|
||||
}
|
||||
|
||||
/// Drops the saved databases of data source `id` that are not in `databases` any more.
|
||||
pub async fn retain_catalog(host: &Host, window: &str, id: &str, databases: Vec<String>) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_retain_catalog(host: &Host, window: &str, id: String, databases: Vec<String>) -> IdeResult<()> {
|
||||
// Drops the saved databases of data source `id` that are not in `databases` any more.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.retain_catalog(id, databases).await
|
||||
db.retain_catalog(&id, databases).await
|
||||
}
|
||||
|
||||
/// The warehouse and role of the Snowflake session of data source `id`, and what it may switch to.
|
||||
pub async fn session_context(host: &Host, window: &str, id: &str) -> IdeResult<ide_db::SessionContext> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_session_context(host: &Host, window: &str, id: String) -> IdeResult<ide_db::SessionContext> {
|
||||
// The warehouse and role of the Snowflake session of data source `id`, and what it may switch to.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.session_context(id).await
|
||||
db.session_context(&id).await
|
||||
}
|
||||
|
||||
/// The schemas of data source `id`.
|
||||
pub async fn schemas(host: &Host, window: &str, id: &str) -> IdeResult<Vec<String>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_schemas(host: &Host, window: &str, id: String) -> IdeResult<Vec<String>> {
|
||||
// The schemas of data source `id`.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.schemas(id).await
|
||||
db.schemas(&id).await
|
||||
}
|
||||
|
||||
/// The tables and views of `schema`.
|
||||
pub async fn tables(host: &Host, window: &str, id: &str, schema: &str) -> IdeResult<Vec<TableInfo>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_tables(host: &Host, window: &str, id: String, schema: String) -> IdeResult<Vec<TableInfo>> {
|
||||
// The tables and views of `schema`.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.tables(id, schema).await
|
||||
db.tables(&id, &schema).await
|
||||
}
|
||||
|
||||
/// Columns, keys and indexes of `table`.
|
||||
pub async fn table_details(host: &Host, window: &str, id: &str, schema: &str, table: &str) -> IdeResult<TableDetails> {
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.table_details(id, schema, table).await
|
||||
}
|
||||
|
||||
/// The DDL of table or view `table` (Go to DDL, Generate DDL).
|
||||
pub async fn ddl(host: &Host, window: &str, id: &str, schema: &str, table: &str) -> IdeResult<String> {
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.ddl(id, schema, table).await
|
||||
}
|
||||
|
||||
/// The routines and sequences of `schema` (the tree's `routines` / `sequences`).
|
||||
pub async fn schema_objects(host: &Host, window: &str, id: &str, schema: &str) -> IdeResult<SchemaObjects> {
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.schema_objects(id, schema).await
|
||||
}
|
||||
|
||||
/// The definition of a routine, trigger or sequence (Go to DDL, Quick Documentation).
|
||||
pub async fn object_ddl(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_table_details(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: &str,
|
||||
schema: &str,
|
||||
kind: DbObjectKind,
|
||||
name: &str,
|
||||
) -> IdeResult<String> {
|
||||
id: String,
|
||||
schema: String,
|
||||
table: String,
|
||||
) -> IdeResult<TableDetails> {
|
||||
// Columns, keys and indexes of `table`.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.object_ddl(id, schema, kind, name).await
|
||||
db.table_details(&id, &schema, &table).await
|
||||
}
|
||||
|
||||
/// Explain Plan: the execution plan of `statement` on `id`, without running it.
|
||||
pub async fn explain(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_ddl(host: &Host, window: &str, id: String, schema: String, table: String) -> IdeResult<String> {
|
||||
// The DDL of table or view `table` (Go to DDL, Generate DDL).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.ddl(&id, &schema, &table).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_schema_objects(host: &Host, window: &str, id: String, schema: String) -> IdeResult<SchemaObjects> {
|
||||
// The routines and sequences of `schema` (the tree's `routines` / `sequences`).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.schema_objects(&id, &schema).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_object_ddl(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: String,
|
||||
schema: String,
|
||||
kind: DbObjectKind,
|
||||
name: String,
|
||||
) -> IdeResult<String> {
|
||||
// The definition of a routine, trigger or sequence (Go to DDL, Quick Documentation).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.object_ddl(&id, &schema, kind, &name).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_explain(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
id: &str,
|
||||
statement: &str,
|
||||
schema: Option<&str>,
|
||||
id: String,
|
||||
statement: String,
|
||||
schema: Option<String>,
|
||||
) -> IdeResult<Vec<PlanNode>> {
|
||||
// Explain Plan: the execution plan of `statement` on `id`, without running it.
|
||||
let db = host.project(window)?.db.clone();
|
||||
let cancel = host.begin_request(request);
|
||||
let result = db.explain(id, statement, &cancel, schema).await;
|
||||
let result = db.explain(&id, &statement, &cancel, schema.as_deref()).await;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
/// The statements data source `id` ran, newest first (Browse Query History).
|
||||
pub async fn history(host: &Host, window: &str, id: &str) -> IdeResult<Vec<HistoryEntry>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_history(host: &Host, window: &str, id: String) -> IdeResult<Vec<HistoryEntry>> {
|
||||
// The statements data source `id` ran, newest first (Browse Query History).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.history(id).await
|
||||
db.history(&id).await
|
||||
}
|
||||
|
||||
/// Removes statements from the query history of `id` (`None`: all of them).
|
||||
pub async fn remove_history(host: &Host, window: &str, id: &str, texts: Option<Vec<String>>) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_remove_history(host: &Host, window: &str, id: String, texts: Option<Vec<String>>) -> IdeResult<()> {
|
||||
// Removes statements from the query history of `id` (`None`: all of them).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.remove_history(id, texts).await
|
||||
db.remove_history(&id, texts).await
|
||||
}
|
||||
|
||||
/// Tables, columns and foreign keys for SQL completion.
|
||||
pub async fn completion(host: &Host, window: &str, id: &str) -> IdeResult<CompletionModel> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_completion(host: &Host, window: &str, id: String) -> IdeResult<CompletionModel> {
|
||||
// Tables, columns and foreign keys for SQL completion.
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.completion(id).await
|
||||
db.completion(&id).await
|
||||
}
|
||||
|
||||
/// Statements a console runs: the selection's (`from < to`) or the one at the caret (`from`).
|
||||
pub fn statements(host: &Host, window: &str, id: &str, text: &str, from: u32, to: u32) -> IdeResult<Vec<SqlStatement>> {
|
||||
let driver = host.project(window)?.db.source(id)?.driver;
|
||||
#[command(trust = trusted)]
|
||||
pub fn db_statements(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: String,
|
||||
text: String,
|
||||
from: u32,
|
||||
to: u32,
|
||||
) -> IdeResult<Vec<SqlStatement>> {
|
||||
// Statements a console runs: the selection's (`from < to`) or the one at the caret (`from`).
|
||||
let driver = host.project(window)?.db.source(&id)?.driver;
|
||||
Ok(if from < to {
|
||||
ide_db::split::statements_in(text, from, to, driver)
|
||||
ide_db::split::statements_in(&text, from, to, driver)
|
||||
} else {
|
||||
ide_db::split::statement_at(text, from, driver).into_iter().collect()
|
||||
ide_db::split::statement_at(&text, from, driver).into_iter().collect()
|
||||
})
|
||||
}
|
||||
|
||||
/// Runs `statements` in order on data source `id`, stopping at the first
|
||||
/// error. Each result reads past its first `skip` rows (a later page) and keeps
|
||||
/// `max_rows`. `schema` is the console's active context: the connection running
|
||||
/// each statement is put in it first. Cancel with `cancel_request(request)`.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub async fn execute(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_execute(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
id: &str,
|
||||
id: String,
|
||||
statements: Vec<SqlStatement>,
|
||||
skip: u32,
|
||||
// Clients before pagination send no `skip`.
|
||||
#[default] skip: u32,
|
||||
max_rows: u32,
|
||||
schema: Option<&str>,
|
||||
schema: Option<String>,
|
||||
) -> IdeResult<Vec<StatementOutcome>> {
|
||||
// Runs `statements` in order on data source `id`, stopping at the first
|
||||
// error. Each result reads past its first `skip` rows (a later page) and keeps
|
||||
// `max_rows`. `schema` is the console's active context: the connection running
|
||||
// each statement is put in it first. Cancel with `cancel_request(request)`.
|
||||
let db = host.project(window)?.db.clone();
|
||||
let cancel = host.begin_request(request);
|
||||
let mut out = Vec::new();
|
||||
for statement in statements {
|
||||
match db.execute_from(id, &statement.text, skip as usize, max_rows.max(1) as usize, &cancel, schema).await {
|
||||
match db
|
||||
.execute_from(&id, &statement.text, skip as usize, max_rows.max(1) as usize, &cancel, schema.as_deref())
|
||||
.await
|
||||
{
|
||||
Ok(result) => out.push(StatementOutcome { statement, result: Some(result), error: None }),
|
||||
Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => {
|
||||
host.end_request(request);
|
||||
@@ -435,57 +335,62 @@ pub async fn execute(
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// One page of the rows of `table` (the table editor).
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub async fn table_page(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_table_page(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
id: &str,
|
||||
schema: &str,
|
||||
table: &str,
|
||||
id: String,
|
||||
schema: String,
|
||||
table: String,
|
||||
filter: Option<String>,
|
||||
sort: Vec<SortKey>,
|
||||
offset: u32,
|
||||
limit: u32,
|
||||
) -> IdeResult<TablePage> {
|
||||
// One page of the rows of `table` (the table editor).
|
||||
let db = host.project(window)?.db.clone();
|
||||
let cancel = host.begin_request(request);
|
||||
let result =
|
||||
db.table_page(id, schema, table, filter.as_deref(), &sort, offset.into(), limit.max(1).into(), &cancel).await;
|
||||
let result = db
|
||||
.table_page(&id, &schema, &table, filter.as_deref(), &sort, offset.into(), limit.max(1).into(), &cancel)
|
||||
.await;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
/// Submits the table editor's changes in one transaction; returns the rows changed.
|
||||
pub async fn apply_edits(
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_apply_edits(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: &str,
|
||||
schema: &str,
|
||||
table: &str,
|
||||
id: String,
|
||||
schema: String,
|
||||
table: String,
|
||||
edits: Vec<DbRowEdit>,
|
||||
) -> IdeResult<f64> {
|
||||
// Submits the table editor's changes in one transaction; returns the rows changed.
|
||||
let db = host.project(window)?.db.clone();
|
||||
Ok(db.apply_edits(id, schema, table, &edits).await? as f64)
|
||||
Ok(db.apply_edits(&id, &schema, &table, &edits).await? as f64)
|
||||
}
|
||||
|
||||
/// The query console file of data source `id` (`<dataDir>/consoles/db/<id>/console.sql`),
|
||||
/// created on first use. Consoles are files of the project, so a remote
|
||||
/// window resolves it on the host the project runs on.
|
||||
pub fn console_path(host: &Host, id: &str) -> IdeResult<IpcPath> {
|
||||
let file = console_dir(host, id)?.join("console.sql");
|
||||
#[command(trust = always)]
|
||||
pub fn db_console_path(host: &Host, id: String) -> IdeResult<IpcPath> {
|
||||
// The query console file of data source `id` (`<dataDir>/consoles/db/<id>/console.sql`),
|
||||
// created on first use. Consoles are files of the project, so a remote
|
||||
// window resolves it on the host the project runs on.
|
||||
let file = console_dir(host, &id)?.join("console.sql");
|
||||
if !file.exists() {
|
||||
std::fs::write(&file, "")?;
|
||||
}
|
||||
Ok(file.into())
|
||||
}
|
||||
|
||||
/// The query consoles of data source `id`: the default `console.sql`, then
|
||||
/// `console_1.sql`, `console_2.sql`… in order. `create` adds the next one first
|
||||
/// (DataGrip's New › Query Console).
|
||||
pub fn consoles(host: &Host, id: &str, create: bool) -> IdeResult<Vec<IpcPath>> {
|
||||
let dir = console_dir(host, id)?;
|
||||
/// The query consoles of data source `id`; `create` adds the next one first.
|
||||
#[command(trust = always)]
|
||||
pub fn db_consoles(host: &Host, id: String, create: bool) -> IdeResult<Vec<IpcPath>> {
|
||||
// The default `console.sql`, then `console_1.sql`, `console_2.sql`… in order
|
||||
// (`create`: DataGrip's New › Query Console).
|
||||
let dir = console_dir(host, &id)?;
|
||||
let default = dir.join("console.sql");
|
||||
let mut numbered: Vec<(u32, PathBuf)> = std::fs::read_dir(&dir)?
|
||||
.filter_map(|e| {
|
||||
@@ -532,3 +437,72 @@ fn console_dir(host: &Host, id: &str) -> IdeResult<PathBuf> {
|
||||
std::fs::create_dir_all(&dir)?;
|
||||
Ok(dir)
|
||||
}
|
||||
|
||||
/// Runs a client tool against target `id` until it exits or the request is cancelled.
|
||||
/// Desktop only: the file paths come from local dialogs.
|
||||
pub async fn run_tool(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
id: &str,
|
||||
executable: &std::path::Path,
|
||||
job: &ide_db::tools::DbToolJob,
|
||||
on_output: impl FnMut(Vec<ide_db::tools::ToolLine>),
|
||||
) -> IdeResult<Option<i32>> {
|
||||
let db = host.project(window)?.db.clone();
|
||||
let cancel = host.begin_request(request);
|
||||
let result = db.run_tool(id, executable, job, &cancel, on_output).await;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
pub fn tool_preview(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: &str,
|
||||
executable: &std::path::Path,
|
||||
job: &ide_db::tools::DbToolJob,
|
||||
) -> IdeResult<String> {
|
||||
host.project(window)?.db.tool_preview(id, executable, job)
|
||||
}
|
||||
|
||||
pub async fn server_version(host: &Host, window: &str, id: &str) -> IdeResult<u32> {
|
||||
host.project(window)?.db.server_version(id).await
|
||||
}
|
||||
|
||||
ide_command::domain!(
|
||||
db:
|
||||
db_apply_edits,
|
||||
db_completion,
|
||||
db_connect,
|
||||
db_connected,
|
||||
db_console_path,
|
||||
db_consoles,
|
||||
db_database_catalog,
|
||||
db_databases,
|
||||
db_ddl,
|
||||
db_disconnect,
|
||||
db_execute,
|
||||
db_explain,
|
||||
db_finish_transaction,
|
||||
db_history,
|
||||
db_object_ddl,
|
||||
db_remove_history,
|
||||
db_retain_catalog,
|
||||
db_save_sources,
|
||||
db_saved_catalog,
|
||||
db_schema_objects,
|
||||
db_schemas,
|
||||
db_session_context,
|
||||
db_set_manual_commit,
|
||||
db_set_password,
|
||||
db_set_ssh_secret,
|
||||
db_sources,
|
||||
db_statements,
|
||||
db_table_details,
|
||||
db_table_page,
|
||||
db_tables,
|
||||
db_test,
|
||||
db_test_tunnel,
|
||||
db_trust_ssh_host,
|
||||
);
|
||||
@@ -4,12 +4,13 @@ mod kotlin_tests;
|
||||
mod output;
|
||||
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
use ide_core::{DebugSessionId, IdeResult};
|
||||
use ide_dap::*;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// Starts a session owned by this window: its events (and those of child sessions) go here only.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> IdeResult<DebugSessionId> {
|
||||
host.require_trust(window)?;
|
||||
let unity_pid = if config.adapter == "unity" {
|
||||
@@ -31,6 +32,8 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let agents = if is_jvm_launch(&config) { ide_run::java_agent::current() } else { Default::default() };
|
||||
let config = add_java_agents(config, &agents.options);
|
||||
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
|
||||
if config.adapter == "debugpy"
|
||||
&& config.request == "launch"
|
||||
@@ -119,6 +122,15 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
|
||||
let server_port = debug_server_port(&config);
|
||||
let result = host.debugger.start_with(config, owner, custom).await;
|
||||
flush_output();
|
||||
if let Ok(id) = &result {
|
||||
let sink = host.window_sink(label);
|
||||
for note in &agents.notes {
|
||||
sink.emit(ide_core::IdeEvent::Debug {
|
||||
session: *id,
|
||||
event: ide_core::event::DebugEvent::Output { category: "console".into(), output: format!("{note}\n") },
|
||||
});
|
||||
}
|
||||
}
|
||||
if result.is_err()
|
||||
&& let Some(pid) = unity_pid
|
||||
{
|
||||
@@ -154,10 +166,54 @@ fn debug_server_port(config: &LaunchConfig) -> Option<u16> {
|
||||
fn attach_jvm_inspector(host: &Host, window: &str, session: DebugSessionId, port: u16) {
|
||||
let Ok(project) = host.project(window) else { return };
|
||||
let Some(module) = project.lsp.java_debug_server_module(port) else { return };
|
||||
let inspector = std::sync::Arc::new(ide_lsp::JdtJvmInspector::new(project.lsp.clone(), module));
|
||||
let inspector = std::sync::Arc::new(ide_lsp::JdtJvmInspector::new(project.lsp.clone(), module.clone()));
|
||||
if let Err(e) = host.debugger.set_jvm_inspector(session, inspector) {
|
||||
tracing::debug!("jvm inspector for session {session:?}: {e}");
|
||||
return;
|
||||
}
|
||||
let tracer = std::sync::Arc::new(ide_lsp::JdtStreamTracer::new(project.lsp.clone(), module));
|
||||
if let Err(e) = host.debugger.set_stream_tracer(session, tracer) {
|
||||
tracing::debug!("stream tracer for session {session:?}: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
/// A JVM the debugger starts itself: an Application or Spring Boot configuration, launched by
|
||||
/// java-debug or the Kotlin debugger (JAR Application debugs through a run with a JDWP agent).
|
||||
fn is_jvm_launch(config: &LaunchConfig) -> bool {
|
||||
config.request == "launch" && matches!(config.adapter.as_str(), "java-debug" | ide_dap::kotlin::ADAPTER)
|
||||
}
|
||||
|
||||
/// Plugins' Java agents ([`ide_run::java_agent`]) after the configuration's VM options:
|
||||
/// java-debug's `vmArgs` (one line, or a list) or the Kotlin debugger's `vmArguments` (a list).
|
||||
fn add_java_agents(mut config: LaunchConfig, options: &[String]) -> LaunchConfig {
|
||||
if options.is_empty() || !is_jvm_launch(&config) {
|
||||
return config;
|
||||
}
|
||||
let Some(serde_json::Value::Object(mut extra)) =
|
||||
config.extra_json.as_deref().and_then(|e| serde_json::from_str(e).ok())
|
||||
else {
|
||||
return config;
|
||||
};
|
||||
let key = if config.adapter == "java-debug" { "vmArgs" } else { "vmArguments" };
|
||||
let value = match extra.get(key) {
|
||||
None | Some(serde_json::Value::Null) if key == "vmArgs" => {
|
||||
ide_run::java_agent::add_to_vm_args_text("", options).into()
|
||||
}
|
||||
Some(serde_json::Value::String(text)) => ide_run::java_agent::add_to_vm_args_text(text, options).into(),
|
||||
None | Some(serde_json::Value::Null) | Some(serde_json::Value::Array(_)) => {
|
||||
let mut list: Vec<String> = extra
|
||||
.get(key)
|
||||
.and_then(serde_json::Value::as_array)
|
||||
.map(|a| a.iter().filter_map(|v| v.as_str().map(str::to_owned)).collect())
|
||||
.unwrap_or_default();
|
||||
ide_run::java_agent::add_to_vm_args(&mut list, options);
|
||||
list.into()
|
||||
}
|
||||
Some(_) => return config,
|
||||
};
|
||||
extra.insert(key.into(), value);
|
||||
config.extra_json = Some(serde_json::Value::Object(extra).to_string());
|
||||
config
|
||||
}
|
||||
|
||||
/// The JVM memory tab reads the class table over the attach socket, which only exists once the
|
||||
@@ -217,44 +273,38 @@ fn match_java_debug_encoding(mut config: LaunchConfig, windows: bool) -> LaunchC
|
||||
config
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_set_breakpoints(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
path: PathBuf,
|
||||
breakpoints: Vec<Breakpoint>,
|
||||
) -> IdeResult<Vec<BreakpointState>> {
|
||||
host.debugger.set_breakpoints(path, breakpoints).await
|
||||
}
|
||||
|
||||
pub async fn debug_threads(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<Vec<ThreadInfo>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_threads(host: &Host, session: DebugSessionId) -> IdeResult<Vec<ThreadInfo>> {
|
||||
host.debugger.threads(session).await
|
||||
}
|
||||
|
||||
pub async fn debug_stack_trace(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
thread_id: i64,
|
||||
) -> IdeResult<Vec<StackFrame>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_stack_trace(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<Vec<StackFrame>> {
|
||||
host.debugger.stack_trace(session, thread_id).await
|
||||
}
|
||||
|
||||
pub async fn debug_scopes(host: &Host, _window: &str, session: DebugSessionId, frame_id: i64) -> IdeResult<Vec<Scope>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_scopes(host: &Host, session: DebugSessionId, frame_id: i64) -> IdeResult<Vec<Scope>> {
|
||||
host.debugger.scopes(session, frame_id).await
|
||||
}
|
||||
|
||||
pub async fn debug_variables(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
reference: i64,
|
||||
) -> IdeResult<Vec<Variable>> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_variables(host: &Host, session: DebugSessionId, reference: i64) -> IdeResult<Vec<Variable>> {
|
||||
host.debugger.variables(session, reference).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_evaluate(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
frame_id: Option<i64>,
|
||||
expression: String,
|
||||
@@ -262,40 +312,38 @@ pub async fn debug_evaluate(
|
||||
host.debugger.evaluate(session, frame_id, expression).await
|
||||
}
|
||||
|
||||
pub async fn debug_resume(host: &Host, _window: &str, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_resume(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
|
||||
host.debugger.resume(session, thread_id).await
|
||||
}
|
||||
|
||||
pub async fn debug_pause(host: &Host, _window: &str, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_pause(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
|
||||
host.debugger.pause(session, thread_id).await
|
||||
}
|
||||
|
||||
/// Types `text` into the session's program (a `runInTerminal` program).
|
||||
pub async fn debug_send_input(host: &Host, _window: &str, session: DebugSessionId, text: String) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_send_input(host: &Host, session: DebugSessionId, text: String) -> IdeResult<()> {
|
||||
host.debugger.send_input(session, &text)
|
||||
}
|
||||
|
||||
pub async fn debug_hot_reload(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
|
||||
pub async fn debug_hot_reload(host: &Host, session: DebugSessionId) -> IdeResult<()> {
|
||||
host.debugger.hot_reload(session).await
|
||||
}
|
||||
|
||||
pub async fn debug_hot_restart(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
|
||||
pub async fn debug_hot_restart(host: &Host, session: DebugSessionId) -> IdeResult<()> {
|
||||
host.debugger.hot_restart(session).await
|
||||
}
|
||||
|
||||
pub async fn debug_step(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
thread_id: i64,
|
||||
kind: StepKind,
|
||||
) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_step(host: &Host, session: DebugSessionId, thread_id: i64, kind: StepKind) -> IdeResult<()> {
|
||||
host.debugger.step(session, thread_id, kind).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_run_to(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
thread_id: i64,
|
||||
path: PathBuf,
|
||||
@@ -305,14 +353,15 @@ pub async fn debug_run_to(
|
||||
host.debugger.run_to(session, thread_id, path, line, force).await
|
||||
}
|
||||
|
||||
pub async fn debug_stop(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn debug_stop(host: &Host, session: DebugSessionId) -> IdeResult<()> {
|
||||
host.debugger.stop(session).await
|
||||
}
|
||||
|
||||
/// The adapter's completions for an expression being typed in the frame `frame_id`.
|
||||
/// Completions for an expression typed in Evaluate (`line` / `column` 0-based, UTF-16).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_completions(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
frame_id: Option<i64>,
|
||||
text: String,
|
||||
@@ -323,9 +372,9 @@ pub async fn debug_completions(
|
||||
}
|
||||
|
||||
/// Evaluate with an explicit DAP context: `repl`, `watch`, `hover` or `clipboard`.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_evaluate_in(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
frame_id: Option<i64>,
|
||||
expression: String,
|
||||
@@ -335,31 +384,34 @@ pub async fn debug_evaluate_in(
|
||||
}
|
||||
|
||||
/// Last known verification states of a file's breakpoints (refetch on `breakpointsChanged`).
|
||||
pub fn debug_breakpoint_states(host: &Host, _window: &str, path: PathBuf) -> IdeResult<Vec<BreakpointState>> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn debug_breakpoint_states(host: &Host, path: PathBuf) -> IdeResult<Vec<BreakpointState>> {
|
||||
Ok(host.debugger.breakpoint_states(&path))
|
||||
}
|
||||
|
||||
/// This window's live sessions, including adapter-started child sessions.
|
||||
#[command(trust = always)]
|
||||
pub fn debug_sessions(host: &Host, window: &str) -> IdeResult<Vec<SessionInfo>> {
|
||||
Ok(host.debugger.sessions(Some(host.owner_window(window))))
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub fn debug_exception_filters(host: &Host, window: &str) -> IdeResult<Vec<SessionExceptionFilters>> {
|
||||
Ok(host.debugger.exception_filters(Some(host.owner_window(window))))
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_set_exception_breakpoints(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
choices: std::collections::BTreeMap<String, bool>,
|
||||
) -> IdeResult<()> {
|
||||
host.debugger.set_exception_breakpoints(choices).await
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_set_variable(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
container: i64,
|
||||
name: String,
|
||||
@@ -371,28 +423,24 @@ pub async fn debug_set_variable(
|
||||
}
|
||||
|
||||
/// Force Step Over: step over with every breakpoint suspended until the step ends.
|
||||
pub async fn debug_force_step_over(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
thread_id: i64,
|
||||
) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_force_step_over(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
|
||||
host.debugger.force_step_over(session, thread_id).await
|
||||
}
|
||||
|
||||
/// Smart Step Into: the calls on the current line of `frame_id`.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_step_in_targets(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
frame_id: i64,
|
||||
) -> IdeResult<Vec<StepInTarget>> {
|
||||
host.debugger.step_in_targets(session, frame_id).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_step_in_target(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
thread_id: i64,
|
||||
target_id: i64,
|
||||
@@ -401,13 +449,15 @@ pub async fn debug_step_in_target(
|
||||
}
|
||||
|
||||
/// Reset Frame (Drop Frame).
|
||||
pub async fn debug_restart_frame(host: &Host, _window: &str, session: DebugSessionId, frame_id: i64) -> IdeResult<()> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_restart_frame(host: &Host, session: DebugSessionId, frame_id: i64) -> IdeResult<()> {
|
||||
host.debugger.restart_frame(session, frame_id).await
|
||||
}
|
||||
|
||||
/// Breakpoints of a debugged page on DOM events and on requests (js-debug).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_js_custom_breakpoints(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
ids: Vec<String>,
|
||||
xhr: Vec<String>,
|
||||
@@ -415,61 +465,65 @@ pub async fn debug_js_custom_breakpoints(
|
||||
host.debugger.js_set_custom_breakpoints(session, ids, xhr).await
|
||||
}
|
||||
|
||||
/// The responses a debugged page gets in place of the server's, by a part of the URL; none
|
||||
/// switches the replacing off.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_js_response_overrides(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
rules: Vec<ide_dap::JsResponseRule>,
|
||||
) -> IdeResult<()> {
|
||||
host.debugger.js_set_response_overrides(session, rules).await
|
||||
}
|
||||
|
||||
/// The body of a response a debugged page received.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_js_response_body(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
request_id: String,
|
||||
) -> IdeResult<ide_dap::JsResponseBody> {
|
||||
host.debugger.js_response_body(session, request_id).await
|
||||
}
|
||||
|
||||
pub async fn debug_js_start_profile(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
|
||||
/// Starts recording a debugged page's CPU profile.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_js_start_profile(host: &Host, session: DebugSessionId) -> IdeResult<()> {
|
||||
host.debugger.js_start_profile(session).await
|
||||
}
|
||||
|
||||
pub async fn debug_js_stop_profile(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
) -> IdeResult<ide_core::IpcPath> {
|
||||
/// Ends the recording: a directory holding the profile as `page.cpuprofile`.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_js_stop_profile(host: &Host, session: DebugSessionId) -> IdeResult<ide_core::IpcPath> {
|
||||
host.debugger.js_stop_profile(session).await.map(Into::into)
|
||||
}
|
||||
|
||||
pub fn debug_capabilities(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<DebugCapabilities> {
|
||||
#[command(trust = trusted)]
|
||||
pub fn debug_capabilities(host: &Host, session: DebugSessionId) -> IdeResult<DebugCapabilities> {
|
||||
host.debugger.capabilities(session)
|
||||
}
|
||||
|
||||
/// Method breakpoints (all files); states aligned with `breakpoints`.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_set_function_breakpoints(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
breakpoints: Vec<FunctionBreakpoint>,
|
||||
) -> IdeResult<Vec<BreakpointState>> {
|
||||
host.debugger.set_function_breakpoints(breakpoints).await
|
||||
}
|
||||
|
||||
/// Field watchpoints; states aligned with `breakpoints`.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_set_data_breakpoints(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
breakpoints: Vec<DataBreakpoint>,
|
||||
) -> IdeResult<Vec<BreakpointState>> {
|
||||
host.debugger.set_data_breakpoints(breakpoints).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_data_breakpoint_info(
|
||||
host: &Host,
|
||||
_window: &str,
|
||||
session: DebugSessionId,
|
||||
container: i64,
|
||||
name: String,
|
||||
@@ -479,20 +533,23 @@ pub async fn debug_data_breakpoint_info(
|
||||
}
|
||||
|
||||
/// Attach to Process: the user's processes a debugger can attach to.
|
||||
pub async fn debug_attachable_processes(_host: &Host, _window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
|
||||
#[command(trust = always)]
|
||||
pub async fn debug_attachable_processes() -> IdeResult<Vec<attach::AttachableProcess>> {
|
||||
tokio::task::spawn_blocking(attach::attachable_processes)
|
||||
.await
|
||||
.map_err(|e| ide_core::IdeError::internal(format!("listing processes failed: {e}")))?
|
||||
}
|
||||
|
||||
/// A loopback port that is free right now, for a debug agent the launch line starts
|
||||
/// (`address=127.0.0.1:<port>`) — used when its "Listening for transport" line never reaches
|
||||
/// the console (a Surefire fork holds it until the tests run, which `suspend=y` prevents).
|
||||
/// A loopback port that is free right now, for a debug agent the launch line starts.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_free_port(host: &Host, window: &str) -> IdeResult<u16> {
|
||||
// `address=127.0.0.1:<port>` — used when its "Listening for transport" line never reaches
|
||||
// the console (a Surefire fork holds it until the tests run, which `suspend=y` prevents).
|
||||
host.require_trust(window)?;
|
||||
ide_dap::adapter::free_port().map_err(ide_core::IdeError::from)
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
@@ -506,26 +563,29 @@ pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<a
|
||||
|
||||
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
|
||||
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_listen_for_jvm(
|
||||
host: &Host,
|
||||
ide: &Host,
|
||||
window: &str,
|
||||
request: ide_core::RequestId,
|
||||
jvm_host: String,
|
||||
host: String,
|
||||
port: u16,
|
||||
) -> IdeResult<u16> {
|
||||
host.require_trust(window)?;
|
||||
let token = host.begin_request(request);
|
||||
let result = jdwp::listen_for_jvm(&jvm_host, port, token).await;
|
||||
host.end_request(request);
|
||||
ide.require_trust(window)?;
|
||||
let token = ide.begin_request(request);
|
||||
let result = jdwp::listen_for_jvm(&host, port, token).await;
|
||||
ide.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
/// HotSwap (Reload Changed Classes) in a java-debug session.
|
||||
pub async fn debug_redefine_classes(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<HotSwapResult> {
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_redefine_classes(host: &Host, session: DebugSessionId) -> IdeResult<HotSwapResult> {
|
||||
host.debugger.redefine_classes(session).await
|
||||
}
|
||||
|
||||
/// The debuggee JVM's loaded classes, or why they cannot be read.
|
||||
/// The debuggee JVM's loaded classes (instances and shallow bytes), or why they cannot be read.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_jvm_memory_classes(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -536,6 +596,7 @@ pub async fn debug_jvm_memory_classes(
|
||||
}
|
||||
|
||||
/// Up to `limit` live instances of the class in the stopped JVM.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_jvm_memory_instances(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -547,7 +608,8 @@ pub async fn debug_jvm_memory_instances(
|
||||
host.debugger.jvm_memory_instances(session, class_name, limit).await
|
||||
}
|
||||
|
||||
/// The fields (or array elements) of an instance listed by [`debug_jvm_memory_instances`].
|
||||
/// The fields (or array elements) of an instance in the stopped JVM.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_jvm_memory_fields(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -559,6 +621,7 @@ pub async fn debug_jvm_memory_fields(
|
||||
}
|
||||
|
||||
/// The objects that hold a reference to `object`; `limit` 0 selects the default.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_jvm_memory_referrers(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -570,166 +633,6 @@ pub async fn debug_jvm_memory_referrers(
|
||||
host.debugger.jvm_memory_referrers(session, object, limit).await
|
||||
}
|
||||
|
||||
/// Commands of this module the remote server answers.
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("debug_start", |c| async move { debug_start(&c.host, &c.window, c.arg("config")?).await });
|
||||
d.add("debug_set_breakpoints", |c| async move {
|
||||
debug_set_breakpoints(&c.host, &c.window, c.arg("path")?, c.arg("breakpoints")?).await
|
||||
});
|
||||
d.add("debug_threads", |c| async move { debug_threads(&c.host, &c.window, c.arg("session")?).await });
|
||||
d.add("debug_stack_trace", |c| async move {
|
||||
debug_stack_trace(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await
|
||||
});
|
||||
d.add(
|
||||
"debug_scopes",
|
||||
|c| async move { debug_scopes(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?).await },
|
||||
);
|
||||
d.add("debug_variables", |c| async move {
|
||||
debug_variables(&c.host, &c.window, c.arg("session")?, c.arg("reference")?).await
|
||||
});
|
||||
d.add("debug_evaluate", |c| async move {
|
||||
debug_evaluate(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?, c.arg("expression")?).await
|
||||
});
|
||||
d.add(
|
||||
"debug_resume",
|
||||
|c| async move { debug_resume(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await },
|
||||
);
|
||||
d.add(
|
||||
"debug_pause",
|
||||
|c| async move { debug_pause(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await },
|
||||
);
|
||||
d.add("debug_send_input", |c| async move {
|
||||
debug_send_input(&c.host, &c.window, c.arg("session")?, c.arg("text")?).await
|
||||
});
|
||||
d.add("debug_step", |c| async move {
|
||||
debug_step(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?, c.arg("kind")?).await
|
||||
});
|
||||
d.add("debug_run_to", |c| async move {
|
||||
debug_run_to(
|
||||
&c.host,
|
||||
&c.window,
|
||||
c.arg("session")?,
|
||||
c.arg("threadId")?,
|
||||
c.arg("path")?,
|
||||
c.arg("line")?,
|
||||
c.arg("force")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("debug_stop", |c| async move { debug_stop(&c.host, &c.window, c.arg("session")?).await });
|
||||
d.add("debug_completions", |c| async move {
|
||||
debug_completions(
|
||||
&c.host,
|
||||
&c.window,
|
||||
c.arg("session")?,
|
||||
c.arg("frameId")?,
|
||||
c.arg("text")?,
|
||||
c.arg("line")?,
|
||||
c.arg("column")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("debug_evaluate_in", |c| async move {
|
||||
debug_evaluate_in(
|
||||
&c.host,
|
||||
&c.window,
|
||||
c.arg("session")?,
|
||||
c.arg("frameId")?,
|
||||
c.arg("expression")?,
|
||||
c.arg("context")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("debug_breakpoint_states", |c| async move { debug_breakpoint_states(&c.host, &c.window, c.arg("path")?) });
|
||||
d.add("debug_sessions", |c| async move { debug_sessions(&c.host, &c.window) });
|
||||
d.add("debug_exception_filters", |c| async move { debug_exception_filters(&c.host, &c.window) });
|
||||
d.add("debug_set_exception_breakpoints", |c| async move {
|
||||
debug_set_exception_breakpoints(&c.host, &c.window, c.arg("choices")?).await
|
||||
});
|
||||
d.add("debug_set_variable", |c| async move {
|
||||
debug_set_variable(
|
||||
&c.host,
|
||||
&c.window,
|
||||
c.arg("session")?,
|
||||
c.arg("container")?,
|
||||
c.arg("name")?,
|
||||
c.arg("evaluateName")?,
|
||||
c.arg("frameId")?,
|
||||
c.arg("value")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("debug_force_step_over", |c| async move {
|
||||
debug_force_step_over(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await
|
||||
});
|
||||
d.add("debug_step_in_targets", |c| async move {
|
||||
debug_step_in_targets(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?).await
|
||||
});
|
||||
d.add("debug_step_in_target", |c| async move {
|
||||
debug_step_in_target(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?, c.arg("targetId")?).await
|
||||
});
|
||||
d.add("debug_restart_frame", |c| async move {
|
||||
debug_restart_frame(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?).await
|
||||
});
|
||||
d.add("debug_capabilities", |c| async move { debug_capabilities(&c.host, &c.window, c.arg("session")?) });
|
||||
d.add("debug_js_response_overrides", |c| async move {
|
||||
debug_js_response_overrides(&c.host, &c.window, c.arg("session")?, c.arg("rules")?).await
|
||||
});
|
||||
d.add("debug_js_response_body", |c| async move {
|
||||
debug_js_response_body(&c.host, &c.window, c.arg("session")?, c.arg("requestId")?).await
|
||||
});
|
||||
d.add("debug_js_custom_breakpoints", |c| async move {
|
||||
debug_js_custom_breakpoints(&c.host, &c.window, c.arg("session")?, c.arg("ids")?, c.arg("xhr")?).await
|
||||
});
|
||||
d.add(
|
||||
"debug_js_start_profile",
|
||||
|c| async move { debug_js_start_profile(&c.host, &c.window, c.arg("session")?).await },
|
||||
);
|
||||
d.add(
|
||||
"debug_js_stop_profile",
|
||||
|c| async move { debug_js_stop_profile(&c.host, &c.window, c.arg("session")?).await },
|
||||
);
|
||||
d.add("debug_set_function_breakpoints", |c| async move {
|
||||
debug_set_function_breakpoints(&c.host, &c.window, c.arg("breakpoints")?).await
|
||||
});
|
||||
d.add("debug_set_data_breakpoints", |c| async move {
|
||||
debug_set_data_breakpoints(&c.host, &c.window, c.arg("breakpoints")?).await
|
||||
});
|
||||
d.add("debug_data_breakpoint_info", |c| async move {
|
||||
debug_data_breakpoint_info(
|
||||
&c.host,
|
||||
&c.window,
|
||||
c.arg("session")?,
|
||||
c.arg("container")?,
|
||||
c.arg("name")?,
|
||||
c.arg("frameId")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("debug_attachable_processes", |c| async move { debug_attachable_processes(&c.host, &c.window).await });
|
||||
d.add("debug_free_port", |c| async move { debug_free_port(&c.host, &c.window).await });
|
||||
d.add("debug_unity_processes", |c| async move { debug_unity_processes(&c.host, &c.window).await });
|
||||
d.add("debug_listen_for_jvm", |c| async move {
|
||||
debug_listen_for_jvm(&c.host, &c.window, c.arg("request")?, c.arg("host")?, c.arg("port")?).await
|
||||
});
|
||||
d.add(
|
||||
"debug_redefine_classes",
|
||||
|c| async move { debug_redefine_classes(&c.host, &c.window, c.arg("session")?).await },
|
||||
);
|
||||
d.add("debug_jvm_memory_classes", |c| async move {
|
||||
debug_jvm_memory_classes(&c.host, &c.window, c.arg("session")?).await
|
||||
});
|
||||
d.add("debug_jvm_memory_instances", |c| async move {
|
||||
debug_jvm_memory_instances(&c.host, &c.window, c.arg("session")?, c.arg("className")?, c.arg("limit")?).await
|
||||
});
|
||||
d.add("debug_jvm_memory_fields", |c| async move {
|
||||
debug_jvm_memory_fields(&c.host, &c.window, c.arg("session")?, c.arg("object")?).await
|
||||
});
|
||||
d.add("debug_jvm_memory_referrers", |c| async move {
|
||||
debug_jvm_memory_referrers(&c.host, &c.window, c.arg("session")?, c.arg("object")?, c.arg("limit")?).await
|
||||
});
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -813,6 +716,36 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plugin_java_agents_join_the_vm_options_of_jvm_launches() {
|
||||
let agent = "-javaagent:/my plugins/agent.jar=port=0".to_owned();
|
||||
let options = std::slice::from_ref(&agent);
|
||||
let field = |config: &LaunchConfig, key: &str| {
|
||||
serde_json::from_str::<serde_json::Value>(config.extra_json.as_deref().unwrap()).unwrap()[key].clone()
|
||||
};
|
||||
let debugged =
|
||||
add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": "-Xmx1g"})), options);
|
||||
assert_eq!(vm_args(&debugged), "-Xmx1g \"-javaagent:/my plugins/agent.jar=port=0\"");
|
||||
assert_eq!(add_java_agents(debugged.clone(), options).extra_json, debugged.extra_json, "not added twice");
|
||||
let none = add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": null})), options);
|
||||
assert_eq!(vm_args(&none), "\"-javaagent:/my plugins/agent.jar=port=0\"");
|
||||
let list = add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": ["-Xmx1g"]})), options);
|
||||
assert_eq!(vm_args(&list), serde_json::json!(["-Xmx1g", agent]));
|
||||
let kotlin = launch(ide_dap::kotlin::ADAPTER, "launch", serde_json::json!({"vmArguments": ["-Xmx1g"]}));
|
||||
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!(["-Xmx1g", agent]));
|
||||
let kotlin = launch(ide_dap::kotlin::ADAPTER, "launch", serde_json::json!({}));
|
||||
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!([agent]));
|
||||
// Attaching (remote debug included), other adapters, and no granted agent: unchanged.
|
||||
for config in [
|
||||
launch("java-debug", "attach", serde_json::json!({"vmArgs": "-Xmx1g"})),
|
||||
launch("debugpy", "launch", serde_json::json!({"vmArgs": "-Xmx1g"})),
|
||||
] {
|
||||
assert_eq!(add_java_agents(config.clone(), options).extra_json, config.extra_json);
|
||||
}
|
||||
let config = launch("java-debug", "launch", serde_json::json!({"vmArgs": "-Xmx1g"}));
|
||||
assert_eq!(add_java_agents(config.clone(), &[]).extra_json, config.extra_json);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn debug_server_port_only_for_local_java_debug() {
|
||||
let port = |adapter: &str, request: &str, extra| debug_server_port(&launch(adapter, request, extra));
|
||||
@@ -833,3 +766,49 @@ mod tests {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ide_command::domain!(
|
||||
debug:
|
||||
debug_attachable_processes,
|
||||
debug_breakpoint_states,
|
||||
debug_capabilities,
|
||||
debug_completions,
|
||||
debug_data_breakpoint_info,
|
||||
debug_evaluate,
|
||||
debug_evaluate_in,
|
||||
debug_exception_filters,
|
||||
debug_force_step_over,
|
||||
debug_free_port,
|
||||
debug_js_custom_breakpoints,
|
||||
debug_js_response_body,
|
||||
debug_js_response_overrides,
|
||||
debug_js_start_profile,
|
||||
debug_js_stop_profile,
|
||||
debug_jvm_memory_classes,
|
||||
debug_jvm_memory_fields,
|
||||
debug_jvm_memory_instances,
|
||||
debug_jvm_memory_referrers,
|
||||
debug_listen_for_jvm,
|
||||
debug_pause,
|
||||
debug_redefine_classes,
|
||||
debug_restart_frame,
|
||||
debug_resume,
|
||||
debug_run_to,
|
||||
debug_scopes,
|
||||
debug_send_input,
|
||||
debug_sessions,
|
||||
debug_set_breakpoints,
|
||||
debug_set_data_breakpoints,
|
||||
debug_set_exception_breakpoints,
|
||||
debug_set_function_breakpoints,
|
||||
debug_set_variable,
|
||||
debug_stack_trace,
|
||||
debug_start,
|
||||
debug_step,
|
||||
debug_step_in_target,
|
||||
debug_step_in_targets,
|
||||
debug_stop,
|
||||
debug_threads,
|
||||
debug_unity_processes,
|
||||
debug_variables,
|
||||
);
|
||||
@@ -1,5 +1,6 @@
|
||||
//! Repository version lookups for manifest inspections and completion.
|
||||
use crate::{Host, rpc::Dispatcher};
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, RequestId};
|
||||
use ide_workspace::dependencies::{DependencyVersionSource, DependencyVersions, cargo, go, maven, npm};
|
||||
use std::collections::BTreeMap;
|
||||
@@ -193,7 +194,7 @@ fn go_source(project: &crate::Project, config_dir: &Path, path: &Path) -> IdeRes
|
||||
Ok(GoModules { root, env })
|
||||
}
|
||||
|
||||
/// `offset` limits a completion request to its version string; inspections omit it.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn dependency_versions(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -201,6 +202,7 @@ pub async fn dependency_versions(
|
||||
offset: Option<u32>,
|
||||
request: RequestId,
|
||||
) -> IdeResult<Vec<DependencyVersions>> {
|
||||
// `offset` limits a completion request to its version string; inspections omit it.
|
||||
let project = host.project(window)?;
|
||||
let cache = host.dependency_versions.clone();
|
||||
let config_dir = host.config_dir.clone();
|
||||
@@ -249,12 +251,6 @@ pub async fn dependency_versions(
|
||||
result
|
||||
}
|
||||
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("dependency_versions", |c| async move {
|
||||
dependency_versions(&c.host, &c.window, c.arg("doc")?, c.arg("offset")?, c.arg("request")?).await
|
||||
});
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -361,3 +357,5 @@ mod tests {
|
||||
host.close_project("main");
|
||||
}
|
||||
}
|
||||
|
||||
ide_command::domain!(dependencies: dependency_versions);
|
||||
@@ -1,4 +1,5 @@
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::{CancellationToken, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
|
||||
use ide_remote::{DeployedPath, DeploymentCoverage, DeploymentRoot, SyncEntry, SyncStep, TransferReport};
|
||||
use ide_ssh::{FsConnection, RemoteEntry};
|
||||
@@ -31,212 +32,204 @@ fn local(paths: Vec<IpcPath>) -> Vec<PathBuf> {
|
||||
paths.into_iter().map(|p| p.to_path_buf()).collect()
|
||||
}
|
||||
|
||||
/// Eligible paths per server, without contacting any deployment host.
|
||||
pub async fn deploy_coverage(window: &str, state: &Host, paths: Vec<IpcPath>) -> IdeResult<Vec<DeploymentCoverage>> {
|
||||
let project = state.project(window)?;
|
||||
#[command(trust = always)]
|
||||
pub async fn deploy_coverage(window: &str, host: &Host, paths: Vec<IpcPath>) -> IdeResult<Vec<DeploymentCoverage>> {
|
||||
// Eligible paths per server, without contacting any deployment host.
|
||||
let project = host.project(window)?;
|
||||
Ok(ide_remote::coverage(&project.settings.effective(), &project.root, &local(paths)))
|
||||
}
|
||||
|
||||
/// Tools › Deployment › Upload to…: files and folders to `server` (default server when `None`).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn deploy_upload(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
paths: Vec<IpcPath>,
|
||||
server: Option<String>,
|
||||
request: RequestId,
|
||||
) -> IdeResult<TransferReport> {
|
||||
let project = state.project(window)?;
|
||||
let token = state.begin_request(request);
|
||||
// Tools › Deployment › Upload to…: files and folders to `server` (default server when `None`).
|
||||
let project = host.project(window)?;
|
||||
let token = host.begin_request(request);
|
||||
let (mut report, done) = progress(project.sink.clone(), "Uploading", token.clone());
|
||||
let r = state
|
||||
let r = host
|
||||
.remote
|
||||
.upload(&project.settings.effective(), &project.root, server.as_deref(), &local(paths), token, &mut report)
|
||||
.await;
|
||||
done();
|
||||
state.end_request(request);
|
||||
host.end_request(request);
|
||||
r
|
||||
}
|
||||
|
||||
/// Download from…: the remote counterparts of files and folders.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn deploy_download(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
paths: Vec<IpcPath>,
|
||||
server: Option<String>,
|
||||
request: RequestId,
|
||||
) -> IdeResult<TransferReport> {
|
||||
let project = state.project(window)?;
|
||||
let token = state.begin_request(request);
|
||||
// Download from…: the remote counterparts of files and folders.
|
||||
let project = host.project(window)?;
|
||||
let token = host.begin_request(request);
|
||||
let (mut report, done) = progress(project.sink.clone(), "Downloading", token.clone());
|
||||
let r = state
|
||||
let r = host
|
||||
.remote
|
||||
.download(&project.settings.effective(), &project.root, server.as_deref(), &local(paths), token, &mut report)
|
||||
.await;
|
||||
done();
|
||||
state.end_request(request);
|
||||
host.end_request(request);
|
||||
r
|
||||
}
|
||||
|
||||
/// Deletes the remote counterparts of files and folders.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn deploy_delete_remote(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
paths: Vec<IpcPath>,
|
||||
server: Option<String>,
|
||||
) -> IdeResult<TransferReport> {
|
||||
let project = state.project(window)?;
|
||||
state.remote.delete_remote(&project.settings.effective(), &project.root, server.as_deref(), &local(paths)).await
|
||||
// Deletes the remote counterparts of files and folders.
|
||||
let project = host.project(window)?;
|
||||
host.remote.delete_remote(&project.settings.effective(), &project.root, server.as_deref(), &local(paths)).await
|
||||
}
|
||||
|
||||
/// Sync with Deployed: local and remote files under `path`, side by side.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn deploy_compare(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
path: IpcPath,
|
||||
server: Option<String>,
|
||||
request: RequestId,
|
||||
) -> IdeResult<Vec<SyncEntry>> {
|
||||
let project = state.project(window)?;
|
||||
let token = state.begin_request(request);
|
||||
let r = state.remote.compare(&project.settings.effective(), &project.root, server.as_deref(), &path, token).await;
|
||||
state.end_request(request);
|
||||
// Sync with Deployed: local and remote files under `path`, side by side.
|
||||
let project = host.project(window)?;
|
||||
let token = host.begin_request(request);
|
||||
let r = host.remote.compare(&project.settings.effective(), &project.root, server.as_deref(), &path, token).await;
|
||||
host.end_request(request);
|
||||
r
|
||||
}
|
||||
|
||||
/// Applies the Sync with Deployed choices.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn deploy_sync(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
steps: Vec<SyncStep>,
|
||||
server: Option<String>,
|
||||
request: RequestId,
|
||||
) -> IdeResult<TransferReport> {
|
||||
let project = state.project(window)?;
|
||||
let token = state.begin_request(request);
|
||||
// Applies the Sync with Deployed choices.
|
||||
let project = host.project(window)?;
|
||||
let token = host.begin_request(request);
|
||||
let (mut report, done) = progress(project.sink.clone(), "Synchronizing", token.clone());
|
||||
let r = state
|
||||
let r = host
|
||||
.remote
|
||||
.sync(&project.settings.effective(), &project.root, server.as_deref(), &steps, token, &mut report)
|
||||
.await;
|
||||
done();
|
||||
state.end_request(request);
|
||||
host.end_request(request);
|
||||
r
|
||||
}
|
||||
|
||||
/// Where `path` is deployed (remote path, web URL); `None` when not mapped.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn deploy_info(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
path: IpcPath,
|
||||
server: Option<String>,
|
||||
) -> IdeResult<Option<DeployedPath>> {
|
||||
let project = state.project(window)?;
|
||||
state.remote.deployed(&project.settings.effective(), &project.root, server.as_deref(), &path).await
|
||||
// Where `path` is deployed (remote path, web URL); `None` when not mapped.
|
||||
let project = host.project(window)?;
|
||||
host.remote.deployed(&project.settings.effective(), &project.root, server.as_deref(), &path).await
|
||||
}
|
||||
|
||||
/// Remote Host tool window: the resolved server root and project mappings.
|
||||
pub async fn deploy_server_root(window: &str, state: &Host, server: String) -> IdeResult<DeploymentRoot> {
|
||||
let project = state.project(window).ok();
|
||||
let settings =
|
||||
project.as_ref().map(|p| p.settings.effective()).unwrap_or_else(|| state.global_settings.effective());
|
||||
state.remote.server_info(&settings, project.as_ref().map(|p| p.root.as_path()), &server).await
|
||||
#[command(trust = trusted)]
|
||||
pub async fn deploy_server_root(window: &str, host: &Host, server: String) -> IdeResult<DeploymentRoot> {
|
||||
// Remote Host tool window: the resolved server root and project mappings.
|
||||
let project = host.project(window).ok();
|
||||
let settings = project.as_ref().map(|p| p.settings.effective()).unwrap_or_else(|| host.global_settings.effective());
|
||||
host.remote.server_info(&settings, project.as_ref().map(|p| p.root.as_path()), &server).await
|
||||
}
|
||||
|
||||
/// Entries of a folder on the selected filesystem (`~`: its home directory).
|
||||
pub async fn remote_list(state: &Host, connection: FsConnection, path: String) -> IdeResult<Vec<RemoteEntry>> {
|
||||
state.remote.list(&connection, &path).await
|
||||
#[command(trust = always)]
|
||||
pub async fn remote_list(host: &Host, connection: FsConnection, path: String) -> IdeResult<Vec<RemoteEntry>> {
|
||||
// Entries of a folder on the selected filesystem (`~`: its home directory).
|
||||
host.remote.list(&connection, &path).await
|
||||
}
|
||||
|
||||
/// Opens a remote file for editing: a local copy, uploaded back on save.
|
||||
pub async fn remote_open(state: &Host, connection: FsConnection, path: String) -> IdeResult<IpcPath> {
|
||||
Ok(state.remote.open_remote(&connection, &path).await?.into())
|
||||
#[command(trust = always)]
|
||||
pub async fn remote_open(host: &Host, connection: FsConnection, path: String) -> IdeResult<IpcPath> {
|
||||
// Opens a remote file for editing: a local copy, uploaded back on save.
|
||||
Ok(host.remote.open_remote(&connection, &path).await?.into())
|
||||
}
|
||||
|
||||
/// The filesystem connection and path a cached editing copy stands for.
|
||||
pub fn remote_of(state: &Host, path: IpcPath) -> Option<(FsConnection, String)> {
|
||||
state.remote.remote_of(&path)
|
||||
#[command(trust = always)]
|
||||
pub fn remote_of(host: &Host, path: IpcPath) -> Option<(FsConnection, String)> {
|
||||
// The filesystem connection and path a cached editing copy stands for.
|
||||
host.remote.remote_of(&path)
|
||||
}
|
||||
|
||||
pub async fn remote_delete(state: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
|
||||
state.remote.remote_delete(&connection, &path).await
|
||||
#[command(trust = trusted)]
|
||||
pub async fn remote_delete(host: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
|
||||
host.remote.remote_delete(&connection, &path).await
|
||||
}
|
||||
|
||||
pub async fn remote_mkdir(state: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
|
||||
state.remote.remote_mkdir(&connection, &path).await
|
||||
#[command(trust = trusted)]
|
||||
pub async fn remote_mkdir(host: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
|
||||
host.remote.remote_mkdir(&connection, &path).await
|
||||
}
|
||||
|
||||
pub async fn remote_rename(state: &Host, connection: FsConnection, from: String, to: String) -> IdeResult<()> {
|
||||
state.remote.remote_rename(&connection, &from, &to).await
|
||||
#[command(trust = trusted)]
|
||||
pub async fn remote_rename(host: &Host, connection: FsConnection, from: String, to: String) -> IdeResult<()> {
|
||||
host.remote.remote_rename(&connection, &from, &to).await
|
||||
}
|
||||
|
||||
/// Remote Host › Download to…: remote files and folders into a local folder, each under its
|
||||
/// own name.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn remote_download_into(
|
||||
window: &str,
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
connection: FsConnection,
|
||||
paths: Vec<String>,
|
||||
target: IpcPath,
|
||||
request: RequestId,
|
||||
) -> IdeResult<TransferReport> {
|
||||
let project = state.project(window)?;
|
||||
let token = state.begin_request(request);
|
||||
// Remote Host › Download to…: remote files and folders into a local folder, each under its
|
||||
// own name.
|
||||
let project = host.project(window)?;
|
||||
let token = host.begin_request(request);
|
||||
let (mut report, done) = progress(project.sink.clone(), "Downloading", token.clone());
|
||||
let r = state.remote.download_into(&connection, &paths, &target, &token, &mut report).await;
|
||||
let r = host.remote.download_into(&connection, &paths, &target, &token, &mut report).await;
|
||||
done();
|
||||
state.end_request(request);
|
||||
host.end_request(request);
|
||||
r
|
||||
}
|
||||
|
||||
/// `password`: an FTP password typed in the settings but not applied yet.
|
||||
#[command(trust = always)]
|
||||
pub async fn deploy_test_connection(
|
||||
state: &Host,
|
||||
host: &Host,
|
||||
connection: FsConnection,
|
||||
path: String,
|
||||
password: Option<String>,
|
||||
) -> IdeResult<()> {
|
||||
state.remote.test_connection_with(&connection, &path, password).await
|
||||
// `password`: an FTP password typed in the settings but not applied yet.
|
||||
host.remote.test_connection_with(&connection, &path, password).await
|
||||
}
|
||||
|
||||
pub(crate) fn register(d: &mut crate::rpc::Dispatcher) {
|
||||
d.add("deploy_coverage", |c| async move { deploy_coverage(&c.window, &c.host, c.arg("paths")?).await });
|
||||
d.add("deploy_upload", |c| async move {
|
||||
deploy_upload(&c.window, &c.host, c.arg("paths")?, c.arg("server")?, c.arg("request")?).await
|
||||
});
|
||||
d.add("deploy_download", |c| async move {
|
||||
deploy_download(&c.window, &c.host, c.arg("paths")?, c.arg("server")?, c.arg("request")?).await
|
||||
});
|
||||
d.add("deploy_delete_remote", |c| async move {
|
||||
deploy_delete_remote(&c.window, &c.host, c.arg("paths")?, c.arg("server")?).await
|
||||
});
|
||||
d.add("deploy_compare", |c| async move {
|
||||
deploy_compare(&c.window, &c.host, c.arg("path")?, c.arg("server")?, c.arg("request")?).await
|
||||
});
|
||||
d.add("deploy_sync", |c| async move {
|
||||
deploy_sync(&c.window, &c.host, c.arg("steps")?, c.arg("server")?, c.arg("request")?).await
|
||||
});
|
||||
d.add("deploy_info", |c| async move { deploy_info(&c.window, &c.host, c.arg("path")?, c.arg("server")?).await });
|
||||
d.add("deploy_server_root", |c| async move { deploy_server_root(&c.window, &c.host, c.arg("server")?).await });
|
||||
d.add("remote_list", |c| async move { remote_list(&c.host, c.arg("connection")?, c.arg("path")?).await });
|
||||
d.add("remote_open", |c| async move { remote_open(&c.host, c.arg("connection")?, c.arg("path")?).await });
|
||||
d.add("remote_of", |c| async move { Ok(remote_of(&c.host, c.arg("path")?)) });
|
||||
d.add("remote_delete", |c| async move { remote_delete(&c.host, c.arg("connection")?, c.arg("path")?).await });
|
||||
d.add("remote_mkdir", |c| async move { remote_mkdir(&c.host, c.arg("connection")?, c.arg("path")?).await });
|
||||
d.add("remote_download_into", |c| async move {
|
||||
remote_download_into(
|
||||
&c.window,
|
||||
&c.host,
|
||||
c.arg("connection")?,
|
||||
c.arg("paths")?,
|
||||
c.arg("target")?,
|
||||
c.arg("request")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("remote_rename", |c| async move {
|
||||
remote_rename(&c.host, c.arg("connection")?, c.arg("from")?, c.arg("to")?).await
|
||||
});
|
||||
d.add("deploy_test_connection", |c| async move {
|
||||
deploy_test_connection(&c.host, c.arg("connection")?, c.arg("path")?, c.arg("password")?).await
|
||||
});
|
||||
}
|
||||
ide_command::domain!(
|
||||
deploy:
|
||||
deploy_compare,
|
||||
deploy_coverage,
|
||||
deploy_delete_remote,
|
||||
deploy_download,
|
||||
deploy_info,
|
||||
deploy_server_root,
|
||||
deploy_sync,
|
||||
deploy_test_connection,
|
||||
deploy_upload,
|
||||
remote_delete,
|
||||
remote_download_into,
|
||||
remote_list,
|
||||
remote_mkdir,
|
||||
remote_of,
|
||||
remote_open,
|
||||
remote_rename,
|
||||
);
|
||||
@@ -1,9 +1,13 @@
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::{ChangeSet, DocId, IdeResult};
|
||||
use ide_workspace::DocumentInfo;
|
||||
use std::path::PathBuf;
|
||||
|
||||
pub async fn open(host: &Host, window: &str, path: PathBuf) -> IdeResult<DocumentInfo> {
|
||||
/// Opens a document. Async: reading and decoding a large file must not block
|
||||
/// the main thread (synchronous commands run on it).
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_open(host: &Host, window: &str, path: PathBuf) -> IdeResult<DocumentInfo> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || {
|
||||
let info = project.documents.open(&path)?;
|
||||
@@ -16,22 +20,30 @@ pub async fn open(host: &Host, window: &str, path: PathBuf) -> IdeResult<Documen
|
||||
.await
|
||||
}
|
||||
|
||||
pub fn close(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
host.project(window)?.documents.close(doc);
|
||||
Ok(())
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_close(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || {
|
||||
project.documents.close(doc);
|
||||
Ok(())
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
/// Opens an editable untitled buffer (a new-file tab); it reaches the disk
|
||||
/// through [`save_as`], which turns it into a regular file document. `name`
|
||||
/// re-references an already minted buffer instead of creating one.
|
||||
pub async fn open_untitled(host: &Host, window: &str, name: Option<String>) -> IdeResult<DocumentInfo> {
|
||||
/// through `doc_save_as`, which turns it into a regular file document.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_open_untitled(host: &Host, window: &str, name: Option<String>) -> IdeResult<DocumentInfo> {
|
||||
// `name` re-references an already minted buffer instead of creating one.
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || project.documents.open_untitled(name.as_deref())).await
|
||||
}
|
||||
|
||||
/// Save As for an untitled buffer ([`Documents::save_as`]); LightEdit windows
|
||||
/// start watching the saved file's folder.
|
||||
pub async fn save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -> IdeResult<DocumentInfo> {
|
||||
/// Save As for an untitled buffer: writes it to `path` and re-keys the buffer
|
||||
/// (undo history and version are kept; the language is re-detected).
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -> IdeResult<DocumentInfo> {
|
||||
// LightEdit windows start watching the saved file's folder.
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || {
|
||||
let info = project.documents.save_as(doc, &path)?;
|
||||
@@ -43,25 +55,31 @@ pub async fn save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -> Id
|
||||
.await
|
||||
}
|
||||
|
||||
/// Applies a CodeMirror change set; returns the new version (`outOfSync` when `base_version` is stale).
|
||||
pub fn edit(host: &Host, window: &str, doc: DocId, base_version: u32, changes: ChangeSet) -> IdeResult<u32> {
|
||||
host.project(window)?.documents.edit(doc, base_version, changes)
|
||||
/// Applies a CodeMirror change set; returns the new version. Rejects with
|
||||
/// `outOfSync` when `base_version` is stale; the UI then calls `doc_snapshot`.
|
||||
#[command(trust = always, desktop_body = async)]
|
||||
pub async fn doc_edit(host: &Host, window: &str, doc: DocId, base_version: u32, changes: ChangeSet) -> IdeResult<u32> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || project.documents.edit(doc, base_version, changes)).await
|
||||
}
|
||||
|
||||
pub async fn save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || project.documents.save(doc)).await?;
|
||||
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
|
||||
}
|
||||
|
||||
pub async fn save_all(host: &Host, window: &str) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_save_all(host: &Host, window: &str) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || project.documents.save_all()).await?;
|
||||
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
|
||||
}
|
||||
|
||||
/// Recovers external changes missed by the project's file watchers.
|
||||
pub async fn sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
|
||||
// Recovers external changes missed by the project's file watchers.
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || {
|
||||
if project.settings.effective().files.sync_on_focus {
|
||||
@@ -72,13 +90,27 @@ pub async fn sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn snapshot(host: &Host, window: &str, doc: DocId) -> IdeResult<DocumentInfo> {
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_snapshot(host: &Host, window: &str, doc: DocId) -> IdeResult<DocumentInfo> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || project.documents.snapshot(doc)).await
|
||||
}
|
||||
|
||||
mod commands;
|
||||
pub mod commands;
|
||||
pub use commands::*;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
ide_command::domain!(
|
||||
doc:
|
||||
doc_close,
|
||||
doc_edit,
|
||||
doc_open,
|
||||
doc_open_untitled,
|
||||
doc_save,
|
||||
doc_save_all,
|
||||
doc_save_as,
|
||||
doc_snapshot,
|
||||
doc_sync_from_disk,
|
||||
);
|
||||
@@ -1,11 +1,9 @@
|
||||
#[allow(unused_imports)]
|
||||
use super::*;
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
use ide_core::{DocId, IdeError, IdeResult, OutlineItem, Range};
|
||||
use ide_language::{FoldRange, SyntaxHighlights};
|
||||
use ide_text::LineEnding;
|
||||
use ide_workspace::{DocumentEncoding, DocumentInfo, HistoryEntry};
|
||||
use ide_workspace::{DocumentEncoding, DocumentInfo, DocumentLanguage, HistoryEntry};
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// Runs blocking work (disk I/O, parsing, large copies) on the blocking pool,
|
||||
@@ -16,6 +14,7 @@ pub async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send
|
||||
|
||||
/// Opens a read-only virtual document (see `lsp_virtual_document`) as an
|
||||
/// editor buffer, so syntax features and language-server requests work in it.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_open_virtual(host: &Host, window: &str, uri: String) -> IdeResult<DocumentInfo> {
|
||||
let project = host.project(window)?;
|
||||
let vd = crate::ops::lsp::lsp_virtual_document(host, window, uri).await?;
|
||||
@@ -32,16 +31,22 @@ pub async fn doc_open_virtual(host: &Host, window: &str, uri: String) -> IdeResu
|
||||
.await
|
||||
}
|
||||
|
||||
/// The CodeMirror mode `path` gets when opened (`DocumentInfo::ui_mode`),
|
||||
/// without opening it: previews of closed files.
|
||||
pub async fn doc_ui_mode(host: &Host, window: &str, path: PathBuf) -> IdeResult<Option<String>> {
|
||||
/// The language and CodeMirror mode `path` is shown with in an editor, without opening
|
||||
/// it: previews of closed files and diffs. `first_line` is the shown text's (a revision's)
|
||||
/// for hashbang detection; without it the file's on disk counts.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_language(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
path: PathBuf,
|
||||
first_line: Option<String>,
|
||||
) -> IdeResult<DocumentLanguage> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || Ok(project.documents.ui_mode_of(&path))).await
|
||||
blocking(move || Ok(project.documents.language_of(&path, first_line.as_deref()))).await
|
||||
}
|
||||
|
||||
/// "Reload with Encoding" (`reload`) or "Convert to Encoding"; returns the new encoding and BOM state.
|
||||
/// Virtual documents re-read their origin (archive, language server, Git blob)
|
||||
/// instead of a disk file; converting them would write to it, so it stays refused.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_set_encoding(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -49,6 +54,8 @@ pub async fn doc_set_encoding(
|
||||
encoding: String,
|
||||
reload: bool,
|
||||
) -> IdeResult<DocumentEncoding> {
|
||||
// Virtual documents re-read their origin (archive, language server, Git blob)
|
||||
// instead of a disk file; converting them would write to it, so it stays refused.
|
||||
let project = host.project(window)?;
|
||||
if reload
|
||||
&& !project.documents.is_untitled(doc)?
|
||||
@@ -64,20 +71,24 @@ pub async fn doc_set_encoding(
|
||||
host.blocking(move || project.documents.set_encoding(doc, &encoding, reload)).await
|
||||
}
|
||||
|
||||
/// Adds or removes the BOM on a UTF-8 document; the change is written on save.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_set_bom(host: &Host, window: &str, doc: DocId, has_bom: bool) -> IdeResult<DocumentEncoding> {
|
||||
// Adds or removes the BOM on a UTF-8 document; the change is written on save.
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || project.documents.set_bom(doc, has_bom)).await
|
||||
}
|
||||
|
||||
pub fn doc_set_line_ending(host: &Host, window: &str, doc: DocId, line_ending: LineEnding) -> IdeResult<()> {
|
||||
host.project(window)?.documents.set_line_ending(doc, line_ending)
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_set_line_ending(host: &Host, window: &str, doc: DocId, line_ending: LineEnding) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || project.documents.set_line_ending(doc, line_ending)).await
|
||||
}
|
||||
|
||||
/// Structure view: LSP document symbols when available (with tree-sitter
|
||||
/// visibility), tree-sitter otherwise.
|
||||
/// Tree-sitter answers come from the per-document tree cache (incremental
|
||||
/// re-parse); large documents get no syntax structure.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<OutlineItem>> {
|
||||
let project = host.project(window)?;
|
||||
let lsp = project.lsp.document_symbols(doc).await.ok().flatten();
|
||||
@@ -116,6 +127,7 @@ pub async fn doc_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec
|
||||
.await
|
||||
}
|
||||
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_folding(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<FoldRange>> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || {
|
||||
@@ -150,6 +162,7 @@ pub async fn doc_folding(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec
|
||||
|
||||
/// Tree-sitter highlighting for languages the UI has no CodeMirror mode for;
|
||||
/// empty when the grammar has no highlights query or the document is large.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_highlights(host: &Host, window: &str, doc: DocId) -> IdeResult<SyntaxHighlights> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || {
|
||||
@@ -162,9 +175,10 @@ pub async fn doc_highlights(host: &Host, window: &str, doc: DocId) -> IdeResult<
|
||||
.await
|
||||
}
|
||||
|
||||
/// Python class facts the inheritance inspections read: base names as written, a method's
|
||||
/// parameters, decorator semantics and its body shape. Tree-sitter answers; no LSP.
|
||||
/// Python class facts for the inheritance inspections: tree-sitter, no language server.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_python_facts(host: &Host, window: &str, doc: DocId) -> IdeResult<ide_language::PythonFacts> {
|
||||
// Base names as written, a method's parameters, decorator semantics and its body shape.
|
||||
let project = host.project(window)?;
|
||||
let syntax = host.syntax();
|
||||
let snap = project.documents.text_snapshot(doc)?;
|
||||
@@ -173,6 +187,7 @@ pub async fn doc_python_facts(host: &Host, window: &str, doc: DocId) -> IdeResul
|
||||
|
||||
/// Extend Selection (⌥↑): syntax ranges around `offset`, innermost first.
|
||||
/// Large documents fall back to word / line / document ranges.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_selection_ranges(host: &Host, window: &str, doc: DocId, offset: u32) -> IdeResult<Vec<Range>> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || {
|
||||
@@ -198,32 +213,30 @@ pub async fn doc_selection_ranges(host: &Host, window: &str, doc: DocId, offset:
|
||||
.await
|
||||
}
|
||||
|
||||
pub fn history_list(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec<HistoryEntry>> {
|
||||
host.project(window)?.history.list(&path)
|
||||
#[command(trust = always)]
|
||||
pub async fn history_list(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec<HistoryEntry>> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || project.history.list(&path)).await
|
||||
}
|
||||
|
||||
pub fn history_content(host: &Host, window: &str, id: String) -> IdeResult<String> {
|
||||
host.project(window)?.history.content(&id)
|
||||
#[command(trust = always)]
|
||||
pub async fn history_content(host: &Host, window: &str, id: String) -> IdeResult<String> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || project.history.content(&id)).await
|
||||
}
|
||||
|
||||
/// Commands of this module the remote server answers.
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("doc_open_virtual", |c| async move { doc_open_virtual(&c.host, &c.window, c.arg("uri")?).await });
|
||||
d.add("doc_ui_mode", |c| async move { doc_ui_mode(&c.host, &c.window, c.arg("path")?).await });
|
||||
d.add("doc_set_encoding", |c| async move {
|
||||
doc_set_encoding(&c.host, &c.window, c.arg("doc")?, c.arg("encoding")?, c.arg("reload")?).await
|
||||
});
|
||||
d.add("doc_set_bom", |c| async move { doc_set_bom(&c.host, &c.window, c.arg("doc")?, c.arg("hasBom")?).await });
|
||||
d.add("doc_set_line_ending", |c| async move {
|
||||
blocking(move || doc_set_line_ending(&c.host, &c.window, c.arg("doc")?, c.arg("lineEnding")?)).await
|
||||
});
|
||||
d.add("doc_outline", |c| async move { doc_outline(&c.host, &c.window, c.arg("doc")?).await });
|
||||
d.add("doc_folding", |c| async move { doc_folding(&c.host, &c.window, c.arg("doc")?).await });
|
||||
d.add("doc_highlights", |c| async move { doc_highlights(&c.host, &c.window, c.arg("doc")?).await });
|
||||
d.add("doc_python_facts", |c| async move { doc_python_facts(&c.host, &c.window, c.arg("doc")?).await });
|
||||
d.add("doc_selection_ranges", |c| async move {
|
||||
doc_selection_ranges(&c.host, &c.window, c.arg("doc")?, c.arg("offset")?).await
|
||||
});
|
||||
d.add("history_list", |c| async move { history_list(&c.host, &c.window, c.arg("path")?) });
|
||||
d.add("history_content", |c| async move { history_content(&c.host, &c.window, c.arg("id")?) });
|
||||
}
|
||||
ide_command::domain!(
|
||||
doc_commands:
|
||||
doc_folding,
|
||||
doc_highlights,
|
||||
doc_language,
|
||||
doc_open_virtual,
|
||||
doc_outline,
|
||||
doc_python_facts,
|
||||
doc_selection_ranges,
|
||||
doc_set_bom,
|
||||
doc_set_encoding,
|
||||
doc_set_line_ending,
|
||||
history_content,
|
||||
history_list,
|
||||
);
|
||||
@@ -46,11 +46,11 @@ impl Fixture {
|
||||
}
|
||||
|
||||
async fn open(&self, path: &Path) -> DocumentInfo {
|
||||
open(&self.host, "main", path.to_path_buf()).await.unwrap()
|
||||
doc_open(&self.host, "main", path.to_path_buf()).await.unwrap()
|
||||
}
|
||||
|
||||
async fn sync(&self) {
|
||||
sync_from_disk(&self.host, "main").await.unwrap();
|
||||
doc_sync_from_disk(&self.host, "main").await.unwrap();
|
||||
}
|
||||
|
||||
fn document_events(&self) -> Vec<IdeEvent> {
|
||||
@@ -95,13 +95,14 @@ async fn unchanged_document_has_no_patch_or_event() {
|
||||
async fn dirty_document_keeps_edits_and_warns_once() {
|
||||
let f = Fixture::new();
|
||||
let original = f.open(&f.path).await;
|
||||
edit(
|
||||
doc_edit(
|
||||
&f.host,
|
||||
"main",
|
||||
original.id,
|
||||
original.version,
|
||||
ChangeSet { changes: vec![TextChange { from: 0, to: 0, insert: "local ".into() }] },
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
f.events.lock().clear();
|
||||
std::fs::write(&f.path, "external replacement\n").unwrap();
|
||||
@@ -196,7 +197,7 @@ async fn synchronization_only_changes_the_calling_windows_documents() {
|
||||
let other_root = f.outside.parent().unwrap().join("other-project");
|
||||
std::fs::create_dir(&other_root).unwrap();
|
||||
let other = f.host.open_project("other", &other_root).unwrap();
|
||||
let other_doc = open(&f.host, "other", f.outside.clone()).await.unwrap();
|
||||
let other_doc = doc_open(&f.host, "other", f.outside.clone()).await.unwrap();
|
||||
std::fs::write(&f.outside, "external change in shared file\n").unwrap();
|
||||
f.sync().await;
|
||||
assert_eq!(f.project.documents.snapshot(original.id).unwrap().text, "external change in shared file\n");
|
||||
|
||||
@@ -1,17 +1,56 @@
|
||||
//! Docker run configurations: the environment their `docker` command line runs with.
|
||||
//! Docker run configurations: the environment their `docker` command line runs with; and Docker
|
||||
//! connections through an SSH configuration, tunnelled with the IDE's own SSH client.
|
||||
use crate::Host;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_core::IdeResult;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use ide_docker::DockerEndpoint;
|
||||
use std::collections::BTreeMap;
|
||||
use ide_ssh::Tunnel;
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
use std::sync::Arc;
|
||||
|
||||
/// The endpoint's variables plus a `PATH` that finds this host's `docker`. A remote project
|
||||
/// gets them from the server, since its run configurations start on the remote host.
|
||||
pub async fn run_env(host: &Host, endpoint: DockerEndpoint) -> IdeResult<BTreeMap<String, String>> {
|
||||
/// 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>>>);
|
||||
|
||||
/// `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).
|
||||
pub async fn resolve(host: &Host, endpoint: DockerEndpoint) -> IdeResult<DockerEndpoint> {
|
||||
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(),
|
||||
None => {
|
||||
let session = host.ssh.session(&id).await?;
|
||||
// Fail with the reason here: a missing docker only shows as a dropped connection later.
|
||||
let probe = session.exec("docker version --format {{.Client.Version}}", None).await?;
|
||||
if !probe.success() {
|
||||
let why = String::from_utf8_lossy(&probe.stderr).trim().to_owned();
|
||||
return Err(IdeError::unavailable(format!(
|
||||
"docker could not be run on {} over SSH{}",
|
||||
session.label(),
|
||||
if why.is_empty() { String::new() } else { format!(": {why}") }
|
||||
)));
|
||||
}
|
||||
let t = Arc::new(Tunnel::command(session, DIAL).await?);
|
||||
tunnels.insert(id, t.clone());
|
||||
t
|
||||
}
|
||||
};
|
||||
Ok(DockerEndpoint::Tcp { host: format!("tcp://127.0.0.1:{}", tunnel.port()), tls_cert_dir: None })
|
||||
}
|
||||
|
||||
/// Environment for a Docker run configuration's command line: selects `endpoint`'s
|
||||
/// daemon and puts the docker executable on `PATH`.
|
||||
#[command(trust = always)]
|
||||
pub async fn docker_run_env(host: &Host, endpoint: DockerEndpoint) -> IdeResult<BTreeMap<String, String>> {
|
||||
// A remote project gets them from the server, since its run configurations start on the remote host.
|
||||
endpoint.validate()?;
|
||||
let endpoint = resolve(host, endpoint).await?;
|
||||
host.blocking(move || Ok(ide_docker::run_env(&endpoint))).await
|
||||
}
|
||||
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("docker_run_env", |c| async move { run_env(&c.host, c.arg("endpoint")?).await });
|
||||
}
|
||||
ide_command::domain!(docker: docker_run_env);
|
||||
@@ -2,19 +2,20 @@
|
||||
//! (and, on the remote server, the project's `remoteEnv`) without a restart.
|
||||
use crate::Host;
|
||||
use crate::environment::EnvReloaded;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_command::command;
|
||||
use ide_core::IdeResult;
|
||||
use std::sync::Arc;
|
||||
|
||||
/// Re-reads the login shell (and the window's project `remoteEnv` where it applies);
|
||||
/// running terminals and processes keep their environment.
|
||||
pub async fn reload(host: &Arc<Host>, window: &str) -> IdeResult<EnvReloaded> {
|
||||
/// Reload Environment: new child processes get the login shell's current environment
|
||||
/// (and the project's `remoteEnv` on a remote host); running ones keep theirs.
|
||||
#[command(trust = always)]
|
||||
pub async fn env_reload(host: &Arc<Host>, window: &str) -> IdeResult<EnvReloaded> {
|
||||
// Re-reads the login shell (and the window's project `remoteEnv` where it applies);
|
||||
// running terminals and processes keep their environment.
|
||||
let root = host.project(window).ok().filter(|p| !p.light && p.is_trusted()).map(|p| p.root.clone());
|
||||
let sink = host.window_sink(window);
|
||||
let h = host.clone();
|
||||
host.blocking(move || h.environment.reload(root.as_deref(), &sink)).await
|
||||
}
|
||||
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("env_reload", |c| async move { reload(&c.host, &c.window).await });
|
||||
}
|
||||
ide_command::domain!(env: env_reload);
|
||||
@@ -1,10 +1,12 @@
|
||||
use super::Channel;
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeError, IdeResult, RequestId};
|
||||
use ide_vfs::FileEntry;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
pub async fn entry_kind(host: &Host, path: PathBuf) -> IdeResult<ide_vfs::EntryKind> {
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_entry_kind(host: &Host, path: PathBuf) -> IdeResult<ide_vfs::EntryKind> {
|
||||
host.blocking(move || {
|
||||
let meta = std::fs::metadata(path)?;
|
||||
Ok(if meta.is_dir() { ide_vfs::EntryKind::Dir } else { ide_vfs::EntryKind::File })
|
||||
@@ -12,7 +14,8 @@ pub async fn entry_kind(host: &Host, path: PathBuf) -> IdeResult<ide_vfs::EntryK
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn compare_directories(
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_compare_directories(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
left: PathBuf,
|
||||
@@ -38,7 +41,8 @@ pub async fn compare_directories(
|
||||
result
|
||||
}
|
||||
|
||||
pub async fn copy_merge(
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_copy_merge(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
source_root: PathBuf,
|
||||
@@ -73,8 +77,9 @@ pub async fn copy_merge(
|
||||
/// Files of a deleted folder snapshotted in Local History.
|
||||
const DELETE_SNAPSHOT_LIMIT: usize = 2000;
|
||||
|
||||
/// Runs on the blocking pool: on a network share (`\\wsl.localhost`) every stat is slow.
|
||||
pub async fn read_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec<FileEntry>> {
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_read_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec<FileEntry>> {
|
||||
// Runs on the blocking pool: on a network share (`\\wsl.localhost`) every stat is slow.
|
||||
let project = host.project(window);
|
||||
host.blocking(move || {
|
||||
let excludes = project
|
||||
@@ -99,7 +104,8 @@ pub async fn read_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec
|
||||
|
||||
/// Creates an empty file; inside a project, honours the EditorConfig
|
||||
/// `charset` (writes the BOM for `utf-8-bom` / UTF-16).
|
||||
pub fn create_file(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub fn fs_create_file(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
match host.project(window) {
|
||||
Ok(p) => {
|
||||
let defaults = p.documents.file_defaults();
|
||||
@@ -124,7 +130,8 @@ pub fn create_file(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn create_file_bytes(host: &Host, window: &str, path: PathBuf, data: Vec<u8>) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_create_file_bytes(host: &Host, window: &str, path: PathBuf, data: Vec<u8>) -> IdeResult<()> {
|
||||
let project = host.project(window).ok();
|
||||
host.blocking(move || {
|
||||
ide_vfs::create_file_bytes(&path, &data)?;
|
||||
@@ -138,17 +145,25 @@ pub async fn create_file_bytes(host: &Host, window: &str, path: PathBuf, data: V
|
||||
.await
|
||||
}
|
||||
|
||||
#[command(trust = always)]
|
||||
pub fn fs_create_dir(path: PathBuf) -> IdeResult<()> {
|
||||
ide_vfs::create_dir(&path)
|
||||
}
|
||||
|
||||
/// Toggle Read-only Attribute: sets the writable bit (and the open document's
|
||||
/// state). Returns whether the file is read-only now.
|
||||
pub fn set_writable(host: &Host, window: &str, path: PathBuf, writable: bool) -> IdeResult<bool> {
|
||||
#[command(trust = always)]
|
||||
pub fn fs_set_writable(host: &Host, window: &str, path: PathBuf, writable: bool) -> IdeResult<bool> {
|
||||
match host.project(window) {
|
||||
Ok(p) => p.documents.set_writable(&path, writable),
|
||||
Err(_) => ide_vfs::set_writable(&path, writable).map(|()| !writable),
|
||||
}
|
||||
}
|
||||
|
||||
/// Moves to the trash; Local History keeps the contents so deleted files can be restored.
|
||||
pub async fn delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
/// Moving to the trash can take a while (large trees): kept off the main thread.
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
// Local History keeps the contents so deleted files can be restored.
|
||||
let project = host.project(window).ok();
|
||||
let history = project.as_ref().map(|p| p.history.clone());
|
||||
host.blocking(move || {
|
||||
@@ -168,7 +183,8 @@ pub async fn delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
|
||||
let project = host.project(window).ok();
|
||||
host.blocking(move || {
|
||||
ide_workspace::file_ops::copy(&from, &to)?;
|
||||
@@ -183,7 +199,8 @@ pub async fn copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeR
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn rename(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_rename(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
|
||||
let project = host.project(window).ok();
|
||||
host.blocking(move || {
|
||||
ide_workspace::file_ops::rename(&from, &to)?;
|
||||
@@ -199,8 +216,10 @@ pub async fn rename(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> Id
|
||||
.await
|
||||
}
|
||||
|
||||
/// Reads a text file without opening it as a document; prefers the unsaved buffer.
|
||||
pub async fn read_text(host: &Host, window: &str, path: PathBuf) -> IdeResult<String> {
|
||||
/// Reads a text file without opening it as a document (previews, quick
|
||||
/// definition). Prefers the unsaved buffer when the file is open.
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_read_text(host: &Host, window: &str, path: PathBuf) -> IdeResult<String> {
|
||||
let project = host.project(window).ok();
|
||||
host.blocking(move || match project {
|
||||
Some(p) => p.text_of(&path),
|
||||
@@ -251,3 +270,19 @@ mod tests {
|
||||
assert!(!inside_any_root(Path::new("/work/spec.pdf"), &[]));
|
||||
}
|
||||
}
|
||||
|
||||
ide_command::domain!(
|
||||
fs:
|
||||
fs_compare_directories,
|
||||
fs_copy,
|
||||
fs_copy_merge,
|
||||
fs_create_dir,
|
||||
fs_create_file,
|
||||
fs_create_file_bytes,
|
||||
fs_delete,
|
||||
fs_entry_kind,
|
||||
fs_read_dir,
|
||||
fs_read_text,
|
||||
fs_rename,
|
||||
fs_set_writable,
|
||||
);
|
||||
Loaded 100 of 1185 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача