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

..
Автор SHA1 Повідомлення Дата
l0ng-ai 45634809e9 fix(editor): keep diagnostics in place through edits when another source updates
Each source's list is placed through the edits made since it arrived, instead
of reading its ranges against the current text again whenever any source
publishes. Lists from checks of the saved file (build, PHPStan, Kotlin bridge)
no longer jump to the wrong code after typing.
2026-11-19 23:39:07 +08:00
Mr0Bread 8b427bcedd test(editor): cover stale formatter responses (#4559)
Regression tests for formatter responses that arrive after the document changed: format on save stays silent, explicit formatting shows the stale-response hint, a same-length edit is still detected, and an unchanged buffer formats as before.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-19 23:31:13 +08:00
l0ng-ai 966963c8b6 feat(plugins): menus on plugin status bar items (API 1.14) (#4561)
A plugin status bar item could only run one command on click, so quick actions needed a centered pick dialog. Plugin API 1.14 adds ui.set-status-item-menu / set-window-status-item-menu: the item with a menu of actions (label, optional description, declared command and argument), separators and headers, at most 64; a click opens it anchored to the item with the shared Menu. Undeclared commands fail the call. SDK wrappers, mock, docs, rebuilt components. Also makes the SDK's wit_coverage export check ignore whitespace (rustfmt split the hover_actions impl, failing it since #4544).
2026-11-19 23:22:59 +08:00
lleviathe ead8dc507b feat(mcp): serve projects that have no window (#4297)
The built-in MCP server answered only for projects open in a window, so agents working across several projects needed a window per project. With Settings › Agents › IDE MCP Server › Serve without a window (off by default; Trusted projects or Listed projects) the server opens a project on a client's first tool call for a path inside it, as an ordinary host project under mcp:<root>, and unloads it after the idle time or at the project limit. Untrusted listed folders open in Restricted Mode with read-only tools; tools that need a window say so; a window opening the same folder takes over; changes to the mode, list, trust or server unload at once. Desktop only: openidea-server serves none.

Co-authored-by: lleviathe <[email protected]>
2026-11-19 23:07:13 +08:00
Gabriel Gondim f5db9714d6 feat(plugins): JVM vmOptions on [[contributes.javaAgents]] (API 1.14) (#4552)
Plugins could load a Java agent but not the JVM flags some agents need (JBR hot reload needs -XX:+AllowEnhancedClassRedefinition), so users edited every run configuration by hand. [[contributes.javaAgents]] now takes optional vmOptions (validated single flags, inserted before -javaagent:) and jdk = "jetbrains" (apply them only on a JetBrains Runtime, read from the JDK's release file) for Application, Spring Boot and JAR Application Run and Debug, under the same java.agent grant; Settings › Plugins and the consent dialog show the flags. Part of plugin API 1.14.

Review fixes: the java.agent permission text is translated apart from the flags the host appends, zh text, clippy.

Co-authored-by: GGVidal <[email protected]>
2026-11-19 22:57:38 +08:00
akshathayadav378-boopтаakshathayadav378-boop f90eca0777 perf(lsp): avoid full document JSON for incremental changes (#4547)
didChange built (and cloned per server) a JSON payload of the whole document before choosing per-encoding incremental edits, so every keystroke in a large file copied its full text even when all servers sync incrementally. The full payload is now built lazily, only for full-sync servers or when the local copy is out of sync. Adds the lsp/did_change_incremental_1mb criterion bench (observe-only in pnpm perf:rust).

Co-authored-by: akshathayadav378-boop <[email protected]>
2026-11-19 22:51:13 +08:00
Vadim LazukтаInf1mum 485a7edc4e fix(php): drop PHPStan diagnostics whose saved text the buffer left behind (#4550)
PHPStan runs on the saved file and its ranges belong to that text, but the editor re-applies every source's stored ranges whenever any source (the language server) republishes, so after an edit PHPStan's squiggles landed on other lines (the trailing ; of new code, comments). An edit now clears a file's PHPStan diagnostics once until the next save, and a check that finishes after the file was edited publishes nothing for it.

Co-authored-by: Inf1mum <[email protected]>
2026-11-19 22:50:09 +08:00
l0ng-ai 786de5f5e8 fix(vcs): build Open In and commit links on the host behind an SSH alias (#4554)
Open In, Copy Path › <hosting> Link and the Git log's View in Browser read the raw remote.<name>.url, so a remote behind an ~/.ssh/config host alias (github.com-work → github.com) produced pages on the alias host and a guessed hosting. They now use the remote's resolvedUrl from vcs_remotes (the existing ~/.ssh/config resolver), falling back to the config value; the agent session's origin lookup for gh links does the same.
2026-11-19 22:44:54 +08:00
QтаNeverKnowsTomorrow ac08cd85b2 feat(plugins): API 1.14 hover actions (#4544)
Adds the optional hover-actions export (plugin API 1.14): plugins contribute a host-rendered action at the left edge of an editor line, revealed by hovering the first four columns of any line in its start-line..end-line range and anchored to its declaration line. The host keeps it left of the line's text, out of the intention bulb's row, never takes focus on hover, collapses several actions into an overflow menu, and lists them in the editor context menu for keyboard access. SDK HoverActions, a minimal fixture, API-compat tests, docs and regenerated components.

Review fixes: the button is positioned on its first show (it was left unpositioned until the next mouse move), the styles use theme tokens, the overflow menu is the shared context menu, and the labels go through the text catalog.

Co-authored-by: NeverKnowsTomorrow <[email protected]>
2026-11-19 22:42:00 +08:00
Akbar Husain 0c8d45154f perf(tty,dap): bound output queues with backpressure (#4048)
Terminal output (native PTY and SSH channels) went through an unbounded channel, so a slow UI or link let a chatty command buffer its whole output in memory. A 16 MiB byte budget now gates the terminal producers (blocking past the high-water mark; remote feeds use block_in_place), and DAP's outgoing queue is bounded at 256 bodies. DAP's incoming queue stays unbounded so a handler awaiting a response behind an event burst still gets it; covered by a_handler_awaiting_a_request_still_gets_its_response_behind_an_event_burst. No output is dropped.

Co-authored-by: akbar1214 <[email protected]>
2026-11-19 22:17:36 +08:00
Gabriel Gondim 7eb186ae8a feat(build): settings to keep the Build tool window hidden (#4539)
Settings > Build, Execution, Deployment > Compiler chooses when builds open and focus the Build tool window (Always / Only on errors / Never; defaults: open without focus). Run/Debug before-launch builds stay hidden until they fail, then follow the open setting.

Co-authored-by: GGVidal <[email protected]>
2026-11-19 22:06:20 +08:00
GuoYuтаguoyucode 31bb1cb797 fix(mcp): point agents at the user when a path is outside the project (#4345)
The two path-refusal errors of the MCP tools now tell the agent to ask the user before reading or changing anything outside the project, so a refused path leads the agent to the user instead of a workaround.

Co-authored-by: guoyucode <[email protected]>
2026-11-19 22:02:47 +08:00
Shohruh Ismoilovтаshohruh-genius 1ba6a6247c fix(vcs): keep Git Log reference labels visible (#4526)
In the fitted Git Log a long commit subject could squeeze branch and tag labels until their text was cut. Ref names now keep their width while the subject keeps a short minimum; names that still need to shrink show an ellipsis, with the full name on hover.

Co-authored-by: shohruh-genius <[email protected]>
2026-11-19 22:00:57 +08:00
l0ng-ai fa74f6e8e4 fix(settings): make Project Structure navigation compact and resizable (#4538)
Project Structure's section navigation starts compact (15% of the dialog) and is resizable with a remembered width; long section names wrap instead of widening the sidebar.
2026-11-19 21:51:59 +08:00
l0ng-ai 5c321f02e4 test(settings): check the Markdown preview font size by field (#4545)
#4530 added the command settings to the validated Markdown settings, so the preview font size test no longer matched the whole object; it now checks that field, and a new test covers the command settings' defaults and validation.
2026-11-19 21:51:41 +08:00
l0ng-ai 00871ab971 fix(build): give build output more room and honor console fonts (#4536)
The Build tool window gives its output two thirds of the width by default, and the build console and message details use the console font (Tools > Terminal > Font, or the editor font) with its row height, like the Run and Debug consoles.
2026-11-19 21:40:05 +08:00
l0ng-ai 5aba5e0629 fix(diff): keep toolbar status visible in narrow editors (#4527)
In a diff editor narrower than 380px the toolbar wraps and keeps the change count visible; the viewer-mode, collapse and scroll-sync toggles move out of the toolbar there and stay in the gear menu.
2026-11-19 21:39:29 +08:00
l0ng-ai eec447872c fix(services): give service details more room (#4524)
Services gives the details pane 70% of the width by default, and when the tool window is docked left or right it stacks the tree above the details; each orientation remembers its own split.
2026-11-19 21:37:55 +08:00
l0ng-ai 98418d727b fix(database): refine console and data editor layout (#4520)
Database console and data editor layout: console tabs show the console name with its data source and database (and the source icon) through new tabTitle/tabIcon file decorations, results tabs, the data source dialog, table editor and schema compare use the spacing scale and fit narrow panes.
2026-11-19 21:37:20 +08:00
l0ng-ai 2265497b18 fix(navigation): keep File Structure filters readable (#4522)
The File Structure popup is 540px wide and its filter options wrap onto further rows instead of being clipped at narrow window widths; the filter field uses the UI font.
2026-11-19 21:34:39 +08:00
l0ng-ai 7f33640895 feat(markdown): run code blocks and command lines from the gutter (#4530)
Markdown files get gutter run icons like IDEA's Markdown command runner: shell code blocks run in a new terminal tab from their fence, and code block lines run when a Run Anything provider recognizes them (Maven/Gradle lines, run configuration names; providers gain accepts()). Languages & Frameworks > Markdown > Commands toggles detection and picks the folder (asking when unset and the project and file folder differ). Untrusted projects get no icons.
2026-11-19 21:17:16 +08:00
l0ng-ai a57e12dbc5 fix(http): don't rescan Spring routes on every keystroke (#4525)
Typing in a Java/Kotlin file rescanned every Spring mapping source once per keystroke: Feign navigation dropped the route index on each docChanged (it already overlays unsaved text), and editor endpoint icons re-queried every provider, Spring included, on each change though they show only plugin endpoints. Typing now keeps the disk index; icons ask only plugin providers after typing pauses.
2026-11-19 21:07:43 +08:00
l0ng-ai b3f8cec272 fix(updates): don't hold the update lock while asking which window is focused (#4523)
The automatic update announcement held updates.ready while asking a window whether it is focused (a main-thread round trip); a window starting up ran app_update_window_ready on the main thread and waited for the same lock, freezing startup with no window. The focused and live windows are now read before taking the lock.
2026-11-19 21:01:13 +08:00
l0ng-ai e44e389571 fix(vcs): improve Commit panel layout and message typography (#4518)
The Commit panel wraps change actions into groups when the pane is narrow, so Expand All and Collapse All stay visible, and Commit and Push… wraps its label instead of cutting it. The commit message uses the editor's font family, size, weight and line height.
2026-11-19 20:58:36 +08:00
l0ng-ai 0cf0e93d92 fix(settings): give settings forms more room (#4515)
Settings starts with 22.5% of its width for navigation instead of a fixed 240px, giving the current form more room at the default window size while leaving space for long labels such as Build, Execution, Deployment. A user-resized divider is still remembered.
2026-11-19 20:56:59 +08:00
l0ng-ai c7ad3459c4 fix(vcs): fit Git Log controls in narrow panes (#4512)
Git Log gives the text filter its own row when the commit pane gets narrow; the other filters stay in More Filters and the action buttons wrap inside the pane, so Refresh, View Options and Go to Hash/Branch/Tag stay usable with the branch and details panes open.
2026-11-19 20:56:31 +08:00
l0ng-ai af281341b1 fix(run): keep console actions visible in short panes (#4511)
Run session controls move above the console: Rerun, Stop, Clear All and configuration controls fit together in a short docked pane, the console gets the full width, and the toolbar wraps by action group in narrow panes. Sessions without lifecycle controls (services, debugger console) keep the vertical toolbar.
2026-11-19 20:55:10 +08:00
l0ng-ai 313a5f3a14 fix(search): give Find in Files previews and scope controls room (#4510)
Find in Files starts with a 33/67 results-to-preview split and remembers the user's split through the splitter's own storage, so a temporarily constrained window no longer overwrites it. Scope controls wrap below the tabs when they need more room.
2026-11-19 20:53:41 +08:00
l0ng-ai 18cd2ef63b fix(debugger): keep controls visible in narrow tool windows (#4507)
Debug controls and view tabs wrap onto separate rows as the tool window narrows, and the action buttons use the standard control size, so every action and view stays reachable in a side pane.
2026-11-19 20:51:55 +08:00
l0ng-ai 4fc55f7520 fix(editor): fit wrapped tabs inside narrow splits (#4505)
Wrapped editor tabs fit inside their own split: a tab never grows past the strip, long labels truncate before the close button, and editor tabs use the 8px inline inset from the spacing scale.
2026-11-19 20:51:03 +08:00
l0ng-ai 795413c366 fix(project-view): prioritize names over paths in narrow trees (#4498)
Project tree rows give file, folder and symbol names priority over secondary text: a long project name can use the row width while paths and details truncate (full text on hover). Row icon spacing uses the spacing token.
2026-11-19 20:49:22 +08:00
l0ng-ai dd3c9c7b0a fix(problems): keep diagnostics readable in narrow panes (#4495)
The Problems tool window moves navigation and severity filters into a vertical toolbar left of the diagnostic list. Long directories, counts and diagnostic sources truncate (full text on hover) so file names and messages stay readable in a narrow split; line numbers use tabular digits.
2026-11-19 20:48:31 +08:00
l0ng-ai 361ca01cc0 fix(todo): improve tool window layout and result typography (#4492)
The TODO tool window moves its actions into a vertical toolbar beside the results, so the scope tabs get the full width. Results use the standard text size with right-aligned line numbers (the full position stays in the tooltip), long directories truncate so file names and counts stay visible, and the list and preview start at equal width.
2026-11-19 20:47:25 +08:00
Mr0Bread 1b9c330613 fix(bench): require current operation postconditions (#4491)
UI benchmarks and Java evals now arm their observation before triggering an action and wait for that action's own postcondition (current file, text, caret, completion/navigation outcome, rename scope, fresh diagnostics publication) instead of accepting editor or result state left by an earlier step. Budgets and goldens are unchanged.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-19 20:45:53 +08:00
wangfeiтаhapput 2d7bb56a8d feat(workbench): open a project as a new tab of this window (#4508)
Adds a New Tab choice to the Open Project prompt: the project opens in its own window, which joins this window's group as a selected project tab (new window_group_join command; window_groups::join is no longer macOS-only, since select handles every platform). The prompt keeps its original text when Attach and New Tab aren't offered (remote projects).

Co-authored-by: happut <[email protected]>
2026-11-19 20:43:26 +08:00
Shohruh Ismoilovтаshohruh-genius 2c8a029939 fix(vcs): fit Git Log commits to the available width (#4517)
Git Log sized its table for the widest graph row plus the saved column widths, so in a narrow pane columns went out of view behind a horizontal scrollbar. The header and rows now fit the pane: the columns shrink, the subject keeps a minimum share, and graph lanes past the room left for the subject are cut off rather than squeezed.

Co-authored-by: shohruh-genius <[email protected]>
2026-11-19 20:37:19 +08:00
l0ng-ai 6e2c19846c test(maven): fix the Always update snapshots test on main (#4514)
always_update_snapshots_adds_dash_u_once (from #4484) turned the setting off and re-applied it to the already-applied configuration, expecting -U to be removed, which failed main's Rust checks on every platform. Maven settings are applied to the stored configuration at each launch, so the test now checks a stored configuration with the setting off.
2026-11-19 20:13:26 +08:00
l0ng-ai 6c2ae13387 fix(vcs): select the best-matching branch while filtering the branches popup (#4509)
Typing a filter in the branches popup selected the first selectable row, the Local group header, so Enter did not act on the branch it found. While filtering, the popup now selects the best match of the first kind that has one: a matching action, then local branches, remote ones and tags (for several repositories: repositories, common branches, then one repository's). A match at the start of the name's last segment or at a word start ranks higher.
2026-11-19 19:44:53 +08:00
Mr0Bread 34cb4ad5e0 fix(bench): preserve failed trials and bound cleanup (#4489)
Failed warmups and repetitions were dropped from benchmark summaries, a failed startup, build or cleanup could leave an earlier success report in place, and a hung renderer or child process could block a run. Every attempt now keeps its status, metrics and error so summaries have the complete denominator; failures replace stale reports; browser and child-process lifecycles are bounded with cleanup of owned resources; and each criterion execution gets its own artifact directory.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-19 19:38:34 +08:00
Mr0Bread d080ca28f8 fix(bench): require selected workloads and finite metrics (#4488)
Benchmark verdicts could pass with selected workloads or required metrics missing, empty or non-finite, and pnpm perf:rust could accept stale or partial criterion results. Selections and counts are now validated before any work starts, every selected workload must report finite values for its required metrics, and Rust results are collected only for the selected packages from fresh, well-formed criterion artifacts, against a list of the benchmarks each package owns.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-19 19:34:55 +08:00
Vadim LazukтаInf1mum 22a5e4c9e6 fix(maven): reuse an existing build configuration for Maven goal runs (#4503)
Running a lifecycle goal such as package from the Maven tool window always created a temporary '<project> [package]' configuration, even when a saved or detected configuration already ran the same goal. adoptTemporary only matched by id or main class. Maven and Gradle runs now also match a kept configuration with the same build tool, command, directory and exact arguments, which is then selected and run instead; a different flag set (for example -DskipTests) still gets its own temporary configuration.

Co-authored-by: Inf1mum <[email protected]>
2026-11-19 19:29:44 +08:00
Vadim LazukтаInf1mum e93ac42489 fix(workbench): coalesce system toasts for external edit bursts (#4502)
Every balloon raised while OpenIDEA was in the background became its own OS toast, so an external agent editing many files produced a stream of toasts. The first toast still shows at once; balloons that follow within a 3-second quiet period become one toast naming the last balloon and how many more arrived, and a steady stream raises such a summary at most every 30 seconds. In-IDE balloons and the Notifications tool window keep every notification.

Closes #4466

Co-authored-by: Inf1mum <[email protected]>
2026-11-19 19:28:02 +08:00
Vadim LazukтаInf1mum ae604b7933 fix(editor): keep target indentation when pasting onto a blank line (#4500)
Pasting onto a blank line in YAML placed the text at column 0, turning a nested key into a root key, even with Reformat on paste. @lezer/yaml has no indent strategy, so the indent engine reports 0 and the blank target line looked already correct. On a blank target line where the engine gives no indent (null or 0), the paste filter now uses the indentation of the nearest non-empty line above, in both reformat modes.

Closes #4474

Co-authored-by: Inf1mum <[email protected]>
2026-11-19 19:25:53 +08:00
Mr0Bread bd27eb5474 fix(agents): preserve effort for pending model switches (#4487)
In an existing chat, a model that only appeared after Refresh models could be selected but its effort levels stayed unavailable until a message was sent, because the refreshed catalog listed the model without the settings a session reports for it. Selecting such a model now discovers its settings without a prompt and keeps the model and chosen effort as a pending switch; the next message reloads the same session, applies the model and the effort, then sends. If either is rejected, the previous selection is restored and nothing is sent.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-19 19:25:08 +08:00
wangfeiтаhapput 15fcf4f2c1 feat(workbench): custom colours for project tabs (#4481)
Right-clicking a project tab in a window group offers Change Project Color…: nine preset colours from the project badge palette, a custom colour and hex field, and Reset to Default. The colour is stored per project root, syncs across windows, and tints the tab, the title bar project badge and the project's badge in Recent Projects and the project popup. Without a choice the tab keeps its plain surface.

Co-authored-by: happut <[email protected]>
2026-11-19 19:20:38 +08:00
C3B6 65415a03bd fix(diff): preserve the selection when expanding unchanged lines (#4480)
Pressing and slightly moving the pointer on a diff viewer's unchanged-lines bar could start a text selection that covered the whole folded block once it expanded. The bar is now unselectable, so expanding keeps the caret and any existing selection.

Co-authored-by: 0xC3B6 <[email protected]>
2026-11-19 19:16:43 +08:00
l0ng-ai 58585e1064 feat(vcs): choose the agent, model and effort for Generate Commit Message (#4504)
Settings › Version Control › Commit › Commit Message Generation gets Agent, Model and Effort dropdowns (vcs.commit.agent / agentModel / agentEffort). Automatic keeps the agent of the latest task on its model; a chosen agent runs on the chosen model and thinking level when it offers them, independent of the chat's model. The lists come from the agent's model catalog.
2026-11-19 19:15:53 +08:00
l0ng-ai 0f355c286d fix(format): keep the caret when a language server replaces the whole file (#4497)
Vue's language server answers Reformat Code with one edit replacing the whole document, which moved the caret and the view to the top of the file. Multi-line LSP formatting edits are now reduced to one edit per changed region via Document::diff, which covers every server that formats this way.
2026-11-19 19:05:18 +08:00
l0ng-ai a0a51a63cb feat(vcs): open a push dialog file's diff in its own window (#4490)
Double-click or Enter on a file in the push dialog opens its diff in a separate diff window (Show Diff in New Window), as IDEA's push dialog does; closing it returns to the dialog. Before, the diff was only shown in a split inside the small modal dialog. Selecting a file still shows the diff in the dialog.
2026-11-19 18:28:32 +08:00
462 змінених файлів з 15352 додано та 2025 видалено

No files matched your search

Створено
+2
Переглянути файл
@@ -4660,6 +4660,7 @@ dependencies = [
name = "ide-lsp"
version = "0.1.49"
dependencies = [
"criterion",
"dunce",
"encoding_rs",
"futures",
@@ -4943,6 +4944,7 @@ dependencies = [
"portable-pty",
"serde",
"specta",
"tokio",
"tracing",
]
+32
Переглянути файл
@@ -256,6 +256,38 @@ impl AgentCatalogs {
.cloned()
}
pub(super) async fn load_levels(
self: &Arc<Self>,
shared: &Arc<Shared>,
provider: &str,
model: &str,
) -> Result<Vec<AgentConfigOption>, String> {
if let Some(levels) = self.levels(shared, provider, model) {
return Ok(levels);
}
let unavailable = || "The agent did not report settings for the selected model".to_owned();
let spec = shared.spec(provider).ok_or_else(unavailable)?;
let (_, flight) = self.request(shared, spec, false, Some(model));
if let Some(mut ready) = flight {
while !*ready.borrow_and_update() {
if ready.changed().await.is_err() {
break;
}
}
}
self.levels(shared, provider, model).ok_or_else(|| {
let state = self.state.lock();
state
.entries
.get(&Self::key(shared, provider))
.and_then(|entry| {
entry.model_failures.get(model).map(|failure| &failure.error).or(entry.error.as_ref())
})
.cloned()
.unwrap_or_else(unavailable)
})
}
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
let key = Self::key(shared, provider);
let mut state = self.state.lock();
+193 -25
Переглянути файл
@@ -323,6 +323,36 @@ async fn discovered_model_can_be_selected_while_the_session_is_not_running() {
switch_chat_model(ChatSwitch::Idle).await;
}
#[tokio::test]
async fn discovered_model_effort_is_discovered_persisted_and_applied_before_the_first_reply() {
switch_chat_model(ChatSwitch::Uncached).await;
}
#[tokio::test]
async fn discovered_model_with_no_effort_can_be_selected() {
switch_chat_model(ChatSwitch::NoEffort).await;
}
#[tokio::test]
async fn discovered_model_settings_failure_leaves_the_chat_unchanged() {
switch_chat_model(ChatSwitch::DiscoveryFails).await;
}
#[tokio::test]
async fn discovered_model_withdrawn_effort_prevents_sending() {
switch_chat_model(ChatSwitch::EffortUnavailable).await;
}
#[tokio::test]
async fn discovered_model_rejected_effort_prevents_sending() {
switch_chat_model(ChatSwitch::EffortRejected).await;
}
#[tokio::test]
async fn discovered_model_lookup_does_not_overwrite_a_newer_selection() {
switch_chat_model(ChatSwitch::Superseded).await;
}
#[derive(Clone, Copy)]
enum ChatSwitch {
Live,
@@ -330,6 +360,12 @@ enum ChatSwitch {
ResumeFails,
Unavailable,
Idle,
Uncached,
NoEffort,
DiscoveryFails,
EffortUnavailable,
EffortRejected,
Superseded,
}
async fn switch_chat_model(scenario: ChatSwitch) {
@@ -376,7 +412,21 @@ async fn switch_chat_model(scenario: ChatSwitch) {
}
let before_entries = serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap();
let before_config = manager.task(&task.id).unwrap().state.lock().task.config.clone();
if matches!(scenario, ChatSwitch::Idle) {
let offline = matches!(scenario, ChatSwitch::Idle | ChatSwitch::Uncached | ChatSwitch::Superseded);
let missing_settings = matches!(
scenario,
ChatSwitch::Uncached | ChatSwitch::NoEffort | ChatSwitch::DiscoveryFails | ChatSwitch::Superseded
);
let no_effort = matches!(scenario, ChatSwitch::NoEffort);
let effort_error = match scenario {
ChatSwitch::EffortUnavailable => Some("no longer offers effort value thorough"),
ChatSwitch::EffortRejected => Some("effort rejected by the agent"),
_ => None,
};
let choose_effort = matches!(scenario, ChatSwitch::Uncached) || effort_error.is_some();
let (catalog_models, catalog_effort): (&[&str], &[&str]) =
if missing_settings { (&["old", "new"], &["low", "high"]) } else { (&["new", "old"], &["quick", "thorough"]) };
if offline {
manager.shutdown();
manager = make_manager(tmp.path(), Arc::default(), &harness);
}
@@ -385,41 +435,122 @@ async fn switch_chat_model(scenario: ChatSwitch) {
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
let next = harness.next().await;
assert_eq!((next.launch, next.method.as_str()), (1, "session/new"));
next.reply.send(Ok(response(&["new", "old"], &["catalog-only"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["new", "old"]);
next.reply.send(Ok(response(catalog_models, catalog_effort))).unwrap();
let catalog = completed(&mut events).await;
assert_eq!(model_values(&catalog), catalog_models);
if missing_settings {
assert!(!catalog.thought_levels.contains_key("new"));
}
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
let live = matches!(scenario, ChatSwitch::Live);
let offline = matches!(scenario, ChatSwitch::Idle);
let resumed_launch = if missing_settings { 3 } else { 2 };
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
let switching = manager.set_config(&task.id, "model", "new".into());
tokio::pin!(switching);
if !offline {
let next = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
if live {
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
} else {
next.reply.send(Err("not in this process's model list".into())).unwrap();
{
let switching = manager.set_config(&task.id, "model", "new".into());
tokio::pin!(switching);
if !offline {
let next = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
if live {
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
} else {
next.reply.send(Err("not in this process's model list".into())).unwrap();
}
}
if missing_settings {
let discovery = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((discovery.launch, discovery.method.as_str()), (2, "session/new"));
discovery.reply.send(Ok(response(catalog_models, catalog_effort))).unwrap();
let set = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!(set.params, json!({"sessionId": "discovery-only", "configId": "model", "value": "new"}));
assert_eq!(set.method, "session/set_config_option");
assert!(
manager
.prompt(&task.id, AgentPrompt { text: "too early".into(), ..Default::default() }, false)
.await
.is_err()
);
if matches!(scenario, ChatSwitch::DiscoveryFails) {
set.reply.send(Err("Sign in required".into())).unwrap();
let error = switching.await.unwrap_err().to_string();
assert!(error.contains("Sign in required"), "{error}");
assert_eq!(manager.subscribe(Arc::new(|_| {})).remove(0).config, before_config);
assert!(harness.pending.try_recv().is_err());
manager.shutdown();
return;
}
if matches!(scenario, ChatSwitch::Superseded) {
manager.set_config(&task.id, "model", "old".into()).await.unwrap();
set.reply.send(Ok(response(&["new", "old"], &["quick", "thorough"]))).unwrap();
switching.await.unwrap();
let task = manager.subscribe(Arc::new(|_| {})).remove(0);
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
assert_eq!(task.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("low"));
assert!(harness.pending.try_recv().is_err());
manager.shutdown();
return;
}
let levels: &[&str] = if no_effort { &[] } else { &["quick", "thorough"] };
set.reply.send(Ok(response(&["new", "old"], levels))).unwrap();
}
tokio::select! {
result = &mut switching => result.unwrap(),
request = harness.next() => panic!("selection must not reopen the chat or send: {request:?}"),
}
}
// A fallback selection settles without waiting for a new process.
tokio::select! {
result = &mut switching => result.unwrap(),
request = harness.next() => panic!("selection must not open another session: {request:?}"),
}
assert_eq!(serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap(), before_entries);
if matches!(scenario, ChatSwitch::Uncached) {
let update = tokio::time::timeout(Duration::from_secs(5), async {
loop {
if let AgentEvent::Task { task: update } = events.recv().await.unwrap()
&& update.id == task.id
{
break update;
}
}
})
.await
.unwrap();
let effort = update.config.iter().find(|o| o.id == "effort").unwrap();
assert_eq!(effort.values.iter().map(|v| v.value.as_str()).collect::<Vec<_>>(), ["quick", "thorough"]);
}
let snapshot = |manager: &AgentManager| manager.subscribe(Arc::new(|_| {})).remove(0);
let current = snapshot(&manager);
assert_eq!(current.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("new"));
assert_eq!(current.model.as_deref(), Some(if live { "new" } else { "old" }));
let effort =
|task: &crate::AgentTask| task.config.iter().find(|o| o.id == "effort").and_then(|o| o.current.clone());
assert_eq!(
effort(&current).as_deref(),
if live {
Some("session-only")
} else if no_effort {
None
} else {
Some("quick")
},
"the new model's effort must be available before sending"
);
if choose_effort {
assert!(manager.set_config(&task.id, "effort", "high".into()).await.is_err());
manager.set_config(&task.id, "effort", "thorough".into()).await.unwrap();
assert_eq!(effort(&snapshot(&manager)).as_deref(), Some("thorough"));
if matches!(scenario, ChatSwitch::Uncached) {
manager.shutdown();
manager = make_manager(tmp.path(), Arc::default(), &harness);
let restored = snapshot(&manager);
assert_eq!(restored.id, task.id);
assert_eq!(effort(&restored).as_deref(), Some("thorough"));
}
}
manager.prompt(&task.id, AgentPrompt { text: "next".into(), ..Default::default() }, false).await.unwrap();
if !live {
let load = harness.next().await;
assert_eq!((load.launch, load.method.as_str()), (2, "session/load"));
assert_eq!((load.launch, load.method.as_str()), (resumed_launch, "session/load"));
assert_eq!(load.params["sessionId"], "saved-chat");
load.notifications
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
@@ -447,6 +578,7 @@ async fn switch_chat_model(scenario: ChatSwitch) {
let task = snapshot(&manager);
assert_eq!(task.model.as_deref(), Some("old"));
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
assert_eq!(effort(&task).as_deref(), Some("low"));
let expected = if load_fails { "cannot resume saved-chat" } else { "does not offer model new" };
assert!(task.error.as_deref().unwrap().contains(expected), "{:?}", task.error);
assert!(harness.pending.try_recv().is_err(), "must not send on the previous model or create a session");
@@ -472,24 +604,60 @@ async fn switch_chat_model(scenario: ChatSwitch) {
return;
}
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_config_option"));
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_config_option"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
set.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
let levels: &[&str] = match scenario {
ChatSwitch::NoEffort => &[],
ChatSwitch::EffortUnavailable => &["session-only", "quick"],
_ if choose_effort => &["session-only", "thorough"],
_ => &["session-only"],
};
set.reply.send(Ok(response(&["new", "old"], levels))).unwrap();
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_mode"));
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_mode"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
set.reply.send(Ok(json!({}))).unwrap();
if choose_effort && !matches!(scenario, ChatSwitch::EffortUnavailable) {
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_config_option"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "effort", "value": "thorough"}));
let reply = if effort_error.is_some() {
Err("effort rejected by the agent".into())
} else {
Ok(response(&["new", "old"], &["thorough", "session-only"]))
};
set.reply.send(reply).unwrap();
}
if let Some(expected) = effort_error {
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
let current = snapshot(&manager);
assert_eq!(current.model.as_deref(), Some("old"));
assert_eq!(effort(&current).as_deref(), Some("low"));
assert!(current.error.as_deref().unwrap().contains(expected), "{:?}", current.error);
assert!(harness.pending.try_recv().is_err(), "must not send using a fallback effort");
manager.shutdown();
return;
}
}
let next = harness.next().await;
assert_eq!(
(next.launch, next.method.as_str(), &next.params["sessionId"]),
(if live { 0 } else { 2 }, "session/prompt", &json!("saved-chat"))
(if live { 0 } else { resumed_launch }, "session/prompt", &json!("saved-chat"))
);
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
let current = snapshot(&manager);
assert_eq!(current.model.as_deref(), Some("new"));
assert_eq!(current.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("session-only"));
assert_eq!(
effort(&current).as_deref(),
if choose_effort {
Some("thorough")
} else if no_effort {
None
} else {
Some("session-only")
}
);
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
manager.shutdown();
}
+309 -112
Переглянути файл
@@ -357,9 +357,11 @@ struct TaskFile {
/// Settings the user chose, re-applied to every new or reloaded session.
#[serde(default)]
wanted: Vec<AgentConfigChoice>,
/// Option id of a discovered model in `wanted` that still needs a same-session reload.
#[serde(default, skip_serializing_if = "Option::is_none")]
/// Pending model option id in task files saved before pending settings were stored separately.
#[serde(default, skip_serializing)]
pending_model: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pending_switch: Option<PendingModel>,
/// In the project's own checkout: files already changed when the task started.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
before: BTreeMap<String, worktree::Stamp>,
@@ -384,6 +386,26 @@ struct TaskFile {
title_renamed: bool,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
struct PendingModel {
model: AgentConfigChoice,
candidate: Option<AgentConfigValue>,
options: Vec<AgentConfigOption>,
choices: Vec<AgentConfigChoice>,
}
impl PendingModel {
fn apply(&self, wanted: &mut Vec<AgentConfigChoice>, confirmed: &[AgentConfigOption]) {
wanted.retain(|choice| {
choice.id != self.model.id
&& !self.options.iter().any(|o| o.id == choice.id)
&& !confirmed.iter().any(|o| o.id == choice.id && config::is_per_model_option(o))
});
wanted.push(self.model.clone());
wanted.extend(self.choices.iter().cloned());
}
}
/// The changed files of a checkout, stamped.
type Snapshot = BTreeMap<String, worktree::Stamp>;
@@ -392,8 +414,9 @@ struct TaskState {
session_id: Option<String>,
conversation: Conversation,
wanted: Vec<AgentConfigChoice>,
pending_model: Option<String>,
pending_model: Option<PendingModel>,
model_choice: u64,
discovering_model: Option<u64>,
before: Arc<BTreeMap<String, worktree::Stamp>>,
saved: Option<String>,
/// See `TaskFile::touched`.
@@ -415,23 +438,43 @@ struct TaskState {
}
impl TaskState {
fn pending_model(&self) -> Option<&AgentConfigChoice> {
let id = self.pending_model.as_deref()?;
self.wanted.iter().find(|c| c.id == id)
}
fn snapshot(&self) -> AgentTask {
let mut task = self.task.clone();
if let Some(choice) = self.pending_model()
&& let Some(model) = task.config.iter_mut().find(|o| o.id == choice.id)
if let Some(pending) = &self.pending_model
&& let Some(model) = task.config.iter_mut().find(|o| o.id == pending.model.id)
{
model.current = Some(choice.value.clone());
model.current = Some(pending.model.value.clone());
if let Some(candidate) = &pending.candidate
&& !model.values.iter().any(|v| v.value == candidate.value)
{
model.values.push(candidate.clone());
}
task.config.retain(|o| !config::is_per_model_option(o));
task.config.extend(pending.options.iter().cloned().map(|mut option| {
if let Some(choice) = pending.choices.iter().find(|choice| choice.id == option.id) {
option.current = Some(choice.value.clone());
}
option
}));
}
task
}
}
struct DiscoveringModel<'a> {
state: &'a Mutex<TaskState>,
generation: u64,
}
impl Drop for DiscoveringModel<'_> {
fn drop(&mut self) {
let mut s = self.state.lock();
if s.discovering_model == Some(self.generation) {
s.discovering_model = None;
}
}
}
/// A running agent and its session.
#[derive(Clone)]
struct Live {
@@ -796,6 +839,7 @@ impl AgentManager {
entries: Vec::new(),
wanted: Vec::new(),
pending_model: None,
pending_switch: None,
before: BTreeMap::new(),
saved: None,
touched: Some(BTreeSet::new()),
@@ -912,6 +956,7 @@ impl AgentManager {
entries: Vec::new(),
wanted: req.config,
pending_model: None,
pending_switch: None,
before,
saved,
touched: (req.isolation == Isolation::Local).then(BTreeSet::new),
@@ -949,6 +994,9 @@ impl AgentManager {
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
if s.discovering_model.is_some() {
return Err(IdeError::unavailable("Model settings are still loading"));
}
if s.busy {
let item = AgentQueued { id: uuid::Uuid::new_v4().simple().to_string(), prompt };
if now {
@@ -1068,6 +1116,24 @@ impl AgentManager {
let task = self.task(id)?;
let (target, change) = {
let mut s = task.state.lock();
let busy = s.busy;
let archived = s.task.status == AgentStatus::Archived;
if let Some(pending) = &mut s.pending_model
&& let Some(target) = pending.options.iter().find(|o| o.id == option)
{
if archived || busy {
return Err(IdeError::invalid("The pending model settings cannot be changed now"));
}
if !target.values.iter().any(|v| v.value == value) {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
}
pending.choices.retain(|c| c.id != option);
pending.choices.push(AgentConfigChoice { id: option.to_owned(), value });
drop(s);
task.persist();
task.emit_task();
return Ok(());
}
let target = s
.task
.config
@@ -1075,6 +1141,9 @@ impl AgentManager {
.find(|o| o.id == option)
.ok_or_else(|| IdeError::not_found("no such setting"))?
.clone();
if s.pending_model.is_some() && config::is_per_model_option(&target) {
return Err(IdeError::invalid("This setting is not available on the selected model"));
}
if !target.values.iter().any(|v| v.value == value) {
if target.category.as_deref() != Some("model") {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
@@ -1083,8 +1152,12 @@ impl AgentManager {
} else {
let switching_model = target.category.as_deref() == Some("model");
if switching_model {
if s.pending_model.is_some() && s.busy {
return Err(IdeError::invalid("The pending model settings cannot be changed now"));
}
s.model_choice += 1;
s.pending_model = None;
s.discovering_model = None;
}
let previous_levels = (switching_model && target.current.as_deref() != Some(value.as_str()))
.then(|| s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>());
@@ -1116,33 +1189,19 @@ impl AgentManager {
&& (previous.as_deref() != Some(value.as_str()) || !model_options)
{
let provider = task.state.lock().task.provider.clone();
let mut levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
let mut error = None;
if levels.is_none()
&& let Some(spec) = self.shared.spec(&provider)
{
let (catalog, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, Some(&value));
error = catalog.error;
if let Some(mut ready) = flight {
while !*ready.borrow_and_update() {
if ready.changed().await.is_err() {
break;
}
}
}
levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
}
let levels = self.shared.paths.catalogs.load_levels(&self.shared, &provider, &value).await;
// Another selection may have superseded this discovery while it was waiting.
if task.state.lock().model_choice != model_choice {
return Ok(());
}
let Some(levels) = levels else {
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
task.persist();
task.emit_task();
return Err(IdeError::unavailable(
error.unwrap_or_else(|| "The agent did not report settings for the selected model".into()),
));
let levels = match levels {
Ok(levels) => levels,
Err(error) => {
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
task.persist();
task.emit_task();
return Err(IdeError::unavailable(error));
}
};
let mut s = task.state.lock();
if s.model_choice != model_choice {
@@ -1265,6 +1324,7 @@ impl AgentManager {
entries,
wanted: s.wanted.clone(),
pending_model: None,
pending_switch: None,
before: (*s.before).clone(),
saved: s.saved.clone(),
touched: s.touched.as_deref().cloned(),
@@ -1310,6 +1370,8 @@ impl AgentManager {
};
s.session_id = None;
s.pending_model = None;
s.model_choice += 1;
s.discovering_model = None;
s.conversation = Conversation::default();
// The fresh session reports its own usage; nothing carries over.
s.task.usage = None;
@@ -1908,6 +1970,24 @@ impl Task {
let mut task = file.task;
config::add_client_options(&task.provider, &mut task.config);
let conversation = Conversation::restore(file.entries, file.subagents);
let mut wanted = file.wanted;
let pending_model = file.pending_switch.or_else(|| {
let id = file.pending_model?;
let index = wanted.iter().position(|choice| choice.id == id)?;
let model = wanted.remove(index);
if let Some(value) = task.model.clone() {
wanted.push(AgentConfigChoice { id, value });
}
let catalog = shared.paths.catalogs.cached(&shared, &task.provider);
let candidate = catalog
.config
.iter()
.find(|o| o.category.as_deref() == Some("model"))
.and_then(|o| o.values.iter().find(|v| v.value == model.value))
.cloned();
let options = catalog.thought_levels.get(&model.value).cloned().unwrap_or_default();
Some(PendingModel { model, candidate, options, choices: Vec::new() })
});
Arc::new(Self {
id: task.id.clone(),
shared,
@@ -1915,9 +1995,10 @@ impl Task {
task,
session_id: file.session_id,
conversation,
wanted: file.wanted,
pending_model: file.pending_model,
wanted,
pending_model,
model_choice: 0,
discovering_model: None,
before: Arc::new(file.before),
saved: file.saved,
touched: file.touched.map(Arc::new),
@@ -2111,7 +2192,8 @@ impl Task {
session_id: s.session_id.clone(),
entries: s.conversation.main.entries.clone(),
wanted: s.wanted.clone(),
pending_model: s.pending_model.clone(),
pending_model: None,
pending_switch: s.pending_model.clone(),
before: (*s.before).clone(),
saved: s.saved.clone(),
touched: s.touched.as_deref().cloned(),
@@ -2264,13 +2346,18 @@ impl Task {
let candidate = self.shared.paths.catalogs.fresh_model(&self.shared, &spec, &value).ok_or_else(|| {
IdeError::invalid(format!("{} has no value {value} in the current model catalog", target.name))
})?;
let model_choice = {
let selection = {
let mut s = self.state.lock();
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
s.model_choice += 1;
s.model_choice
s.discovering_model = Some(s.model_choice);
DiscoveringModel { state: &self.state, generation: s.model_choice }
};
let model_choice = selection.generation;
// A prompt starting during the switch must not grab the peer we're about to recycle.
let _connecting = self.connecting.lock().await;
let connecting = self.connecting.lock().await;
{
let s = self.state.lock();
if s.model_choice != model_choice {
@@ -2293,16 +2380,16 @@ impl Task {
Ok(None)
};
let accepted = {
let mut s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
let pending = match result {
Ok(Some(reply)) => {
let refused = match result {
Ok(Some(reply)) => {
let (config, model) = {
let mut s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
if let Some(options) = reply.get("configOptions") {
config::merge_update(&mut s.task.config, options);
} else if s.task.model.as_deref() != Some(value.as_str()) {
@@ -2321,36 +2408,66 @@ impl Task {
model.current = Some(value.clone());
s.task.model = Some(value.clone());
sync_usage_context_size(&mut s.task);
false
}
refused => {
if s.session_id.is_none()
|| live.as_ref().is_some_and(|l| !l.resumable)
|| self.start_fresh.load(Ordering::Acquire)
{
return Err(IdeError::unavailable(
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
));
}
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
return Err(IdeError::invalid("wait until the agent is done"));
}
true
}
};
s.wanted.retain(|c| c.id != target.id);
s.pending_model = pending.then(|| target.id.clone());
s.wanted.push(AgentConfigChoice { id: target.id, value });
(!pending).then(|| {
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
(s.task.config.clone(), model)
})
s.pending_model = None;
s.wanted.retain(|c| c.id != target.id);
s.wanted.push(AgentConfigChoice { id: target.id, value });
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
(s.task.config.clone(), model)
};
self.shared.remember(&provider, Some(&config), None, model.as_deref());
self.persist();
self.emit_task();
return Ok(());
}
refused => refused,
};
if let Some((config, model)) = accepted {
self.shared.remember(&provider, Some(&config), None, model.as_deref());
} else {
self.recycle_resumable_session();
{
let s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.session_id.is_none()
|| live.as_ref().is_some_and(|l| !l.resumable)
|| self.start_fresh.load(Ordering::Acquire)
{
return Err(IdeError::unavailable(
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
));
}
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
return Err(IdeError::invalid("wait until the agent is done"));
}
}
// Catalog discovery never owns the chat session. Let a newer model choice supersede it.
drop(connecting);
let options = self.shared.paths.catalogs.load_levels(&self.shared, &provider, &value).await;
let _connecting = self.connecting.lock().await;
{
let mut s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
return Err(IdeError::invalid("wait until the agent is done"));
}
let options = options.map_err(IdeError::unavailable)?;
let choices = s
.pending_model
.take()
.filter(|pending| pending.model.value == value)
.map(|pending| pending.choices)
.unwrap_or_default();
s.pending_model = Some(PendingModel {
model: AgentConfigChoice { id: target.id, value },
candidate: Some(candidate),
options,
choices,
});
}
self.recycle_resumable_session();
self.persist();
self.emit_task();
Ok(())
@@ -2612,10 +2729,9 @@ impl Task {
}
let (provider_id, cwd, saved, pending) = {
let s = self.state.lock();
let pending = s.pending_model().map(|choice| (choice.clone(), s.task.model.clone()));
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), pending)
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), s.pending_model.clone())
};
let pending_model = pending.as_ref().map(|(choice, _)| choice);
let pending_model = pending.as_ref();
let raw_spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
let can_fallback =
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
@@ -2641,22 +2757,12 @@ impl Task {
let live = match opened {
Ok(live) => live,
Err(err) => {
if let Some((choice, previous)) = pending {
let mut s = self.state.lock();
if s.pending_model() == Some(&choice) {
s.pending_model = None;
s.wanted.retain(|c| c.id != choice.id);
if let Some(model) = s.task.config.iter_mut().find(|o| o.id == choice.id) {
model.current.clone_from(&previous);
}
s.task.model.clone_from(&previous);
if let Some(value) = previous {
s.wanted.push(AgentConfigChoice { id: choice.id, value });
}
drop(s);
self.persist();
self.emit_task();
}
let mut s = self.state.lock();
if pending.is_some() && s.pending_model == pending {
s.pending_model = None;
drop(s);
self.persist();
self.emit_task();
}
return Err(err.message);
}
@@ -2671,7 +2777,7 @@ impl Task {
spec: provider::ProviderSpec,
cwd: &Path,
saved: Option<String>,
pending_model: Option<&AgentConfigChoice>,
pending_model: Option<&PendingModel>,
) -> Result<Live, SessionOpenError> {
let launch_cwd = cwd.to_path_buf();
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
@@ -2697,14 +2803,15 @@ impl Task {
}
});
// Speaks ACP v1 or v2, whichever the agent chooses; the task sees v1 either way.
let client = acp::Dialect::wrap(Arc::new(Client { task: Arc::downgrade(self) }));
let client = Client::new(self, saved.as_deref().filter(|_| pending_model.is_some()));
let handler = acp::Dialect::wrap(client.clone());
let raw_peer =
(self.shared.connector)(&spec, cwd, client.clone(), on_stderr).map_err(|e| SessionOpenError {
(self.shared.connector)(&spec, cwd, handler.clone(), on_stderr).map_err(|e| SessionOpenError {
message: format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command),
allow_acp_fallback: !native::copilot::is_missing_binary_error(&e),
})?;
let mut stop_on_err = KillOnDrop(Some(raw_peer.clone()));
let peer = acp::Conn::new(raw_peer, client);
let peer = acp::Conn::new(raw_peer, handler);
let init = peer.initialize(&client_info()).await.map_err(|e| {
let is_auth = matches!(&e, RpcError::Server { code, message, .. } if acp::auth_required(*code, message));
@@ -2803,7 +2910,13 @@ impl Task {
// The session's settings, then the user's choices on top.
// A session that reports none keeps the last known ones, but what is set is unknown.
let reported = config::options_of(&result);
let mut reported = config::options_of(&result);
if let Some(update) = client.take_opening_config()
&& let Some(config) = update.get("configOptions")
&& reported.iter().all(|o| o.category.as_deref() != Some("model"))
{
config::merge_update(&mut reported, config);
}
let known = !reported.is_empty();
if known {
self.shared.remember(provider_id, Some(&reported), None, model_of(&reported).as_deref());
@@ -2811,19 +2924,33 @@ impl Task {
let (mut options, mut wanted) = {
let s = self.state.lock();
let options = if known { reported } else { s.task.config.clone() };
let wanted = s.wanted.clone();
let mut wanted = s.wanted.clone();
if let Some(pending) = pending_model {
pending.apply(&mut wanted, &s.task.config);
}
(options, wanted)
};
config::add_client_options(provider_id, &mut options);
// Changing model can replace the effort / context-tier choices; validate those only afterwards.
wanted.sort_by_key(|c| match options.iter().find(|o| o.id == c.id) {
Some(o) if o.category.as_deref() == Some("model") => 0,
Some(o) if config::is_per_model_option(o) => 2,
_ => 1,
wanted.sort_by_key(|c| {
if let Some(pending) = pending_model {
if c == &pending.model {
return 0;
}
if pending.choices.contains(c) {
return 2;
}
}
match options.iter().find(|o| o.id == c.id) {
Some(o) if o.category.as_deref() == Some("model") => 0,
Some(o) if config::is_per_model_option(o) => 2,
_ => 1,
}
});
let mut model_options = known;
for choice in &wanted {
let pending = pending_model == Some(choice);
let pending = pending_model.is_some_and(|p| &p.model == choice);
let explicit = pending_model.is_some_and(|p| p.choices.contains(choice));
if pending
&& !options.iter().any(|o| {
o.id == choice.id
@@ -2836,6 +2963,19 @@ impl Task {
allow_acp_fallback: false,
});
}
if explicit
&& (!model_options
|| !options.iter().any(|o| {
o.id == choice.id
&& config::is_per_model_option(o)
&& o.values.iter().any(|v| v.value == choice.value)
}))
{
return Err(SessionOpenError {
message: format!("The selected model no longer offers {} value {}.", choice.id, choice.value),
allow_acp_fallback: false,
});
}
// An option the session doesn't offer yet is set once it does (`apply_late_choices`).
let Some(o) = options.iter().find(|o| o.id == choice.id).cloned() else { continue };
if o.id == config::CURSOR_APPROVAL {
@@ -2847,7 +2987,7 @@ impl Task {
if config::is_per_model_option(&o) && !model_options {
continue;
}
let already = known && o.current.as_deref() == Some(choice.value.as_str());
let already = (known || explicit) && o.current.as_deref() == Some(choice.value.as_str());
if already || !o.values.iter().any(|v| v.value == choice.value) {
continue;
}
@@ -2856,14 +2996,30 @@ impl Task {
params["sessionId"] = json!(session_id);
match peer.request::<_, Value>(method, params, None).await {
Ok(reply) => {
if pending && !config::accepts_model(&reply, &o.id, &choice.value) {
let observed = client.take_opening_config();
let report =
if reply.get("configOptions").is_some() { &reply } else { observed.as_ref().unwrap_or(&reply) };
if pending && !config::accepts_model(report, &o.id, &choice.value) {
return Err(SessionOpenError {
message: format!("The reloaded session did not switch to model {}.", choice.value),
allow_acp_fallback: false,
});
}
if let Some(fresh) = reply.get("configOptions") {
if let Some(fresh) = report.get("configOptions") {
config::merge_update(&mut options, fresh);
if explicit
&& !options.iter().any(|option| {
option.id == choice.id && option.current.as_deref() == Some(choice.value.as_str())
})
{
return Err(SessionOpenError {
message: format!(
"The selected model did not accept {} value {}.",
choice.id, choice.value
),
allow_acp_fallback: false,
});
}
model_options = true;
} else if o.category.as_deref() == Some("model") {
if o.current.as_deref() != Some(choice.value.as_str()) {
@@ -2875,7 +3031,7 @@ impl Task {
o.current = Some(choice.value.clone());
}
}
Err(e) if pending => {
Err(e) if pending || explicit => {
return Err(SessionOpenError { message: self.describe(e), allow_acp_fallback: false });
}
Err(e) => tracing::warn!("agent task {}: setting {} to {} failed: {e}", self.id, o.id, choice.value),
@@ -2885,6 +3041,16 @@ impl Task {
self.shared.remember(provider_id, Some(&options), None, model.as_deref());
{
let mut s = self.state.lock();
if let Some(pending) = pending_model {
if s.pending_model.as_ref() != Some(pending) {
return Err(SessionOpenError {
message: "The pending model settings changed while reopening the session.".into(),
allow_acp_fallback: false,
});
}
let TaskState { task, wanted, .. } = &mut *s;
pending.apply(wanted, &task.config);
}
s.task.model = model_of(&options).or(s.task.model.take());
s.task.config = options;
s.pending_model = None;
@@ -2894,6 +3060,7 @@ impl Task {
// The (re)started process runs nothing yet: whatever it reports next is all of it.
s.background_tasks = Vec::new();
s.task.background.clear();
*client.opening_config.lock() = None;
}
self.persist();
self.emit_task();
@@ -3361,6 +3528,28 @@ impl Task {
/// Answers the agent's requests on behalf of one task.
struct Client {
task: Weak<Task>,
opening_config: Mutex<Option<OpeningConfig>>,
}
/// Config replays belong to the candidate connection until its model and settings are confirmed.
struct OpeningConfig {
session: String,
options: Option<Value>,
}
impl Client {
fn new(task: &Arc<Task>, opening_session: Option<&str>) -> Arc<Self> {
Arc::new(Self {
task: Arc::downgrade(task),
opening_config: Mutex::new(
opening_session.map(|id| OpeningConfig { session: id.to_owned(), options: None }),
),
})
}
fn take_opening_config(&self) -> Option<Value> {
self.opening_config.lock().as_mut()?.options.take()
}
}
impl Handler for Client {
@@ -3377,6 +3566,14 @@ impl Handler for Client {
if method == "session/update"
&& let (Some(task), Some(update)) = (self.task.upgrade(), params.get("update"))
{
if update.get("sessionUpdate").and_then(Value::as_str) == Some("config_option_update")
&& let Some(opening) = self.opening_config.lock().as_mut()
{
if params.get("sessionId").and_then(Value::as_str) == Some(opening.session.as_str()) {
opening.options = Some(update.clone());
}
return;
}
task.on_update(params.get("sessionId").and_then(Value::as_str), update);
}
}
+1 -1
Переглянути файл
@@ -1935,7 +1935,7 @@ async fn startup_warnings_survive_replay_and_restart_without_failing_the_task()
let handle = mgr.task(&task.id).unwrap();
handle.replaying.store(true, Ordering::Release);
handle.turn_started.store(false, Ordering::Release);
let client = Client { task: Arc::downgrade(&handle) };
let client = Client::new(&handle, None);
client.on_notification(WARNING_NOTIFICATION, json!({"message": "Project MCP config is disabled until trusted."}));
client.on_notification(WARNING_NOTIFICATION, json!({"message": " "}));
client.on_notification(WARNING_NOTIFICATION, json!({}));
+2
Переглянути файл
@@ -36,6 +36,8 @@ pub enum IdeEvent {
},
/// Project window membership or selection changed.
WindowGroupsChanged,
/// A project was loaded or unloaded for the MCP server without a window of its own.
McpBackgroundProjectsChanged,
/// A window entered or left full screen, itself or as a member of a full-screen window group.
WindowFullscreenChanged,
/// This remote window's connection to its host ended on its own (network loss, the host or
+114 -1
Переглянути файл
@@ -34,6 +34,8 @@ pub struct Settings {
pub project_structure: ProjectStructureSettings,
/// Version Control (Git, Commit, Confirmation, Issue Navigation).
pub vcs: VcsSettings,
/// Build, Execution, Deployment › Compiler (Build tool window).
pub build: BuildSettings,
/// Build, Execution, Deployment › Console.
pub console: ConsoleSettings,
pub debugger: DebuggerSettings,
@@ -317,6 +319,20 @@ pub enum NewTaskApprovals {
Ask,
}
/// Which folders without an open window the MCP server still serves tools for.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum McpBackgroundProjects {
/// Only projects open in a window.
#[default]
Off,
/// Also folders the user trusts: trusted projects, recent projects and the repositories inside
/// trusted locations.
Trusted,
/// Only the folders in [`McpServerSettings::background_project_paths`] (and below them).
Listed,
}
/// Agents › MCP Server: agents use the IDE's built-in tools.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
@@ -341,6 +357,21 @@ pub struct McpServerSettings {
/// Keep the bearer token across runs (in the app data, readable by this user only) rather than
/// make a new one each run.
pub fixed_token: bool,
/// Serve tools for folders that have no open window (see [`McpBackgroundProjects`]); the
/// project loads when an agent first asks for it.
#[serde(deserialize_with = "or_default")]
#[specta(type = McpBackgroundProjects)]
pub background_projects: McpBackgroundProjects,
/// The folders [`McpBackgroundProjects::Listed`] serves, and the ones `Trusted` serves even
/// when untrusted.
#[serde(deserialize_with = "or_default")]
#[specta(type = Vec<String>)]
pub background_project_paths: Vec<String>,
/// Minutes a background project may go without a tool call before it is unloaded, at most
/// 1440; 0 keeps it until the IDE quits.
pub background_idle_minutes: u32,
/// Background projects loaded at once, 1 to 32; the least recently used one makes room.
pub background_project_limit: u32,
}
/// The default of [`McpServerSettings::port`].
@@ -359,6 +390,10 @@ impl Default for McpServerSettings {
fixed_port: true,
port: DEFAULT_MCP_PORT,
fixed_token: false,
background_projects: McpBackgroundProjects::Off,
background_project_paths: Vec::new(),
background_idle_minutes: 30,
background_project_limit: 8,
}
}
}
@@ -508,6 +543,7 @@ impl Default for Settings {
languages: LanguagesSettings::default(),
project_structure: ProjectStructureSettings::default(),
vcs: VcsSettings::default(),
build: BuildSettings::default(),
console: ConsoleSettings::default(),
debugger: DebuggerSettings::default(),
run: RunSettings::default(),
@@ -1194,11 +1230,31 @@ pub struct ArduinoSettings {
}
/// Languages & Frameworks › Markdown. Like IDEA's, it is application-level only.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct MarkdownSettings {
/// Preview (and notebook Markdown cell) font size in px; unset follows the editor font size.
pub preview_font_size: Option<u32>,
/// "Detect commands that can be run right from Markdown files": gutter run icons on
/// shell code blocks and on command lines in code blocks.
pub run_commands: bool,
/// Where those commands run; unset asks when the project and the file's folder differ.
pub command_directory: Option<MarkdownCommandDirectory>,
}
impl Default for MarkdownSettings {
fn default() -> Self {
Self { preview_font_size: None, run_commands: true, command_directory: None }
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "lowercase")]
pub enum MarkdownCommandDirectory {
/// The project's root folder.
Project,
/// The Markdown file's parent folder.
File,
}
impl LanguagesSettings {
@@ -2117,6 +2173,63 @@ mod tests {
let restored: Settings = serde_json::from_value(value).unwrap();
assert_eq!(restored, settings);
}
#[test]
fn background_projects_default_to_off_with_no_paths_30_idle_minutes_and_a_limit_of_8() {
for settings in [Settings::default(), serde_json::from_str(r#"{"mcpServer":{"enabled":true}}"#).unwrap()] {
let mcp = settings.mcp_server;
assert_eq!(mcp.background_projects, McpBackgroundProjects::Off);
assert!(mcp.background_project_paths.is_empty());
assert_eq!((mcp.background_idle_minutes, mcp.background_project_limit), (30, 8));
}
}
#[test]
fn a_bad_background_mode_or_path_list_reads_as_its_default_and_keeps_the_rest() {
for (key, bad) in
[("backgroundProjects", serde_json::json!("bogus")), ("backgroundProjectPaths", serde_json::json!(5))]
{
let mut json = serde_json::json!({
"appearance": { "theme": "solarized-dark" },
"mcpServer": {
"enabled": true,
"port": 7000,
"backgroundProjects": "listed",
"backgroundProjectPaths": ["/projects/inventory"],
"backgroundIdleMinutes": 10,
"backgroundProjectLimit": 3,
},
});
json["mcpServer"][key] = bad;
let settings: Settings = serde_json::from_value(json).unwrap_or_else(|e| panic!("{key}: {e}"));
let mcp = settings.mcp_server;
let (mode, paths) = if key == "backgroundProjects" {
(McpBackgroundProjects::Off, vec!["/projects/inventory".to_owned()])
} else {
(McpBackgroundProjects::Listed, Vec::new())
};
assert_eq!((mcp.background_projects, mcp.background_project_paths), (mode, paths), "{key}");
assert_eq!((mcp.enabled, mcp.port), (true, 7000), "{key}");
assert_eq!((mcp.background_idle_minutes, mcp.background_project_limit), (10, 3), "{key}");
assert_eq!(settings.appearance.theme, "solarized-dark", "{key}");
}
}
#[test]
fn background_project_settings_round_trip() {
for mode in [McpBackgroundProjects::Off, McpBackgroundProjects::Trusted, McpBackgroundProjects::Listed] {
let mut settings = Settings::default();
settings.mcp_server.background_projects = mode;
settings.mcp_server.background_project_paths =
vec!["/projects/inventory".into(), "/projects/billing".into()];
settings.mcp_server.background_idle_minutes = 0;
settings.mcp_server.background_project_limit = 32;
let json = serde_json::to_string(&settings).unwrap();
assert!(json.contains(r#""backgroundProjects":""#), "{json}");
let restored: Settings = serde_json::from_str(&json).unwrap();
assert_eq!(restored.mcp_server, settings.mcp_server);
}
}
}
#[cfg(test)]
+26
Переглянути файл
@@ -170,6 +170,12 @@ pub struct CommitSettings {
pub double_click_opens_diff: Option<bool>,
/// Team conventions for Generate Commit Message with Agent, added to its prompt.
pub agent_instructions: String,
/// The coding agent Generate Commit Message with Agent uses; empty follows the latest task's agent.
pub agent: String,
/// That agent's model for commit messages; empty keeps the model the agent would use.
pub agent_model: String,
/// That model's thinking level for commit messages; empty keeps the agent's.
pub agent_effort: String,
}
impl Default for CommitSettings {
@@ -192,6 +198,9 @@ impl Default for CommitSettings {
disabled_plugin_checks: Vec::new(),
double_click_opens_diff: None,
agent_instructions: String::new(),
agent: String::new(),
agent_model: String::new(),
agent_effort: String::new(),
}
}
}
@@ -308,6 +317,23 @@ pub struct SqlResolutionScope {
pub schema: String,
}
/// Build, Execution, Deployment › Compiler (Build tool window behaviour).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct BuildSettings {
/// When to open the Build tool window: `always` | `onError` | `never`.
pub open_tool_window: String,
/// When to focus the Build tool window: `always` | `onError` | `never`.
pub focus_tool_window: String,
}
impl Default for BuildSettings {
fn default() -> Self {
// Builds open the tool window without taking focus.
Self { open_tool_window: "always".into(), focus_tool_window: "never".into() }
}
}
/// Build, Execution, Deployment › Console.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
+76 -9
Переглянути файл
@@ -68,10 +68,16 @@ pub enum Incoming {
Closed,
}
/// Bounded outgoing queue: an adapter that stops reading its input holds back `send`
/// instead of the IDE accumulating unbounded messages. The incoming queue stays unbounded:
/// the event loop awaits requests while handling events (`stopped` restores breakpoints), so
/// a reader parked on a full queue would never read the response that loop waits for.
const OUT_CAPACITY: usize = 256;
type Pending = HashMap<i64, (String, oneshot::Sender<Result<Value, DapError>>)>;
struct Inner {
out: mpsc::UnboundedSender<Vec<u8>>,
out: mpsc::Sender<Vec<u8>>,
pending: Mutex<Pending>,
seq: AtomicI64,
closed: AtomicBool,
@@ -114,7 +120,7 @@ impl Connection {
R: AsyncRead + Unpin + Send + 'static,
W: AsyncWrite + Unpin + Send + 'static,
{
let (out_tx, mut out_rx) = mpsc::unbounded_channel::<Vec<u8>>();
let (out_tx, mut out_rx) = mpsc::channel::<Vec<u8>>(OUT_CAPACITY);
let (in_tx, in_rx) = mpsc::unbounded_channel();
let inner = Arc::new(Inner {
out: out_tx,
@@ -183,17 +189,17 @@ impl Connection {
self.inner.closed.load(Ordering::Acquire)
}
fn send(&self, value: &Value) -> Result<(), DapError> {
async fn send(&self, value: &Value) -> Result<(), DapError> {
if self.is_closed() {
return Err(DapError::Closed);
}
let body = serde_json::to_vec(value).map_err(|e| DapError::Protocol(e.to_string()))?;
tracing::trace!(target: "ide_dap::wire", "--> {}", String::from_utf8_lossy(&body));
self.inner.out.send(body).map_err(|_| DapError::Closed)
self.inner.out.send(body).await.map_err(|_| DapError::Closed)
}
/// Sends a request and returns a receiver for its response body, without waiting.
pub fn send_request(
pub async fn send_request(
&self,
command: &str,
arguments: Value,
@@ -205,7 +211,7 @@ impl Connection {
if !arguments.is_null() {
msg["arguments"] = arguments;
}
if let Err(e) = self.send(&msg) {
if let Err(e) = self.send(&msg).await {
self.inner.pending.lock().remove(&seq);
return Err(e);
}
@@ -214,7 +220,7 @@ impl Connection {
/// Sends a request and waits for the response body (`null` when absent).
pub async fn request(&self, command: &str, arguments: Value) -> Result<Value, DapError> {
let rx = self.send_request(command, arguments)?;
let rx = self.send_request(command, arguments).await?;
rx.await.unwrap_or(Err(DapError::Closed))
}
@@ -226,7 +232,12 @@ impl Connection {
}
/// Answers a reverse request.
pub fn respond(&self, request_seq: i64, command: &str, result: Result<Value, String>) -> Result<(), DapError> {
pub async fn respond(
&self,
request_seq: i64,
command: &str,
result: Result<Value, String>,
) -> Result<(), DapError> {
let seq = self.inner.seq.fetch_add(1, Ordering::Relaxed);
let mut msg = json!({
"seq": seq,
@@ -240,7 +251,7 @@ impl Connection {
Ok(_) => {}
Err(message) => msg["message"] = Value::String(message),
}
self.send(&msg)
self.send(&msg).await
}
}
@@ -319,6 +330,62 @@ fn error_message(msg: &Value) -> String {
mod tests {
use super::*;
#[tokio::test]
async fn a_handler_awaiting_a_request_still_gets_its_response_behind_an_event_burst() {
// The event loop handles `stopped` by sending `setBreakpoints` and awaiting the reply
// while the adapter keeps printing: the reply arrives behind thousands of events.
let (client_in, mut adapter_out) = tokio::io::duplex(64 * 1024);
let (client_out, adapter_in) = tokio::io::duplex(64 * 1024);
let (conn, mut incoming) = Connection::start(client_in, client_out);
let adapter = tokio::spawn(async move {
let event =
|seq: i64, event: &str| json!({"seq": seq, "type": "event", "event": event, "body": {"output": "x"}});
framing::write_message(&mut adapter_out, event(0, "stopped").to_string().as_bytes()).await.unwrap();
for i in 1..=5000 {
framing::write_message(&mut adapter_out, event(i, "output").to_string().as_bytes()).await.unwrap();
}
let mut requests = BufReader::new(adapter_in);
let request = framing::read_message(&mut requests).await.unwrap().unwrap();
let request: Value = serde_json::from_slice(&request).unwrap();
let response = json!({"seq": 5001, "type": "response", "request_seq": request["seq"], "success": true, "command": request["command"], "body": {"breakpoints": []}});
framing::write_message(&mut adapter_out, response.to_string().as_bytes()).await.unwrap();
adapter_out
});
let Some(Incoming::Event { event, .. }) = incoming.recv().await else { panic!("no event") };
assert_eq!(event, "stopped");
let reply = tokio::time::timeout(Duration::from_secs(10), conn.request("setBreakpoints", json!({})))
.await
.expect("the reader stalled behind the events")
.unwrap();
assert_eq!(reply, json!({"breakpoints": []}));
let _ = adapter.await;
}
#[tokio::test]
async fn outgoing_commands_are_backpressured_when_the_adapter_is_slow() {
let (writer, _unread_peer) = tokio::io::duplex(32 * 1024);
let (reader, _idle_peer) = tokio::io::duplex(32 * 1024);
// Nobody reads the writer's pipe, so it fills and the writer task stalls.
let (conn, _incoming) = Connection::start(reader, writer);
let producer_conn = conn.clone();
let sent = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let count = sent.clone();
let producer = tokio::spawn(async move {
for i in 0..2000 {
let body = json!({"seq": i, "type": "event", "event": "output", "body": {"output": "x"}});
if producer_conn.send(&body).await.is_err() {
break;
}
count.fetch_add(1, Ordering::Relaxed);
}
});
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(sent.load(Ordering::Relaxed) < 2000);
// The bounded queue held `send` back; closing cancels the writer task.
conn.close();
producer.abort();
}
#[test]
fn parses_output_events_with_non_utf8_text() {
// "中文" in GBK inside an output event, as netcoredbg sends it on a Chinese Windows.
+4 -4
Переглянути файл
@@ -1144,7 +1144,7 @@ impl DebugManager {
let mut launch = if launch_in_config {
None
} else {
let reply = s.conn.send_request(request, arguments.clone())?;
let reply = s.conn.send_request(request, arguments.clone()).await?;
Some(Box::pin(async move { reply.await.unwrap_or(Err(DapError::Closed)) }))
};
let mut initialized = s.initialized.subscribe();
@@ -1222,7 +1222,7 @@ impl DebugManager {
}
if s.supports("supportsConfigurationDoneRequest") {
if s.adapter == kotlin::ADAPTER {
drop(s.conn.send_request("configurationDone", json!({}))?);
drop(s.conn.send_request("configurationDone", json!({})).await?);
} else {
s.conn.request_timeout("configurationDone", Value::Null, REQUEST_TIMEOUT).await?;
}
@@ -1236,7 +1236,7 @@ impl DebugManager {
}
None => {
// GDB 15: the breakpoints are in, so its `run` cannot miss them.
let reply = s.conn.send_request(request, arguments)?;
let reply = s.conn.send_request(request, arguments).await?;
reply.await.unwrap_or(Err(DapError::Closed))?;
}
}
@@ -1246,7 +1246,7 @@ impl DebugManager {
// never answered), and the page is already loading: its document and first scripts
// are not in the list.
if js_debug::is_page(s) {
let answer = s.conn.send_request("enableNetworking", js_debug::networking_arguments())?;
let answer = s.conn.send_request("enableNetworking", js_debug::networking_arguments()).await?;
let session = s.clone();
// Not waited for here: the page runs on. A refusal is told to the Network view,
// which would otherwise wait for requests that never come.
+11 -3
Переглянути файл
@@ -924,7 +924,11 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
match command {
"runInTerminal" => {
let result = run_in_terminal(s, &args);
let _ = s.conn.respond(seq, command, result);
let conn = s.conn.clone();
let command = command.to_owned();
tokio::spawn(async move {
let _ = conn.respond(seq, &command, result).await;
});
}
"startDebugging" => {
let mgr = mgr.clone();
@@ -933,11 +937,15 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
let request = args.get("request").and_then(Value::as_str).unwrap_or("launch").to_owned();
let configuration = args.get("configuration").cloned().unwrap_or_else(|| json!({}));
let result = mgr.start_child(&s, request, configuration).await;
let _ = s.conn.respond(seq, "startDebugging", result.map(|_| Value::Null).map_err(|e| e.message));
let _ = s.conn.respond(seq, "startDebugging", result.map(|_| Value::Null).map_err(|e| e.message)).await;
});
}
_ => {
let _ = s.conn.respond(seq, command, Err(format!("unsupported reverse request {command}")));
let conn = s.conn.clone();
let command = command.to_owned();
tokio::spawn(async move {
let _ = conn.respond(seq, &command, Err(format!("unsupported reverse request {command}"))).await;
});
}
}
}
+1 -1
Переглянути файл
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
pub const MANIFEST_FILE: &str = "plugin.toml";
/// The plugin API (engine) version this host implements.
pub const ENGINE_VERSION: &str = "1.13.0";
pub const ENGINE_VERSION: &str = "1.14.0";
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
pub const LEGACY_API: &str = "0.1";
/// Marketplace categories, in the order they are shown.
+1
Переглянути файл
@@ -98,6 +98,7 @@ async fn run(base: PathBuf) -> i32 {
}));
// A stable path for `--mcp-stdio` client configurations across server upgrades.
host.mcp.set_stdio_link(base.join("bin").join("openidea-server"));
host.mcp_background.serve_none();
host.mcp.apply(&host);
// The desktop's code plugins run here, next to the project (`plugin_sync_packages`).
let plugins = match RemotePlugins::start(&plugins_data, &host, peer.clone()) {
+47 -1
Переглянути файл
@@ -119,6 +119,29 @@ fn php_cs_fixer_edits(
.collect())
}
/// Some language servers (Vue's, for one) answer Reformat Code with one edit replacing the
/// whole file; applied as is, it moves the caret and the view to the top of the file. The same
/// result as one edit per changed region keeps them where they were.
fn minimal_edits(text: &str, edits: Vec<TextEdit>) -> Vec<TextEdit> {
if !edits.iter().any(|e| e.range.end.line > e.range.start.line) {
return edits;
}
let original = ide_text::Document::new(text);
let mut formatted = original.clone();
if formatted.apply_edits(&edits).is_err() {
return edits;
}
original
.diff(&formatted.text())
.changes
.into_iter()
.map(|c| TextEdit {
range: Range::new(original.offset_to_pos(c.from), original.offset_to_pos(c.to)),
new_text: c.insert,
})
.collect()
}
pub async fn format(
host: &Host,
window: &str,
@@ -292,7 +315,11 @@ async fn provider_edits(
if options.on_save && !settings.editor.format_on_save {
return Ok(None);
}
return project.lsp.format(doc, range, options).await.map(Some);
let edits = project.lsp.format(doc, range, options).await?;
let text = snap.text;
return tokio::task::spawn_blocking(move || Some(minimal_edits(&text, edits)))
.await
.map_err(|e| IdeError::internal(e.to_string()));
};
let tool_settings = settings.languages.formatter(selected);
if options.on_save && !tool_settings.run_on_save {
@@ -523,6 +550,25 @@ mod tests {
const ALIGN: PhpAlignment = PhpAlignment { key_value_pairs: true, assignments: true };
#[test]
fn a_whole_file_edit_becomes_one_edit_per_changed_region() {
let text = "a\n b\nc\nd\n e\n";
let formatted = "a\nb\nc\nd\ne\n";
let whole = vec![TextEdit { range: Range::new(Pos::new(0, 0), Pos::new(5, 0)), new_text: formatted.into() }];
let edits = minimal_edits(text, whole);
assert_eq!(
edits,
[
TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 2)), new_text: String::new() },
TextEdit { range: Range::new(Pos::new(4, 0), Pos::new(4, 2)), new_text: String::new() },
]
);
assert_eq!(after(text, &edits), formatted);
// Single-line edits are already minimal and pass through.
let small = vec![TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 2)), new_text: String::new() }];
assert_eq!(minimal_edits(text, small.clone()), small);
}
#[test]
fn php_alignment_is_off_unless_the_php_code_style_turns_it_on() {
let php = LanguageId::new("php");
+37 -11
Переглянути файл
@@ -69,6 +69,8 @@ pub struct Host {
pub mcp_requests: mcp::Requests,
/// Commands agents run in the Run tool window (`run_command`).
pub mcp_agent_runs: mcp::AgentRuns,
/// Projects the MCP server serves without a window.
pub mcp_background: mcp::BackgroundProjects,
pub(crate) agent_catalogs: Arc<ide_agent::AgentCatalogs>,
pub trust: trust::TrustStore,
pub(crate) mcp_approvals: Arc<trust::McpServerApprovals>,
@@ -125,10 +127,16 @@ pub struct Host {
const EXIT_SHUTDOWN_WAIT: std::time::Duration = std::time::Duration::from_secs(10);
impl Host {
/// Windows whose current project has this root.
/// Windows whose current project has this root. A project served without a window
/// has none.
pub(crate) fn windows_for_root(&self, root: &std::path::Path) -> Vec<String> {
let mut windows: Vec<_> =
self.projects.read().iter().filter(|(_, p)| p.root == root).map(|(w, _)| w.clone()).collect();
let mut windows: Vec<_> = self
.projects
.read()
.iter()
.filter(|(w, p)| p.root == root && !mcp::BackgroundProjects::is_key(w))
.map(|(w, _)| w.clone())
.collect();
windows.sort();
windows
}
@@ -159,6 +167,7 @@ impl Host {
mcp_reports: Default::default(),
mcp_requests: Default::default(),
mcp_agent_runs: Default::default(),
mcp_background: Default::default(),
agent_catalogs: Arc::default(),
trust: trust::TrustStore::load(&config_dir, &data_dir),
mcp_approvals: Arc::new(trust::McpServerApprovals::load(&data_dir)),
@@ -322,9 +331,18 @@ impl Host {
}
project.files_events_active.store(false, std::sync::atomic::Ordering::Release);
project.plugin_diagnostics.close();
// A project served without a window shares its files with a window whose root lies
// around or below its own: their diagnostics stay.
let background = mcp::BackgroundProjects::is_key(window);
let shared = background
&& self.projects.read().values().any(|other| {
!other.light && (other.root.starts_with(&project.root) || project.root.starts_with(&other.root))
});
// The producers will re-report when a project reopens; until then the snapshot
// must not answer for files whose project is gone.
self.diagnostics.forget_root(&project.root);
if !shared {
self.diagnostics.forget_root(&project.root);
}
if let Some(plugins) = plugins::editor_plugin_host() {
plugins.invalidate_client_navigation(&project.root, Some(window), None);
plugins.set_active_file(window, None);
@@ -355,7 +373,8 @@ impl Host {
vec![project.notebooks.clone()],
project.kotlin_bridge.iter().cloned().collect(),
Some(project.lsp.clone()),
Some((self.debugger.clone(), window.to_owned(), project.root.clone())),
// Debug sessions under the root belong to windows: a project served without one starts none.
Some((self.debugger.clone(), window.to_owned(), (!background).then(|| project.root.clone()))),
Some(project),
))
}
@@ -368,7 +387,7 @@ impl Host {
notebooks: Vec<Arc<notebook::NotebookService>>,
bridges: Vec<Arc<kotlin_bridge::KotlinBridge>>,
lsp: Option<Arc<ide_lsp::LspManager>>,
debug: Option<(Arc<ide_dap::DebugManager>, String, std::path::PathBuf)>,
debug: Option<(Arc<ide_dap::DebugManager>, String, Option<std::path::PathBuf>)>,
retired: Option<Arc<Project>>,
) -> std::thread::JoinHandle<()> {
for bridge in &bridges {
@@ -395,7 +414,9 @@ impl Host {
}
if let Some((debug, key, root)) = debug {
debug.stop_key(&key).await;
debug.stop_under(&root).await;
if let Some(root) = root {
debug.stop_under(&root).await;
}
}
});
if let Some(retired) = retired {
@@ -414,17 +435,22 @@ impl Host {
}
fn wait_blocking(&self, shutdown: std::thread::JoinHandle<()>) {
let wait = move || {
Self::in_place(move || {
if let Err(error) = shutdown.join() {
tracing::error!("project shutdown thread failed: {error:?}");
}
};
});
}
/// Runs blocking work on this thread. On a worker of a multi-thread runtime the
/// runtime is told first, so the worker's other tasks move to another thread.
pub(crate) fn in_place<T>(work: impl FnOnce() -> T) -> T {
if tokio::runtime::Handle::try_current()
.is_ok_and(|handle| handle.runtime_flavor() == tokio::runtime::RuntimeFlavor::MultiThread)
{
tokio::task::block_in_place(wait);
tokio::task::block_in_place(work)
} else {
wait();
work()
}
}
+498
Переглянути файл
@@ -0,0 +1,498 @@
//! Projects the MCP server serves without a window ("background projects"): opened by a
//! client's first tool call under the key `mcp:<root>` in the host's projects, held by the
//! calls and runs in flight, unloaded when idle or when the limit needs room, and closed
//! when a window opens the same root or the settings and trust decisions stop serving it.
mod policy;
#[cfg(test)]
mod tests;
use crate::{Host, Project};
use ide_core::settings::McpBackgroundProjects;
use ide_core::{IdeError, IdeResult, IpcPath};
use parking_lot::{Mutex, RwLock};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::time::{Duration, Instant};
/// Starts the key of every background project; window labels never contain `:`.
const KEY_PREFIX: &str = "mcp:";
/// `mcpServer.backgroundIdleMinutes` counts up to a day.
const MAX_IDLE_MINUTES: u32 = 24 * 60;
/// `mcpServer.backgroundProjectLimit` stays within these bounds.
const MIN_PROJECTS: u32 = 1;
const MAX_PROJECTS: u32 = 32;
/// How often idle projects are looked for.
const SWEEP_EVERY: Duration = Duration::from_secs(30);
/// A project served without a window, as the IDE lists it.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpBackgroundProject {
pub root: IpcPath,
/// Seconds since its last tool call began or ended.
pub idle_seconds: u32,
/// Seconds until it is unloaded for being idle. Absent while something keeps it open
/// and when idle projects are never unloaded.
#[serde(default, skip_serializing_if = "Option::is_none")]
#[specta(optional)]
pub unloads_in_seconds: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[specta(optional)]
pub kept_open_by: Option<McpBackgroundHold>,
}
/// What keeps an idle background project loaded.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase")]
pub enum McpBackgroundHold {
/// A tool call is in flight.
Request,
/// A run it started is alive; `name` is the first one's.
Run { name: String },
}
type Observer = Arc<dyn Fn() + Send + Sync>;
/// The background projects of one [`Host`].
#[derive(Default)]
pub struct BackgroundProjects {
/// Serializes opens and unloads, and is held across the open itself. Taken before
/// `state`, never with it held.
gate: Mutex<()>,
state: Mutex<State>,
observer: RwLock<Option<Observer>>,
/// Set by [`BackgroundProjects::serve_none`].
serves_none: AtomicBool,
}
#[derive(Default)]
struct State {
entries: HashMap<PathBuf, Arc<Entry>>,
/// Windows that are opening a root right now, counted per root.
claims: HashMap<PathBuf, usize>,
/// The root a background open under way is opening; the gate allows one at a time.
opening: Option<PathBuf>,
}
/// Marks the root of the open under way in [`State::opening`] until that open is over.
struct Opening<'a>(&'a BackgroundProjects);
impl Drop for Opening<'_> {
fn drop(&mut self) {
self.0.state.lock().opening = None;
}
}
struct Entry {
/// Tool calls running in the project.
in_flight: AtomicUsize,
/// When a call last reached the project or left it.
last_used: Mutex<Instant>,
}
/// Keeps a background project loaded while a tool call runs in it.
pub(crate) struct ActivityGuard(Arc<Entry>);
/// What answers a tool call: the window label or background key, the project, and the
/// call's guard when the project is served in the background.
pub(crate) type Served = (String, Arc<Project>, Option<ActivityGuard>);
impl Drop for ActivityGuard {
fn drop(&mut self) {
// The time first: a sweep that sees no call in flight then sees a fresh time.
*self.0.last_used.lock() = Instant::now();
self.0.in_flight.fetch_sub(1, Ordering::AcqRel);
}
}
/// A window is opening the root: no background project of it is opened meanwhile.
pub(crate) struct Claim<'a> {
owner: &'a BackgroundProjects,
root: PathBuf,
}
impl Drop for Claim<'_> {
fn drop(&mut self) {
let mut state = self.owner.state.lock();
if let Some(count) = state.claims.get_mut(&self.root) {
*count -= 1;
if *count == 0 {
state.claims.remove(&self.root);
}
}
}
}
/// When [`BackgroundProjects::remove`] unloads a project.
#[derive(Clone, Copy)]
enum Only {
Always,
/// No call or run holds it.
Unheld,
/// Nothing holds it and it has been idle for the configured time at this moment.
Idle(Instant),
}
/// The inputs of [`policy::resolve`] at one moment.
struct Policy {
mode: McpBackgroundProjects,
listed: Vec<PathBuf>,
decisions: crate::trust::TrustDecisions,
recents: Vec<PathBuf>,
home: Option<PathBuf>,
}
impl Policy {
/// `None` when the MCP server or its background projects are off, and when the trust
/// decisions cannot be read.
fn current(host: &Host) -> Option<Self> {
let settings = host.global_settings.effective().mcp_server;
// Without the server no client is served, a request it accepted before it stopped included.
if !settings.enabled || host.mcp_background.serves_none.load(Ordering::Relaxed) {
return None;
}
let mode = settings.background_projects;
let by_trust = match mode {
McpBackgroundProjects::Off => return None,
McpBackgroundProjects::Trusted => true,
McpBackgroundProjects::Listed => false,
};
let recents = if by_trust { ide_workspace::RecentProjects::load(&host.config_dir).paths() } else { Vec::new() };
Some(Self {
mode,
listed: settings.background_project_paths.iter().map(PathBuf::from).collect(),
decisions: host.trust.decisions().ok()?,
recents,
home: dirs::home_dir(),
})
}
fn resolve(&self, path: &Path) -> Option<PathBuf> {
policy::resolve(self.mode, &self.listed, &self.decisions, &self.recents, self.home.as_deref(), path)
}
}
/// The root of the project that serves `path` in the background under the current
/// settings and trust decisions. Opens nothing.
pub(crate) fn serving_root(host: &Host, path: &Path) -> Option<PathBuf> {
Policy::current(host)?.resolve(path)
}
/// How long a project may stay idle; `None` when `minutes` is 0 (never unloaded).
fn idle_limit(minutes: u32) -> Option<Duration> {
(minutes > 0).then(|| Duration::from_secs(u64::from(minutes.min(MAX_IDLE_MINUTES)) * 60))
}
fn project_limit(limit: u32) -> usize {
limit.clamp(MIN_PROJECTS, MAX_PROJECTS) as usize
}
fn whole_seconds(time: Duration) -> u32 {
u32::try_from(time.as_secs()).unwrap_or(u32::MAX)
}
/// What keeps the project at `root` loaded, a call before a run.
fn hold(host: &Host, root: &Path, entry: &Entry) -> Option<McpBackgroundHold> {
if entry.in_flight.load(Ordering::Acquire) > 0 {
return Some(McpBackgroundHold::Request);
}
host.processes.running_in(root).into_iter().next().map(|run| McpBackgroundHold::Run { name: run.name })
}
impl BackgroundProjects {
/// The key of the background project at `root` in the host's projects.
pub fn key(root: &Path) -> String {
format!("{KEY_PREFIX}{}", root.display())
}
/// Serves no project in the background, whatever the settings say: the remote server,
/// which exists for its window's project and holds no trust decisions of its own.
pub fn serve_none(&self) {
self.serves_none.store(true, Ordering::Relaxed);
}
/// Whether `window` is the key of a background project and not a window's label.
pub fn is_key(window: &str) -> bool {
window.starts_with(KEY_PREFIX)
}
/// The loaded background project at `root`. Leaves its idle time alone.
pub(crate) fn project(&self, host: &Host, root: &Path) -> Option<Arc<Project>> {
self.state.lock().entries.contains_key(root).then(|| host.project(&Self::key(root)).ok()).flatten()
}
/// The project that answers a tool call for `root`, opened now unless it is loaded: its
/// key, the project and the guard of the call, which counts as in flight from here on,
/// so nothing unloads the project before the call runs. A window that opened the root
/// meanwhile answers instead, with its label and no guard. Refused while a window is
/// opening the root, when the settings and trust decisions do not serve it, and when
/// the limit is reached with every loaded project held.
pub(crate) fn open(&self, host: &Host, root: &Path) -> IdeResult<Served> {
let key = Self::key(root);
// Without the gate, which the open of another root may hold for seconds.
if let Some((project, call)) = self.reach(host, root, &key) {
return Ok((key, project, Some(call)));
}
let mut changed = false;
let opened = {
let _gate = self.gate.lock();
self.open_gated(host, root, &key, &mut changed)
};
if changed {
self.notify();
}
opened
}
/// The loaded project at `root`, with a call entered in it.
fn reach(&self, host: &Host, root: &Path, key: &str) -> Option<(Arc<Project>, ActivityGuard)> {
let call = {
// Under `state`, so an unload either sees the call or has removed the entry.
let state = self.state.lock();
let entry = state.entries.get(root)?.clone();
entry.in_flight.fetch_add(1, Ordering::AcqRel);
*entry.last_used.lock() = Instant::now();
ActivityGuard(entry)
};
// A project closed behind its entry drops the guard here; the gated open replaces both.
host.project(key).ok().map(|project| (project, call))
}
fn open_gated(&self, host: &Host, root: &Path, key: &str, changed: &mut bool) -> IdeResult<Served> {
// Another call opened it while this one waited for the gate.
if let Some((project, call)) = self.reach(host, root, key) {
return Ok((key.to_owned(), project, Some(call)));
}
if let Some((window, project)) = host.window_project(root) {
return Ok((window, project, None));
}
let _opening = {
let mut state = self.state.lock();
if state.claims.contains_key(root) {
return Err(IdeError::unavailable(format!("{} is opening in a window; retry", root.display())));
}
// An entry whose project was closed behind its back would count against the limit.
*changed |= state.entries.remove(root).is_some();
// In the same step as the look at the claims: a window that claims the root from
// here on sees this open and waits for it.
state.opening = Some(root.to_path_buf());
Opening(self)
};
if serving_root(host, root).as_deref() != Some(root) {
return Err(IdeError::unavailable(format!("{} is not served in the background", root.display())));
}
let limit = project_limit(host.global_settings.effective().mcp_server.background_project_limit);
while self.state.lock().entries.len() >= limit {
let Some(idle) = self.longest_idle(host) else {
return Err(IdeError::unavailable(format!(
"the limit of {limit} background projects is reached and all are busy"
)));
};
// A call that entered it meanwhile keeps it; the loop then looks again.
*changed |= self.remove(host, &idle, Only::Unheld);
}
let project = host.open_project(key, root)?;
// Entered from the start: the next open cannot evict it before this call runs.
let entry = Arc::new(Entry { in_flight: AtomicUsize::new(1), last_used: Mutex::new(Instant::now()) });
self.state.lock().entries.insert(root.to_path_buf(), entry.clone());
if let Some(plugins) = host.plugin_host() {
plugins.reopen_client(key);
}
*changed = true;
Ok((key.to_owned(), project, Some(ActivityGuard(entry))))
}
/// Unloads the background project at `root` and stops what it started; its workers
/// finish shutting down in the background. It waits for a background open that is under
/// way, so call it from a blocking context. With `only_if_idle`, a project that a call
/// or a run holds, or that is not idle for the configured time at that moment, stays.
/// `false` when nothing was unloaded, an unknown root included.
pub fn detach(&self, host: &Host, root: &Path, only_if_idle: Option<Instant>) -> bool {
let removed = {
let _gate = self.gate.lock();
self.remove(host, root, only_if_idle.map_or(Only::Always, Only::Idle))
};
if removed {
self.notify();
}
removed
}
/// The single way a background project closes. The caller holds the gate.
fn remove(&self, host: &Host, root: &Path, only: Only) -> bool {
// Before `state`: the runs have a lock of their own.
let running = !host.processes.running_in(root).is_empty();
let may_idle = idle_limit(host.global_settings.effective().mcp_server.background_idle_minutes);
{
let mut state = self.state.lock();
let Some(entry) = state.entries.get(root) else { return false };
let held = running || entry.in_flight.load(Ordering::Acquire) > 0;
let idle = |now: Instant| {
may_idle.is_some_and(|limit| now.saturating_duration_since(*entry.last_used.lock()) >= limit)
};
let stays = match only {
Only::Always => false,
Only::Unheld => held,
Only::Idle(now) => held || !idle(now),
};
if stays {
return false;
}
state.entries.remove(root);
}
let key = Self::key(root);
if let Some(plugins) = host.plugin_host() {
plugins.forget_client(&key);
}
host.close_project_detached(&key);
true
}
/// The projects no call or run holds that have been idle for the configured time at `now`.
pub(crate) fn sweep_candidates(&self, host: &Host, now: Instant) -> Vec<PathBuf> {
let minutes = host.global_settings.effective().mcp_server.background_idle_minutes;
let Some(limit) = idle_limit(minutes) else { return Vec::new() };
let idle = |entry: &Entry| now.saturating_duration_since(*entry.last_used.lock()) >= limit;
let entries = self.entries().into_iter();
entries.filter(|(root, entry)| idle(entry) && hold(host, root, entry).is_none()).map(|(root, _)| root).collect()
}
/// Unloads the projects that are idle at `now`; each is checked again as it is unloaded.
pub(crate) fn sweep(&self, host: &Host, now: Instant) {
for root in self.sweep_candidates(host, now) {
self.detach(host, &root, Some(now));
}
}
/// A window is about to open `root`: unloads the root's background project and keeps
/// another from opening until the claim drops. It waits for a background open only when
/// the root is loaded or is the one being opened; a window on any other folder goes on
/// at once.
pub(crate) fn claim(&self, host: &Host, root: &Path) -> Claim<'_> {
let contested = {
let mut state = self.state.lock();
// From here no background open of the root gets past its look at the claims.
*state.claims.entry(root.to_path_buf()).or_default() += 1;
state.entries.contains_key(root) || state.opening.as_deref() == Some(root)
};
let claim = Claim { owner: self, root: root.to_path_buf() };
if contested {
let removed = {
let _gate = self.gate.lock();
self.remove(host, root, Only::Always)
};
if removed {
self.notify();
}
}
claim
}
/// Waits for a background open that is under way. After it, the project that open
/// read its settings and trust for is registered, and an open that starts later reads
/// what is stored now.
pub(crate) fn wait_for_open(&self) {
drop(self.gate.lock());
}
/// The loaded background projects at `now`, sorted by root.
pub fn snapshot(&self, host: &Host, now: Instant) -> Vec<McpBackgroundProject> {
let may_idle = idle_limit(host.global_settings.effective().mcp_server.background_idle_minutes);
let mut projects: Vec<_> = self
.entries()
.into_iter()
.map(|(root, entry)| {
let idle = now.saturating_duration_since(*entry.last_used.lock());
let kept_open_by = hold(host, &root, &entry);
let unloads_in = may_idle.filter(|_| kept_open_by.is_none()).map(|limit| limit.saturating_sub(idle));
McpBackgroundProject {
root: root.into(),
idle_seconds: whole_seconds(idle),
unloads_in_seconds: unloads_in.map(whole_seconds),
kept_open_by,
}
})
.collect();
projects.sort_by(|a, b| a.root.cmp(&b.root));
projects
}
fn entries(&self) -> Vec<(PathBuf, Arc<Entry>)> {
self.state.lock().entries.iter().map(|(root, entry)| (root.clone(), entry.clone())).collect()
}
/// The project nothing holds that was used the longest ago.
fn longest_idle(&self, host: &Host) -> Option<PathBuf> {
let unheld = self.entries().into_iter().filter(|(root, entry)| hold(host, root, entry).is_none());
unheld.min_by_key(|(_, entry)| *entry.last_used.lock()).map(|(root, _)| root)
}
/// Tells the observer that the loaded projects changed. Never called with a lock of
/// this type held.
fn notify(&self) {
let observer = self.observer.read().clone();
if let Some(observer) = observer {
observer();
}
}
}
impl Host {
/// The window, and its project, that has `root` open as a project (not in LightEdit).
fn window_project(&self, root: &Path) -> Option<(String, Arc<Project>)> {
let projects = self.projects.read();
let windows = projects.iter().filter(|(w, p)| !BackgroundProjects::is_key(w) && !p.light && p.root == root);
windows.min_by_key(|(w, _)| w.as_str()).map(|(w, p)| (w.clone(), p.clone()))
}
/// Unloads the background projects the settings and trust decisions no longer serve:
/// all of them when the MCP server is off, otherwise each whose root no longer serves
/// itself. Call it after either changes, from a blocking context: it reads the recent
/// projects and waits for a background open that is under way.
pub fn apply_background_policy(&self) {
// First: a project that is being opened under the old settings has no entry yet.
self.mcp_background.wait_for_open();
let roots: Vec<PathBuf> = self.mcp_background.entries().into_iter().map(|(root, _)| root).collect();
if roots.is_empty() {
return;
}
let policy = Policy::current(self);
for root in roots {
if policy.as_ref().and_then(|policy| policy.resolve(&root)).as_deref() != Some(&root) {
self.mcp_background.detach(self, &root, None);
}
}
}
/// Starts the timer that unloads idle background projects for as long as the host lives.
pub fn start_background_sweeper(self: &Arc<Self>) {
let host = Arc::downgrade(self);
self.runtime.spawn(async move {
let mut tick = tokio::time::interval(SWEEP_EVERY);
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
tick.tick().await;
loop {
tick.tick().await;
let Some(host) = host.upgrade() else { break };
// The timer's clock, so a sweep and its tick agree on the time.
let now = tokio::time::Instant::now().into_std();
// An unload waits for the gate, which an open in flight holds: off the async workers.
let sweep = tokio::task::spawn_blocking(move || host.mcp_background.sweep(&host, now));
if let Err(error) = sweep.await {
tracing::warn!(%error, "sweeping idle background projects failed");
}
}
});
}
/// Sets what is told when a background project is opened or unloaded. It runs on the
/// thread that made the change, outside the locks of the background projects.
pub fn set_background_projects_observer(&self, observer: Arc<dyn Fn() + Send + Sync>) {
*self.mcp_background.observer.write() = Some(observer);
}
}
+229
Переглянути файл
@@ -0,0 +1,229 @@
//! Which folder serves a client's path as a background project: a pure function of the
//! setting, the listed folders, the trust decisions, the recent projects and the project
//! markers on disk.
use crate::trust::TrustDecisions;
use ide_core::settings::McpBackgroundProjects;
use std::path::{Path, PathBuf};
/// The root of the background project that serves `path`: the innermost of the `listed`
/// folders containing it and, in `Trusted` mode, of the trusted projects, the trusted recent
/// projects and the nearest trusted folder with a project marker. `None` when the mode is
/// `Off`, when `path` is relative or missing, and when no folder qualifies. Listed and
/// recent folders that are gone or not absolute paths are skipped.
pub(crate) fn resolve(
mode: McpBackgroundProjects,
listed: &[PathBuf],
decisions: &TrustDecisions,
recents: &[PathBuf],
home: Option<&Path>,
path: &Path,
) -> Option<PathBuf> {
let by_trust = match mode {
McpBackgroundProjects::Off => return None,
McpBackgroundProjects::Trusted => true,
McpBackgroundProjects::Listed => false,
};
if !path.is_absolute() {
return None;
}
let path = dunce::canonicalize(path).ok()?;
// A relative entry would be read against the working directory, which says nothing
// about the user's folders (`/` for an app started from the Finder).
let existing = |entry: &PathBuf| entry.is_absolute().then(|| dunce::canonicalize(entry).ok()).flatten();
// A listed folder serves its subtree whether or not it is trusted: it opens restricted then.
let mut candidates: Vec<PathBuf> = listed.iter().filter_map(existing).collect();
if by_trust {
candidates.extend(decisions.projects.iter().filter(|p| trusted_here(decisions, p)).cloned());
// Remote projects are recorded as locations (`ssh://…`), not as folders of this machine.
let local = recents.iter().filter(|p| !p.to_string_lossy().contains("://"));
candidates.extend(local.filter_map(existing).filter(|p| trusted_here(decisions, p)));
let home = home.map(|h| dunce::canonicalize(h).unwrap_or_else(|_| h.to_path_buf()));
// A trusted location and the home folder hold projects; neither is one.
candidates
.extend(marker_root(&path).filter(|a| {
trusted_here(decisions, a) && !decisions.locations.contains(a) && home.as_ref() != Some(a)
}));
}
innermost(&candidates, &path).cloned()
}
/// The entry with the most components among those of `entries` that contain `path`.
fn innermost<'a>(entries: impl IntoIterator<Item = &'a PathBuf>, path: &Path) -> Option<&'a PathBuf> {
entries.into_iter().filter(|entry| path.starts_with(entry)).max_by_key(|entry| entry.components().count())
}
/// Whether the decisions trust a project at `root`: its innermost grant (the project itself
/// or a trusted location around it) lies deeper than every restricted folder around it, so a
/// restricted folder vetoes everything below it short of a grant made further down.
fn trusted_here(decisions: &TrustDecisions, root: &Path) -> bool {
let own = decisions.projects.iter().filter(|project| *project == root);
let Some(grant) = innermost(own.chain(&decisions.locations), root) else { return false };
innermost(&decisions.restricted, root).is_none_or(|veto| veto.components().count() < grant.components().count())
}
/// The first ancestor of `path`, itself included, that looks like a project: it holds an
/// `.openidea` folder, or a `.git` or `.jj` entry (a linked worktree's `.git` is a file).
fn marker_root(path: &Path) -> Option<PathBuf> {
let marked = |dir: &&Path| dir.join(".openidea").is_dir() || dir.join(".git").exists() || dir.join(".jj").exists();
path.ancestors().find(marked).map(Path::to_path_buf)
}
#[cfg(test)]
mod tests {
use super::*;
use McpBackgroundProjects::{Listed, Off, Trusted};
type Folders = &'static [&'static str];
/// What is asked, the mode, the listed folders, the trusted projects, the trusted
/// locations, the restricted folders, the recent projects, the path and the root that
/// serves it; folders are relative to the tree.
type Case = (
&'static str,
McpBackgroundProjects,
Folders,
Folders,
Folders,
Folders,
Folders,
&'static str,
Option<&'static str>,
);
/// `code/` with projects of every marker kind, and `home/` standing in for the user's home.
fn tree() -> (tempfile::TempDir, PathBuf) {
let tmp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(tmp.path()).unwrap();
for dir in [
"code/app/.git",
"code/app/src",
"code/app/.wt/feature/src",
"code/lib/.jj",
"code/tool/.openidea",
"code/tool/sub",
"code/plain/src",
"code/vendor/dep/.git",
"home/.openidea",
"home/notes",
"home/work/.git",
] {
std::fs::create_dir_all(base.join(dir)).unwrap();
}
// A linked worktree's `.git` is a file.
std::fs::write(base.join("code/app/.wt/feature/.git"), "gitdir: ../../.git/worktrees/feature\n").unwrap();
// A file named like the settings folder is no marker.
std::fs::write(base.join("code/plain/.openidea"), "").unwrap();
(tmp, base)
}
#[test]
fn the_innermost_folder_the_policy_allows_serves_a_path() {
let (_tmp, base) = tree();
let paths = |names: &[&str]| names.iter().map(|n| base.join(n)).collect::<Vec<_>>();
#[rustfmt::skip]
let cases: &[Case] = &[
("off serves nothing", Off, &["code/app"], &["code/app"], &["code"], &[], &["code/app"], "code/app/src", None),
("a listed folder, trusted or not", Listed, &["code/app"], &[], &[], &[], &[], "code/app/src", Some("code/app")),
("a listed folder itself", Listed, &["code/app"], &[], &[], &[], &[], "code/app", Some("code/app")),
("listed mode ignores trust", Listed, &[], &["code/app"], &["code"], &[], &["code/app"], "code/app/src", None),
("a sibling of a listed folder", Listed, &["code/app"], &[], &[], &[], &[], "code/lib", None),
("a listed folder that is gone", Listed, &["code/gone", "code/app"], &[], &[], &[], &[], "code/app/src", Some("code/app")),
("a trusted project", Trusted, &[], &["code/plain"], &[], &[], &[], "code/plain/src", Some("code/plain")),
("a recent project in a trusted location", Trusted, &[], &[], &["code"], &[], &["code/plain"], "code/plain/src", Some("code/plain")),
("a recent project nobody trusted", Trusted, &[], &[], &[], &[], &["code/plain"], "code/plain/src", None),
("a recent project that was restricted", Trusted, &[], &[], &["code"], &["code/plain"], &["code/plain"], "code/plain/src", None),
("a recent project that is gone", Trusted, &[], &[], &["code"], &[], &["code/gone"], "code/plain/src", None),
("a .git folder", Trusted, &[], &[], &["code"], &[], &[], "code/app/src", Some("code/app")),
("a .git file", Trusted, &[], &[], &["code"], &[], &[], "code/app/.wt/feature/src", Some("code/app/.wt/feature")),
("a .jj folder, from the root itself", Trusted, &[], &[], &["code"], &[], &[], "code/lib", Some("code/lib")),
("an .openidea folder", Trusted, &[], &[], &["code"], &[], &[], "code/tool/sub", Some("code/tool")),
("an .openidea file is no marker", Trusted, &[], &[], &["code"], &[], &[], "code/plain/src", None),
("a marker nobody trusted", Trusted, &[], &[], &[], &[], &[], "code/app/src", None),
("the walk stops at the first marker", Trusted, &[], &[], &["code"], &["code/app/.wt/feature"], &[], "code/app/.wt/feature/src", None),
("a worktree in a trusted location inside a trusted project", Trusted, &[], &["code/app"], &["code/app/.wt"], &[], &[], "code/app/.wt/feature/src", Some("code/app/.wt/feature")),
("an untrusted worktree inside a trusted project", Trusted, &[], &["code/app"], &[], &[], &[], "code/app/.wt/feature/src", Some("code/app")),
("a trusted child of a listed untrusted parent", Trusted, &["code"], &["code/plain"], &[], &[], &[], "code/plain/src", Some("code/plain")),
("the listed parent for the rest of it", Trusted, &["code"], &["code/plain"], &[], &[], &[], "code/tool/sub", Some("code")),
("a marker under a restricted folder", Trusted, &[], &[], &["code"], &["code/vendor"], &[], "code/vendor/dep", None),
("a deeper grant under a restricted folder", Trusted, &[], &["code/vendor/dep"], &["code"], &["code/vendor"], &[], "code/vendor/dep", Some("code/vendor/dep")),
("a restricted trusted location", Trusted, &[], &[], &["code"], &["code"], &[], "code/app/src", None),
("a trusted location is no project", Trusted, &[], &[], &["code/app"], &[], &[], "code/app/src", None),
("the home folder is no project", Trusted, &[], &[], &[""], &[], &[], "home/notes", None),
("a repository in the home folder", Trusted, &[], &[], &[""], &[], &[], "home/work", Some("home/work")),
("a missing path", Listed, &["code/app"], &[], &[], &[], &[], "code/app/missing", None),
];
for (what, mode, listed, projects, locations, restricted, recents, path, expected) in cases {
let decisions = TrustDecisions {
projects: paths(projects),
locations: paths(locations),
restricted: paths(restricted),
};
let home = base.join("home");
let found = resolve(*mode, &paths(listed), &decisions, &paths(recents), Some(&home), &base.join(path));
assert_eq!(found, expected.map(|root| base.join(root)), "{what}");
}
}
#[test]
fn a_relative_path_is_served_by_nothing() {
let (_tmp, base) = tree();
let listed = [base.join("code/app"), PathBuf::from("code/app"), PathBuf::from(".")];
let none = TrustDecisions::default();
for path in ["code/app/src", ".", "src"] {
assert_eq!(resolve(Listed, &listed, &none, &[], None, Path::new(path)), None, "{path}");
}
}
#[test]
fn a_relative_list_or_recent_entry_serves_nothing() {
// Read against the working directory, `.` would serve whatever folder the app was started from.
let here = dunce::canonicalize(std::env::current_dir().unwrap()).unwrap();
let around = TrustDecisions { locations: vec![here.parent().unwrap().to_path_buf()], ..Default::default() };
let none = TrustDecisions::default();
let (dot, absolute): (&[PathBuf], &[PathBuf]) = (&[PathBuf::from(".")], std::slice::from_ref(&here));
for (what, mode, listed, decisions, recents, expected) in [
("a listed `.`", Listed, dot, &none, &[][..], None),
("a listed `.` with trusted projects served", Trusted, dot, &none, &[][..], None),
("a recent `.`", Trusted, &[][..], &around, dot, None),
("the same folder listed by its full path", Listed, absolute, &none, &[][..], Some(&here)),
("the same folder recent by its full path", Trusted, &[][..], &around, absolute, Some(&here)),
] {
assert_eq!(resolve(mode, listed, decisions, recents, None, &here).as_ref(), expected, "{what}");
}
}
#[cfg(unix)]
#[test]
fn a_folder_reached_through_a_link_is_the_folder_itself() {
let (_tmp, base) = tree();
std::os::unix::fs::symlink(base.join("code"), base.join("link")).unwrap();
let none = TrustDecisions::default();
// Listed by the link, asked for by the real path, and the other way round (`/tmp` and `/private/tmp`).
for (listed, path) in [("link/app", "code/app/src"), ("code/app", "link/app/src"), ("link/app", "link/app")] {
let found = resolve(Listed, &[base.join(listed)], &none, &[], None, &base.join(path));
assert_eq!(found, Some(base.join("code/app")), "{listed} for {path}");
}
let trusted = TrustDecisions { locations: vec![base.join("code")], ..Default::default() };
let recent = [base.join("link/plain")];
assert_eq!(
resolve(Trusted, &[], &trusted, &recent, None, &base.join("link/plain/src")),
Some(base.join("code/plain"))
);
}
#[cfg(unix)]
#[test]
fn a_remote_recent_project_is_skipped_even_when_its_text_names_a_local_folder() {
let (_tmp, base) = tree();
// `<base>/ssh://box/app` reads as the local folder `<base>/ssh:/box/app`.
std::fs::create_dir_all(base.join("ssh:/box/app/src")).unwrap();
let recent = [PathBuf::from(format!("{}/ssh://box/app", base.display()))];
let trusted = TrustDecisions { locations: vec![base.clone()], ..Default::default() };
assert_eq!(resolve(Trusted, &[], &trusted, &recent, None, &base.join("ssh:/box/app/src")), None);
let local = [base.join("ssh:/box/app")];
assert_eq!(
resolve(Trusted, &[], &trusted, &local, None, &base.join("ssh:/box/app/src")),
Some(base.join("ssh:/box/app"))
);
}
}
+792
Переглянути файл
@@ -0,0 +1,792 @@
use super::*;
use crate::HostConfig;
use ide_workspace::SettingsScope;
use serde_json::json;
const MINUTE: Duration = Duration::from_secs(60);
const SECOND: Duration = Duration::from_secs(1);
/// A host with the MCP server on that serves the folders `inventory`, `billing` and
/// `orders` as listed background projects; no window is open.
struct Fixture {
host: Arc<Host>,
base: PathBuf,
syntax: Arc<std::sync::OnceLock<Arc<ide_language::Syntax>>>,
_tmp: tempfile::TempDir,
}
/// The grammars' warm-up, held unfinished as at start-up until this is dropped. Every open
/// waits for it after it has read the settings and the trust decision, before it registers
/// its project.
struct WarmUp(#[expect(dead_code, reason = "dropping it ends the warm-up")] std::sync::mpsc::Sender<()>);
/// Returns once `done` holds; no later than half a minute from now.
fn wait_until(what: &str, done: impl Fn() -> bool) {
let deadline = Instant::now() + 30 * SECOND;
while !done() {
assert!(Instant::now() < deadline, "{what}");
std::thread::yield_now();
}
}
/// Long enough to tell work that waits from work that has finished.
const A_MOMENT: Duration = Duration::from_millis(300);
impl Fixture {
fn new() -> Self {
let tmp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(tmp.path()).unwrap();
for name in ["inventory", "billing", "orders"] {
std::fs::create_dir_all(base.join(name).join("parts")).unwrap();
std::fs::write(base.join(name).join("notes.txt"), "stock\n").unwrap();
}
let syntax: Arc<std::sync::OnceLock<Arc<ide_language::Syntax>>> = Arc::default();
let host = Arc::new(Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: syntax.clone(),
sink_for: Box::new(|_| Arc::new(|_| {})),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
}));
let fixture = Self { host, base, syntax, _tmp: tmp };
fixture.set("enabled", json!(true));
fixture.set("backgroundProjects", json!("listed"));
fixture.list(&["inventory", "billing", "orders"]);
fixture
}
fn set(&self, key: &str, value: serde_json::Value) {
self.host.global_settings.set(SettingsScope::Global, &format!("mcpServer.{key}"), value).unwrap();
}
fn list(&self, names: &[&str]) {
self.set("backgroundProjectPaths", json!(names.iter().map(|name| self.root(name)).collect::<Vec<_>>()));
}
fn root(&self, name: &str) -> PathBuf {
self.base.join(name)
}
fn background(&self) -> &BackgroundProjects {
&self.host.mcp_background
}
fn open(&self, name: &str) -> Arc<Project> {
self.background().open(&self.host, &self.root(name)).expect("the project is served").1
}
/// A tool call that reached the project `name` and has not ended yet.
fn call(&self, name: &str) -> ActivityGuard {
let (_, _, call) = self.background().open(&self.host, &self.root(name)).expect("the project is served");
call.expect("in the background")
}
fn hold_warm_up(&self) -> WarmUp {
let (started, holding) = std::sync::mpsc::channel();
let (finish, finished) = std::sync::mpsc::channel::<()>();
let syntax = self.syntax.clone();
std::thread::spawn(move || {
syntax.get_or_init(|| {
// Both ends hang up when the test is over.
let _ = started.send(());
let _ = finished.recv();
Arc::new(ide_language::Syntax::new())
});
});
holding.recv_timeout(30 * SECOND).expect("the warm-up starts");
WarmUp(finish)
}
/// A client's first call for `name` on another thread, once its open is under way.
fn open_in_flight(&self, name: &str) -> tokio::task::JoinHandle<Arc<Project>> {
let (host, root) = (self.host.clone(), self.root(name));
let open = tokio::task::spawn_blocking(move || host.mcp_background.open(&host, &root).expect("served").1);
wait_until("the open is under way", || self.background().gate.is_locked());
open
}
/// Whether an open has read its settings and trust decision: Local History, which it
/// creates next, is there.
fn an_open_has_read_its_decisions(&self) -> bool {
std::fs::read_dir(self.base.join("data/history")).is_ok_and(|mut entries| entries.next().is_some())
}
fn refused(&self, name: &str) -> String {
self.background().open(&self.host, &self.root(name)).err().expect("the open is refused").message
}
fn snapshot(&self) -> Vec<McpBackgroundProject> {
self.background().snapshot(&self.host, Instant::now())
}
/// The folder names of the loaded projects, sorted.
fn loaded(&self) -> Vec<String> {
let name = |project: McpBackgroundProject| project.root.0.file_name().unwrap().to_string_lossy().into_owned();
self.snapshot().into_iter().map(name).collect()
}
fn held_by(&self, name: &str) -> Option<McpBackgroundHold> {
let root = self.root(name);
self.snapshot().into_iter().find(|project| project.root.0 == root).unwrap().kept_open_by
}
fn used(&self, name: &str) -> Instant {
*self.background().state.lock().entries[&self.root(name)].last_used.lock()
}
fn claims(&self, name: &str) -> usize {
self.background().state.lock().claims.get(&self.root(name)).copied().unwrap_or(0)
}
}
impl Drop for Fixture {
fn drop(&mut self) {
// Waits for each shutdown, so nothing still works in the folder when it is deleted.
for (root, _) in self.background().entries() {
self.host.close_project(&BackgroundProjects::key(&root));
}
self.host.close_project("main");
}
}
/// Returns once the clock reads later than `time`, so the next reading is strictly after it.
fn tick_past(time: Instant) {
while Instant::now() <= time {
std::hint::spin_loop();
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn the_first_call_opens_a_project_under_its_key_and_the_next_one_reuses_it() {
let f = Fixture::new();
let root = f.root("inventory");
let (key, project, _) = f.background().open(&f.host, &root).unwrap();
assert_eq!(key, format!("mcp:{}", root.display()));
assert!(BackgroundProjects::is_key(&key));
assert!(!BackgroundProjects::is_key("main") && !BackgroundProjects::is_key("settings-main"));
assert_eq!(project.root, root);
assert!(Arc::ptr_eq(&f.host.project(&key).unwrap(), &project));
assert!(!project.is_trusted(), "a listed folder nobody trusted opens in Restricted Mode");
let (_, again, _) = f.background().open(&f.host, &root).unwrap();
assert!(Arc::ptr_eq(&again, &project));
assert_eq!(f.loaded(), ["inventory"]);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_root_the_settings_do_not_serve_is_refused_and_nothing_opens() {
let f = Fixture::new();
f.list(&["billing"]);
let root = f.root("inventory");
assert_eq!(f.refused("inventory"), format!("{} is not served in the background", root.display()));
// A folder inside a served root is not a root itself.
assert!(f.refused("billing/parts").contains("is not served in the background"));
f.set("backgroundProjects", json!("off"));
assert!(f.refused("billing").contains("is not served in the background"));
assert!(f.loaded().is_empty());
assert!(f.host.projects().is_empty());
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_call_in_flight_holds_the_project_and_its_end_restarts_the_idle_time() {
let f = Fixture::new();
f.open("inventory");
let root = f.root("inventory");
let opened = f.used("inventory");
tick_past(opened);
let call = f.call("inventory");
let entered = f.used("inventory");
assert!(entered > opened, "entering counts as use");
assert_eq!(f.held_by("inventory"), Some(McpBackgroundHold::Request));
// Held: no idle time unloads it.
let days_later = entered + 2 * 24 * 60 * MINUTE;
assert!(f.background().sweep_candidates(&f.host, days_later).is_empty());
assert!(!f.background().detach(&f.host, &root, Some(days_later)));
tick_past(entered);
drop(call);
let left = f.used("inventory");
assert!(left > entered, "the end of the call restarts the idle time");
assert_eq!(f.held_by("inventory"), None);
assert!(f.background().sweep_candidates(&f.host, left + 30 * MINUTE - SECOND).is_empty());
assert_eq!(f.background().sweep_candidates(&f.host, left + 30 * MINUTE), [root]);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_call_that_outlives_its_project_leaves_the_reopened_project_alone() {
let f = Fixture::new();
f.open("inventory");
let root = f.root("inventory");
let outlived = f.call("inventory");
assert!(f.background().detach(&f.host, &root, None), "an unload by hand does not wait for the call");
f.open("inventory");
let current = f.call("inventory");
drop(outlived);
assert_eq!(
f.held_by("inventory"),
Some(McpBackgroundHold::Request),
"the call in the reopened project still counts"
);
drop(current);
assert_eq!(f.held_by("inventory"), None);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn an_idle_project_is_unloaded_exactly_when_its_idle_time_is_up() {
let f = Fixture::new();
f.open("inventory");
let used = f.used("inventory");
f.background().sweep(&f.host, used + 30 * MINUTE - SECOND);
assert_eq!(f.loaded(), ["inventory"], "one second short");
f.set("backgroundIdleMinutes", json!(0));
f.background().sweep(&f.host, used + 365 * 24 * 60 * MINUTE);
assert_eq!(f.loaded(), ["inventory"], "0 never unloads");
// More than a day counts as a day.
f.set("backgroundIdleMinutes", json!(5000));
f.background().sweep(&f.host, used + 1440 * MINUTE - SECOND);
assert_eq!(f.loaded(), ["inventory"]);
f.background().sweep(&f.host, used + 1440 * MINUTE);
assert!(f.loaded().is_empty());
assert!(f.host.project(&BackgroundProjects::key(&f.root("inventory"))).is_err());
f.set("backgroundIdleMinutes", json!(30));
f.open("inventory");
f.background().sweep(&f.host, f.used("inventory") + 30 * MINUTE);
assert!(f.loaded().is_empty(), "exactly at the limit");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_call_that_arrives_between_the_sweep_and_the_unload_keeps_the_project() {
let f = Fixture::new();
f.open("inventory");
let root = f.root("inventory");
let now = f.used("inventory") + 30 * MINUTE;
assert_eq!(f.background().sweep_candidates(&f.host, now), std::slice::from_ref(&root));
let call = f.call("inventory");
assert!(!f.background().detach(&f.host, &root, Some(now)), "held by the call");
drop(call);
assert!(!f.background().detach(&f.host, &root, Some(now)), "used since the sweep looked");
assert_eq!(f.loaded(), ["inventory"]);
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_live_run_holds_the_project_and_an_unload_by_hand_stops_it() {
let f = Fixture::new();
f.open("inventory");
let root = f.root("inventory");
let (exits, exited) = std::sync::mpsc::channel();
let exits = Mutex::new(exits);
let sink: ide_core::SharedSink = Arc::new(move |event: ide_core::IdeEvent| {
if let ide_core::IdeEvent::RunExited { run, .. } = event {
// The receiver is gone once the test has seen the exit.
let _ = exits.lock().send(run);
}
});
let config = ide_run::RunConfig {
id: "serve".into(),
name: "serve stock".into(),
kind: "shell".into(),
command: "sleep 30".into(),
args: Vec::new(),
cwd: None,
env: Default::default(),
detected: false,
is_test: false,
debug_adapter: None,
allow_parallel: false,
extras: Default::default(),
};
let run = f.host.processes.start(&root, &config, &Default::default(), sink, Box::new(|_| {})).unwrap();
assert_eq!(f.held_by("inventory"), Some(McpBackgroundHold::Run { name: "serve stock".into() }));
assert_eq!(f.snapshot()[0].unloads_in_seconds, None);
let days_later = f.used("inventory") + 2 * 24 * 60 * MINUTE;
assert!(f.background().sweep_candidates(&f.host, days_later).is_empty());
assert!(!f.background().detach(&f.host, &root, Some(days_later)));
// The limit does not unload it either.
f.set("backgroundProjectLimit", json!(1));
assert_eq!(f.refused("billing"), "the limit of 1 background projects is reached and all are busy");
assert!(f.background().detach(&f.host, &root, None));
assert_eq!(exited.recv_timeout(Duration::from_secs(30)).unwrap(), run.id);
assert!(f.host.processes.running_in(&root).is_empty());
assert!(!f.background().detach(&f.host, &root, None), "already unloaded");
assert!(!f.background().detach(&f.host, &f.root("billing"), None), "never loaded");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn the_limit_unloads_the_project_used_longest_ago_and_refuses_when_all_are_held() {
let f = Fixture::new();
f.set("backgroundProjectLimit", json!(2));
f.open("inventory");
tick_past(f.used("inventory"));
f.open("billing");
// A call in `inventory` makes `billing` the one used longest ago.
tick_past(f.used("billing"));
drop(f.call("inventory"));
f.open("orders");
assert_eq!(f.loaded(), ["inventory", "orders"]);
assert!(f.host.project(&BackgroundProjects::key(&f.root("billing"))).is_err());
let in_inventory = f.call("inventory");
let in_orders = f.call("orders");
assert_eq!(f.refused("billing"), "the limit of 2 background projects is reached and all are busy");
assert_eq!(f.loaded(), ["inventory", "orders"]);
// A loaded project answers at the limit.
f.open("inventory");
drop(in_orders);
f.open("billing");
assert_eq!(f.loaded(), ["billing", "inventory"]);
// A lowered limit is reached by the next open.
drop(in_inventory);
f.set("backgroundProjectLimit", json!(0));
f.open("orders");
assert_eq!(f.loaded(), ["orders"], "0 serves one project");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_project_whose_call_has_not_started_running_is_not_evicted_for_another_client() {
let f = Fixture::new();
f.set("backgroundProjectLimit", json!(1));
// The open hands the call over already counted: nothing unloads the project before it runs.
let call = f.call("inventory");
assert_eq!(f.refused("billing"), "the limit of 1 background projects is reached and all are busy");
assert_eq!(f.loaded(), ["inventory"]);
assert_eq!(f.held_by("inventory"), Some(McpBackgroundHold::Request));
drop(call);
f.open("billing");
assert_eq!(f.loaded(), ["billing"], "with the call over, the other client's project takes the place");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn a_trust_refresh_leaves_its_runtime_worker_to_other_tasks_while_it_unloads_projects() {
let f = Fixture::new();
f.open("inventory");
f.set("backgroundProjects", json!("off"));
// The observer runs inside the policy step: holding it there holds the step.
let (inside, entered) = std::sync::mpsc::channel();
let (release, released) = std::sync::mpsc::channel::<()>();
let released = Mutex::new(Some(released));
f.host.set_background_projects_observer(Arc::new(move || {
if let Some(released) = released.lock().take() {
// Both ends hang up when the test is over.
let _ = inside.send(());
let _ = released.recv();
}
}));
let host = f.host.clone();
let refresh = tokio::spawn(async move { host.refresh_project_trust().await });
// Waits on this thread, which is none of the runtime's: its timers stand while the worker is held.
entered.recv_timeout(30 * SECOND).expect("the policy step unloads the project");
// The runtime's only worker is inside the step; a task spawned now still runs.
let (ran, other) = std::sync::mpsc::channel();
tokio::spawn(async move {
// The test may have given up waiting.
let _ = ran.send(());
});
other.recv_timeout(10 * SECOND).expect("another task runs meanwhile");
drop(release);
refresh.await.unwrap().unwrap();
assert!(f.loaded().is_empty());
}
#[test]
fn the_limit_and_the_idle_time_stay_within_their_bounds() {
for (setting, limit) in [(0, 1), (1, 1), (8, 8), (32, 32), (99, 32), (u32::MAX, 32)] {
assert_eq!(project_limit(setting), limit, "{setting}");
}
let day = 24 * 60 * MINUTE;
for (minutes, limit) in [
(0, None),
(1, Some(MINUTE)),
(30, Some(30 * MINUTE)),
(1440, Some(day)),
(5000, Some(day)),
(u32::MAX, Some(day)),
] {
assert_eq!(idle_limit(minutes), limit, "{minutes}");
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_window_that_opens_the_root_takes_it_over_and_gives_it_back_when_it_closes() {
let f = Fixture::new();
let background = f.open("inventory");
f.open("billing");
let root = f.root("inventory");
let key = BackgroundProjects::key(&root);
let window = f.host.open_project("main", &root).unwrap();
assert!(!Arc::ptr_eq(&window, &background));
assert!(f.host.project(&key).is_err());
assert_eq!(f.loaded(), ["billing"], "the other project is left alone");
assert_eq!(f.claims("inventory"), 0);
// A call for the root reaches the window now.
let (label, project, call) = f.background().open(&f.host, &root).unwrap();
assert_eq!(label, "main");
assert!(call.is_none(), "a window is not held by calls");
assert!(Arc::ptr_eq(&project, &window));
assert_eq!(f.loaded(), ["billing"]);
f.host.close_project("main");
assert_eq!(f.background().open(&f.host, &root).unwrap().0, key);
assert_eq!(f.loaded(), ["billing", "inventory"]);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_background_open_is_refused_until_every_window_opening_the_root_is_done() {
let f = Fixture::new();
let root = f.root("inventory");
let first = f.background().claim(&f.host, &root);
let second = f.background().claim(&f.host, &root);
let refusal = format!("{} is opening in a window; retry", root.display());
assert_eq!(f.refused("inventory"), refusal);
drop(first);
assert_eq!(f.refused("inventory"), refusal, "the second window is still opening it");
f.open("billing");
drop(second);
assert_eq!(f.claims("inventory"), 0);
f.open("inventory");
assert_eq!(f.loaded(), ["billing", "inventory"]);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_window_open_that_fails_releases_the_root() {
let f = Fixture::new();
// Local History cannot be created, which fails the open after the window claimed the root.
let history = f.base.join("data/history");
std::fs::create_dir_all(history.parent().unwrap()).unwrap();
std::fs::write(&history, "").unwrap();
assert!(f.host.open_project("main", &f.root("inventory")).is_err());
assert_eq!(f.claims("inventory"), 0);
std::fs::remove_file(&history).unwrap();
f.open("inventory");
assert_eq!(f.loaded(), ["inventory"]);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn revoked_trust_unloads_a_project_served_for_its_trust_and_restricts_a_listed_one() {
let f = Fixture::new();
f.set("backgroundProjects", json!("trusted"));
f.list(&["billing"]);
for name in ["inventory", "billing"] {
f.host.trust.decide(&f.root(name), true, false).unwrap();
}
let inventory = f.open("inventory");
let billing = f.open("billing");
assert!(inventory.is_trusted() && billing.is_trusted());
for name in ["inventory", "billing"] {
f.host.set_project_trust(&f.root(name), false, false).await.unwrap();
}
assert_eq!(f.loaded(), ["billing"]);
assert!(!billing.is_trusted(), "the listed project stays, in Restricted Mode");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_folder_taken_off_the_list_is_unloaded_and_the_others_stay() {
let f = Fixture::new();
f.open("inventory");
f.open("billing");
f.list(&["billing", "orders"]);
f.host.apply_background_policy();
assert_eq!(f.loaded(), ["billing"]);
f.host.apply_background_policy();
assert_eq!(f.loaded(), ["billing"], "nothing more to unload");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn turning_background_projects_or_the_server_off_unloads_every_project() {
for (key, value) in [("backgroundProjects", json!("off")), ("enabled", json!(false))] {
let f = Fixture::new();
f.open("inventory");
f.open("billing");
f.set(key, value);
f.host.apply_background_policy();
assert!(f.loaded().is_empty(), "{key}");
assert!(f.host.projects().is_empty(), "{key}");
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn the_observer_hears_of_every_open_unload_and_eviction_outside_the_locks() {
let f = Fixture::new();
let heard = Arc::new(AtomicUsize::new(0));
let locked = Arc::new(AtomicUsize::new(0));
let (count, under_lock, host) = (heard.clone(), locked.clone(), Arc::downgrade(&f.host));
f.host.set_background_projects_observer(Arc::new(move || {
count.fetch_add(1, Ordering::AcqRel);
let host = host.upgrade().unwrap();
let background = &host.mcp_background;
if background.gate.try_lock().is_none() || background.state.try_lock().is_none() {
under_lock.fetch_add(1, Ordering::AcqRel);
}
}));
let heard = || heard.load(Ordering::Acquire);
let root = f.root("inventory");
f.open("inventory");
assert_eq!(heard(), 1, "an open");
f.open("inventory");
assert_eq!(heard(), 1, "a loaded project is reused silently");
assert!(f.background().detach(&f.host, &root, None));
assert_eq!(heard(), 2, "an unload");
assert!(!f.background().detach(&f.host, &root, None));
f.list(&["inventory", "billing"]);
assert!(f.refused("orders").contains("not served"));
assert_eq!(heard(), 2, "nothing changed");
f.set("backgroundProjectLimit", json!(1));
f.open("inventory");
f.open("billing");
assert_eq!(heard(), 4, "an open, then an eviction with its open");
f.background().sweep(&f.host, f.used("billing") + 30 * MINUTE);
assert_eq!(heard(), 5, "an idle unload");
f.open("billing");
f.host.open_project("main", &f.root("billing")).unwrap();
assert_eq!(heard(), 7, "an open, then a window taking the root over");
assert_eq!(locked.load(Ordering::Acquire), 0);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_background_project_is_not_a_window_of_its_root() {
use crate::plugins::{HostWorkspace, PluginWorkspace};
let f = Fixture::new();
f.open("inventory");
f.host.open_project("main", &f.root("billing")).unwrap();
let workspace = HostWorkspace(Arc::downgrade(&f.host));
assert!(f.host.windows_for_root(&f.root("inventory")).is_empty());
assert!(workspace.project_windows(&f.root("inventory")).is_empty(), "a plugin's notification finds no window");
assert_eq!(f.host.windows_for_root(&f.root("billing")), ["main"]);
assert_eq!(workspace.project_windows(&f.root("billing")), ["main"]);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn unloading_a_project_keeps_the_diagnostics_of_a_window_around_it() {
let f = Fixture::new();
f.list(&["inventory/parts", "billing"]);
f.host.open_project("main", &f.root("inventory")).unwrap();
f.open("inventory/parts");
f.open("billing");
let problem = ide_core::Diagnostic {
range: ide_core::Range::point(ide_core::Pos::new(0, 0)),
severity: ide_core::Severity::Warning,
message: "low stock".into(),
source: Some("lint".into()),
code: None,
unnecessary: false,
deprecated: false,
server: None,
};
let (nested, apart) = (f.root("inventory/parts/list.txt"), f.root("billing/notes.txt"));
for file in [&nested, &apart] {
f.host.diagnostics.replace(file, "lint", vec![problem.clone()]);
}
assert!(f.background().detach(&f.host, &f.root("inventory/parts"), None));
assert!(f.background().detach(&f.host, &f.root("billing"), None));
assert!(!f.host.diagnostics.file(&nested).is_empty(), "the window on `inventory` still shows them");
assert!(f.host.diagnostics.file(&apart).is_empty(), "no project is left for these");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn the_snapshot_lists_projects_by_root_with_their_idle_time_and_what_holds_them() {
let f = Fixture::new();
f.open("orders");
f.open("billing");
let now = f.used("billing") + 10 * MINUTE;
let snapshot = f.background().snapshot(&f.host, now);
let roots: Vec<_> = snapshot.iter().map(|project| project.root.0.clone()).collect();
assert_eq!(roots, [f.root("billing"), f.root("orders")]);
let expected = McpBackgroundProject {
root: f.root("billing").into(),
idle_seconds: 600,
unloads_in_seconds: Some(1200),
kept_open_by: None,
};
assert_eq!(snapshot[0], expected);
assert_eq!(
serde_json::to_value(&snapshot[0]).unwrap(),
json!({ "root": IpcPath::from(f.root("billing")), "idleSeconds": 600, "unloadsInSeconds": 1200 })
);
// Past its time and not swept yet: due now.
assert_eq!(f.background().snapshot(&f.host, now + 60 * MINUTE)[0].unloads_in_seconds, Some(0));
let call = f.call("billing");
let held = f.background().snapshot(&f.host, f.used("billing") + MINUTE).remove(0);
assert_eq!((held.idle_seconds, held.unloads_in_seconds), (60, None));
assert_eq!(serde_json::to_value(&held).unwrap()["keptOpenBy"], json!({ "kind": "request" }));
drop(call);
let run = McpBackgroundHold::Run { name: "serve stock".into() };
assert_eq!(serde_json::to_value(run).unwrap(), json!({ "kind": "run", "name": "serve stock" }));
f.set("backgroundIdleMinutes", json!(0));
assert!(f.snapshot().iter().all(|project| project.unloads_in_seconds.is_none()), "never unloaded");
}
#[tokio::test(start_paused = true)]
async fn the_timer_unloads_a_project_once_it_has_been_idle_for_the_configured_time() {
let f = Fixture::new();
f.set("backgroundIdleMinutes", json!(1));
f.open("inventory");
f.host.start_background_sweeper();
// The clock is the runtime's and stands still unless the test moves it.
tokio::time::sleep(45 * SECOND).await;
assert_eq!(f.loaded(), ["inventory"], "swept once, half a minute idle");
tokio::time::sleep(60 * SECOND).await;
assert!(f.loaded().is_empty(), "swept again at a minute and a half");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn trust_revoked_while_a_project_opens_restricts_or_unloads_it_once_it_is_open() {
use ide_mcp::ToolRegistry;
for (mode, stays) in [("listed", true), ("trusted", false)] {
let f = Fixture::new();
let root = f.root("inventory");
f.set("backgroundProjects", json!(mode));
f.list(if stays { &["inventory"] } else { &[] });
f.host.trust.decide(&root, true, false).unwrap();
let warm_up = f.hold_warm_up();
let open = f.open_in_flight("inventory");
wait_until("the open reads the trust decision", || f.an_open_has_read_its_decisions());
let (host, folder) = (f.host.clone(), root.clone());
let (done, refreshed) = std::sync::mpsc::channel();
tokio::spawn(async move {
// The test may have given up waiting.
let _ = done.send(host.set_project_trust(&folder, false, false).await.is_ok());
});
let waited = refreshed.recv_timeout(A_MOMENT).is_err();
drop(warm_up);
let project = open.await.unwrap();
if waited {
assert!(refreshed.recv_timeout(30 * SECOND).unwrap(), "{mode}");
}
assert!(!project.is_trusted(), "{mode}: opened with the trust it read, the project is restricted afterwards");
if stays {
assert_eq!(f.loaded(), ["inventory"]);
let tools = crate::mcp::Registry::new(f.host.clone()).tools(&root).unwrap();
assert!(tools.iter().all(|tool| tool.read_only), "only the tools that read stay on offer");
} else {
assert!(f.loaded().is_empty(), "served for its trust, it is unloaded");
assert!(f.host.project(&BackgroundProjects::key(&root)).is_err());
}
assert!(waited, "{mode}: the refresh waits for the open under way");
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_policy_change_while_a_project_opens_unloads_it_once_it_is_open() {
for change in ["the mode turned off", "the folder taken off the list", "the server turned off"] {
let f = Fixture::new();
let root = f.root("inventory");
let warm_up = f.hold_warm_up();
let open = f.open_in_flight("inventory");
wait_until("the open reads the settings", || f.an_open_has_read_its_decisions());
match change {
"the mode turned off" => f.set("backgroundProjects", json!("off")),
"the folder taken off the list" => f.list(&["billing"]),
_ => f.set("enabled", json!(false)),
}
let host = f.host.clone();
let (done, applied) = std::sync::mpsc::channel();
tokio::task::spawn_blocking(move || {
host.apply_background_policy();
// The test may have given up waiting.
let _ = done.send(());
});
let waited = applied.recv_timeout(A_MOMENT).is_err();
drop(warm_up);
open.await.unwrap();
if waited {
applied.recv_timeout(30 * SECOND).expect(change);
}
assert!(f.loaded().is_empty(), "{change}: the project that was opening is unloaded");
assert!(f.host.project(&BackgroundProjects::key(&root)).is_err(), "{change}");
assert!(waited, "{change}: the policy waits for the open under way");
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_host_that_serves_none_refuses_every_folder_whatever_the_settings_say() {
use ide_mcp::ToolRegistry;
let f = Fixture::new();
let root = f.root("inventory");
f.host.mcp_background.serve_none();
let registry = crate::mcp::Registry::new(f.host.clone());
assert_eq!(registry.resolve(&root.join("parts")), None);
assert_eq!(f.refused("inventory"), format!("{} is not served in the background", root.display()));
assert!(f.loaded().is_empty());
assert!(f.host.projects().is_empty());
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_call_that_arrives_after_the_server_was_turned_off_opens_nothing() {
use ide_mcp::ToolRegistry;
let f = Fixture::new();
let root = f.root("inventory");
// A request the server had accepted before it stopped still reaches the open.
f.set("enabled", json!(false));
f.host.apply_background_policy();
assert_eq!(f.refused("inventory"), format!("{} is not served in the background", root.display()));
assert!(f.loaded().is_empty());
assert!(f.host.projects().is_empty());
let registry = crate::mcp::Registry::new(f.host.clone());
assert_eq!(registry.resolve(&root.join("parts")), None, "no folder is served with the server off");
assert!(registry.tools(&root).is_err());
f.set("enabled", json!(true));
assert_eq!(registry.resolve(&root.join("parts")), Some(root));
f.open("inventory");
assert_eq!(f.loaded(), ["inventory"]);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_window_opening_another_folder_does_not_wait_for_a_background_open() {
let f = Fixture::new();
let key = BackgroundProjects::key(&f.root("inventory"));
// The background open stops at its own open lock, which it takes with the gate held.
let lock = f.host.opening(&key);
let held = lock.lock();
let open = f.open_in_flight("inventory");
let (host, billing) = (f.host.clone(), f.root("billing"));
let (done, opened) = std::sync::mpsc::channel();
tokio::task::spawn_blocking(move || {
// The test may have given up waiting.
let _ = done.send(host.open_project("main", &billing).map(|project| project.root.clone()));
});
let window = opened.recv_timeout(10 * SECOND).expect("the window opens while the background open is held");
assert_eq!(window.unwrap(), f.root("billing"));
assert!(f.loaded().is_empty(), "the background open is still under way");
drop(held);
open.await.unwrap();
assert_eq!(f.loaded(), ["inventory"]);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_window_opening_the_folder_that_is_being_opened_waits_for_it_and_takes_it_over() {
let f = Fixture::new();
let root = f.root("inventory");
let key = BackgroundProjects::key(&root);
let lock = f.host.opening(&key);
let held = lock.lock();
let open = f.open_in_flight("inventory");
wait_until("the open marks its root", || f.background().state.lock().opening.as_deref() == Some(root.as_path()));
let (host, folder) = (f.host.clone(), root.clone());
let (done, opened) = std::sync::mpsc::channel();
tokio::task::spawn_blocking(move || {
// The test may have given up waiting.
let _ = done.send(host.open_project("main", &folder).map(|project| project.root.clone()));
});
let early = opened.recv_timeout(A_MOMENT).ok();
assert!(early.is_none(), "the window waits for the background open of its own folder");
drop(held);
open.await.unwrap();
assert_eq!(opened.recv_timeout(30 * SECOND).unwrap().unwrap(), root);
assert!(f.host.project(&key).is_err(), "the window took the folder over");
assert!(f.loaded().is_empty());
assert_eq!(f.claims("inventory"), 0);
}
+25 -1
Переглянути файл
@@ -1,7 +1,7 @@
use super::page::{OFFSET, Page};
use super::search::{PathScope, paths_param};
use super::tool::{Call, Output, Param, ParamType, Tool};
use ide_core::{Diagnostic, IdeResult, Severity};
use ide_core::{Diagnostic, IdeError, IdeResult, Severity};
use serde_json::{Map, Value, json};
/// Problems `get_project_problems` lists by default.
@@ -51,7 +51,28 @@ Lines and UTF-16 columns are 1-based.",
]
}
/// Editors and the Problems view are reported by a window: a project served in the
/// background has none, and says so instead of answering as if nothing were open.
fn reported_by_a_window(call: &Call) -> IdeResult<()> {
if !super::BackgroundProjects::is_key(call.window()) {
return Ok(());
}
let (tool, root) = (&call.tool, call.root().display());
Err(IdeError::unavailable(format!(
"{tool} needs the project open in a window: {root} is served in the background."
)))
}
/// [`reported_by_a_window`] for the Problems view, which `check_files` stands in for.
fn problems_reported_by_a_window(call: &Call) -> IdeResult<()> {
reported_by_a_window(call).map_err(|mut error| {
error.message.push_str(" Use check_files for diagnostics.");
error
})
}
async fn open_editors(call: Call) -> IdeResult<Output> {
reported_by_a_window(&call)?;
let paths = PathScope::of(&call)?;
let windows = call.host.mcp_windows(call.root());
let open = call.host.mcp_reports.editors(&windows);
@@ -63,6 +84,7 @@ async fn open_editors(call: Call) -> IdeResult<Output> {
}
async fn current_file(call: Call) -> IdeResult<Output> {
reported_by_a_window(&call)?;
let editor = call.host.mcp_reports.focused(call.window());
Output::json(match editor {
None => json!({}),
@@ -85,6 +107,7 @@ pub(super) fn problem(d: Diagnostic, text: &str) -> Value {
}
async fn file_problems(call: Call) -> IdeResult<Output> {
problems_reported_by_a_window(&call)?;
let path = call.resolve_readable(&call.str("filePath")?).await?;
let errors_only = call.flag("errorsOnly", true)?;
let files = call.host.mcp_reports.problems(&call.host.mcp_windows(call.root()));
@@ -101,6 +124,7 @@ async fn file_problems(call: Call) -> IdeResult<Output> {
}
async fn project_problems(call: Call) -> IdeResult<Output> {
problems_reported_by_a_window(&call)?;
let page = Page::of(&call, PROBLEMS_LIMIT)?;
let errors_only = call.flag("errorsOnly", true)?;
let paths = PathScope::of(&call)?;
+46 -7
Переглянути файл
@@ -1,10 +1,12 @@
//! Built-in IDE tools. Transport and discovery live in `ide-mcp`.
mod background;
mod check;
mod edit;
mod editors;
mod requests;
pub(crate) mod run;
mod vcs;
pub use background::{BackgroundProjects, McpBackgroundHold, McpBackgroundProject};
pub use requests::Requests;
mod files;
mod http;
@@ -55,12 +57,13 @@ fn allowed(tool: &ide_mcp::Tool, trusted: bool) -> bool {
}
impl Registry {
fn target(&self, root: &Path) -> Result<(String, Arc<crate::Project>), String> {
/// The window that answers for `root`: one with the root open, or one it is attached in.
fn window(&self, root: &Path) -> Result<Option<(String, Arc<crate::Project>)>, String> {
if self.0.mcp_reports.remote_roots().iter().any(|p| p == root) {
return Err("project is on a remote host; connect to the MCP server on that host".into());
}
let projects = self.0.projects.read();
let open = || projects.iter().filter(|(_, p)| !p.light);
let open = || projects.iter().filter(|(w, p)| !p.light && !BackgroundProjects::is_key(w));
let mut windows: Vec<_> = open().filter(|(_, p)| p.root == root).map(|(w, p)| (w.clone(), p.clone())).collect();
if windows.is_empty() {
// A project attached to an open one: the window it is attached in.
@@ -74,23 +77,57 @@ impl Registry {
windows.sort_by(|a, b| {
(Some(&b.0) == focused.as_ref()).cmp(&(Some(&a.0) == focused.as_ref())).then(a.0.cmp(&b.0))
});
windows.into_iter().next().ok_or_else(|| "project is no longer open".into())
Ok(windows.into_iter().next())
}
/// The window and project a tool call for `root` runs in. Without a window the project
/// is served in the background, under its key, and opened now if need be; the guard
/// then keeps it loaded for as long as the caller holds it.
fn target(&self, root: &Path) -> Result<background::Served, String> {
match self.window(root)? {
Some((window, project)) => Ok((window, project, None)),
None => self.0.mcp_background.open(&self.0, root).map_err(|e| e.message),
}
}
/// Whether the tools listed for `root` include those that write and run. Opens nothing:
/// a background project that is not loaded is judged as its open will judge it.
fn lists_as_trusted(&self, root: &Path) -> Result<bool, String> {
if let Some((_, project)) = self.window(root)? {
return Ok(project.is_trusted());
}
if let Some(project) = self.0.mcp_background.project(&self.0, root) {
return Ok(project.is_trusted());
}
if background::serving_root(&self.0, root).as_deref() == Some(root) {
return Ok(self.0.trust.window_trusted(root).unwrap_or(false));
}
Err("project is no longer open".into())
}
}
impl ToolRegistry for Registry {
fn projects(&self) -> Vec<PathBuf> {
let open: Vec<_> = self.0.projects().into_iter().filter(|p| !p.light).collect();
// Window projects only: a background project is reached through `resolve`, so a
// request that names no folder still means the only window.
let open: Vec<_> = {
let projects = self.0.projects.read();
let windows = projects.iter().filter(|(w, p)| !p.light && !BackgroundProjects::is_key(w));
windows.map(|(_, p)| p.clone()).collect()
};
// Attached projects are listed too, so a `projectPath` inside one names it.
let attached: Vec<_> = open.iter().flat_map(|p| tool::attached_projects(&p.root)).collect();
open.into_iter().map(|p| p.root.clone()).chain(attached).chain(self.0.mcp_reports.remote_roots()).collect()
}
fn resolve(&self, path: &Path) -> Option<PathBuf> {
background::serving_root(&self.0, path)
}
fn tools(&self, root: &Path) -> Result<Vec<ide_mcp::Tool>, String> {
let (_, project) = self.target(root)?;
let trusted = self.lists_as_trusted(root)?;
let mut all: Vec<_> = tools().into_iter().map(|t| t.metadata).collect();
if let Some(plugins) = self.0.plugin_host() {
all.extend(plugins.mcp_tools(root).into_iter().map(|(_, _, tool)| tool));
}
Ok(all.into_iter().filter(|t| allowed(t, project.is_trusted())).collect())
Ok(all.into_iter().filter(|t| allowed(t, trusted)).collect())
}
fn call(
&self,
@@ -109,7 +146,9 @@ impl ToolRegistry for Registry {
cancel: CancellationToken,
client: &str,
) -> Result<String, ToolCallError> {
let (window, project) = self.target(root).map_err(ToolCallError::Failed)?;
// The guard lives until the call ends, whichever way it leaves: neither the idle
// sweep nor the limit unloads a background project a call runs in.
let (window, project, _activity) = self.target(root).map_err(ToolCallError::Failed)?;
if let Some(plugins) = self.0.plugin_host()
&& let Some((plugin, tool, metadata)) =
plugins.mcp_tools(root).into_iter().find(|(_, _, t)| t.name == name && allowed(t, project.is_trusted()))
+33
Переглянути файл
@@ -1,6 +1,7 @@
//! Agents › IDE MCP Server: runs `ide_mcp::McpServer` over built-in host tools
//! while `mcpServer.enabled` is on, and reports where it listens.
use super::McpBackgroundProject;
use crate::Host;
use ide_command::command;
use ide_core::{IdeResult, IpcPath};
@@ -10,6 +11,7 @@ use specta::Type;
use std::net::IpAddr;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Instant;
/// The server while it runs, or why it doesn't.
#[derive(Default)]
@@ -57,6 +59,17 @@ impl McpService {
/// Starts, stops or restarts the server to match the global `mcpServer` settings:
/// `enabled`, and the address, port and token it listens with.
pub fn apply(&self, host: &Arc<Host>) {
// Callers include the main thread (sync commands, app set-up), which must not wait for
// a background project that is being opened.
let worker = {
let host = host.clone();
host.runtime.clone().spawn_blocking(move || host.apply_background_policy())
};
host.runtime.spawn(async move {
if let Err(error) = worker.await {
tracing::warn!(%error, "applying the background project policy failed");
}
});
let settings = host.global_settings.effective().mcp_server;
let mut server = self.server.lock();
if !settings.enabled {
@@ -247,6 +260,24 @@ pub fn mcp_regenerate_token(host: &Arc<Host>) -> IdeResult<()> {
Ok(())
}
/// Settings › Agents › IDE MCP Server › Background projects: the projects this host's server
/// keeps loaded without a window.
#[command(trust = always)]
pub fn mcp_background_projects(host: &Host) -> IdeResult<Vec<McpBackgroundProject>> {
Ok(host.mcp_background.snapshot(host, Instant::now()))
}
/// Unloads one background project; a root that is not loaded is already unloaded.
#[command(trust = always)]
pub async fn mcp_unload_background_project(host: &Arc<Host>, root: IpcPath) -> IdeResult<()> {
let h = host.clone();
host.blocking(move || {
h.mcp_background.detach(&h, &root, None);
Ok(())
})
.await
}
#[command(trust = trusted)]
pub fn mcp_ui_ready(host: &Host, window: &str, ready: bool) -> IdeResult<()> {
let window = host.owner_window(window);
@@ -289,8 +320,10 @@ mod tests {
ide_command::domain!(
mcp:
mcp_agent_run_closed,
mcp_background_projects,
mcp_regenerate_token,
mcp_respond,
mcp_server_status,
mcp_ui_ready,
mcp_unload_background_project,
);
+7 -3
Переглянути файл
@@ -176,7 +176,9 @@ impl Call {
let r = ide_vfs::split_archive_path(&r).map_or(r.clone(), |(archive, _)| archive);
dunce::canonicalize(r).is_ok_and(|r| real.starts_with(r))
}) {
return Err(IdeError::invalid("path is outside the project's content roots"));
return Err(IdeError::invalid(
"path is outside the project's content roots: ask the user before reading anything else outside the project",
));
}
Ok(entry.map_or_else(|| real.clone(), |entry| PathBuf::from(format!("{}!/{entry}", real.display()))))
})
@@ -236,7 +238,7 @@ impl Tool {
destructive: false,
output_schema: None,
input_schema: json!({ "type": "object", "properties": {
"projectPath": { "type": "string", "description": "Any directory inside an open project. Defaults to the connection's project (`?project=`) or the only open one." }
"projectPath": { "type": "string", "description": "Any directory inside a project that is open in a window or served in the background. Defaults to the connection's project (`?project=`) or the only one open in a window." }
}, "required": [] }),
},
handler: Arc::new(move |call| Box::pin(handler(call))),
@@ -307,7 +309,9 @@ pub fn resolve_inside(root: &Path, raw: &str) -> IdeResult<PathBuf> {
}
let root = dunce::canonicalize(root)?;
if !real.starts_with(&root) {
return Err(IdeError::invalid("path is outside the project"));
return Err(IdeError::invalid(
"path is outside the project: these tools change files inside it only; ask the user before touching anything outside it",
));
}
if real
.strip_prefix(&root)
+12 -1
Переглянути файл
@@ -32,7 +32,12 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
} else {
None
};
let agents = if is_jvm_launch(&config) { ide_run::java_agent::current() } else { Default::default() };
let java_exec = java_exec_path(&config);
let agents = if is_jvm_launch(&config) {
ide_run::java_agent::current_for(java_exec.as_deref())
} else {
Default::default()
};
let config = add_java_agents(config, &agents.options);
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
if config.adapter == "debugpy"
@@ -211,6 +216,12 @@ fn is_jvm_launch(config: &LaunchConfig) -> bool {
&& matches!(config.adapter.as_str(), "java-debug" | ide_dap::kotlin::ADAPTER | ide_dap::adapter::JAVA_ANALYZER)
}
/// `javaExec` from the launch extras, for gating contributed `vmOptions` on JetBrains Runtime.
fn java_exec_path(config: &LaunchConfig) -> Option<std::path::PathBuf> {
let extra: serde_json::Value = serde_json::from_str(config.extra_json.as_deref()?).ok()?;
extra.get("javaExec").and_then(|v| v.as_str()).filter(|s| !s.is_empty()).map(std::path::PathBuf::from)
}
/// Plugins' Java agents ([`ide_run::java_agent`]) after the configuration's VM options:
/// java-debug's and java-analyzer's `vmArgs` (one line, or a list) or the Kotlin debugger's
/// `vmArguments` (a list).
+9 -2
Переглянути файл
@@ -1976,6 +1976,7 @@ pub struct PluginLanguageVisuals {
pub injections: Vec<ide_plugin::language_features::Injection>,
pub colors: Vec<(String, ide_plugin::language_features::ColorInfo)>,
pub gutter_actions: Vec<(String, ide_plugin::language_features::GutterAction)>,
pub hover_actions: Vec<(String, ide_plugin::language_features::HoverAction)>,
}
#[command(trust = trusted)]
pub async fn plugin_language_visuals(host: &Host, window: &str, doc: DocId) -> IdeResult<PluginLanguageVisuals> {
@@ -1989,14 +1990,20 @@ pub async fn plugin_language_visuals(host: &Host, window: &str, doc: DocId) -> I
version: u64::from(snap.version),
text: snap.text,
};
let mut out =
PluginLanguageVisuals { version: d.version, injections: vec![], colors: vec![], gutter_actions: vec![] };
let mut out = PluginLanguageVisuals {
version: d.version,
injections: vec![],
colors: vec![],
gutter_actions: vec![],
hover_actions: vec![],
};
if d.text.len() <= crate::plugins::navigation::MAX_DOCUMENT_BYTES
&& let Some(plugins) = crate::plugins::editor_plugin_host()
{
out.injections = plugins.provide_injections(&d);
out.colors = plugins.language_colors(&d);
out.gutter_actions = plugins.language_gutter_actions(&d);
out.hover_actions = plugins.language_hover_actions(&d);
}
project.lsp.set_injections_at(
doc,
+2 -1
Переглянути файл
@@ -542,7 +542,8 @@ fn add_java_agents(config: &mut RunConfig, on_output: &Emit<OutputChunk>, local:
if !ide_run::java_agent::applies(&config.kind) {
return;
}
let agents = ide_run::java_agent::current();
let java = std::path::Path::new(&config.command);
let agents = ide_run::java_agent::current_for(Some(java));
let say = |text: &str| on_output(OutputChunk::System { text: format!("{text}\n") });
if !local {
if !agents.options.is_empty() {
+79
Переглянути файл
@@ -3,6 +3,7 @@
use ide_core::event::NotifyLevel;
use ide_core::output_encoding::decode_tool_output;
use ide_core::{CancellationToken, Diagnostic, IdeEvent, Pos, Range, Severity, SharedSink};
use ide_text::AppliedChange;
use ide_workspace::SettingsStore;
use ide_workspace::documents::DocumentObserver;
use parking_lot::Mutex;
@@ -51,6 +52,8 @@ pub(crate) struct Phpstan {
changed: Notify,
/// Files with PHPStan diagnostics, the only ones a clean result or a removal clears.
shown: Mutex<HashSet<PathBuf>>,
/// Files edited since their last save: a check of the saved text has no ranges for them.
edited: Mutex<HashSet<PathBuf>>,
}
impl Phpstan {
@@ -71,6 +74,7 @@ impl Phpstan {
queue: Mutex::new(Queue::default()),
changed: Notify::new(),
shown: Mutex::new(HashSet::new()),
edited: Mutex::new(HashSet::new()),
})
}
@@ -96,6 +100,12 @@ impl Phpstan {
if self.lifetime.is_cancelled() || files.peek().is_none() {
return;
}
let files: Vec<PathBuf> = files.collect();
let mut edited = self.edited.lock();
for path in &files {
edited.remove(path);
}
drop(edited);
self.queue.lock().push(files);
self.changed.notify_one();
}
@@ -205,6 +215,10 @@ impl Phpstan {
.await
.unwrap_or_default();
for (path, items) in results {
// Edited while the saved text was checked: its lines moved since.
if self.edited.lock().contains(&path) {
continue;
}
// Severe errors (a syntax error) stop the analysis of the other files.
if report.complete || !items.is_empty() {
self.publish(path, items);
@@ -246,6 +260,23 @@ impl DocumentObserver for Phpstan {
fn saved(&self, _doc: ide_core::DocId, path: &Path, _text: &str) {
self.files_saved([path.to_path_buf()]);
}
/// The shown ranges belong to the saved text PHPStan ran on, so an edit that
/// reaches the buffer before the next save would paint them on other lines
/// (`issue #4482`): drop them until the file is saved again.
fn changed(
&self,
_doc: ide_core::DocId,
path: &Path,
_version: u32,
_changes: &[AppliedChange],
_full_text: &dyn Fn() -> String,
) {
if !path.extension().is_some_and(|e| e == "php") || !self.edited.lock().insert(path.to_path_buf()) {
return;
}
self.publish(path.to_path_buf(), Vec::new());
}
}
async fn debounce(cancel: &CancellationToken, lifetime: &CancellationToken) -> bool {
@@ -847,4 +878,52 @@ mod tests {
assert_eq!(f.diagnostics()[1], (a, vec![]));
f.checker.stop();
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn an_edit_before_the_next_save_drops_the_saved_text_diagnostics() {
let f = Fixture::new();
let a = f.file("A.php");
f.report(&a, &["constant.notFound"]);
f.checker.files_saved([a.clone()]);
f.until("the check", |f| f.diagnostics().len() == 1).await;
let edit = || {
[AppliedChange { range: ide_core::Range::point(ide_core::Pos::new(1, 0)), text: "$aaa = array();".into() }]
};
let full = || String::new();
DocumentObserver::changed(f.checker.as_ref(), ide_core::DocId(0), &a, 1, &edit(), &full);
f.until("the drop", |f| f.diagnostics().len() == 2).await;
assert_eq!(f.diagnostics()[1], (a.clone(), vec![]));
// Further edits of the same dirty buffer change nothing.
DocumentObserver::changed(f.checker.as_ref(), ide_core::DocId(0), &a, 2, &edit(), &full);
tokio::time::sleep(Duration::from_millis(150)).await;
assert_eq!(f.diagnostics().len(), 2);
// The next save checks the file again.
f.report(&a, &["constant.notFound"]);
f.checker.files_saved([a.clone()]);
f.until("the fresh check", |f| f.diagnostics().len() == 3).await;
assert_eq!(f.diagnostics()[2], (a.clone(), vec![Some("constant.notFound".to_string())]));
f.checker.stop();
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_check_finishing_after_an_edit_shows_nothing_until_the_next_save() {
let f = Fixture::new();
let a = f.file("A.php");
f.report(&a, &["constant.notFound"]);
f.checker.files_saved([a.clone()]);
let edit = [AppliedChange { range: ide_core::Range::point(ide_core::Pos::new(1, 0)), text: "\n".into() }];
DocumentObserver::changed(f.checker.as_ref(), ide_core::DocId(0), &a, 1, &edit, &String::new);
f.until("the check", |f| !f.runs().is_empty()).await;
tokio::time::sleep(Duration::from_millis(300)).await;
assert!(f.diagnostics().is_empty(), "{:?}", f.diagnostics());
f.checker.files_saved([a.clone()]);
f.until("the next check", |f| f.diagnostics().len() == 1).await;
assert_eq!(f.diagnostics()[0], (a.clone(), vec![Some("constant.notFound".to_string())]));
f.checker.stop();
}
}
+17
Переглянути файл
@@ -2116,6 +2116,23 @@ impl HostApi for PluginApi {
.emit(None, PluginEvent::StatusItemChanged { plugin_id: self.id().to_owned(), id: id.to_owned(), item });
}
fn check_status_menu(&self, menu: &[ide_plugin::StatusMenuEntry]) -> Result<(), HostError> {
let actions: Vec<ide_plugin::NotificationAction> = menu
.iter()
.filter_map(|entry| match entry {
ide_plugin::StatusMenuEntry::Action { label, command, argument, .. } => {
Some(ide_plugin::NotificationAction {
label: label.clone(),
command: command.clone(),
argument: argument.clone(),
})
}
_ => None,
})
.collect();
check_actions(self, &actions)
}
fn window_status_item(&self, client: &str, id: &str, item: Option<StatusItem>) -> Result<(), HostError> {
let closed = self.shared.closed_clients.lock();
let blocked = self.shared.prompts_blocked.lock();
+125 -7
Переглянути файл
@@ -1,10 +1,13 @@
//! The `javaAgents` extension point (API 1.10): a Java agent the host loads into the
//! JVM of Application, Spring Boot and JAR Application configurations.
//! The `javaAgents` extension point (API 1.10; `vmOptions` / `jdk` in 1.14): a Java
//! agent the host loads into the JVM of Application, Spring Boot and JAR Application
//! configurations, with optional JVM flags.
//!
//! ```toml
//! [[contributes.javaAgents]]
//! path = "agent/openidea-spring-agent.jar" # inside the package
//! args = "optional-arguments" # optional
//! vmOptions = ["-XX:+AllowEnhancedClassRedefinition"] # optional, API 1.14
//! jdk = "jetbrains" # optional: only those VM options on JBR
//! ```
//!
//! One agent per plugin. The declaration derives the optional high-risk `java.agent`
@@ -23,6 +26,8 @@ use std::sync::atomic::{AtomicU64, Ordering};
pub const POINT_ID: &str = "javaAgents";
const MAX_ARGS: usize = 4096;
const MAX_VM_OPTION: usize = 512;
const MAX_VM_OPTIONS: usize = 32;
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
@@ -30,6 +35,10 @@ struct Decl {
path: PathBuf,
#[serde(default)]
args: Option<String>,
#[serde(default, rename = "vmOptions")]
vm_options: Vec<String>,
#[serde(default)]
jdk: Option<String>,
}
#[derive(Clone, Debug)]
@@ -37,6 +46,8 @@ pub(super) struct Agent {
/// The jar, resolved inside the package.
pub(super) jar: PathBuf,
pub(super) args: Option<String>,
pub(super) vm_options: Vec<String>,
pub(super) jdk: Option<String>,
}
/// Agents of enabled plugins.
@@ -95,20 +106,65 @@ impl ExtensionPoint for JavaAgentsPoint {
{
return Err(format!("contributes.javaAgents: `args` must be one line of at most {MAX_ARGS} bytes"));
}
let label = label(&d.path, args.as_deref());
let vm_options = validate_vm_options(&d.vm_options)?;
let jdk = validate_jdk(d.jdk)?;
if !vm_options.is_empty() || jdk.is_some() {
pkg.manifest.needs_api("contributes.javaAgents.vmOptions", 14)?;
}
let label = label(&d.path, args.as_deref(), &vm_options);
let (store, plugin) = (self.store.clone(), pkg.id().to_owned());
let agent = Agent { jar, args };
let agent = Agent { jar, args, vm_options, jdk };
Ok(Prepared::new(label, move || Ok(store.add(plugin, agent))).file(d.path).capability(Capability::JavaAgent))
}
}
/// What Settings › Plugins shows: the jar's file name and its arguments, as `-javaagent:` takes them.
fn label(path: &Path, args: Option<&str>) -> String {
fn validate_vm_options(raw: &[String]) -> Result<Vec<String>, String> {
if raw.len() > MAX_VM_OPTIONS {
return Err(format!("contributes.javaAgents: at most {MAX_VM_OPTIONS} `vmOptions`"));
}
let mut out = Vec::with_capacity(raw.len());
for opt in raw {
let opt = opt.trim();
if opt.is_empty() {
continue;
}
if !opt.starts_with('-')
|| opt.len() > MAX_VM_OPTION
|| opt.contains(|c: char| c.is_control() || c.is_whitespace())
{
return Err(format!(
"contributes.javaAgents: each `vmOptions` entry must be one flag starting with `-` (at most {MAX_VM_OPTION} bytes, no spaces)"
));
}
if !out.iter().any(|o: &String| o == opt) {
out.push(opt.to_owned());
}
}
Ok(out)
}
fn validate_jdk(jdk: Option<String>) -> Result<Option<String>, String> {
let Some(raw) = jdk.map(|s| s.trim().to_ascii_lowercase()).filter(|s| !s.is_empty()) else {
return Ok(None);
};
if raw != "jetbrains" {
return Err("contributes.javaAgents: `jdk` must be \"jetbrains\" when set".into());
}
Ok(Some(raw))
}
/// What Settings › Plugins shows: jar name, args, and any JVM options.
fn label(path: &Path, args: Option<&str>, vm_options: &[String]) -> String {
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
match args {
let mut out = match args {
Some(args) => format!("{name}={args}"),
None => name,
};
if !vm_options.is_empty() {
out.push(' ');
out.push_str(&vm_options.join(" "));
}
out
}
/// The jar a package's declaration names, as an absolute path inside the package:
@@ -135,6 +191,16 @@ pub(super) fn declared_jar(manifest: &Manifest, dir: &Path) -> Option<PathBuf> {
resolve(dir, &d.path).ok()
}
/// Declared `vmOptions` (for consent / Settings copy), if the package has a valid declaration.
pub(super) fn declared_vm_options(manifest: &Manifest) -> Vec<String> {
let decl = manifest.declarations(POINT_ID).into_iter().next();
let Some(decl) = decl else { return Vec::new() };
let Ok(d) = decode::<Decl>(POINT_ID, decl) else {
return Vec::new();
};
validate_vm_options(&d.vm_options).unwrap_or_default()
}
type Pins = Arc<RwLock<HashMap<(String, String), ProgramPin>>>;
/// [`JavaAgentSource`] over the agents and the hashes granted for them.
@@ -155,6 +221,8 @@ impl JavaAgentSource for PluginJavaAgents {
plugin: plugin.clone(),
jar: agent.jar.clone(),
args: agent.args.clone(),
vm_options: agent.vm_options.clone(),
jdk: agent.jdk.clone(),
approved_hash: pins.get(&(plugin.clone(), cap.clone())).map(|pin| pin.hash.clone()),
})
.collect()
@@ -167,6 +235,8 @@ mod tests {
const MANIFEST: &str =
"id = \"acme.spring\"\nname = \"Spring\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.10\"\n";
const MANIFEST_14: &str =
"id = \"acme.spring\"\nname = \"Spring\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.14\"\n";
fn package(dir: &Path, manifest: &str) -> Package {
std::fs::create_dir_all(dir.join("agent")).unwrap();
@@ -209,12 +279,33 @@ mod tests {
(agents[0].plugin.as_str(), agents[0].args.as_deref(), agents[0].approved_hash.as_ref()),
("acme.spring", Some("port=0,trace"), None)
);
assert!(agents[0].vm_options.is_empty());
source.pins.write().insert(("acme.spring".into(), "java.agent".into()), ProgramPin::approve(&jar).unwrap());
assert!(source.agents()[0].approved_hash.is_some());
disposable.dispose();
assert!(source.agents().is_empty(), "disabling the plugin drops its agent");
}
#[test]
fn parses_vm_options_and_jdk_gate() {
let tmp = tempfile::tempdir().unwrap();
let toml = format!(
"{MANIFEST_14}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nvmOptions = [\"-XX:+AllowEnhancedClassRedefinition\"]\njdk = \"jetbrains\"\n"
);
let pkg = package(tmp.path(), &toml);
let prepared = prepare(&pkg).unwrap();
assert_eq!(prepared.label, "spring agent.jar -XX:+AllowEnhancedClassRedefinition");
assert_eq!(declared_vm_options(&pkg.manifest), ["-XX:+AllowEnhancedClassRedefinition"]);
let store: Arc<JavaAgents> = Arc::default();
let point = JavaAgentsPoint::new(store.clone());
let decl = pkg.manifest.declarations(POINT_ID).remove(0);
let _keep = (point.prepare(&pkg, decl).unwrap().commit)().unwrap();
let agent = store.for_plugin("acme.spring").unwrap();
assert_eq!(agent.vm_options, ["-XX:+AllowEnhancedClassRedefinition"]);
assert_eq!(agent.jdk.as_deref(), Some("jetbrains"));
}
#[test]
fn refuses_what_would_fail_at_launch() {
let tmp = tempfile::tempdir().unwrap();
@@ -242,6 +333,33 @@ mod tests {
);
let old = format!("{}{}", MANIFEST.replace("^1.10", "^1.9"), agent("agent/spring agent.jar"));
assert!(refused(7, &old).contains("new in plugin API 1.10"));
assert!(
refused(
9,
&format!(
"{MANIFEST}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nvmOptions = [\"-XX:+AllowEnhancedClassRedefinition\"]\n"
),
)
.contains("new in plugin API 1.14")
);
assert!(
refused(
10,
&format!(
"{MANIFEST_14}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nvmOptions = [\"not-a-flag\"]\n"
),
)
.contains("starting with `-`")
);
assert!(
refused(
11,
&format!(
"{MANIFEST_14}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\njdk = \"temurin\"\n"
),
)
.contains("jetbrains")
);
#[cfg(unix)]
{
let dir = tmp.path().join("8");
+28
Переглянути файл
@@ -276,6 +276,34 @@ impl PluginHost {
}
out
}
/// Optional API 1.14 hover actions. Only plugins declaring the
/// `hover-actions` provider kind are asked; the released language-features
/// export remains unchanged.
pub fn language_hover_actions(&self, doc: &ProviderDocument) -> Vec<(String, HoverAction)> {
let mut out = Vec::new();
for (d, _bounds) in self.feature_documents(doc, None) {
let snapshot = d.clone();
let text = ide_text::Document::new(&snapshot.text);
let d = Arc::new(d);
let results = self
.document_calls(ProviderKind::HoverActions, &snapshot, move |rt, t| rt.language_hover_actions(&d, t));
for (p, items) in results {
let commands: std::collections::HashSet<_> =
self.ui.items(super::COMMANDS, Some(p.id())).into_iter().map(|c| c.key).collect();
for i in items {
let lines = text.line_count();
let anchor_ok = i.line < lines;
let range_ok = i.start_line <= i.end_line && i.end_line < lines;
let contains_anchor = i.start_line <= i.line && i.line <= i.end_line;
if anchor_ok && range_ok && contains_anchor && commands.contains(&i.command) {
out.push((p.id().to_owned(), i));
}
}
}
}
out
}
pub fn language_gutter_actions(&self, doc: &ProviderDocument) -> Vec<(String, GutterAction)> {
let mut out = Vec::new();
for (d, bounds) in self.feature_documents(doc, None) {
+18
Переглянути файл
@@ -925,6 +925,7 @@ impl PluginHost {
capabilities.push(CapabilityInfo::new(extra, true, granted(extra)));
}
}
annotate_java_agent_vm_options(&mut capabilities, m);
capabilities.sort_by(|a, b| b.risk.cmp(&a.risk).then(a.id.cmp(&b.id)));
let signer_changed = self.signer_changed(&m.id, src);
let answered = |c: &CapabilityInfo| {
@@ -3085,6 +3086,7 @@ impl PluginHost {
capabilities.push(CapabilityInfo::new(extra, true, granted(extra)));
}
}
annotate_java_agent_vm_options(&mut capabilities, m);
// Hosts remembered through `net:ask` are grants of their own: listed
// separately so the user can revoke them one by one.
let net_hosts = grant
@@ -3118,6 +3120,8 @@ impl PluginHost {
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_else(|| agent.jar.display().to_string()),
args: agent.args,
vm_options: agent.vm_options,
jdk: agent.jdk,
approved,
}
}),
@@ -3157,6 +3161,20 @@ fn agent_jar_grant(manifest: &Manifest, dir: &Path) -> Option<BinaryGrant> {
Some(BinaryGrant { path, hash })
}
/// Consent / Settings: surface exact contributed JVM flags on the `java.agent` permission.
fn annotate_java_agent_vm_options(capabilities: &mut [CapabilityInfo], manifest: &Manifest) {
let opts = java_agents::declared_vm_options(manifest);
if opts.is_empty() {
return;
}
let flags = opts.join(" ");
for cap in capabilities.iter_mut() {
if cap.id == "java.agent" {
cap.description = format!("{}; JVM options: {flags}", cap.description);
}
}
}
fn request_for<'a>(subject: &Subject, m: &'a Manifest, hash: &'a str, declared: &[Capability]) -> Request<'a> {
let mut optional = m.capabilities.optional.clone();
// What declarations need (a language server's `process:`) is optional:
+5
Переглянути файл
@@ -54,6 +54,7 @@ pub enum ProviderKind {
Implementation,
TypeDefinition,
GutterActions,
HoverActions,
Injections,
}
@@ -204,11 +205,15 @@ impl ExtensionPoint for ProvidersPoint {
| ProviderKind::Implementation
| ProviderKind::TypeDefinition
| ProviderKind::GutterActions
| ProviderKind::HoverActions
| ProviderKind::Injections
)
}) {
pkg.manifest.needs_api("contributes.providers: language features and injections", 4)?;
}
if d.kinds.contains(&ProviderKind::HoverActions) {
pkg.manifest.needs_api("contributes.providers: hover-actions", 14)?;
}
for l in &d.languages {
if l != "*"
&& (l.is_empty()
+4
Переглянути файл
@@ -63,6 +63,10 @@ pub struct PluginJavaAgent {
pub file_name: String,
/// The optional argument passed after `=`.
pub args: Option<String>,
/// Extra JVM flags from `vmOptions` (API 1.14).
pub vm_options: Vec<String>,
/// When `Some("jetbrains")`, those VM options apply only on JetBrains Runtime.
pub jdk: Option<String>,
/// The jar still has the hash recorded when `java.agent` was granted.
pub approved: bool,
}
+3
Переглянути файл
@@ -106,6 +106,9 @@ impl Host {
{
return Ok(current);
}
// A window takes the root over from the MCP server's background project, whose
// shutdown the wait below sits out; none opens until this open is over.
let _claim = (!crate::mcp::BackgroundProjects::is_key(window)).then(|| self.mcp_background.claim(self, &root));
self.close_project(window);
self.wait_detached_closes();
let sink: SharedSink = (self.sink_for)(window);
+2
Переглянути файл
@@ -177,6 +177,7 @@ pub fn event_sink(peer: Arc<OnceLock<Peer>>, window: Option<String>) -> ide_core
pub fn client_accepts(event: &IdeEvent, trusted: bool) -> bool {
match event {
IdeEvent::WindowGroupsChanged
| IdeEvent::McpBackgroundProjectsChanged
| IdeEvent::WindowFullscreenChanged
| IdeEvent::RemoteConnectionLost { .. }
| IdeEvent::UpdateStatusChanged { .. }
@@ -323,6 +324,7 @@ mod tests {
},
IdeEvent::WindowGroupsChanged,
IdeEvent::WindowFullscreenChanged,
IdeEvent::McpBackgroundProjectsChanged,
] {
assert!(!client_accepts(&event, true), "{event:?}");
}
+6
Переглянути файл
@@ -244,6 +244,9 @@ impl crate::Host {
}
pub async fn refresh_project_trust(&self) -> IdeResult<()> {
// A background project that is being opened read the trust before this decision and
// is not among the projects yet: once its open is over, the loop below corrects it.
Self::in_place(|| self.mcp_background.wait_for_open());
for project in self.projects().into_iter().filter(|p| !p.light) {
let trusted = self.trust.window_trusted(&project.root).unwrap_or(false);
let roots = project.content_roots();
@@ -305,6 +308,9 @@ impl crate::Host {
crate::ops::sdk::container_python::ensure(self, &project);
project.sink.emit(ide_core::IdeEvent::ProjectTrustChanged { root: project.root.clone().into(), trusted });
}
// Trust decides which projects are served without a window. The step waits for a
// background open under way and reads files: not on an async worker.
Self::in_place(|| self.apply_background_policy());
Ok(())
}
}
+284 -1
Переглянути файл
@@ -1,5 +1,5 @@
use ide_core::{CancellationToken, ChangeSet, Diagnostic, IdeEvent, Pos, Range, Severity, TextChange};
use ide_host::mcp::{FileProblems, FocusedEditor, Registry};
use ide_host::mcp::{BackgroundProjects, FileProblems, FocusedEditor, Registry};
use ide_host::{Host, HostConfig};
use ide_mcp::ToolRegistry;
use serde_json::{Value, json};
@@ -83,14 +83,65 @@ impl Harness {
async fn json(&self, name: &str, args: Value) -> Value {
serde_json::from_str(&self.call(name, args).await).unwrap()
}
fn set(&self, key: &str, value: Value) {
let key = format!("mcpServer.{key}");
self.host.global_settings.set(ide_workspace::SettingsScope::Global, &key, value).unwrap();
}
/// The folder `inventory` next to the open project, listed to be served without a window.
fn serve_inventory(&self) -> PathBuf {
let inventory = self.root.parent().unwrap().join("inventory");
std::fs::create_dir_all(inventory.join("src")).unwrap();
std::fs::write(inventory.join("src/stock.txt"), "forty crates\n").unwrap();
self.set("enabled", json!(true));
self.set("backgroundProjects", json!("listed"));
self.set("backgroundProjectPaths", json!([inventory]));
inventory
}
/// Roots of the projects loaded without a window.
fn background(&self) -> Vec<PathBuf> {
let loaded = self.host.mcp_background.snapshot(&self.host, std::time::Instant::now());
loaded.into_iter().map(|project| project.root.into_path_buf()).collect()
}
/// A tool call for the project at `root`: its text, or its error.
async fn call_at(&self, root: &Path, name: &str, args: Value) -> Result<String, String> {
let (host, root, name) = (self.host.clone(), root.to_owned(), name.to_owned());
let call = move || Registry::new(host).call(&root, &name, &args.to_string(), CancellationToken::new());
tokio::task::spawn_blocking(call).await.unwrap().map_err(|e| match e {
ide_mcp::ToolCallError::Failed(e) | ide_mcp::ToolCallError::UnknownTool(e) => e,
})
}
fn server(&self) -> (ide_mcp::McpServer, PathBuf) {
let discovery = ide_mcp::discovery_path(self.tmp.path());
let registry = Arc::new(Registry::new(self.host.clone()));
let runtime = tokio::runtime::Handle::current();
(ide_mcp::McpServer::start(registry, Some(discovery.clone()), &runtime).unwrap(), discovery)
}
}
impl Drop for Harness {
fn drop(&mut self) {
self.host.close_project("main");
self.host.close_project("second");
for root in self.background() {
self.host.close_project(&BackgroundProjects::key(&root));
}
}
}
/// What the stdio bridge started in `folder` answers to `requests`, by request id.
async fn bridged(discovery: &Path, folder: &Path, requests: &[Value]) -> Vec<Value> {
let input: String = requests.iter().map(|request| format!("{request}\n")).collect();
let mut output = Vec::new();
ide_mcp::stdio::bridge(discovery, folder, input.as_bytes(), &mut output).await.unwrap();
let mut replies: Vec<Value> =
String::from_utf8(output).unwrap().lines().map(|line| serde_json::from_str(line).unwrap()).collect();
replies.sort_by_key(|reply| reply["id"].as_i64());
replies
}
fn rpc(id: u32, method: &str, params: Value) -> Value {
json!({"jsonrpc":"2.0","id":id,"method":method,"params":params})
}
#[tokio::test(flavor = "multi_thread")]
async fn reads_unsaved_text_and_searches_the_overlay_with_a_limit() {
let h = Harness::new();
@@ -1300,3 +1351,235 @@ async fn call_hierarchy_pages_are_sorted_and_scoped() {
assert_eq!(scoped["total"], 1);
assert_eq!(scoped["root"]["name"], "price", "the root is shown whatever the paths");
}
#[tokio::test(flavor = "multi_thread")]
async fn a_folder_without_a_window_is_opened_by_its_first_tool_call() {
let h = Harness::new();
let inventory = h.serve_inventory();
let (_server, discovery) = h.server();
let folder = inventory.join("src");
let replies =
bridged(&discovery, &folder, &[rpc(1, "initialize", json!({})), rpc(2, "tools/list", json!({}))]).await;
let instructions = replies[0]["result"]["instructions"].as_str().unwrap();
assert!(instructions.contains(inventory.to_str().unwrap()), "{instructions}");
let tools = replies[1]["result"]["tools"].as_array().unwrap();
assert!(tools.iter().any(|tool| tool["name"] == "read_file"), "{tools:?}");
assert!(tools.iter().all(|tool| tool["annotations"]["readOnlyHint"] == true), "nobody trusted the folder");
assert!(h.background().is_empty(), "initialize and tools/list open nothing");
assert_eq!(h.host.projects().len(), 1);
let read = rpc(3, "tools/call", json!({"name":"read_file","arguments":{"file_path":"src/stock.txt"}}));
let replies = bridged(&discovery, &folder, &[read]).await;
assert_eq!(replies[0]["result"]["content"][0]["text"], "L1: forty crates\nL2: ", "{replies:?}");
assert_eq!(h.background(), std::slice::from_ref(&inventory));
// Loaded, it is still no project of a window.
assert_eq!(Registry::new(h.host.clone()).projects(), std::slice::from_ref(&h.root));
assert!(h.host.project("main").is_ok());
}
#[tokio::test(flavor = "multi_thread")]
async fn with_background_projects_off_a_folder_outside_the_open_projects_is_refused() {
let h = Harness::new();
let inventory = h.root.parent().unwrap().join("inventory");
std::fs::create_dir_all(&inventory).unwrap();
let (_server, discovery) = h.server();
let list = rpc(1, "tools/list", json!({}));
let read = rpc(2, "tools/call", json!({"name":"read_file","arguments":{"file_path":"a.txt"}}));
for reply in bridged(&discovery, &inventory, &[list, read]).await {
assert_eq!(reply["error"]["code"], -32001, "{reply}");
let message = reply["error"]["message"].as_str().unwrap();
assert!(message.contains("isn't served in the background"), "{message}");
}
assert!(h.background().is_empty());
assert_eq!(h.host.projects().len(), 1);
}
#[tokio::test(flavor = "multi_thread")]
async fn the_tools_of_a_background_project_are_the_same_before_and_after_it_opens() {
let h = Harness::new();
let inventory = h.serve_inventory();
let registry = Registry::new(h.host.clone());
let restricted = registry.tools(&inventory).unwrap();
assert!(!restricted.is_empty() && restricted.iter().all(|t| t.read_only && !t.destructive));
assert!(h.background().is_empty(), "listing opens nothing");
h.call_at(&inventory, "read_file", json!({"file_path":"src/stock.txt"})).await.unwrap();
assert_eq!(registry.tools(&inventory).unwrap(), restricted);
// Trusted, loaded or not, it has the tools that write and run as well.
h.host.set_project_trust(&inventory, true, false).await.unwrap();
let trusted = registry.tools(&inventory).unwrap();
assert!(trusted.iter().any(|t| t.name == "create_new_file" && !t.read_only));
assert!(h.host.mcp_background.detach(&h.host, &inventory, None));
assert_eq!(registry.tools(&inventory).unwrap(), trusted);
assert!(h.background().is_empty());
// The project in the window lists what it did before.
assert!(registry.tools(&h.root).unwrap().iter().all(|t| t.read_only));
// A folder nothing serves has no tools.
assert!(registry.tools(&inventory.join("src")).is_err());
}
/// POSTs `body` to the server without naming a project.
async fn post(server: &ide_mcp::McpServer, body: &Value) -> Value {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let (port, body) = (server.port(), body.to_string());
let request = format!(
"POST /mcp HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nAuthorization: Bearer {}\r\nContent-Type: application/json\r\nAccept: application/json, text/event-stream\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
server.token(),
body.len()
);
let mut stream = tokio::net::TcpStream::connect(("127.0.0.1", port)).await.unwrap();
stream.write_all(request.as_bytes()).await.unwrap();
let mut reply = String::new();
stream.read_to_string(&mut reply).await.unwrap();
serde_json::from_str(reply.split_once("\r\n\r\n").unwrap().1).unwrap()
}
#[tokio::test(flavor = "multi_thread")]
async fn a_project_open_in_a_window_answers_before_any_background_project() {
let h = Harness::new();
let inventory = h.serve_inventory();
// A listed folder inside the open project: the window's project answers for it.
h.set("backgroundProjectPaths", json!([inventory, h.root.join("src")]));
let (server, discovery) = h.server();
let inside = json!({"projectPath": h.root.join("src"), "file_path": "src/b.txt"});
let read = rpc(1, "tools/call", json!({"name":"read_file","arguments":inside.clone()}));
let replies = bridged(&discovery, &inventory, &[read]).await;
assert_eq!(replies[0]["result"]["content"][0]["text"], "L1: needle\nL2: ", "{replies:?}");
assert!(h.background().is_empty());
// With a background project loaded, a request that names no folder goes to the only window.
h.call_at(&inventory, "read_file", json!({"file_path":"src/stock.txt"})).await.unwrap();
assert_eq!(h.background(), std::slice::from_ref(&inventory));
let unnamed = rpc(2, "tools/call", json!({"name":"read_file","arguments":{"file_path":"src/b.txt"}}));
let reply = post(&server, &unnamed).await;
assert_eq!(reply["result"]["content"][0]["text"], "L1: needle\nL2: ", "{reply}");
// Nor does a background project loaded inside the window's project take its folder over.
let nested = h.root.join("src");
h.call_at(&nested, "read_file", json!({"file_path":"b.txt"})).await.unwrap();
assert_eq!(h.background(), [inventory.clone(), nested]);
let read = rpc(3, "tools/call", json!({"name":"read_file","arguments":inside}));
let replies = bridged(&discovery, &inventory, &[read]).await;
assert_eq!(replies[0]["result"]["content"][0]["text"], "L1: needle\nL2: ", "{replies:?}");
// A second window on another root is served as before.
let second = h.root.parent().unwrap().join("second");
std::fs::create_dir_all(&second).unwrap();
std::fs::write(second.join("unique.txt"), "second project").unwrap();
h.host.open_project("second", &second).unwrap();
let read = h.call_at(&second, "read_file", json!({"file_path":"unique.txt"})).await.unwrap();
assert_eq!(read, "L1: second project");
assert_eq!(h.background().len(), 2);
}
#[tokio::test(flavor = "multi_thread")]
async fn tools_fed_by_a_window_say_that_a_background_project_has_none() {
let h = Harness::new();
let inventory = h.serve_inventory();
for (tool, args, hint) in [
("get_all_open_file_paths", json!({}), ""),
("get_current_file", json!({}), ""),
("get_file_problems", json!({"filePath":"src/stock.txt"}), " Use check_files for diagnostics."),
("get_project_problems", json!({}), " Use check_files for diagnostics."),
] {
let error = h.call_at(&inventory, tool, args).await.unwrap_err();
let root = inventory.display();
let expected = format!("{tool} needs the project open in a window: {root} is served in the background.{hint}");
assert_eq!(error, expected);
}
// `check_files` answers there, and the project in the window keeps its answers.
let checked = h.call_at(&inventory, "check_files", json!({"filePaths":["src/stock.txt"]})).await.unwrap();
assert_eq!(serde_json::from_str::<Value>(&checked).unwrap()["files"][0]["status"], "untrusted", "{checked}");
assert_eq!(h.json("get_all_open_file_paths", json!({})).await["openFiles"], json!([]));
assert_eq!(h.json("get_current_file", json!({})).await, json!({}));
assert_eq!(h.json("get_project_problems", json!({})).await["files"], json!([]));
let problems = h.json("get_file_problems", json!({"filePath":"src/a.txt"})).await;
assert_eq!(problems["errors"], json!([]));
}
#[tokio::test(flavor = "multi_thread")]
async fn tools_that_ask_the_user_fail_closed_in_a_background_project() {
let h = Harness::new();
let inventory = h.serve_inventory();
h.host.trust.decide(&inventory, true, false).unwrap();
for (tool, args) in [
("build_project", json!({})),
("run_command", json!({"name":"check","command":"true"})),
("open_file_in_editor", json!({"filePath":"src/stock.txt"})),
] {
let error = h.call_at(&inventory, tool, args).await.unwrap_err();
assert!(error.contains("no project window"), "{tool}: {error}");
}
assert!(h.host.processes.list().is_empty());
// Running without confirmation does not give `run_command` or the editor a window.
h.set("runWithoutConfirmation", json!(true));
for (tool, args) in [
("run_command", json!({"name":"check","command":"true"})),
("open_file_in_editor", json!({"filePath":"src/stock.txt"})),
] {
let error = h.call_at(&inventory, tool, args).await.unwrap_err();
assert!(error.contains("no project window"), "{tool}: {error}");
}
assert_eq!(h.background(), [inventory]);
}
#[tokio::test(flavor = "multi_thread")]
async fn a_cancelled_or_failed_call_leaves_nothing_holding_the_project() {
let h = Harness::new();
let inventory = h.serve_inventory();
let (host, root, cancel) = (h.host.clone(), inventory.clone(), CancellationToken::new());
cancel.cancel();
let cancelled = tokio::task::spawn_blocking(move || {
Registry::new(host).call(&root, "read_file", r#"{"file_path":"src/stock.txt"}"#, cancel)
});
assert!(cancelled.await.unwrap().is_err());
assert!(h.call_at(&inventory, "read_file", json!({"file_path":"src/gone.txt"})).await.is_err());
assert!(h.call_at(&inventory, "no_such_tool", json!({})).await.is_err());
let loaded = h.host.mcp_background.snapshot(&h.host, std::time::Instant::now());
assert_eq!(loaded.len(), 1);
assert_eq!(loaded[0].kept_open_by, None);
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread")]
async fn a_run_started_without_confirmation_works_in_a_background_project_and_holds_it() {
let h = Harness::new();
let inventory = h.serve_inventory();
h.host.trust.decide(&inventory, true, false).unwrap();
h.set("runWithoutConfirmation", json!(true));
let config = ide_run::RunConfig {
id: "serve".into(),
name: "serve stock".into(),
kind: "shell".into(),
command: "sleep 30".into(),
args: vec![],
cwd: None,
env: Default::default(),
detected: false,
is_test: false,
debug_adapter: None,
allow_parallel: false,
extras: Default::default(),
};
ide_run::save_user_configs(&inventory, &[config]).unwrap();
let call = h.call_at(&inventory, "execute_run_configuration", json!({"configurationName":"serve stock"}));
let observe = async {
let run = tokio::time::timeout(std::time::Duration::from_secs(30), async {
loop {
if let Some(run) = h.host.processes.running_in(&inventory).pop() {
break run;
}
tokio::task::yield_now().await;
}
})
.await
.expect("the run starts");
// The call still waits for the run: it holds the project first, the run second.
let held = h.host.mcp_background.snapshot(&h.host, std::time::Instant::now()).remove(0);
assert_eq!(held.kept_open_by, Some(ide_host::mcp::McpBackgroundHold::Request));
h.host.processes.stop(run.id).unwrap();
};
let (result, ()) = tokio::join!(call, observe);
let result: Value = serde_json::from_str(&result.unwrap()).unwrap();
assert!(result["exitCode"].is_number() || result["exitCode"].is_null(), "{result}");
let loaded = h.host.mcp_background.snapshot(&h.host, std::time::Instant::now()).remove(0);
assert_eq!(loaded.kept_open_by, None, "the call is over and the run has exited");
}
+35
Переглянути файл
@@ -193,6 +193,41 @@ async fn mcp_listing_dispatch_confirmation_and_lifecycle_use_plugin_authority()
assert!(spin.await.unwrap().is_err(), "command budget interrupts wasm");
}
#[tokio::test(flavor = "multi_thread")]
async fn a_plugin_tool_call_holds_its_background_project_until_it_ends() {
use ide_host::mcp::{BackgroundProjects, McpBackgroundHold};
// The fixture's `spin` runs until it is cancelled or its budget ends.
let f = Harness::with_timeout(Duration::from_secs(10));
let inventory = f.root.parent().unwrap().join("inventory");
std::fs::create_dir(&inventory).unwrap();
for (key, value) in [
("enabled", serde_json::json!(true)),
("backgroundProjects", serde_json::json!("listed")),
("backgroundProjectPaths", serde_json::json!([inventory])),
] {
let key = format!("mcpServer.{key}");
f.host.global_settings.set(ide_workspace::SettingsScope::Global, &key, value).unwrap();
}
let held_by = || {
let loaded = f.host.mcp_background.snapshot(&f.host, std::time::Instant::now());
loaded.into_iter().next().map(|project| project.kept_open_by)
};
let (registry, root, cancel) = (Registry::new(f.host.clone()), inventory.clone(), CancellationToken::new());
let stop = cancel.clone();
let call = tokio::task::spawn_blocking(move || registry.call(&root, "test_data_tools__spin", "{}", cancel));
tokio::time::timeout(Duration::from_secs(10), async {
while held_by() != Some(Some(McpBackgroundHold::Request)) {
tokio::task::yield_now().await;
}
})
.await
.expect("the call holds the project while the plugin runs");
stop.cancel();
assert!(call.await.unwrap().is_err());
assert_eq!(held_by(), Some(None), "the project stays loaded with nothing holding it");
f.host.close_project(&BackgroundProjects::key(&inventory));
}
#[tokio::test(flavor = "multi_thread")]
async fn database_imports_are_denied_without_the_optional_grant() {
let f = Harness::new();
+3
Переглянути файл
@@ -152,6 +152,9 @@ async fn editor_ops_merge_the_fixture_format_selection_and_execute_owned_command
let visuals = ops::lsp::plugin_language_visuals(&host, "main", doc.id).await.unwrap();
assert_eq!(visuals.colors.len(), 1);
assert_eq!(visuals.gutter_actions.len(), 1);
assert_eq!(visuals.hover_actions.len(), 1);
assert_eq!(visuals.hover_actions[0].1.command, "run");
assert_eq!(visuals.hover_actions[0].1.end_line, 2);
assert_eq!(
ops::lsp::plugin_color_presentations(&host, "main", doc.id, ID.into(), visuals.colors[0].1.clone())
.await
+28
Переглянути файл
@@ -2218,6 +2218,8 @@ fn java_agent_loads_only_while_granted_and_unchanged() {
let agent = info.java_agent.clone().expect("agent metadata");
assert_eq!(agent.file_name, "fixture agent.jar");
assert_eq!(agent.args.as_deref(), Some("mode=test"));
assert!(agent.vm_options.is_empty());
assert!(agent.jdk.is_none());
assert!(!agent.approved);
let source = f.host.java_agents();
let launch = || {
@@ -6384,6 +6386,32 @@ fn api14_window_status_overrides_fall_back_and_are_withdrawn() {
&& matches!(event, PluginEvent::WindowStatusItemChanged { item: None, .. })));
}
#[test]
fn a_status_item_menu_reaches_the_ui_and_names_only_declared_commands() {
let f = fixture(Limits::default());
f.install(&sample("api14"));
f.run("api14", "menu-status", Some("App: running")).unwrap();
let item = f.host.status_snapshot("main").into_iter().find(|i| i.id == "menu").unwrap().item;
assert_eq!(item.text, "App: running");
assert_eq!(
item.menu,
[
ide_plugin::StatusMenuEntry::Header { label: "App".into() },
ide_plugin::StatusMenuEntry::Action {
label: "Open".into(),
description: Some("https://app.test".into()),
command: "events".into(),
argument: Some("web".into()),
},
ide_plugin::StatusMenuEntry::Separator,
]
);
let err = f.run("api14", "bad-menu-status", Some("changed")).unwrap_err();
assert!(err.contains("undeclared"), "{err}");
let item = f.host.status_snapshot("main").into_iter().find(|i| i.id == "menu").unwrap().item;
assert_eq!(item.text, "App: running", "a refused menu changes nothing");
}
#[test]
fn api14_command_requests_preserve_window_result_and_reject_cycles() {
let f = Arc::new(fixture(Limits::default()));
+5
Переглянути файл
@@ -31,3 +31,8 @@ zip.workspace = true
tempfile.workspace = true
encoding_rs.workspace = true
tokio = { workspace = true, features = ["rt-multi-thread", "macros", "test-util"] }
criterion = { version = "0.5", default-features = false }
[[bench]]
name = "did_change"
harness = false
+158
Переглянути файл
@@ -0,0 +1,158 @@
//! `cargo bench -p ide-lsp`: an incremental LSP change on a 1 MB document.
use criterion::{Criterion, black_box, criterion_group, criterion_main};
use ide_core::event::ServerStatus;
use ide_core::{DocId, IdeEvent, LanguageId, Pos, Range};
use ide_jsonrpc::{Handler, Peer};
use ide_language::{LanguageConfig, LanguageRegistry, LanguageServerConfig};
use ide_lsp::{Launcher, LspManager};
use ide_text::AppliedChange;
use serde_json::{Value, json};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
struct MockServer;
impl Handler for MockServer {
fn on_notification(&self, _method: &str, _params: Value) {}
fn on_request(&self, method: &str, _params: Value) -> Result<Value, (i64, String)> {
match method {
"initialize" => Ok(json!({
"capabilities": {
"textDocumentSync": { "openClose": true, "change": 2 }
}
})),
"shutdown" => Ok(Value::Null),
_ => Ok(Value::Null),
}
}
}
#[derive(Default)]
struct MockLauncher {
servers: Mutex<Vec<Peer>>,
}
impl Launcher for MockLauncher {
fn launch(
&self,
_config: &LanguageServerConfig,
_root: &Path,
handler: Arc<dyn Handler>,
_on_stderr: Box<dyn Fn(String) + Send + Sync>,
) -> Result<Peer, ide_lsp::LaunchError> {
let (server_io, client_io) = tokio::io::duplex(1 << 20);
let (server_read, server_write) = tokio::io::split(server_io);
let (client_read, client_write) = tokio::io::split(client_io);
let server = Peer::connect(server_read, server_write, Arc::new(MockServer));
self.servers.lock().unwrap().push(server);
Ok(Peer::connect(client_read, client_write, handler))
}
}
fn server_config() -> LanguageServerConfig {
LanguageServerConfig {
name: "mock".into(),
command: "mock".into(),
args: vec![],
env: Default::default(),
requires_env: Vec::new(),
root_markers: vec!["mock.toml".into()],
require_root_marker: false,
initialization_options: None,
settings: None,
install_hint: None,
connect: None,
fallback: false,
replaces: Vec::new(),
features: Vec::new(),
code_action_kinds: Vec::new(),
max_java: None,
launch_error: None,
tsserver_project: false,
tsserver_project_extras: Default::default(),
resync_on_configuration: false,
display_name: None,
pinned: None,
}
}
fn language_config() -> LanguageConfig {
LanguageConfig {
id: LanguageId::new("mock"),
name: "Mock".into(),
extensions: vec!["mk".into()],
filenames: vec![],
first_line: None,
line_comment: None,
block_comment: None,
indent: None,
ui_mode: None,
framework_ui_modes: Vec::new(),
framework_files: Vec::new(),
formatter: None,
scratch_template: None,
rainbow_brackets: Default::default(),
tree_sitter: None,
language_servers: vec![server_config()],
debugger: None,
}
}
fn sample_text(bytes: usize) -> String {
let mut text = String::with_capacity(bytes);
let mut i = 0;
while text.len() < bytes {
text.push_str(&format!(" let value_{i} = compute({i});\n"));
i += 1;
}
text
}
fn wait_until_ready(manager: &LspManager) {
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
while manager.servers().iter().all(|server| server.status != ServerStatus::Ready) {
assert!(std::time::Instant::now() < deadline, "mock language server did not become ready");
std::thread::sleep(std::time::Duration::from_millis(10));
}
}
fn bench(c: &mut Criterion) {
let root = tempfile::tempdir().unwrap();
let registry = Arc::new(LanguageRegistry::from_configs(vec![language_config()]));
let manager = LspManager::with_launcher(
root.path().to_owned(),
registry,
Arc::new(|_: IdeEvent| {}),
Arc::new(MockLauncher::default()),
);
let text = sample_text(1 << 20);
let path: PathBuf = root.path().join("large.mk");
std::fs::write(&path, &text).unwrap();
let doc = DocId::next();
manager.did_open(doc, &path, &LanguageId::new("mock"), 1, &text);
wait_until_ready(&manager);
let changes = [AppliedChange { range: Range::new(Pos::new(0, 4), Pos::new(0, 8)), text: "same".into() }];
let mut version = 2;
c.bench_function("lsp/did_change_incremental_1mb", |b| {
b.iter(|| {
manager.did_change(doc, version, black_box(&changes), &|| unreachable!("valid incremental edit"));
version = version.wrapping_add(1);
});
});
tokio::runtime::Runtime::new().unwrap().block_on(manager.shutdown_all());
}
criterion_group! {
name = benches;
config = Criterion::default()
.sample_size(30)
.warm_up_time(std::time::Duration::from_secs(1))
.measurement_time(std::time::Duration::from_secs(3));
targets = bench
}
criterion_main!(benches);
+68 -7
Переглянути файл
@@ -79,7 +79,7 @@ use server::{Conn, Running, Server};
use std::collections::{BTreeMap, HashMap, HashSet};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Weak};
use std::sync::{Arc, OnceLock, Weak};
use std::time::Duration;
use text::{DocText, Encoding};
use types::*;
@@ -88,6 +88,21 @@ const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);
const COMPLETION_TIMEOUT: Duration = Duration::from_secs(5);
const LONG_TIMEOUT: Duration = Duration::from_secs(30);
fn did_change_content(
sync: SyncKind,
in_sync: bool,
key: u8,
events: &HashMap<u8, Vec<Value>>,
full: &OnceLock<Value>,
text: &str,
) -> Value {
if !in_sync || sync == SyncKind::Full {
full.get_or_init(|| json!([{ "text": text }])).clone()
} else {
Value::Array(events.get(&key).cloned().unwrap_or_default())
}
}
/// How long a server may take to answer `initialize`. Some import the whole
/// build there (kotlin-lsp, jdtls on a large Gradle project) and need minutes
/// on a cold start; the status shows "starting" meanwhile, and a crash still
@@ -1366,18 +1381,14 @@ impl LspManager {
tracing::warn!("lsp text copy of {} out of sync; resending full text", d.path.display());
text.set(&full_text());
}
let full = json!([{ "text": text.as_str() }]);
let full = OnceLock::new();
for (server, run, sync, enc) in targets {
let key = match enc {
Encoding::Utf8 => 8,
Encoding::Utf16 => 16,
Encoding::Utf32 => 32,
};
let content = if !in_sync || sync == SyncKind::Full {
full.clone()
} else {
Value::Array(events.get(&key).cloned().unwrap_or_default())
};
let content = did_change_content(sync, in_sync, key, &events, &full, text.as_str());
let params = json!({
"textDocument": { "uri": d.uri, "version": d.version },
"contentChanges": content,
@@ -4378,6 +4389,56 @@ mod code_action_tests {
}
}
#[cfg(test)]
mod did_change_content_tests {
use super::*;
#[test]
fn incremental_content_does_not_build_the_full_document() {
let full = OnceLock::new();
let key = 16;
let events = HashMap::from([(
key,
vec![json!({
"range": {
"start": { "line": 0, "character": 0 },
"end": { "line": 0, "character": 1 }
},
"text": "x"
})],
)]);
let content = did_change_content(SyncKind::Incremental, true, key, &events, &full, "1 MB document");
assert_eq!(content, Value::Array(events[&key].clone()));
assert!(full.get().is_none(), "incremental sync must not materialize the full document");
}
#[test]
fn full_sync_reuses_the_full_document_payload() {
let full = OnceLock::new();
let key = 16;
let events = HashMap::new();
let first = did_change_content(SyncKind::Full, true, key, &events, &full, "whole document");
let second = did_change_content(SyncKind::Full, true, key, &events, &full, "whole document");
assert_eq!(first, json!([{ "text": "whole document" }]));
assert_eq!(second, first);
assert!(full.get().is_some());
}
#[test]
fn out_of_sync_incremental_change_sends_the_full_document() {
let full = OnceLock::new();
let events = HashMap::new();
let content = did_change_content(SyncKind::Incremental, false, 16, &events, &full, "whole document");
assert_eq!(content, json!([{ "text": "whole document" }]));
}
}
#[cfg(test)]
mod external_go_routing_tests {
use super::*;
+11 -4
Переглянути файл
@@ -8,7 +8,8 @@
//! `Authorization: Bearer <token>` (random, per run); requests from another
//! `Origin` or `Host` are refused (DNS rebinding).
//! - **Projects:** the `X-OpenIDEA-Project` header or the `?project=` query
//! names a folder; the server picks the open project containing it.
//! names a folder; the server picks the open project containing it, or the
//! project the IDE serves it from without a window.
//! - **Discovery:** `<app-data>/mcp/server.json` (`address`, `port`, `token`,
//! `pid`, `version`; readable only by the user) while the server runs.
//! - **Stdio:** `<app exe> --mcp-stdio [--project <path>]` reads the discovery
@@ -60,10 +61,16 @@ pub enum ToolCallError {
/// Where the tools come from (the IDE host). Calls block; the server runs
/// them off its async threads.
pub trait ToolRegistry: Send + Sync + 'static {
/// Roots of the projects open in the IDE that the server serves.
/// Roots of the projects open in a window of the IDE that the server serves.
fn projects(&self) -> Vec<PathBuf>;
/// The tools callable for `project` (one of [`Self::projects`]). `Err`
/// says why there are none (an unsupported project).
/// The root of the project the IDE serves `path` from without a window (a background
/// project), asked when no project of [`Self::projects`] contains `path`. Opens nothing:
/// the first call for that root does.
fn resolve(&self, _path: &Path) -> Option<PathBuf> {
None
}
/// The tools callable for `project` (one of [`Self::projects`] or a root
/// [`Self::resolve`] gave). `Err` says why there are none (an unsupported project).
fn tools(&self, project: &Path) -> Result<Vec<Tool>, String>;
fn call_with_client(
&self,
+11 -7
Переглянути файл
@@ -34,7 +34,7 @@ const PARSE_ERROR: i64 = -32700;
const INVALID_REQUEST: i64 = -32600;
const METHOD_NOT_FOUND: i64 = -32601;
const INVALID_PARAMS: i64 = -32602;
/// The requested folder isn't a project open in the IDE (or has no tools there).
/// The requested folder isn't in a project the IDE serves (or has no tools there).
pub(crate) const NOT_OPEN: i64 = -32001;
pub(crate) struct RpcError {
@@ -158,15 +158,16 @@ impl Session<'_> {
let asked = params.get("protocolVersion").and_then(Value::as_str).unwrap_or(LATEST);
let version = if SUPPORTED.contains(&asked) { asked } else { LATEST };
let about = match self.project() {
Ok(root) => format!("the project open in OpenIDEA at {}", root.display()),
Err(_) => "a project open in OpenIDEA".to_owned(),
Ok(root) => format!("the project OpenIDEA serves at {}", root.display()),
Err(_) => "a project open in OpenIDEA or served in the background".to_owned(),
};
json!({
"protocolVersion": version,
"capabilities": { "tools": { "listChanged": false } },
"serverInfo": { "name": "OpenIDEA", "version": env!("CARGO_PKG_VERSION") },
"instructions": format!(
"Built-in OpenIDEA tools for {about}: they see the files and editors the IDE has open."
"Built-in OpenIDEA tools for {about}: they see the files as the IDE has them and, \
for a project open in a window, its editors."
),
})
}
@@ -205,7 +206,7 @@ impl Session<'_> {
Ok(result)
}
/// The open project the request names.
/// The project the request names.
fn project(&self) -> Result<PathBuf, RpcError> {
self.resolve_project(self.project)
}
@@ -215,11 +216,14 @@ impl Session<'_> {
roots.sort();
roots.dedup();
if let Some(requested) = requested.filter(|p| !p.trim().is_empty()) {
return resolve(&roots, Path::new(requested)).ok_or_else(|| {
let path = Path::new(requested);
// An open project wins; the registry is asked only for a folder outside all of them.
return resolve(&roots, path).or_else(|| self.registry.resolve(path)).ok_or_else(|| {
RpcError::new(
NOT_OPEN,
format!(
"this folder isn't open in OpenIDEA: {requested}. Open projects: {}",
"this folder isn't open in OpenIDEA and isn't served in the background \
(Settings › Agents › IDE MCP Server): {requested}. Open projects: {}",
roots.iter().map(|p| p.display().to_string()).collect::<Vec<_>>().join(", ")
),
)
+81
Переглянути файл
@@ -213,6 +213,87 @@ async fn folders_that_are_not_open_are_named_in_the_error() {
assert!(serde_json::from_str::<Value>(&body).unwrap()["result"]["tools"].is_array());
}
/// One project open in a window and, optionally, one folder served without a window.
struct WithBackground {
open: PathBuf,
background: Option<PathBuf>,
}
impl ToolRegistry for WithBackground {
fn projects(&self) -> Vec<PathBuf> {
vec![self.open.clone()]
}
fn resolve(&self, path: &Path) -> Option<PathBuf> {
self.background.clone().filter(|root| path.starts_with(root))
}
fn tools(&self, project: &Path) -> Result<Vec<Tool>, String> {
Ok(vec![Tool {
name: "where".into(),
description: format!("Names {}", project.display()),
input_schema: json!({ "type": "object" }),
read_only: true,
destructive: false,
output_schema: None,
}])
}
fn call(&self, project: &Path, _: &str, _: &str, _: ide_mcp::CancellationToken) -> Result<String, ToolCallError> {
Ok(json!({"project":project}).to_string())
}
}
/// The server over [`WithBackground`]; the folder `inventory` next to the open project.
fn setup_with_background(served: bool) -> (Setup, PathBuf) {
let mut s = setup();
s.server.take().unwrap().stop();
let inventory = s.project.parent().unwrap().join("inventory");
std::fs::create_dir_all(inventory.join("src")).unwrap();
let registry = WithBackground { open: s.project.clone(), background: served.then(|| inventory.clone()) };
s.server = Some(McpServer::start(Arc::new(registry), None, &tokio::runtime::Handle::current()).unwrap());
(s, inventory)
}
async fn rpc_for(s: &Setup, folder: &Path, method: &str, params: Value) -> Value {
let project = format!("X-OpenIDEA-Project: {}", folder.display());
let body = json!({ "jsonrpc": "2.0", "id": 7, "method": method, "params": params });
let (status, body) = post(s, "/mcp", &[&bearer(s), &project], &body).await;
assert_eq!(status, 200, "{body}");
serde_json::from_str(&body).unwrap()
}
#[tokio::test(flavor = "multi_thread")]
async fn a_folder_served_in_the_background_answers_initialize_list_and_call() {
let (s, inventory) = setup_with_background(true);
let inside = inventory.join("src");
let init = rpc_for(&s, &inside, "initialize", json!({})).await;
let instructions = init["result"]["instructions"].as_str().unwrap();
assert!(instructions.contains(inventory.to_str().unwrap()), "{instructions}");
let list = rpc_for(&s, &inside, "tools/list", json!({})).await;
assert_eq!(list["result"]["tools"][0]["description"], format!("Names {}", inventory.display()), "{list}");
let call = rpc_for(&s, &inside, "tools/call", json!({ "name": "where" })).await;
assert_eq!(call["result"]["structuredContent"]["project"], json!(inventory), "{call}");
// The argument names it as well, whatever project the header is for.
let routed = rpc(&s, "tools/call", json!({ "name": "where", "arguments": { "projectPath": inside } })).await;
assert_eq!(routed["result"]["structuredContent"]["project"], json!(inventory), "{routed}");
// A folder inside the open project stays with that project.
let open = rpc(&s, "tools/call", json!({ "name": "where" })).await;
assert_eq!(open["result"]["structuredContent"]["project"], json!(s.project), "{open}");
}
#[tokio::test(flavor = "multi_thread")]
async fn a_folder_that_is_neither_open_nor_served_in_the_background_says_where_to_turn_it_on() {
let (s, inventory) = setup_with_background(false);
for (method, params) in [("tools/list", json!({})), ("tools/call", json!({ "name": "where" }))] {
let reply = rpc_for(&s, &inventory, method, params).await;
assert_eq!(reply["error"]["code"], -32001, "{method}: {reply}");
let message = reply["error"]["message"].as_str().unwrap();
assert!(message.contains("isn't open in OpenIDEA and isn't served in the background"), "{message}");
assert!(message.contains("Settings › Agents › IDE MCP Server"), "{message}");
assert!(message.contains(inventory.to_str().unwrap()) && message.contains(s.project.to_str().unwrap()));
}
let init = rpc_for(&s, &inventory, "initialize", json!({})).await;
assert!(init["result"]["instructions"].is_string(), "initialize answers without a project: {init}");
}
#[tokio::test(flavor = "multi_thread")]
async fn the_discovery_file_lives_while_the_server_runs() {
let mut s = setup();
+16
Переглянути файл
@@ -100,6 +100,22 @@ pub struct GutterAction {
pub command: String,
pub argument: Option<String>,
}
/// An action rendered at the left edge of a line and revealed by hover.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct HoverAction {
/// The line the button is drawn on; normally the declaration line.
pub line: u32,
/// First line whose leftmost strip reveals this action, inclusive.
pub start_line: u32,
/// Last line whose leftmost strip reveals this action, inclusive.
pub end_line: u32,
pub icon: Option<String>,
pub label: String,
pub tooltip: Option<String>,
pub command: String,
pub argument: Option<String>,
}
/// Injection data.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
+49 -1
Переглянути файл
@@ -16,6 +16,7 @@ use crate::types::{
FieldValue, ServiceLog, ServiceLogToggle, ServicePane, ServiceTab, TableSort, View, ViewBody, ViewButton,
ViewEvent, ViewField, ViewListItem, ViewTable, ViewTreeItem, Viewport,
};
use crate::wit_host::hover_actions_bindings::exports::openidea::plugin::hover_actions as wit_hia;
use crate::wit_host::injections_bindings::exports::openidea::plugin::injections as wit_inj;
use crate::wit_host::language_features_bindings::exports::openidea::plugin::language_features as wit_lf;
use crate::wit_host::run_target_validation_bindings::exports::openidea::plugin::run_target_validation as wit_rtv;
@@ -57,7 +58,7 @@ use views_bindings::exports::openidea::plugin::view_provider as wit_view;
use views_bindings::openidea::plugin::view_types as wit_vt;
/// The API version of the world above, `major.minor` of [`host_api`].
pub const API_VERSION: &str = "1.13";
pub const API_VERSION: &str = "1.14";
const EPOCH_TICK: Duration = Duration::from_millis(10);
pub(crate) const MAX_TEXT: usize = 1 << 20;
/// The most text, and the most PNG bytes, `ui.read-clipboard` returns.
@@ -387,6 +388,11 @@ pub trait HostApi: Send + Sync {
}
/// Sets (`Some`) or removes the plugin's status bar item `id`.
fn status_item(&self, id: &str, item: Option<StatusItem>);
/// Checks a status item menu before it is set: its actions name commands the plugin declares.
fn check_status_menu(&self, menu: &[crate::StatusMenuEntry]) -> Result<(), HostError> {
let _ = menu;
Ok(())
}
/// Sets or removes the status override in the invoking window.
fn window_status_item(&self, client: &str, id: &str, item: Option<StatusItem>) -> Result<(), HostError> {
let _ = (client, id, item);
@@ -1049,6 +1055,7 @@ struct Exports {
inlay: Option<wit_inlay::Guest>,
endpoints: Option<wit_endpoints::Guest>,
search: Option<wit_search::Guest>,
hover_actions: Option<wit_hia::Guest>,
run_configurations: Option<wit_configs::Guest>,
launch_configurations: Option<wit_launch::Guest>,
test_results: Option<wit_tests::Guest>,
@@ -1190,6 +1197,7 @@ impl Runtime {
let inlay_indices = wit_inlay::GuestIndices::new(&pre).ok();
let endpoint_indices = wit_endpoints::GuestIndices::new(&pre).ok();
let search_indices = wit_search::GuestIndices::new(&pre).ok();
let hover_actions_indices = wit_hia::GuestIndices::new(&pre).ok();
let configs_indices = wit_configs::GuestIndices::new(&pre).ok();
let launch_indices = wit_launch::GuestIndices::new(&pre).ok();
let tests_indices = wit_tests::GuestIndices::new(&pre).ok();
@@ -1255,6 +1263,8 @@ impl Runtime {
None => None,
};
let search = search_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
let hover_actions =
hover_actions_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
let endpoints = match endpoint_indices {
Some(indices) => Some(indices.load(&mut store, &instance).map_err(api_hint)?),
None => None,
@@ -1278,6 +1288,7 @@ impl Runtime {
inlay,
endpoints,
search,
hover_actions,
run_configurations,
launch_configurations,
test_results,
@@ -2616,6 +2627,19 @@ fn gutter_action_from(v: wit_lf::GutterAction) -> crate::language_features::Gutt
argument: v.argument.map(|v| crate::runtime::clip(v, 65536)),
}
}
fn hover_action_from(v: wit_hia::HoverAction) -> crate::language_features::HoverAction {
crate::language_features::HoverAction {
line: v.line,
start_line: v.start_line,
end_line: v.end_line,
icon: v.icon.map(|v| crate::runtime::clip(v, 65536)),
label: crate::runtime::clip(v.label, 65536),
tooltip: v.tooltip.map(|v| crate::runtime::clip(v, 65536)),
command: crate::runtime::clip(v.command, 65536),
argument: v.argument.map(|v| crate::runtime::clip(v, 65536)),
}
}
fn parameter_label_from(v: wit_lf::ParameterLabel) -> crate::language_features::ParameterLabel {
use crate::language_features::ParameterLabel as P;
match v {
@@ -2844,6 +2868,30 @@ impl Runtime {
let result = self.language_feature_call(timeout, |p, s| p.call_gutter_actions(s, &d))?;
Ok(result.into_iter().take(10000).map(gutter_action_from).collect())
}
pub fn has_hover_actions(&self) -> bool {
self.exports.hover_actions.is_some()
}
pub fn language_hover_actions(
&mut self,
doc: &ProviderDocument,
timeout: Duration,
) -> Result<Vec<crate::language_features::HoverAction>, CallError> {
if self.exports.hover_actions.is_none() {
return Err(CallError::missing_export("hover-actions"));
}
let d = wit_hia::Document {
path: to_ipc(&doc.path),
language: doc.language.clone(),
version: doc.version,
text: doc.text.clone(),
};
let result = self.call(Invocation::default(), timeout, |exports, store| {
exports.hover_actions.as_ref().expect("checked").call_hover_actions(store, &d)
})?;
Ok(result.into_iter().take(10_000).map(hover_action_from).collect())
}
pub fn provide_injections(
&mut self,
doc: &ProviderDocument,
+22
Переглянути файл
@@ -70,6 +70,28 @@ pub struct StatusItem {
pub tooltip: Option<String>,
/// One of the plugin's commands, run on click.
pub command: Option<String>,
/// Opened on click instead of running `command` when not empty (API 1.14).
#[serde(default, skip_serializing_if = "Vec::is_empty")]
#[specta(optional)]
pub menu: Vec<StatusMenuEntry>,
}
/// An entry of a plugin status bar item's menu (API 1.14, `ui.set-status-item-menu`).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase")]
pub enum StatusMenuEntry {
/// Runs one of the plugin's commands with `argument`.
#[serde(rename_all = "camelCase")]
Action {
label: String,
description: Option<String>,
command: String,
argument: Option<String>,
},
Separator,
Header {
label: String,
},
}
/// A plugin's highlight rule for Run and Debug console output (API 1.12, `ui.set-console-rules`).
+130
Переглянути файл
@@ -72,6 +72,46 @@ pub(crate) mod syntax_bindings {
});
}
/// The optional `hover-actions` export, bound on its own when present.
pub(crate) mod hover_actions_bindings {
wasmtime::component::bindgen!({
world: "plugin-hover-actions",
path: "../../wit",
imports: { default: trappable },
with: {
"openidea:plugin/types": super::bindings::openidea::plugin::types,
"openidea:plugin/log": super::bindings::openidea::plugin::log,
"openidea:plugin/ui": super::bindings::openidea::plugin::ui,
"openidea:plugin/storage": super::bindings::openidea::plugin::storage,
"openidea:plugin/workspace": super::bindings::openidea::plugin::workspace,
"openidea:plugin/editor": super::bindings::openidea::plugin::editor,
"openidea:plugin/decorations": super::bindings::openidea::plugin::decorations,
"openidea:plugin/invocation": super::bindings::openidea::plugin::invocation,
"openidea:plugin/vcs": super::bindings::openidea::plugin::vcs,
"openidea:plugin/build": super::bindings::openidea::plugin::build,
"openidea:plugin/commit": super::bindings::openidea::plugin::commit,
"openidea:plugin/events": super::bindings::openidea::plugin::events,
"openidea:plugin/tasks": super::bindings::openidea::plugin::tasks,
"openidea:plugin/diagnostics": super::bindings::openidea::plugin::diagnostics,
"openidea:plugin/net": super::bindings::openidea::plugin::net,
"openidea:plugin/secrets": super::bindings::openidea::plugin::secrets,
"openidea:plugin/run": super::bindings::openidea::plugin::run,
"openidea:plugin/process": super::bindings::openidea::plugin::process,
"openidea:plugin/output": super::bindings::openidea::plugin::output,
"openidea:plugin/auth": super::bindings::openidea::plugin::auth,
"openidea:plugin/command-runner": super::bindings::openidea::plugin::command_runner,
"openidea:plugin/language-servers": super::bindings::openidea::plugin::language_servers,
"openidea:plugin/ipc": super::bindings::openidea::plugin::ipc,
"openidea:plugin/fs": super::bindings::openidea::plugin::fs,
"openidea:plugin/views": super::bindings::openidea::plugin::views,
"openidea:plugin/settings": super::bindings::openidea::plugin::settings,
"openidea:plugin/database": super::bindings::openidea::plugin::database,
"openidea:plugin/mcp": super::bindings::openidea::plugin::mcp,
"openidea:plugin/extensions": super::bindings::openidea::plugin::extensions,
},
});
}
/// The optional `providers` export.
pub(crate) mod providers_bindings {
wasmtime::component::bindgen!({
@@ -387,6 +427,22 @@ impl StoreData {
self.ask(Prompt::QuickPick { title: clip(title, MAX_TITLE), items, multiple })
}
/// A status item with its checked menu (`ui.set-status-item-menu`).
fn status_item_with_menu(
&self,
item: ui::StatusItem,
menu: Vec<ui::StatusMenuEntry>,
) -> Result<StatusItem, wit::Error> {
let menu = status_menu(menu)?;
self.host.check_status_menu(&menu).map_err(to_wit)?;
Ok(StatusItem {
text: clip(item.text, MAX_STATUS_TEXT),
tooltip: item.tooltip.map(|t| clip(t, 1024)),
command: item.command.map(|c| clip(c, 128)),
menu,
})
}
fn require_window(&self) -> Result<(), wit::Error> {
self.require_interactive()?;
if self.invocation.client.is_none() {
@@ -404,6 +460,47 @@ impl StoreData {
}
}
/// Checks a status item's menu (`ui.set-status-item-menu`); the host checks that its commands are declared.
fn status_menu(entries: Vec<ui::StatusMenuEntry>) -> Result<Vec<crate::StatusMenuEntry>, wit::Error> {
const MAX_ENTRIES: usize = 64;
if entries.len() > MAX_ENTRIES {
return Err(wit::Error::Invalid(format!("a status item menu has at most {MAX_ENTRIES} entries")));
}
let line = |text: &str, what: &str| {
if text.trim().is_empty() || text.len() > 256 || text.chars().any(char::is_control) {
Err(wit::Error::Invalid(format!("invalid menu {what} {text:?}")))
} else {
Ok(())
}
};
let mut checked = Vec::with_capacity(entries.len());
for entry in entries {
checked.push(match entry {
ui::StatusMenuEntry::Action(a) => {
line(&a.label, "label")?;
if let Some(description) = &a.description {
line(description, "description")?;
}
if a.argument.as_ref().is_some_and(|arg| arg.len() > 64 << 10) {
return Err(wit::Error::Invalid("a menu argument is limited to 64 KiB".into()));
}
crate::StatusMenuEntry::Action {
label: a.label,
description: a.description,
command: a.command,
argument: a.argument,
}
}
ui::StatusMenuEntry::Separator => crate::StatusMenuEntry::Separator,
ui::StatusMenuEntry::Header(label) => {
line(&label, "header")?;
crate::StatusMenuEntry::Header { label }
}
});
}
Ok(checked)
}
/// Checks `ui.notify` buttons; the host checks that their commands are declared.
fn notification_actions(actions: Vec<ui::NotificationAction>) -> Result<Vec<crate::NotificationAction>, wit::Error> {
const MAX_ACTIONS: usize = 3;
@@ -473,6 +570,7 @@ impl ui::Host for StoreData {
text: clip(item.text, MAX_STATUS_TEXT),
tooltip: item.tooltip.map(|t| clip(t, 1024)),
command: item.command.map(|c| clip(c, 128)),
menu: Vec::new(),
};
self.host.status_item(&clip(id, 64), Some(item));
Ok(())
@@ -491,6 +589,38 @@ impl ui::Host for StoreData {
text: clip(item.text, MAX_STATUS_TEXT),
tooltip: item.tooltip.map(|t| clip(t, 1024)),
command: item.command.map(|c| clip(c, 128)),
menu: Vec::new(),
};
Ok(self
.host
.window_status_item(self.invocation.client.as_deref().expect("checked"), &clip(id, 64), Some(item))
.map_err(to_wit))
}
fn set_status_item_menu(
&mut self,
id: String,
item: ui::StatusItem,
menu: Vec<ui::StatusMenuEntry>,
) -> Fallible<()> {
let item = match self.status_item_with_menu(item, menu) {
Ok(item) => item,
Err(e) => return Ok(Err(e)),
};
self.host.status_item(&clip(id, 64), Some(item));
Ok(Ok(()))
}
fn set_window_status_item_menu(
&mut self,
id: String,
item: ui::StatusItem,
menu: Vec<ui::StatusMenuEntry>,
) -> Fallible<()> {
if let Err(e) = self.require_window() {
return Ok(Err(e));
}
let item = match self.status_item_with_menu(item, menu) {
Ok(item) => item,
Err(e) => return Ok(Err(e)),
};
Ok(self
.host
+21 -4
Переглянути файл
@@ -33,6 +33,7 @@ fn components() -> Vec<PathBuf> {
repo().join("crates/ide-plugin/tests/fixtures/diagnostics/dist/plugin.wasm"),
repo().join("crates/ide-plugin/tests/fixtures/inlay-hints/dist/plugin.wasm"),
repo().join("crates/ide-plugin/tests/fixtures/language-features/dist/plugin.wasm"),
repo().join("crates/ide-plugin/tests/fixtures/hover-actions/dist/plugin.wasm"),
repo().join("crates/ide-plugin/tests/fixtures/symbols/dist/plugin.wasm"),
repo().join("crates/ide-plugin/tests/fixtures/api14/dist/plugin.wasm"),
repo().join("crates/ide-plugin/tests/fixtures/execution/dist/plugin.wasm"),
@@ -92,7 +93,7 @@ fn the_sdk_carries_the_hosts_wit() {
#[test]
fn the_version_check_runs_compatible_components_and_explains_the_rest() {
let host = v("1.13.0");
let host = v("1.14.0");
for ok in [
"1.0.0",
"1.3.0",
@@ -106,15 +107,16 @@ fn the_version_check_runs_compatible_components_and_explains_the_rest() {
"1.11.0",
"1.12.0",
"1.13.0",
"1.14.0",
"1.0.0-rc.1",
] {
assert_eq!(check_api(&v(ok), &host), Ok(()), "{ok}");
}
let newer = check_api(&v("1.14.0"), &host).unwrap_err();
assert!(newer.contains("1.13") && newer.contains("update OpenIDEA"), "{newer}");
let newer = check_api(&v("1.15.0"), &host).unwrap_err();
assert!(newer.contains("1.15") && newer.contains("update OpenIDEA"), "{newer}");
assert!(check_api(&v("2.0.0"), &host).unwrap_err().contains("update OpenIDEA"));
let older = check_api(&v("0.2.0"), &host).unwrap_err();
assert!(older.contains("rebuild it with the 1.13 SDK"), "{older}");
assert!(older.contains("rebuild it with the 1.14 SDK"), "{older}");
// 0.x: every minor is its own API.
assert_eq!(check_api(&v("0.2.0"), &v("0.2.5")), Ok(()));
assert!(check_api(&v("0.1.0"), &v("0.2.0")).is_err());
@@ -141,6 +143,21 @@ fn shipped_components_are_built_for_this_api() {
}
}
#[test]
fn a_1_14_component_exports_the_optional_hover_actions_world() {
let engine = PluginEngine::new().unwrap();
let component =
engine.compile(&repo().join("crates/ide-plugin/tests/fixtures/hover-actions/dist/plugin.wasm")).unwrap();
let exports: Vec<String> =
component.component_type().exports(engine.engine()).map(|(name, _)| name.to_owned()).collect();
assert!(exports.iter().any(|name| name.starts_with("openidea:plugin/[email protected]")), "{exports:?}");
// A 1.13-compatible plugin that does not export the new world stays valid.
let old = engine.compile(&repo().join("plugins/official/test-runner/dist/plugin.wasm")).unwrap();
let old_exports: Vec<String> =
old.component_type().exports(engine.engine()).map(|(name, _)| name.to_owned()).collect();
assert!(!old_exports.iter().any(|name| name.starts_with("openidea:plugin/hover-actions")));
}
// --- a later host, simulated -------------------------------------------------------------
struct Data {
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
1e2844d1172750841afd4ba2a8b811522e90522588b1330474207468cbf2a3df
9ec6fcb9763867a747206b0efaf8bbeac7934a4ec0d1915623557839cf2dba5e
+8
Переглянути файл
@@ -28,6 +28,14 @@ title = "fetch"
id = "window-status"
title = "window-status"
[[contributes.commands]]
id = "menu-status"
title = "menu-status"
[[contributes.commands]]
id = "bad-menu-status"
title = "bad-menu-status"
[[contributes.commands]]
id = "remove-window-status"
title = "remove-window-status"
+12 -1
Переглянути файл
@@ -1,4 +1,4 @@
use openidea_plugin::{Error, Event, Invocation, Plugin, StatusItem, host, register_plugin};
use openidea_plugin::{Error, Event, Invocation, Plugin, StatusItem, StatusMenuEntry, host, register_plugin};
#[derive(Default)]
struct Api14;
impl Plugin for Api14 {
@@ -82,6 +82,17 @@ impl Plugin for Api14 {
}
Ok(None)
}
"menu-status" | "bad-menu-status" => {
let item = StatusItem { text: arg.into(), tooltip: None, command: None };
let command = if id == "menu-status" { "events" } else { "undeclared" };
let menu = [
StatusMenuEntry::Header("App".into()),
StatusMenuEntry::action("Open", command).with_description("https://app.test").with_argument("web"),
StatusMenuEntry::Separator,
];
host::set_status_item_menu("menu", &item, &menu)?;
Ok(None)
}
"remove-window-status" => {
host::remove_window_status_item("state")?;
Ok(None)
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
c4d00fe3170a0159e56af61fe715ffb892755cce17cdae5ecb1355fd8e90189e
2015380825fc406a6466f90658443f824ef06311894b82acae2ecc1446ff0813
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
ce791decf9a771b43872777a5c97050d9b7b48f5dd0ba0342ad0580bceb93d8c
7388e5ef7a5bff42f41ed613bfb75a8da835f93a63f8fb26358bb50b77b44c00
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
f8e768db576e717ec00696098faa3434e9cea0680a1770f303bc071206727607
aded25a93667f14a683b0bbb7547b35eed23e4971fdf2761496b09fd898b5034
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
2bd0f9e7f3ca03410389d0b125372eb322fae411272b597795cbd77ea894076d
178bba6e74a51c0911502524f253cf7148854c46883c3f7f96d2c968e70522f5
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
30dee06cb90e54e7d930996569a3d44e9c9013077c2439880f99e1c99e15cf58
786e1abf853d615bf0eab7315280b3884e4c2ff6362c23a41a917d6af4c050e9
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
63772fa0f67274c5326a162340aa773c54bd08d0233c726213feedc827bd1a6c
77a825aa6adc3aa39ee390204e1fd35a12425d0a38552f116c74497dac446046
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
910d62d7f53480961b8c25b5e8d6300bee3fc0e413f35d3b7d78d6e238c65387
352246ecdba1e3d43127c7b808a3b1cdf48cf0b4ae7d85d532ffaae734158e15
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
b05e1146eb97d5c787c826206b0d2257d1390f21a87501efa8901de3f5cb6017
da9abe9bd086f7808cc1520a592f47c843f26ecc0a5291110915467f57816dc4
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
aa14bcafa1009b014ba2ca754711fc3b19149ff05dfefddd10edb94d16551c3d
322b82aa432e072f8ae1d4345d321d227dbcb9376bd113c166b816254e7ddf13
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
3c0d0aa400e83c2f8e77fbec32277a23af290d4469d62d5c0046923ee7ae2c49
e1ff50682e4aa18ca6bb96547cdd7b2815ad700e6ecaa3aede6d9f20205d4cdb
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
a1a3f1691d6d7e837f893580f75935bf83a6c0ae9224ac832c9401885f9ef504
d3757cea9bcc8e33521c50c66b396d8ece2a90d830c2e57e651ebeb018536c62
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
97f80158eda60e5b34e4760607cfdf5c8f22debf49e438a4b3fffaf7184ad59e
409e7017849fc68bd3241bfa5357366259e1eb634fb71ef69d4b857bec0aa821
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
7eff77b3997303adab7b8ef7999b563325e333f0696c63e1a6505579a2a41070
0b217ad8f0c8f802c1d670422d9621d07553985b9852f3efb724b17688cfa3b9
+336
Переглянути файл
@@ -0,0 +1,336 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "anyhow"
version = "1.0.104"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
[[package]]
name = "bitflags"
version = "2.13.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
[[package]]
name = "equivalent"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
[[package]]
name = "foldhash"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
[[package]]
name = "hashbrown"
version = "0.17.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
dependencies = [
"foldhash",
]
[[package]]
name = "heck"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
[[package]]
name = "id-arena"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
[[package]]
name = "indexmap"
version = "2.14.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
dependencies = [
"equivalent",
"hashbrown",
"serde",
"serde_core",
]
[[package]]
name = "itoa"
version = "1.0.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3bd1574e617a9a6c1f8f8181bd7e841e1f20e4277607ef28945765188d6284d4"
[[package]]
name = "leb128fmt"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
[[package]]
name = "log"
version = "0.4.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d15f86d12da44cd8d4ec3c73984537eb7f4cadcb9776a575a0a8a05ca11005c"
[[package]]
name = "macro-string"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e7b3a5bbb2f63aaa223a671ea1bd0e7bc16bd30ce387324cf63995deaddbbd2"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "memchr"
version = "2.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
[[package]]
name = "openidea-plugin"
version = "0.1.0"
dependencies = [
"serde",
"serde_json",
"wit-bindgen",
]
[[package]]
name = "openidea-test-hover-actions"
version = "0.1.0"
dependencies = [
"openidea-plugin",
]
[[package]]
name = "prettyplease"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2bfe0f4c752e450fc2faf62654f1c134747922825d5b04ca717b8874f41a40c0"
dependencies = [
"proc-macro2",
"syn",
]
[[package]]
name = "proc-macro2"
version = "1.0.107"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quote"
version = "1.0.47"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
dependencies = [
"proc-macro2",
]
[[package]]
name = "semver"
version = "1.0.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
[[package]]
name = "serde"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
dependencies = [
"serde_core",
"serde_derive",
]
[[package]]
name = "serde_core"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "serde_json"
version = "1.0.154"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
dependencies = [
"itoa",
"memchr",
"serde",
"serde_core",
"zmij",
]
[[package]]
name = "syn"
version = "3.0.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4ae9ccbea3a7b0b09443036490c8f34a8b1b760fd345e5c0dae0aac718faea79"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "unicode-ident"
version = "1.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
[[package]]
name = "wasm-encoder"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4495a6f85dd94c411c749303efcbc5defade0b0cbdbc0541495241ab917a9b5a"
dependencies = [
"leb128fmt",
"wasmparser",
]
[[package]]
name = "wasm-metadata"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c86ff6668190d9fb70372b306b4f9fe8930f0e2f57ce72e4922bf2f117900949"
dependencies = [
"anyhow",
"indexmap",
"wasm-encoder",
"wasmparser",
]
[[package]]
name = "wasmparser"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "974d643b125b272607e2fff8012ea14a8328acd7621e4bafa7afb32500052b1b"
dependencies = [
"bitflags",
"hashbrown",
"indexmap",
"semver",
]
[[package]]
name = "wit-bindgen"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b85a987ab61d365382d25c7d47e26edd48941b3bf6e3fbf76eff918bc71dab06"
dependencies = [
"bitflags",
"wit-bindgen-rust-macro",
]
[[package]]
name = "wit-bindgen-core"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "775e122e390603abfacd548027016cd0113a6e2bf2f8ce6bdd3658b013456ea8"
dependencies = [
"anyhow",
"heck",
"wit-parser",
]
[[package]]
name = "wit-bindgen-rust"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "84e26e13b9d972026778d2ffb7985736de116026fdc8d9464f966e12df2eb240"
dependencies = [
"anyhow",
"heck",
"indexmap",
"prettyplease",
"syn",
"wasm-metadata",
"wit-bindgen-core",
"wit-component",
]
[[package]]
name = "wit-bindgen-rust-macro"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "16a008a0d6b4840677326beb4edbeb210a2f1b7d0183fb7cc33f466b90fd7fb6"
dependencies = [
"anyhow",
"macro-string",
"prettyplease",
"proc-macro2",
"quote",
"syn",
"wit-bindgen-core",
"wit-bindgen-rust",
]
[[package]]
name = "wit-component"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "078def49fdb49cab405c3006e05793b3fdaf7069126ba6b9c97d01ec8c98fe4c"
dependencies = [
"anyhow",
"bitflags",
"indexmap",
"log",
"serde",
"serde_derive",
"serde_json",
"wasm-encoder",
"wasm-metadata",
"wasmparser",
"wit-parser",
]
[[package]]
name = "wit-parser"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00f0dc051466ffe46787721fca3d088536f158ae400be044f1b1c386ba9397ad"
dependencies = [
"anyhow",
"hashbrown",
"id-arena",
"indexmap",
"log",
"semver",
"serde",
"serde_derive",
"serde_json",
"unicode-ident",
"wasmparser",
]
[[package]]
name = "zmij"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
+20
Переглянути файл
@@ -0,0 +1,20 @@
[package]
name = "openidea-test-hover-actions"
version = "0.1.0"
edition = "2024"
publish = false
[workspace]
[lib]
crate-type = ["cdylib", "rlib"]
[dependencies]
openidea-plugin = { path = "../../../../../sdk/rust/openidea-plugin" }
[profile.release]
opt-level = "s"
lto = true
strip = true
codegen-units = 1
panic = "abort"
Бінарний файл не відображається.
+1
Переглянути файл
@@ -0,0 +1 @@
8cc7d2ce4e21838f8f1b0f5bd56aea61257fe288f6b7189343ccf849a78de665
+14
Переглянути файл
@@ -0,0 +1,14 @@
id = "test.hover-actions"
name = "Hover actions fixture"
version = "0.1.0"
engines.openidea = "^1.14"
wasm = "dist/plugin.wasm"
[[contributes.providers]]
kinds = ["hover-actions"]
languages = ["plaintext", "text"]
[[contributes.commands]]
id = "run"
title = "Run hover action"
icon = "run"
+32
Переглянути файл
@@ -0,0 +1,32 @@
//! Minimal API 1.13 fixture for the optional `hover-actions` export.
use openidea_plugin::language_features::Document;
use openidea_plugin::{Error, HoverAction, HoverActions, Invocation, Plugin, register_plugin};
#[derive(Default)]
struct Fixture;
impl Plugin for Fixture {
fn run_command(&mut self, id: &str, _: &Invocation, arg: Option<&str>) -> Result<Option<String>, Error> {
match id {
"run" => Ok(arg.map(str::to_owned)),
_ => Err(Error::NotFound(id.into())),
}
}
}
impl HoverActions for Fixture {
fn hover_actions(&mut self, _: &Document) -> Vec<HoverAction> {
vec![HoverAction {
line: 0,
start_line: 0,
end_line: 2,
icon: Some("run".into()),
label: "Run hover action".into(),
tooltip: Some("Run hover action".into()),
command: "run".into(),
argument: Some("hover".into()),
}]
}
}
register_plugin!(Fixture, hover_actions);
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
507827131b48fc6c679d8c2558c2e519e03e77ebbdeaaf25d9322f36d721201e
19b8af5e283a0a6ae866538096d2fa95e51020a9fd423768224c2ae4cfcefa27
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
ba97c6ec41ee0e2996ddd1d1c9432fad2ea0afb4c237f67c2ffb61cd25b4296c
ccaa7d24825c05409dbcfe1491276b229ee6d712f2ba18556413a87d851c475c
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
2db9659a4a5fee1cf7179fc5f66ee7ea93f98fa8e844db4213be8cb280998b62
b0ae383f86a8059e0bc723ca1cd21dfa76a0faa68975a1b827b44ebe1ffad2f1
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
f6ca5c93b202794571b09d0882b6809e28cd54be61765265565e991c49f9b021
38eadb34cc096538f2b529beb07d10860323356c554dd8171ccc7ca25ebfec8e
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
ef28c6f306a3adfc7d9fc7e6ec057845b2dc159866cd07745e949436de8a2107
1c5c9a19b4dc05219b3c144b21cad6e05a98fe5c01da7c67383cc39223b6e4d8
+2 -2
Переглянути файл
@@ -1,11 +1,11 @@
id = "test.language-features"
name = "Language features fixture"
version = "0.1.0"
engines.openidea = "^1.4"
engines.openidea = "^1.14"
wasm = "dist/plugin.wasm"
[[contributes.providers]]
kinds = ["formatting", "signature-help", "document-highlights", "document-links", "code-lenses", "selection-ranges", "folding", "colors", "document-symbols", "implementation", "type-definition", "gutter-actions", "injections"]
kinds = ["formatting", "signature-help", "document-highlights", "document-links", "code-lenses", "selection-ranges", "folding", "colors", "document-symbols", "implementation", "type-definition", "gutter-actions", "hover-actions", "injections"]
languages = ["plaintext", "text", "sql"]
[[contributes.providers]]
+17 -2
Переглянути файл
@@ -1,6 +1,7 @@
use openidea_plugin::language_features::*;
use openidea_plugin::{
Diagnostic, Error, Invocation, Location, Plugin, Position, Range, Severity, TextEdit, register_plugin, text,
Diagnostic, Error, HoverAction, HoverActions, Invocation, Location, Plugin, Position, Range, Severity, TextEdit,
register_plugin, text,
};
#[derive(Default)]
struct Fixture {
@@ -102,6 +103,20 @@ impl LanguageFeatures for Fixture {
}]
}
}
impl HoverActions for Fixture {
fn hover_actions(&mut self, _: &Document) -> Vec<HoverAction> {
vec![HoverAction {
line: 0,
start_line: 0,
end_line: 2,
icon: Some("run".into()),
label: "Run fixture".into(),
tooltip: Some("Run fixture".into()),
command: "run".into(),
argument: Some("inline".into()),
}]
}
}
impl Injections for Fixture {
fn injections(&mut self, d: &Document) -> Vec<Injection> {
if d.language == "sql" {
@@ -141,4 +156,4 @@ impl openidea_plugin::diagnostics::DiagnosticsProvider for Fixture {
]
}
}
register_plugin!(Fixture, language_features, injections, providers, hover, diagnostics);
register_plugin!(Fixture, language_features, hover_actions, injections, providers, hover, diagnostics);
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
abcb633eb89a522e4659cb21770517bb51e889d55c80854d6adc55d0ba33c41b
d76fe0c659ef337ae7bb9c75ecfa5a9bcdff2eb92d487ca0df2aefa77bd21daf
Loaded 100 of 462 files, more files were not shown because too many files have changed in this diff. Show more