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

...
Автор SHA1 Повідомлення Дата
l0ng-ai 18bdd908ca Merge remote-tracking branch 'origin/main' into fix/git-log-filter-layout 2026-11-19 20:55:14 +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 a4ee6110e8 fix(vcs): fit Git Log controls in narrow panes 2026-11-19 20:03:55 +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
l0ng-ai b44393a989 feat(welcome): show project groups in the title bar's recent projects (#4485)
The title bar project popup's Recent Projects section now lists each Welcome-screen project group's name above its projects (collapsed groups included), then the ungrouped projects after a separator; a search stays a flat list. Before, recent projects were always flat, so similarly named projects were easy to mix up.
2026-11-19 18:23:12 +08:00
l0ng-ai eda632866a feat(maven): Always update snapshots setting (#4484)
Settings › Build Tools › Maven gets Always update snapshots (off by default, Global or This project). On, Maven runs, builds, goals and sync get -U and jdtls imports with java.maven.updateSnapshots, so newer SNAPSHOT dependencies are picked up from remote repositories. A configuration's own -U/--update-snapshots is kept; turning the setting off removes the -U it added.
2026-11-19 18:20:15 +08:00
HEOJUNFO 3eaaa71ae1 fix(http-client): keep a > inside an attribute value within its tag (#4470)
The HTTP Client's formatted XML/HTML response cut a tag at the first `>` even inside a quoted attribute value, splitting the value across lines, over-indenting what followed and, in HTML, dropping the space after the `>`. The tag pattern now skips "…" and '…' values; a tag with an unclosed quote still ends at the first `>`.

Co-authored-by: HEOJUNFO <[email protected]>
2026-11-19 17:58:48 +08:00
Mansur Akhmadiтаmansur-akhmadi 77503e5fee feat(run): Export Test Results to HTML or XML from the test results toolbar (#4413)
The test results toolbar and Find Action get Export Test Results…: a dialog with HTML or XML format, the output file (default "<working directory>/Test Results - <configuration>.html") and an option to open the HTML report in the browser. HTML is a self-contained report (summary, suites, per-test status, duration, output and location, no scripts); XML uses the <testrun> format with count, suite, test, output and expected/actual diff. An existing file is replaced only after confirmation. Both entry points are disabled while tests run and when there are no results.

Closes #4412

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-19 17:57:29 +08:00
l0ng-ai 8edab7b8e6 fix(vim): drop text an input method echoes after a key Vim handled (#4479)
Some macOS input methods (Doubao in its English mode) still insert a key's character after Vim handled and prevented its keydown, so Normal-mode j/k moved and typed, and i/a entered Insert mode and typed. Text input equal to the last keydown is dropped when Vim took that key outside Insert mode within 100 ms; any later keydown clears the record, so keys typed in the new Insert mode stay text.
2026-11-19 17:56:25 +08:00
l0ng-ai f8474fc2a2 feat(project-view): option to turn off horizontal scrolling (#4478)
The Project view's options menu gets Horizontal Scrolling under Appearance (on by default, as before). Turned off, long rows are clipped with an ellipsis instead of the whole tree scrolling sideways and cutting names on the left.
2026-11-19 17:56:15 +08:00
l0ng-ai 0558c1127c feat(terminal): option to use the application title as the tab name always (#4477)
Settings › Tools › Terminal gets "Use application title as tab name" (When command is running, the default; Always; Never). The title a program sets via OSC 0/2 named the tab only while a command ran, so a CLI agent's own title did not show when shell integration could not tell a command was running.
2026-11-19 17:55:24 +08:00
l0ng-ai e335e8bcf6 fix(languages): run a language server set to a .jar with java -jar (#4475)
A language server whose executable in Settings › Language Servers was a runnable jar (a locally built groovy-language-server-all.jar) was spawned as the program and never started. A .jar command now runs as java -jar <jar> <args>, on the project JDK's java when one is set, else java from PATH. Fixes #4403
2026-11-19 17:39:42 +08:00
Deng Liuтаdengliu 7e2e2e6cc9 feat(agents): colocate effort and context settings (#4382)
Effort moves into the model popup, next to context size and model settings, with the current effort shown on the model chip (Atlas · Gentle), as Codex and Copilot keep it in the model picker. Up to four levels use the segmented control, more (Codex has six) a dropdown row; the chip's effort/context detail stays visible in the narrow composer layout, where the model name truncates first.

Co-authored-by: dengliu <[email protected]>
2026-11-19 17:36:23 +08:00
Mamaev Igor de73495ab0 fix(vim): support the clipboard option and +=/-=/^= operators in .ideavimrc (#4318)
#4136 added the clipboard option with += only. The rc parser and engine now also take Vim's -= (remove an item / subtract) and ^= (prepend / multiply) for comma-list and number options, clipboard gets its cb alias, and the Vim guide documents the clipboard option.

Co-authored-by: pxc1984 <[email protected]>
2026-11-19 17:32:41 +08:00
l0ng-ai 6c848b9a43 fix(database): connect without TLS when a Prefer handshake fails (#4473)
With SSL mode Prefer, a MySQL/PostgreSQL server whose TLS handshake fails (e.g. TLS 1.0/1.1 only) failed with "received fatal alert: HandshakeFailure", since sqlx only skips TLS when the server doesn't offer it. Prefer now retries once without TLS after a failed handshake (sqlx::Error::Tls or an I/O error carrying a rustls error), as libpq's sslmode=prefer does; the pool keeps the plain options. Fixes #4447
2026-11-19 17:30:57 +08:00
l0ng-ai 4812adba97 fix(deps): update wasmtime to 49.0.6 for RUSTSEC-2026-0571/0572/0573 (#4472)
cargo deny reported three wasmtime advisories (RUSTSEC-2026-0571/0572/0573). wasmtime, wasmtime-wasi and their internal crates move from 49.0.5 to 49.0.6, the patch release with the fixes.
2026-11-19 17:28:27 +08:00
LU XIANGRUIтаwildcatDownstairs af938d0726 feat(structure): show the Flutter widget tree in the Structure view (#4433)
In Flutter projects the Structure view now shows the widget nesting inside build() (e.g. Scaffold > Column > Text 'Hello') from the Dart analysis server's dart/textDocument/publishFlutterOutline, following the Flutter plugin's former Outline window: letter badges (private widgets in pink), properties after the name, bold build methods, and Show Only Widgets in View Options. A new doc_flutter_outline command keeps doc_outline unchanged; the outline is cached per document and server and refreshed via LspRefresh. Refs #4096

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:25:21 +08:00
Moler1995 8562fadde2 fix(vim): render the command line in the editor font (#4419)
The Vim : command line and / ? prompts used codemirror-vim's inline font-family: monospace (Consolas under WebView2) instead of the editor font. The prompt panel now uses the editor's font variables, overrides the inline declaration on the wrapping span, and follows the ligatures toggle. Closes #4401

Co-authored-by: Moler1995 <[email protected]>
2026-11-19 17:24:01 +08:00
Muuтаmuutot a50813eb56 fix(editor): keep fold chip clicks working when inline blame refreshes the line (#4469)
Clicking a fold placeholder while the caret was on another line could do nothing: the mousedown started a selection that moved the caret, the inline blame refresh rebuilt the line's DOM, and the browser dropped the click on the detached chip. The chip now swallows its mousedown, so the caret stays put and the click always expands the fold.

Co-authored-by: muutot <[email protected]>
2026-11-19 17:23:54 +08:00
LU XIANGRUIтаwildcatDownstairs 282f1fd482 feat(run): import Flutter/Dart run configurations from JetBrains and VS Code (#4460)
Importing run configurations skipped every Flutter/Dart entry. JetBrains FlutterRunConfigurationType (filePath, additionalArgs, buildFlavor, envs) and VS Code dart launches (deviceId, flutterMode, toolArgs, args as --dart-entrypoint-args; plain Dart projects as dart run) now become Flutter configurations run from the owning pubspec.yaml's directory. An imported entry identical to an existing configuration is skipped with the new sameAs reason, and compounds point to the existing one.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:23:44 +08:00
LU XIANGRUIтаwildcatDownstairs 2129efd196 feat(debugger): add Flutter DevTools tool windows (#4422)
Flutter projects get four tool windows on the right, as in the Flutter plugin: Flutter Inspector (one tab per app started with Debug, selecting a widget jumps to its source), Flutter DevTools, Flutter Deep Links and Flutter DevTools Extensions. They embed one dart devtools --machine server per trusted project (stopped on close, trust revoke or quit); the VM Service URI comes from the Dart debug adapter's dart.debuggerUris. Links in embedded pages that open a new window go to the system browser. Icons from flutter-intellij (BSD-3-Clause, THIRD_PARTY_LICENSES.md). Refs #4096

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:23:30 +08:00
LU XIANGRUIтаwildcatDownstairs a4de18796b feat(run): add Flutter Hot Reload and Hot Restart buttons to the Run tool window (#4415)
Flutter apps started with Run had no hot reload control. Hot Reload and Hot Restart now follow Stop in the Run tool window for flutter run configurations in a hot-reload mode, sending r / R to flutter run's stdin (plain console and terminal emulation); disabled once the process ends. Refs #4096

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:23:12 +08:00
LU XIANGRUIтаwildcatDownstairs cbf09b8962 feat(vcs): update several selected branches at once from the Branches pane (#4457)
With several local branches selected in the Branches pane, Update Selected (context menu and toolbar) now fast-forwards each to its tracked branch and reports updated / up to date / diverged / no tracked branch / failed in one notification, as IDEA's Git.Update.Selected. The new vcs_update_branches fetches each remote once, uses merge --ff-only for the current branch and fetch . <tracked>:<branch> for others (refusing branches checked out in another worktree), and groups per repository. Branches common to several repositories also get Update in the multi-repo branch popup. Closes #4397

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:22:52 +08:00
jiejie1133таliufajie f9077a1f93 feat(vcs): open files from Commit groups with F4 (#4442)
Co-authored-by: liufajie <[email protected]>
2026-11-19 17:19:18 +08:00
LU XIANGRUIтаwildcatDownstairs 68d2370c8f fix(maven): apply offline mode to the Java language server's Maven import too (#4456)
Offline mode in the Maven tool window only added -o to sync's mvn; jdtls's m2e kept downloading. Each sync now records the offline mode (in the build cache, like profiles) and jdtls follows it via java.import.maven.offline.enabled, reconfigured when it changes; toggling offline reloads Maven. Offline sync keeps maven-dependency-plugin 3.8.1 when the local repository has it, and "No plugin found for prefix 'help'" now explains why and offers Open Maven Settings.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:07:13 +08:00
Mansur Akhmadiтаmansur-akhmadi d735a7b7ce fix(services): close a Docker connection's SSH tunnel on Disconnect and Remove (#4432)
Disconnect, Remove Connection and moving a connection to another SSH configuration left the Docker SSH tunnel and its SSH connection open until exit. The new docker_disconnect command closes the tunnel (Tunnel::close waits for the listener and forwarded connections) and then releases the SSH connection unless something else holds it; the UI waits for a snapshot in flight first, keeps it while another connected Docker connection uses the same configuration, and Connect waits for a close in progress. Closes #4431

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-19 17:06:31 +08:00
l0ng-ai 4ac0cbd908 fix(agents): run ! commands from the new task composer and complete them (#4443)
A ! line typed in the New Task composer went to the agent as a normal message. It now creates the task without starting a turn (NewAgentTask.idle) and runs the command there; the command and output go along with the first message. ! commands also complete earlier commands and paths under the task's folder (Tab accepts, Enter runs), and a command's output starts expanded.
2026-11-19 17:04:27 +08:00
Muuтаmuutot 142552741a perf(intentions): show the ⌥↵ list at once, not after the server answers (#4429)
⌥↵ opened the list only after the language server answered. It now opens after 100 ms with the rows found locally and a spinner ("Computing…" when empty), and fills in when the actions arrive; a faster answer paints once. The caret line's error quick fixes are requested in parallel with the caret's actions, a late answer doesn't reopen a dismissed list, and a stale answer after an edit is dropped.

Co-authored-by: muutot <[email protected]>
2026-11-19 17:04:09 +08:00
LU XIANGRUIтаwildcatDownstairs 685b458ad0 fix(web): keep Open in Browser for HTML files associated with another file type (#4462)
Associating .html/.htm/.xhtml/.shtml with another language (or overriding a file's type) removed Open in Browser and Open In › Browser, because they shared isHtmlPath with the preview. The browser entry points now also recognise pages by name, while the toolbar and Built-in Preview still follow File Types; .shtml is served as text/html.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:03:54 +08:00
LU XIANGRUIтаwildcatDownstairs 846794450a fix(agents): let Send to Agent reference files of non-primary workspace projects (#4459)
Send to Agent resolved paths against the primary project only, so files of other workspace projects were dropped silently. It now goes through referenceOf with the target composer's roots (the task's cwd/project, or the project picked on the New Task page), keeps folders as folder references, maps only the task's own project into a worktree, and shows the existing notice for paths outside every project. Closes #4438

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:03:44 +08:00
LU XIANGRUIтаwildcatDownstairs 5e78713188 fix(maven): give the Java language server's Maven import the same settings as mvn (#4455)
jdtls's Maven import (m2e) got different settings from the IDE's mvn: it ignored the Maven home's conf/settings.xml, lost ~/.m2/settings.xml's mirrors when only a local repository was configured, kept a settings.xml's own <localRepository> over the configured one, and dropped the configured repository from the profiles copy. m2e now gets the Maven home's global settings and user settings derived the same way mvn's are (m2e_user_settings), shared with the profiles copy.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:03:36 +08:00
LU XIANGRUIтаwildcatDownstairs 33c802c048 fix(vcs): keep the unsent commit message per project across restarts (#4454)
A half-written commit message was lost on restart: it lived only in useCommit's memory. The draft is now kept per project root in localStorage (debounced, flushed on blur/pagehide/project switch), cleared by a successful commit, and not overwritten by Amend's message or a message kept after commit. Closes #4423

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:03:20 +08:00
Qingтаqtvbwfn 1e75b7717b fix(run): run a Java class's main even when its file is named like a test (#4453)
Running the file context of a Test.java / XxxTest.kt that declares a main ran mvn test -Dtest=... instead of the program, because fileRole checked the test-name pattern before the content. A JVM file with a main is now a program first; a caret inside a @Test method still runs that test, and a test-named class without a main still runs its tests.

Co-authored-by: qtvbwfn <[email protected]>
2026-11-19 17:03:12 +08:00
Bin 28a464d3b7 fix(editor): show IDEA-style comment fold previews (#4451)
Folded block comments, Javadoc, line documentation and docstrings now show their opener, the first summary line, an ellipsis and the closer (/** Summary ...*/), as in IDEA. Backend folds of a comment now start at the comment itself, and the syntax-fold placeholder adapts when CodeMirror leaves /* and */ outside the range.

Co-authored-by: ffgenius <[email protected]>
2026-11-19 17:03:04 +08:00
LU XIANGRUIтаwildcatDownstairs 0b9048ce02 fix(build): start mvnw / gradlew without the execute bit through sh (#4444)
On macOS/Linux a mvnw / gradlew without the execute bit (committed from Windows, unpacked from a zip) failed with Permission denied in sync and runs. A #! script without the execute bit is now started as /bin/sh <script> in ide-build's process runner and ide-run's process start; the file mode is left alone and the console still shows ./mvnw. Other non-executable files are left to fail as before.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:02:49 +08:00
J 1996таjameingh 4567540b95 fix(vcs): retry an index git could not replace while it is open (#4418)
After a partial commit, aligning the real index with `git reset` could fail on Windows with "fatal: Could not write new index file." while the status scan still had .git/index open; only the index.lock conflict was retried, so the Changes view kept listing committed files as staged. That failure is now retried for reset, add and rm --cached (not switch or plain rm).

Co-authored-by: jameingh <[email protected]>
2026-11-19 17:02:42 +08:00
LU XIANGRUIтаwildcatDownstairs 3a0288111d fix(run): keep the Stop button red while a process is stopping (#4411)
While stopping, the title bar's Stop button switched to the warning background and the spinner took --fg-muted, so it read as a warning and the spinner was barely visible. It now keeps Stop's red background and the spinner uses --bg-elev.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:02:33 +08:00
l0ng-ai a83fc0f3d1 fix(editor): keep line-end annotations past the code with wrapped-part indent (#4463)
With soft wrap and "Use original line's indent for wrapped parts", an indented
line carries a negative text-indent. Inline widgets inherited it, so the inline
blame (and other line-end hints drawn in a block box) started that many columns
to the left, over the code. Widgets now reset text-indent.
2026-11-19 15:49:10 +08:00
l0ng-ai 1a12c88f0c fix(build): give the type check in pnpm build a 4 GB heap (#4448)
tsc --noEmit now peaks at about 2.8 GB, past Node's default heap on the 7 GB macOS runners, so the macOS release builds died with "JavaScript heap out of memory" in beforeBuildCommand.
2026-11-19 14:48:55 +08:00
l0ng-ai 6400206a94 chore: v0.1.49 2026-11-19 14:07:24 +08:00
l0ng-ai 49d8e1bc71 test: fix main CI failures on Windows and slow runners (#4437)
Windows: compare the java-analyzer jdkHome with dunce::canonicalize (std adds the \\?\ prefix). macOS: wait for the hard-deadline interruption instead of a fixed sleep. Ubuntu: give a reclaimed plugin instance room to restart within the run-target validation timeout.
2026-11-19 13:36:34 +08:00
l0ng-ai 8a56c204f4 fix(editor): drop kept unsaved files when the project closes (#4435)
With autosave off, a modified file whose last tab closed stayed in the document manager across Close Project / project switch, so after Don't Save the reopened project reused the stale model: it showed the discarded text and the close prompt counted it again. A project change now drops every model except untitled buffers.
2026-11-19 13:00:30 +08:00
l0ng-ai 5bf4d4bb15 fix(search): Delete in Recent Files and Recent Locations edits the filter first (#4434)
Delete in the filter field always removed the selected entry, so a typed filter couldn't be edited with forward-delete. It now edits the filter while there is a selection or text after the caret, and removes the entry otherwise.
2026-11-19 13:00:21 +08:00
l0ng-ai 84dcd99f7b revert: start Python debuggees in the internal console on Windows (#4404) (#4430)
#4404 assumed 0.1.48 already had #4185 (ConPTY cursor position answer)
and still failed on Windows. It doesn't: #4185 merged after the 0.1.48
release, so the reports on 0.1.48 say nothing about it. Python debugging
on Windows goes back to runInTerminal with #4185, which keeps input()
working in the debug console.
2026-11-19 12:10:43 +08:00
l0ng-ai ea8351d9f6 feat(java): add java-analyzer as a Java language server (#4420)
java-analyzer joins jdtls and kmp-lsp as a fallback Java language server
(jdtls → java-analyzer → kmp-lsp), so it can be chosen with "Use only
java-analyzer" in Settings › Language Servers. It installs from the GitHub
releases of l0ng-ai/java-analyzer (gzip binaries on macOS and Linux, zip on
Windows).

The project JDK and the Maven local repository, when set, are passed as
`jdkHome` and `maven.localRepository`; otherwise the server finds them
itself, and the server's own `initializationOptions` in settings win.

A built-in server given an executable path in Settings › Language Servers
now reports that executable as its custom path in the tools list, matching
the program that is actually launched.
2026-11-19 11:40:53 +08:00
l0ng-ai aab6d9ffdc feat(services): connect and disconnect Docker connections (#4425)
A Docker connection could only be removed. While the Services tree is
shown, every connection keeps an event stream and a 10 s poll going,
which for a remote daemon means SSH sessions. A connection's context
menu now has Disconnect (and Connect), also as the actions
docker.disconnect / docker.connect: a disconnected connection stops its
events and polling, shows "disconnected" in the tree and a Connect
button in the detail pane, until Connect or the next session.

Closes #4394
2026-11-19 11:36:24 +08:00
l0ng-ai 72f286d619 fix(debugger): don't wait forever for a killed program on Windows (#4407)
Stopping a launch waits for the program to exit and kills it after 10 s.
On Windows the wait had no end after the kill: while any process of the
launch still looked alive, Stop stayed on "Waiting for the process to
exit" and Kill Process could not end it. Like on Unix, the stop now gives
up 5 s after the kill (termination is asynchronous there) and logs it.

Fixes #4280
2026-11-19 11:25:14 +08:00
l0ng-ai ecb0631b89 fix(debugger): start Python debuggees in the internal console on Windows (#4404)
Since debugpy runs the program through runInTerminal, debugging Python on
Windows hangs or ends with "Timed out waiting for launcher to connect":
the launcher on the ConPTY never connects back, even with the terminal's
cursor query answered. On Windows the debug launch now asks debugpy to
start the program itself (internalConsole), which reporters confirmed
works. The program can't read typed input there.

Fixes #4224
2026-11-19 11:25:08 +08:00
l0ng-ai f26d3e2612 fix(run): run Dart test files with flutter test / dart test (#4416)
A *_test.dart file ran with `dart run`, which can't load Flutter code
(dart:ui) and doesn't run package:test suites as tests. In a Flutter app
it now runs with `flutter test <file>` from the app's folder, elsewhere
with `dart test <file>`.
2026-11-19 11:17:09 +08:00
l0ng-ai e36cd37e56 fix(run): run a Flutter app's Dart files with flutter run (#4409)
Current File (and Run on a Dart file) ran `dart run <file>` even inside a
Flutter app, which can't start a Flutter program. In a folder with a
detected Flutter configuration the file now runs and debugs as the app,
`flutter run -t <file>` from the app's folder, on the toolbar's device.
Dart files outside a Flutter app keep `dart run`.
2026-11-19 11:01:17 +08:00
l0ng-ai 0f652824b3 fix(database): don't leave the tree loading after a disconnect or rename (#4406)
Disconnecting a data source (Deactivate, or Auto-disconnect when idle)
forgets what it loaded, but its expanded tree nodes stayed expanded and
showed Loading until collapsed by hand, since only expanding a node loads
its children. A disconnect now also collapses the nodes of what it
forgot: the source with all its databases, or one database. Renaming a
source dropped its metadata the same way; it now saves like any edit,
which reloads what the tree had expanded.

Fixes #4388
2026-11-19 10:51:01 +08:00
l0ng-ai 10aa367df3 feat(vcs): add File › New › Project from Version Control (#4398)
The clone dialog was only reachable from the Git menu and the welcome
screen. File › New now lists it too, as its own action
(vcs.cloneProject) since a menu bar holds each action id once.

Closes #4100
2026-11-19 10:35:19 +08:00
LU XIANGRUIтаwildcatDownstairs 9622bff6bd feat(run): add a Flutter device selector (#4393)
Flutter projects get a device selector next to the run configuration. A new ide-flutter crate keeps one `flutter daemon` per project for the device list (restartable from the menu); on Unix a watchdog ends the daemon when the IDE exits. Detected Flutter apps get a `flutter run -t lib/main.dart` configuration and a Flutter run type, and Run/Debug pass `-d <id>` for the selected device, or for the device a configuration pins.

Refs #4096

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 10:29:15 +08:00
LU XIANGRUIтаwildcatDownstairs ad1621dee6 feat(debugger): hot reload Flutter apps on save (#4392)
While a Flutter debug session runs, saving a Dart file of its package (or a package it depends on, from .dart_tool/package_config.json) hot reloads the app, on by default and switchable under Settings › Build, Execution, Deployment › Debugger › Flutter. Flutter sessions are recognised by the flutter.appStarted event; saves are debounced (300 ms) so Save All reloads once; files with Dart errors skip the reload until fixed; saves during a pause reload on resume; failures go to the Debug console. hotReload now passes a reason (save / manual).

Refs #4096

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 10:18:57 +08:00
Vladislav Kuzmin 450c78b90d feat(database): support custom JDBC driver profiles (#4331)
A Custom JDBC driver connects any database that ships a JDBC driver. Driver profiles (driver and dependency JARs, driver class detected from the JARs, URL template with {host}/{port}/{database}/{file} fields) are stored locally and shared by all projects; project files can't start a driver until the user approves the source. Queries run through a bundled Java 17 bridge (java/jdbc-bridge, reproducible from source) found with the existing JDK discovery. Options › Read-only calls Connection.setReadOnly(true) and the IDE rejects table edits; Cancel calls Statement.cancel() and keeps the session, with a three-second fallback that reconnects. Transactions, Explain Plan and grid edits are off for JDBC sources.

Co-authored-by: principalwater <[email protected]>
2026-11-19 09:13:12 +08:00
Deng Liuтаdengliu 62058d5932 feat(mcp): support the built-in IDE MCP server in remote development (#4380)
In remote development (SSH, WSL, Dev Containers) the built-in IDE MCP server ran only in the desktop
shell: openidea-server never started it or answered --mcp-stdio, MCP status and confirmation commands
ran locally, and the Settings window showed the desktop's mcpServer settings for a remote window.

McpService and the MCP commands move into ide-host, so openidea-server runs its own MCP server per
host with a stable ~/.openidea/bin/openidea-server --mcp-stdio bridge. mcpServer.* settings of a
remote window apply to the remote host only. Remote MCP confirmation requests show only when this
machine trusts the remote project, and their answers route back to the server. Several servers sharing
one data directory (several remote windows on a host) each record a discovery entry; the stdio bridge
picks the one that has the project open by probing tools/list, and a server leaving promotes a live one.

Review follow-ups: the bridge no longer matches the initialize instructions text, a starting server
drops entries of servers that stopped listening, the stdio link is written only when the MCP server
starts, the MCP settings page reloads its status after Apply (a remote server's settings events reach
the project window only), and the unused process-wide MCP executable in ide-agent is gone.

Co-authored-by: dengliu <[email protected]>
2026-11-19 09:01:27 +08:00
Mansur Akhmadiтаmansur-akhmadi f0c383fc6d feat(go): add a Format with gofumpt setting for gopls (#4390)
Settings › Languages & Frameworks › Go gets a Formatting section with a Format with gofumpt checkbox (languages.go.gofumpt, off by default, global or per project). On sends gopls gofumpt: true; off sends an explicit false (gopls keeps omitted keys on reconfiguration) unless a value is already set for gopls in the language definition or in Settings › Language Servers. The explicit-default fill now also reads the Language Servers initializationOptions, so buildFlags / env given there are no longer shadowed either.

Closes #4389

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-19 09:01:01 +08:00
xiaohuiduanтаxiaohuiduan 4766a4bdef feat(tools): optional GitHub mirror prefix for tool downloads (#4038)
Adds Settings › Tools › Download Mirrors with a mirror prefix for GitHub downloads (empty by default, so nothing changes unless it is set). With a prefix such as https://gh-proxy.com/, tool and language server assets from github.com are fetched through it first and fall back to the official host on failure. Eclipse, Open VSX, Maven Central and authenticated hosts are never mirrored.

Checksums are always read from the official release data or .sha256 file, never through the mirror; a mirrored file that fails the check, or that has no published checksum at all, is discarded and the official host is used instead. The remote development server always downloads from its own release.

Closes #3295

Co-authored-by: xiaohuiduan <[email protected]>
2026-11-19 08:59:42 +08:00
l0ng-ai 44e7508af3 ci: add an always-reporting Rust checks job for the ruleset to require (#4391)
A skipped matrix job reports under its unexpanded name, so the per-OS Rust checks never appear on frontend-only PRs and requiring them blocked those PRs. The new job passes when the Rust matrix succeeded or was skipped.
2026-11-19 08:50:39 +08:00
Mansur Akhmadiтаmansur-akhmadi 42b99b9df7 feat(go): go from a go.mod dependency to its folder under External Libraries (#4379)
⌘-click / ⌘B on the module path of a require entry (single line or block, quoted or not) or the replaced module of a replace entry in go.mod selects that module's folder under External Libraries › Go Modules: the module cache folder (path@version) or vendor/<path>. Modules that aren't downloaded, versions, comments and other directives fall through to gopls as before.

Closes #4378

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-19 08:50:09 +08:00
l0ng-ai 72c84b9131 ci: run CI in the merge queue and let main's runs finish (#4387)
Adds the merge_group trigger so the merge queue's required Rust checks report, and cancels superseded runs only for pull requests: main's runs used to be cancelled by the next merge, so a broken main went unnoticed.
2026-11-19 08:45:30 +08:00
l0ng-ai 3de33f21d3 fix(editor): keep preview layouts per editor tab, not per file (#4386)
Split panes of one file shared their Markdown layout because the mode was stored per path. The HTML Built-in Preview toggle and plugin side-by-side editors had the same per-path state. All three are now kept per editor tab; a new Markdown tab still starts in the last layout chosen, and shown tabs keep theirs when another tab switches.

Fixes #4377
2026-11-19 08:43:20 +08:00
Gabriel Gondim 4e8a392fed feat(editor): Open in New Window uses a lightweight editor window (#4368)
Open in New Window on a project file's tab now opens an editor-only window (editor-<parent>-n) instead of a second project workbench. It shares the parent's documents and language servers; unsaved text, caret and selection move with the tab, and the source tab is removed only after the new window reports ready. Files outside the project keep opening a full window.

Review changes: closing the window settles only its own unsaved files (the project window's guard also asked to terminate running processes); Escape no longer closes it; error messages go through the text catalog; the window has its own stylesheet.

Closes #4117

Co-authored-by: GGVidal <[email protected]>
2026-11-19 08:36:35 +08:00
l0ng-ai 7c3b40b1c4 ci: find closed PRs' runs without the API status filter (#4384)
The status filter of the workflow-runs API lags behind newly created runs, so the first run found nothing to cancel while the PR's CI was still in progress. List the branch's runs and skip completed ones instead.
2026-11-19 08:29:15 +08:00
l0ng-ai 38279f3c29 ci: cancel a pull request's remaining runs when it is closed or merged (#4383)
Runs of merged or closed PRs kept holding runners while other PRs' checks sat queued for hours. cancel-on-close.yml runs on pull_request_target closed (covering forks), never checks out PR code, and cancels the unfinished pull_request / pull_request_target runs of the PR's head branch from its head repository. Permissions: actions: write.

Closes #4362
2026-11-19 08:26:11 +08:00
498 змінених файлів з 21991 додано та 2661 видалено

No files matched your search

+41
Переглянути файл
@@ -0,0 +1,41 @@
name: Cancel runs of closed PRs
on:
# pull_request_target so it also runs for PRs from forks. It never checks out or
# runs PR code: it only lists and cancels workflow runs of the closed PR's branch.
pull_request_target:
types: [closed]
permissions:
actions: write
jobs:
cancel:
runs-on: ubuntu-latest
steps:
- uses: actions/github-script@v8
with:
script: |
// A merged or closed PR's remaining CI only holds runners other PRs wait for.
const pr = context.payload.pull_request;
const { owner, repo } = context.repo;
const headRepo = pr.head.repo?.full_name;
// The API's status filter lags behind new runs: list the branch and check each one.
const runs = await github.paginate(github.rest.actions.listWorkflowRunsForRepo, {
owner,
repo,
branch: pr.head.ref,
per_page: 100,
});
let cancelled = 0;
for (const run of runs) {
if (run.id === context.runId || run.status === 'completed') continue;
if (run.head_repository?.full_name !== headRepo) continue;
if (!['pull_request', 'pull_request_target'].includes(run.event)) continue;
try {
await github.rest.actions.cancelWorkflowRun({ owner, repo, run_id: run.id });
cancelled++;
} catch (e) {
core.warning(`run ${run.id}: ${e.message}`);
}
}
core.info(`Cancelled ${cancelled} run(s) of #${pr.number}`);
+21 -3
Переглянути файл
@@ -5,6 +5,7 @@ on:
pull_request:
branches: [main]
types: [opened, synchronize, reopened]
merge_group:
workflow_dispatch:
permissions:
@@ -12,8 +13,9 @@ permissions:
concurrency:
group: ci-${{ github.ref }}
# A newer push supersedes the run in progress, on main too.
cancel-in-progress: true
# A newer push supersedes a pull request's run in progress. Runs on main and in the merge
# queue finish, so a broken main shows up and the queue's required checks report.
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
env:
CARGO_TERM_COLOR: always
@@ -23,7 +25,7 @@ env:
jobs:
# Which parts a pull request touches, so jobs it can't affect skip and leave the
# shared runners to others. Pushes and manual runs always run everything.
# shared runners to others. Pushes, the merge queue and manual runs always run everything.
changes:
name: Changes
runs-on: ubuntu-latest
@@ -140,6 +142,22 @@ jobs:
if: runner.os == 'Linux'
run: git diff --exit-code src/bindings.ts src-tauri/tests/commands.snap
# One check that always reports, for the ruleset to require: a skipped matrix job reports
# under its unexpanded name, so the per-OS checks never appear on frontend-only PRs.
rust-checks:
name: Rust checks
needs: [changes, rust]
if: always()
runs-on: ubuntu-latest
timeout-minutes: 5
steps:
- env:
CHANGES: ${{ needs.changes.result }}
RUST: ${{ needs.rust.result }}
run: |
echo "changes: $CHANGES, rust: $RUST"
[ "$CHANGES" = success ] && { [ "$RUST" = success ] || [ "$RUST" = skipped ]; }
# The remote development server ships as a static Linux binary (release-build.yml):
# keep that build working.
server:
Створено
+119 -105
Переглянути файл
@@ -1203,27 +1203,27 @@ dependencies = [
[[package]]
name = "cranelift-assembler-x64"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "249a61efca6a54425e027f5704a6f68a0232b4df527e05a3ef947d89dbdcb078"
checksum = "aecefa88696b62f833cc0c997d19c93246b0268e2aaf23e0e8692e527f6de088"
dependencies = [
"cranelift-assembler-x64-meta",
]
[[package]]
name = "cranelift-assembler-x64-meta"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d5336a46e05db2d515440b1ce8a9363e7bc04b608c0f66cc98dddc5492a66fbf"
checksum = "1391a2546f5edf06a0ff5e9430d73c2713fd536aefec53200dc21846d1467f53"
dependencies = [
"cranelift-srcgen",
]
[[package]]
name = "cranelift-bforest"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "01b3675b13214270fddbd257d5fbf4109be8b02d92fc636fe96e2829514a7235"
checksum = "9528915fbc2c950702329e08c6d72aaff8ece9b7ecdbd225742825c09a445227"
dependencies = [
"cranelift-entity",
"wasmtime-internal-core",
@@ -1231,9 +1231,9 @@ dependencies = [
[[package]]
name = "cranelift-bitset"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d7c1d67aa02b6e174bd2b165c113e94af9498fcc20e2892d0f4d5ab8c9618d09"
checksum = "9dd69a6db85c1bcff989809e0e0b3b06506425f32b545c46aeafda5fe7775d6a"
dependencies = [
"serde",
"serde_derive",
@@ -1242,9 +1242,9 @@ dependencies = [
[[package]]
name = "cranelift-codegen"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "26fe6f3ec5344c32602c414e986dcbe699fa501a3e3e7b02f887d9d12b14ae42"
checksum = "24c2db6c26cd96393cf785c4b51b900738963cc7422aa0045416a7641ae2f6cd"
dependencies = [
"bumpalo",
"cranelift-assembler-x64",
@@ -1273,9 +1273,9 @@ dependencies = [
[[package]]
name = "cranelift-codegen-meta"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96c5e6323d458486d95781defdb5016a1176fc911d8bc8e64b696adbda6e9044"
checksum = "e284270142e7f1dcb73a992a62a8b3716b4062a65a52d8f2732c6ebf6f7f342f"
dependencies = [
"cranelift-assembler-x64-meta",
"cranelift-codegen-shared",
@@ -1286,24 +1286,24 @@ dependencies = [
[[package]]
name = "cranelift-codegen-shared"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1260aa93b0bd48e8e55c1c7fd9ff6a260f1a1bc46e1f0151a5055b124e5b15d"
checksum = "6595667b7d505cf85d5bdd014e6f57ad6128183238f8e372319d9384782472f5"
[[package]]
name = "cranelift-control"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "50c179632a09850f81f1a1e9116cb09330c734a86689f3ee4c3f4ec81543acbd"
checksum = "f26ffdbfcd24c3833d730849e6d132af34a400a2b89b44446015c01eecbea21d"
dependencies = [
"arbitrary",
]
[[package]]
name = "cranelift-entity"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d8c071188cb1c3b1803e23ae415a8d5f58d741d3a4b26a79b83dd61921112eac"
checksum = "9ffb08ccd8a77fb31cdbbda2afa2333d8f85299b1bc0d1c194259ba66d160d74"
dependencies = [
"cranelift-bitset",
"serde",
@@ -1313,9 +1313,9 @@ dependencies = [
[[package]]
name = "cranelift-frontend"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e2b85ba0a55d7685117b275fe6f36c819d438862e4223d28f0b97902460ff0ac"
checksum = "b447e4f2bb44b1188185a77f478e5a91b7723a40b3b58c3e2d5b26df2ed5a665"
dependencies = [
"cranelift-codegen",
"hashbrown 0.17.1",
@@ -1326,15 +1326,15 @@ dependencies = [
[[package]]
name = "cranelift-isle"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "20ed364edcaed769da7b2709d540f8f7d0ff257749ba193f475e22dba6a0178b"
checksum = "2f0989e943f3a9d41989595826bba544df9fda64bcddd4df0c06fb2e26af3cb3"
[[package]]
name = "cranelift-native"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "418d98c3dce08f0d13526692bbd1888bff4c5f45207f5093d168b5a224fbc88c"
checksum = "5fa10df59e776c42dae5b6ba5216ba5321707a2136abd2219e615c54b234fc1b"
dependencies = [
"cranelift-codegen",
"libc",
@@ -1343,9 +1343,9 @@ dependencies = [
[[package]]
name = "cranelift-srcgen"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4f016b9994e39cad68107f33fa5b8dcee8fb7e38332bde3f97690e5e8abe1b10"
checksum = "36508559c8839a8b6ee091f9deaa9cfe620a82f1abb5e358a0a0c65290583622"
[[package]]
name = "crc"
@@ -4144,7 +4144,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
[[package]]
name = "ide-agent"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"blake3",
"dunce",
@@ -4169,7 +4169,7 @@ dependencies = [
[[package]]
name = "ide-analysis"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"ast-grep-core",
"ide-core",
@@ -4183,7 +4183,7 @@ dependencies = [
[[package]]
name = "ide-android"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"ide-core",
"serde",
@@ -4194,7 +4194,7 @@ dependencies = [
[[package]]
name = "ide-build"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"blake3",
"chardetng",
@@ -4212,7 +4212,7 @@ dependencies = [
[[package]]
name = "ide-cli"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"dirs 6.0.0",
"serde",
@@ -4226,7 +4226,7 @@ dependencies = [
[[package]]
name = "ide-clipboard"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"gtk",
"objc2 0.6.5",
@@ -4237,7 +4237,7 @@ dependencies = [
[[package]]
name = "ide-command"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"heck 0.5.0",
"proc-macro2",
@@ -4248,7 +4248,7 @@ dependencies = [
[[package]]
name = "ide-core"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"dunce",
"encoding_rs",
@@ -4265,7 +4265,7 @@ dependencies = [
[[package]]
name = "ide-coverage"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-run",
@@ -4279,7 +4279,7 @@ dependencies = [
[[package]]
name = "ide-dap"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"base64 0.22.1",
"futures",
@@ -4308,7 +4308,7 @@ dependencies = [
[[package]]
name = "ide-db"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"base64 0.22.1",
"bb8",
@@ -4319,6 +4319,7 @@ dependencies = [
"futures",
"ide-core",
"ide-http",
"ide-sdk",
"ide-ssh",
"notify",
"open",
@@ -4340,11 +4341,12 @@ dependencies = [
"tracing",
"uuid",
"zeroize",
"zip",
]
[[package]]
name = "ide-docker"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"ide-core",
"serde",
@@ -4357,7 +4359,7 @@ dependencies = [
[[package]]
name = "ide-extension"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4376,9 +4378,20 @@ dependencies = [
"zip",
]
[[package]]
name = "ide-flutter"
version = "0.1.49"
dependencies = [
"ide-android",
"ide-core",
"parking_lot",
"serde_json",
"tempfile",
]
[[package]]
name = "ide-fonts"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"objc2-core-foundation",
"objc2-core-text",
@@ -4390,7 +4403,7 @@ dependencies = [
[[package]]
name = "ide-github"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-vcs",
@@ -4403,7 +4416,7 @@ dependencies = [
[[package]]
name = "ide-heap"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"criterion",
"ide-core",
@@ -4421,7 +4434,7 @@ dependencies = [
[[package]]
name = "ide-host"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4442,6 +4455,7 @@ dependencies = [
"ide-db",
"ide-docker",
"ide-extension",
"ide-flutter",
"ide-heap",
"ide-http",
"ide-index",
@@ -4495,7 +4509,7 @@ dependencies = [
[[package]]
name = "ide-http"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-vfs",
@@ -4514,7 +4528,7 @@ dependencies = [
[[package]]
name = "ide-index"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"blake3",
"criterion",
@@ -4536,7 +4550,7 @@ dependencies = [
[[package]]
name = "ide-jdwp"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"ide-jvm-inspect",
"proptest",
@@ -4548,7 +4562,7 @@ dependencies = [
[[package]]
name = "ide-jsonrpc"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"encoding_rs",
"futures",
@@ -4565,7 +4579,7 @@ dependencies = [
[[package]]
name = "ide-jvm-attach"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"libc",
"tempfile",
@@ -4574,7 +4588,7 @@ dependencies = [
[[package]]
name = "ide-jvm-inspect"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"futures",
"serde",
@@ -4585,7 +4599,7 @@ dependencies = [
[[package]]
name = "ide-language"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"blake3",
"criterion",
@@ -4644,7 +4658,7 @@ dependencies = [
[[package]]
name = "ide-lsp"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"dunce",
"encoding_rs",
@@ -4672,7 +4686,7 @@ dependencies = [
[[package]]
name = "ide-mcp"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"bytes",
"dunce",
@@ -4691,7 +4705,7 @@ dependencies = [
[[package]]
name = "ide-notebook"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"futures",
"ide-core",
@@ -4714,7 +4728,7 @@ dependencies = [
[[package]]
name = "ide-plugin"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"blake3",
"dunce",
@@ -4737,7 +4751,7 @@ dependencies = [
[[package]]
name = "ide-profiler"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-jvm-attach",
@@ -4751,7 +4765,7 @@ dependencies = [
[[package]]
name = "ide-remote"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"dunce",
"futures",
@@ -4771,7 +4785,7 @@ dependencies = [
[[package]]
name = "ide-run"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"dunce",
"encoding_rs",
@@ -4795,7 +4809,7 @@ dependencies = [
[[package]]
name = "ide-scaffold"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-tools",
@@ -4811,7 +4825,7 @@ dependencies = [
[[package]]
name = "ide-sdk"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"dunce",
"flate2",
@@ -4834,7 +4848,7 @@ dependencies = [
[[package]]
name = "ide-search"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"criterion",
"encoding_rs",
@@ -4855,7 +4869,7 @@ dependencies = [
[[package]]
name = "ide-spell"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"ide-core",
"parking_lot",
@@ -4868,7 +4882,7 @@ dependencies = [
[[package]]
name = "ide-ssh"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"dirs 6.0.0",
"flate2",
@@ -4893,7 +4907,7 @@ dependencies = [
[[package]]
name = "ide-streams"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-language",
@@ -4906,7 +4920,7 @@ dependencies = [
[[package]]
name = "ide-syntax"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-language",
@@ -4921,7 +4935,7 @@ dependencies = [
[[package]]
name = "ide-terminal"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"ide-core",
"libc",
@@ -4934,7 +4948,7 @@ dependencies = [
[[package]]
name = "ide-text"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"criterion",
"ide-core",
@@ -4947,7 +4961,7 @@ dependencies = [
[[package]]
name = "ide-tools"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"flate2",
"hex",
@@ -4968,7 +4982,7 @@ dependencies = [
[[package]]
name = "ide-vcs"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"blake3",
"dunce",
@@ -4989,7 +5003,7 @@ dependencies = [
[[package]]
name = "ide-vfs"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"chardetng",
"dunce",
@@ -5015,7 +5029,7 @@ dependencies = [
[[package]]
name = "ide-web"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"dirs 6.0.0",
"ide-core",
@@ -5031,7 +5045,7 @@ dependencies = [
[[package]]
name = "ide-workspace"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"blake3",
"dunce",
@@ -6660,7 +6674,7 @@ dependencies = [
[[package]]
name = "openidea"
version = "0.1.48"
version = "0.1.49"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -7389,9 +7403,9 @@ dependencies = [
[[package]]
name = "pulley-interpreter"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d74df9e20cba0f6dd07f01c3140535a6b23e40aecccfcacfb921621b41d0acb"
checksum = "335e459f9c7809af04768799880504d014d07e8e2fc6ae682fe2a105d8ced33f"
dependencies = [
"cranelift-bitset",
"log",
@@ -7401,9 +7415,9 @@ dependencies = [
[[package]]
name = "pulley-macros"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8415513bfa407c06de6f11dbe9437f2352e075a5520ff491a131166d3d90aed1"
checksum = "dd492ac929a6ca0357362d9fa0a09e31290feac5914550ccfb539b21f89c4b9e"
dependencies = [
"proc-macro2",
"quote",
@@ -9745,7 +9759,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
dependencies = [
"fastrand",
"getrandom 0.4.3",
"getrandom 0.3.4",
"once_cell",
"rustix",
"windows-sys 0.61.2",
@@ -11082,9 +11096,9 @@ dependencies = [
[[package]]
name = "wasmtime"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d45bf3b13781b9febb0eef42e1e145146c92ef891f345fd918e0e0fa1568c992"
checksum = "f32390bdc8d7cdb6259a1b855178bfed88226b4004b209fd48fb30e0deb01cd3"
dependencies = [
"addr2line",
"async-trait",
@@ -11124,9 +11138,9 @@ dependencies = [
[[package]]
name = "wasmtime-environ"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "833f00f3dc6128159284c5b71e211f24c97d45e052230a14f767fd830a6fb8b0"
checksum = "9c10f8ef1c9ee5e0f125c775fe56a4d07b8525db30a96e6358c61d93bd11dee4"
dependencies = [
"anyhow",
"cpp_demangle",
@@ -11155,9 +11169,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-component-macro"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0d69c34412409072d2e8ec399101524c330e334ff313f77415e6984cc9c6a172"
checksum = "620c53182ebd26c9fff5b90dd53cf8ec3103c381403fd32f8d395da31a9e4a46"
dependencies = [
"anyhow",
"proc-macro2",
@@ -11170,15 +11184,15 @@ dependencies = [
[[package]]
name = "wasmtime-internal-component-util"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b168d39f2d6b896d89fe096afa4ccdd7a8e927b01469b590af84f02fca3126a1"
checksum = "011e31ca343d9ba0ec623153cd94131b6f03973ef1a0ab791161f642e4a16a93"
[[package]]
name = "wasmtime-internal-core"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ad86a65d12c6a9202584ceb658c9a20cf5b25c32eed61c9be5e5f863f88f0d9"
checksum = "ab15e50a060b746493e6e95ef3ce4e6e7ebfdd7cc336a7dff0f0277e01b447ef"
dependencies = [
"hashbrown 0.17.1",
"libm",
@@ -11187,9 +11201,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-cranelift"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a71f0fd1dd40e4e18d4a20cdba29ff8e0eb2c0f21b12c2eb5869e0fea789dd05"
checksum = "dc3d27440a83fba26dd2784a997e13d9acb3606a75fb127c324929b52221c5c5"
dependencies = [
"cranelift-codegen",
"cranelift-control",
@@ -11213,9 +11227,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-fiber"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa4dfa39e58735b24ce3d28bfc8c2b3041603cc8a941bb268395351beff90172"
checksum = "6e54b28d0d453ca8932e4504065ae66a78f01fcb22b1a2ee287128d732fa9d6f"
dependencies = [
"cc",
"libc",
@@ -11227,9 +11241,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-jit-debug"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2eb98d4486c7b0163447d77dea06f3cc87e5e5ba5fc93613f8ec42e27ea181d"
checksum = "9293e75a3048b900f7b7c524702abca16d8a2332f970324eefc519f454cd5d69"
dependencies = [
"cc",
"wasmtime-internal-versioned-export-macros",
@@ -11237,9 +11251,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-jit-icache-coherence"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "852cae234735d79db6c58fe0d04b32f4078ad01fdb3fd6d488ac366132ba9785"
checksum = "b852e568831b913d410541bb37edc45a5002e472208fbdbaf844ed801dd4255f"
dependencies = [
"libc",
"wasmtime-internal-core",
@@ -11248,9 +11262,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-unwinder"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b9289378c82b9db7e7cf933d6bb441ad968536ac48f3f38c55b7cf9d3e8d87e1"
checksum = "a1f7349c9834a542275ad757340079e6453fccb429efce581454d23f85af92c0"
dependencies = [
"cranelift-codegen",
"log",
@@ -11260,9 +11274,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-versioned-export-macros"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc5c60c732d99dbcc5d670b71ba6ccf2b015cd16fc828990eaad2c4b8805ebdb"
checksum = "30b3e0768a450d9dea3e16b83f2498f0b08db0e32bad695e35564eef017be3f1"
dependencies = [
"proc-macro2",
"quote",
@@ -11271,9 +11285,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-wit-bindgen"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c77e4fcc7cd22772578458c5e233df47190ebc9b8b65788797d99a02787c9000"
checksum = "b9d085c540b95d0ffebf98c266e6f152e1acf96a9f676f224a74307b9d422c15"
dependencies = [
"anyhow",
"bitflags 2.13.2",
@@ -11285,9 +11299,9 @@ dependencies = [
[[package]]
name = "wasmtime-wasi"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "705b90d1fa1084cc73df656868948da77711b97f6b895d145a4949f86bcea674"
checksum = "17f8ce6b9e77539b5f52d440346f876a84c513ec1b07162845282f8652f7f7f9"
dependencies = [
"async-trait",
"bitflags 2.13.2",
@@ -11309,9 +11323,9 @@ dependencies = [
[[package]]
name = "wasmtime-wasi-io"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f3d2b6a255be488639f450b380e7e0923789f946de3463696cd30f2fe8a65cc3"
checksum = "da9f90eb7ce6edbead27dba3a58843398875defa73b8dce4bbc29d0ce3dc9b40"
dependencies = [
"async-trait",
"bytes",
+1 -1
Переглянути файл
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
exclude = ["sdk", "plugins"]
[workspace.package]
version = "0.1.48"
version = "0.1.49"
edition = "2024"
rust-version = "1.96"
license = "Apache-2.0"
+38
Переглянути файл
@@ -60,6 +60,44 @@ Their original copyright headers and Apache-2.0 licensing are retained.
At render time `src/ui/icons.tsx` may recolour monochrome icons to `currentColor`.
## Flutter plugin icons
These icons of [flutter-intellij](https://github.com/flutter/flutter-intellij) (commit `d02813ad5890`) are used
under the BSD 3-Clause License:
- `src/ui/expui/flutter/*.svg`: the DevTools tool window icons, copied unmodified from
`resources/icons/expui/`.
- `src/ui/expui/flutter/[email protected]` and `[email protected]`: the Flutter outline's widget
icons, `resources/icons/custom/[email protected]` and `[email protected]`, renamed, content unmodified.
```text
Copyright 2016 The Chromium Authors. All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
```
## JetBrains IntelliJ Platform VCS log graph algorithms
`crates/ide-vcs/src/bek.rs` and `src/features/vcs/graph.ts` adapt the Bek ordering,
+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();
}
+337 -130
Переглянути файл
@@ -125,6 +125,9 @@ type Connector = Arc<
/// Returns the configured MCP servers (User and Workspace) for this project.
pub type McpServersFn = dyn Fn() -> Vec<McpServer> + Send + Sync;
/// Returns the executable of the running built-in MCP server, if any.
pub type McpExecutableFn = dyn Fn() -> Option<PathBuf> + Send + Sync;
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
struct CopilotBinaryKey {
command: String,
@@ -148,6 +151,7 @@ struct Shared {
/// [`IDLE_RELEASE`], in milliseconds (shorter in tests).
idle_release_ms: AtomicU64,
mcp_servers_hook: RwLock<Option<Arc<McpServersFn>>>,
mcp_executable_hook: RwLock<Option<Arc<McpExecutableFn>>>,
/// Monotonic id for [`AgentEvent::Attention`] episodes.
attention_seq: AtomicU64,
}
@@ -220,8 +224,12 @@ impl Shared {
overrides: &BTreeMap<String, bool>,
) -> McpForSession {
let builtin_off = overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false);
let mut servers =
if builtin_off { Vec::new() } else { mcp_servers_for(init.mcp_stdio(), &self.paths.project_root) };
let mut servers = if builtin_off {
Vec::new()
} else {
let exe = self.mcp_executable_hook.read().as_ref().and_then(|hook| hook());
stdio_mcp_servers(exe.as_deref(), init.mcp_stdio(), &self.paths.project_root)
};
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
servers.extend(mcp::acp_mcp_servers(&configured, provider, init, overrides));
let off = Self::mcp_off(&configured, provider, overrides);
@@ -349,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>,
@@ -376,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>;
@@ -384,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`.
@@ -407,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 {
@@ -516,6 +567,7 @@ impl AgentManager {
copilot_acp_fallback: Mutex::new(HashSet::new()),
idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),
mcp_servers_hook: RwLock::new(None),
mcp_executable_hook: RwLock::new(None),
attention_seq: AtomicU64::new(0),
});
shared.paths.catalogs.subscribe(&shared);
@@ -650,6 +702,11 @@ impl AgentManager {
*self.shared.mcp_servers_hook.write() = Some(Arc::from(hook));
}
/// Provides the executable of the running built-in MCP server for this host.
pub fn set_mcp_executable_hook(&self, hook: Box<McpExecutableFn>) {
*self.shared.mcp_executable_hook.write() = Some(Arc::from(hook));
}
/// The slash commands to complete for `provider`, in `task`'s directory or (without one)
/// in the project: what the agent offered last time there, unadvertised builtins,
/// and, for Claude Code, skills and custom commands on disk it has not listed.
@@ -782,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()),
@@ -797,7 +855,8 @@ impl AgentManager {
Ok(task)
}
/// Creates the task (and its worktree) and sends `req.prompt` as its first message.
/// Creates the task (and its worktree) and sends `req.prompt` as its first message, unless
/// `req.idle`.
pub async fn create(&self, req: NewAgentTask) -> IdeResult<AgentTask> {
let spec = self
.shared
@@ -872,7 +931,7 @@ impl AgentManager {
title,
provider: spec.id.clone(),
model: model_of(&config),
status: AgentStatus::Starting,
status: if req.idle { AgentStatus::Ready } else { AgentStatus::Starting },
isolation: req.isolation,
cwd: IpcPath(cwd),
branch,
@@ -897,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),
@@ -906,11 +966,13 @@ impl AgentManager {
title_renamed: false,
};
let handle = Task::restore(file, self.shared.clone());
handle.state.lock().busy = true;
handle.state.lock().busy = !req.idle;
self.tasks.write().insert(task.id.clone(), handle.clone());
handle.emit_task();
handle.persist();
self.shared.runtime.spawn(async move { handle.run(prompt).await });
if !req.idle {
self.shared.runtime.spawn(async move { handle.run(prompt).await });
}
Ok(task)
}
@@ -932,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 {
@@ -1051,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
@@ -1058,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)));
@@ -1066,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<_>>());
@@ -1099,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 {
@@ -1248,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(),
@@ -1293,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;
@@ -1891,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,
@@ -1898,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),
@@ -2094,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(),
@@ -2247,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 {
@@ -2276,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()) {
@@ -2304,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(())
@@ -2595,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);
@@ -2624,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);
}
@@ -2654,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))
@@ -2680,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));
@@ -2786,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());
@@ -2794,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
@@ -2819,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 {
@@ -2830,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;
}
@@ -2839,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()) {
@@ -2858,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),
@@ -2868,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;
@@ -2877,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();
@@ -3344,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 {
@@ -3360,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);
}
}
@@ -3768,21 +3982,14 @@ mod tests;
/// The name agents know the built-in server by (its tools are `mcp__OpenIDEA__…` in Claude Code).
const BUILTIN_SERVER: &str = "OpenIDEA";
// The desktop advertises its relay only while the built-in server is listening.
static MCP_EXECUTABLE: parking_lot::RwLock<Option<std::path::PathBuf>> = parking_lot::RwLock::new(None);
pub fn set_mcp_executable(executable: Option<std::path::PathBuf>) {
*MCP_EXECUTABLE.write() = executable;
}
fn mcp_servers_for(supported: bool, root: &std::path::Path) -> Vec<Value> {
stdio_mcp_servers(MCP_EXECUTABLE.read().as_deref(), supported, root)
}
fn stdio_mcp_servers(executable: Option<&std::path::Path>, supported: bool, root: &std::path::Path) -> Vec<Value> {
let Some(executable) = executable.filter(|_| supported) else { return Vec::new() };
let command = ide_mcp::stdio_command(executable, root);
vec![json!({ "name": BUILTIN_SERVER, "command": command[0], "args": command[1..], "env": [] })]
let env: Vec<Value> = ["OPENIDEA_SERVER_HOME", "OPENIDEA_DATA_DIR"]
.into_iter()
.filter_map(|name| std::env::var(name).ok().map(|value| json!({ "name": name, "value": value })))
.collect();
vec![json!({ "name": BUILTIN_SERVER, "command": command[0], "args": command[1..], "env": env })]
}
/// What was sent of a streaming message: its first `bytes` (`utf16` UTF-16 units), which
+4
Переглянути файл
@@ -633,6 +633,10 @@ pub struct NewAgentTask {
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
#[serde(default)]
pub mcp_overrides: BTreeMap<String, bool>,
/// Creates the task without sending `prompt` (it only names the task): the composer's
/// `!` command runs in it first.
#[serde(default)]
pub idle: bool,
}
/// A file the task changed: against [`AgentTask::base_commit`], or against `HEAD` in the
+30 -1
Переглянути файл
@@ -1420,6 +1420,32 @@ async fn shell_commands_show_in_the_conversation_and_go_with_the_next_message()
assert_eq!(sent.pointer("/0/text").and_then(Value::as_str), Some("again"));
}
#[tokio::test(flavor = "multi_thread")]
async fn an_idle_task_starts_no_turn_until_its_first_message() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("! echo first"),
provider: "claude".into(),
isolation: Isolation::Local,
idle: true,
..Default::default()
})
.await
.unwrap();
assert_eq!((task.status, task.title.as_str()), (AgentStatus::Ready, "! echo first"));
mgr.run_shell(&task.id, "echo first", ide_core::CancellationToken::new()).await.unwrap();
assert!(agent.prompts.lock().is_empty(), "an idle task starts no turn");
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let sent = agent.prompts.lock().last().cloned().unwrap();
assert!(sent.pointer("/0/text").and_then(Value::as_str).is_some_and(|t| t.contains("echo first")));
assert_eq!(sent.pointer("/1/text").and_then(Value::as_str), Some("again"));
}
#[tokio::test(flavor = "multi_thread")]
async fn send_now_interrupts_the_turn_when_steering_is_refused() {
let tmp = tempfile::tempdir().unwrap();
@@ -1909,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!({}));
@@ -4377,6 +4403,7 @@ async fn per_session_mcp_overrides_filter_session_and_reload_when_idle() {
isolation: Isolation::Local,
base: None,
mcp_overrides: BTreeMap::from([("slack".into(), false)]),
idle: false,
})
.await
.unwrap();
@@ -4504,6 +4531,7 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
isolation: Isolation::Local,
base: None,
mcp_overrides: BTreeMap::new(),
idle: false,
})
.await
.unwrap();
@@ -4528,6 +4556,7 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
isolation: Isolation::Local,
base: None,
mcp_overrides: BTreeMap::new(),
idle: false,
})
.await
.unwrap();
+2 -1
Переглянути файл
@@ -25,7 +25,8 @@ pub use gradle_deps::{GradleDependency, GradleReport, gradle_dependencies, gradl
pub use maven::{MavenDependency, MavenModel, MavenPlugin, MavenProfile, MavenProject, Omission};
pub use sbt::{SbtBuild, SbtProject};
pub use sync::{
SyncOptions, SyncProgress, maven_profiles, save_maven_profiles, sync_gradle, sync_gradle_model, sync_maven,
SyncOptions, SyncProgress, maven_offline, maven_profiles, save_maven_offline, save_maven_profiles, sync_gradle,
sync_gradle_model, sync_maven,
};
use serde::{Deserialize, Serialize};
+7 -1
Переглянути файл
@@ -163,7 +163,13 @@ fn run_with_env_capture(
let encoding =
ide_core::output_encoding::fix(program, args, env, |k| std::env::var(k).ok(), "UTF-8", cfg!(windows));
let program = program_path(program, env, cwd);
let mut command = Command::new(&program);
let mut command = if ide_core::process::needs_sh(&program) {
let mut sh = Command::new("/bin/sh");
sh.arg(&program);
sh
} else {
Command::new(&program)
};
command.args(args).current_dir(cwd).envs(env).envs(encoding.env.iter().map(|(k, v)| (k, v))).stdin(Stdio::null());
command.stdout(Stdio::piped()).stderr(Stdio::piped());
// Its own group: `mvnw` / `gradlew` start the JVM as a child, and cancelling kills both.
+88 -17
Переглянути файл
@@ -86,15 +86,20 @@ const MAVEN_CACHE_VERSION: u32 = 1;
/// `dependency:tree` of a plugin version whose `-Dverbose` lists the occurrences Maven
/// omitted (conflicts, duplicates): verbose output was dropped in 3.0 and is back since 3.2.
/// Offline, the project's own plugin version is used instead, since this one may not be cached.
/// Offline, it is used only when an earlier sync downloaded it; otherwise the project's own
/// plugin version is, which may be cached instead.
const DEPENDENCY_TREE: &str = "org.apache.maven.plugins:maven-dependency-plugin:3.8.1:tree";
const DEPENDENCY_TREE_JAR: &str =
"org/apache/maven/plugins/maven-dependency-plugin/3.8.1/maven-dependency-plugin-3.8.1.jar";
/// The goals that read the effective POM into `effective` and the verbose dependency trees.
fn maven_sync_goals(effective: &Path, offline: bool) -> Vec<String> {
/// The goals that read the effective POM into `effective` and the verbose dependency trees;
/// `repo` is the local repository the build resolves from.
fn maven_sync_goals(effective: &Path, offline: bool, repo: Option<&Path>) -> Vec<String> {
let pinned = !offline || repo.is_some_and(|repo| repo.join(DEPENDENCY_TREE_JAR).is_file());
vec![
"help:effective-pom".into(),
format!("-Doutput={}", effective.to_string_lossy()),
if offline { "dependency:tree".into() } else { DEPENDENCY_TREE.into() },
if pinned { DEPENDENCY_TREE.into() } else { "dependency:tree".into() },
"-Dverbose".into(),
]
}
@@ -118,6 +123,7 @@ fn sync_maven_options(options: &[String]) -> Vec<String> {
}
const GRADLE_CACHE: &str = "gradle.json";
const MAVEN_PROFILES: &str = "maven-profiles.json";
const MAVEN_OFFLINE: &str = "maven-offline.json";
/// The Maven profiles (`-P` entries, `!id` deactivates) the project was last synced
/// with: what the IDE resolves it with besides `mvn` (the Java language server, Build Project).
@@ -127,12 +133,31 @@ pub fn maven_profiles(cache_dir: &Path) -> Vec<String> {
/// Records the profiles of a sync for [`maven_profiles`]; `true` when they changed.
pub fn save_maven_profiles(cache_dir: &Path, profiles: &[String]) -> IdeResult<bool> {
if maven_profiles(cache_dir) == profiles {
save_if_changed(cache_dir, MAVEN_PROFILES, &profiles.to_vec())
}
/// Whether the project was last synced offline (`-o`): the Java language server then
/// resolves it offline too.
pub fn maven_offline(cache_dir: &Path) -> bool {
read_cache(cache_dir, MAVEN_OFFLINE).unwrap_or(false)
}
/// Records the offline mode of a sync for [`maven_offline`]; `true` when it changed.
pub fn save_maven_offline(cache_dir: &Path, offline: bool) -> IdeResult<bool> {
save_if_changed(cache_dir, MAVEN_OFFLINE, &offline)
}
fn save_if_changed<T: Serialize + DeserializeOwned + PartialEq + Default>(
dir: &Path,
name: &str,
value: &T,
) -> IdeResult<bool> {
if read_cache::<T>(dir, name).unwrap_or_default() == *value {
return Ok(false);
}
std::fs::create_dir_all(cache_dir)?;
let json = serde_json::to_vec(profiles).map_err(|e| IdeError::internal(e.to_string()))?;
std::fs::write(cache_dir.join(MAVEN_PROFILES), json)?;
std::fs::create_dir_all(dir)?;
let json = serde_json::to_vec(value).map_err(|e| IdeError::internal(e.to_string()))?;
std::fs::write(dir.join(name), json)?;
Ok(true)
}
@@ -382,7 +407,8 @@ pub fn sync_maven(
if !options.profiles.is_empty() {
args.push(format!("-P{}", options.profiles.join(",")));
}
args.extend(maven_sync_goals(&effective, options.offline));
let repo = local_repo.clone().or_else(maven::default_local_repo);
args.extend(maven_sync_goals(&effective, options.offline, repo.as_deref()));
progress(SyncProgress { message: format!("Reading {}", top.display_name), fraction: None });
let command = options.maven_command.as_deref().unwrap_or(&top.command);
let out = run(command, &args, &root.join(&top.dir), &options.env, cancel, |line| {
@@ -532,14 +558,18 @@ mod tests {
assert!(loaded.gradle[0].sync_error.as_deref().unwrap().contains("cannot start"));
assert!(loaded.gradle[1].sync_error.is_none());
assert_eq!(loaded.gradle[1].projects[0].tasks[0].name, "healthy");
let bad_wrapper = root.join("a/gradlew");
std::fs::write(&bad_wrapper, "#!/bin/sh\nexit 0\n").unwrap();
std::fs::set_permissions(&bad_wrapper, std::fs::Permissions::from_mode(0o644)).unwrap();
models[0].command = bad_wrapper.to_string_lossy().into_owned();
// A wrapper without the execute bit (committed from Windows, unpacked from a zip)
// runs through `sh`, and its mode is left alone.
let plain_wrapper = root.join("a/gradlew");
std::fs::write(&plain_wrapper, "#!/bin/sh\nprintf '%s\\n' 'Build tasks' '-----------' 'plain - ok'\n").unwrap();
std::fs::set_permissions(&plain_wrapper, std::fs::Permissions::from_mode(0o644)).unwrap();
models[0].command = plain_wrapper.to_string_lossy().into_owned();
run(&models[0]).unwrap();
let loaded = crate::load_linked(root, &cache, None, &Default::default(), &settings);
assert!(loaded.gradle[0].sync_error.as_deref().unwrap().contains("cannot start"));
assert!(loaded.gradle[0].sync_error.is_none());
assert_eq!(loaded.gradle[0].projects[0].tasks[0].name, "plain");
assert!(loaded.gradle[1].sync_error.is_none());
assert_eq!(std::fs::metadata(&plain_wrapper).unwrap().permissions().mode() & 0o777, 0o644);
let blocked_cache = root.join("blocked-cache");
std::fs::write(&blocked_cache, "a file cannot contain sync caches").unwrap();
assert!(
@@ -908,12 +938,31 @@ mod tests {
}
#[test]
fn sync_reads_verbose_trees_with_a_pinned_plugin_unless_offline() {
let online = maven_sync_goals(Path::new("e.xml"), false);
fn the_offline_mode_of_the_last_sync_is_kept_for_the_language_server() {
let tmp = tempfile::tempdir().unwrap();
let cache = tmp.path().join("cache");
assert!(!maven_offline(&cache), "never synced: online");
assert!(save_maven_offline(&cache, true).unwrap());
assert!(maven_offline(&cache));
assert!(!save_maven_offline(&cache, true).unwrap(), "unchanged");
assert!(save_maven_offline(&cache, false).unwrap());
assert!(!maven_offline(&cache));
assert!(!save_maven_offline(&tmp.path().join("other"), false).unwrap(), "online is the default");
}
#[test]
fn sync_reads_verbose_trees_with_a_pinned_plugin_unless_offline_without_it() {
let tmp = tempfile::tempdir().unwrap();
let online = maven_sync_goals(Path::new("e.xml"), false, None);
assert_eq!(online, ["help:effective-pom", "-Doutput=e.xml", DEPENDENCY_TREE, "-Dverbose"]);
let offline = maven_sync_goals(Path::new("e.xml"), true);
let offline = maven_sync_goals(Path::new("e.xml"), true, Some(tmp.path()));
assert_eq!(offline[2], "dependency:tree");
assert!(offline.contains(&"-Dverbose".to_owned()));
// Downloaded by an online sync: offline keeps using it, the project's version may be missing.
let jar = tmp.path().join(DEPENDENCY_TREE_JAR);
std::fs::create_dir_all(jar.parent().unwrap()).unwrap();
std::fs::write(&jar, "").unwrap();
assert_eq!(maven_sync_goals(Path::new("e.xml"), true, Some(tmp.path()))[2], DEPENDENCY_TREE);
}
#[test]
@@ -965,6 +1014,28 @@ mod tests {
assert!(sync_maven_options(&[]).is_empty());
}
#[cfg(unix)]
#[test]
fn maven_sync_runs_a_wrapper_without_the_execute_bit() {
use std::os::unix::fs::PermissionsExt;
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("p");
std::fs::create_dir_all(&root).unwrap();
std::fs::write(root.join("pom.xml"), "<project><groupId>g</groupId><artifactId>a</artifactId></project>")
.unwrap();
let mvnw = root.join("mvnw");
std::fs::write(&mvnw, "#!/bin/sh\nprintf '%s\\n' \"$@\" > mvnw-args\n").unwrap();
std::fs::set_permissions(&mvnw, std::fs::Permissions::from_mode(0o644)).unwrap();
let cache = tmp.path().join("cache");
sync_maven(&root, &cache, &SyncOptions::default(), &CancellationToken::new(), &|_| {}).unwrap();
let args = std::fs::read_to_string(root.join("mvnw-args")).unwrap();
assert!(args.contains("help:effective-pom"), "args: {args}");
let loaded = crate::load_linked(&root, &cache, None, &Default::default(), &Default::default());
let maven = loaded.maven.unwrap();
assert!(maven.synced_at.is_some() && maven.sync_error.is_none(), "{:?}", maven.sync_error);
assert_eq!(std::fs::metadata(&mvnw).unwrap().permissions().mode() & 0o777, 0o644);
}
#[cfg(unix)]
#[test]
fn maven_sync_runs_the_daemon_command_serially() {
+61
Переглянути файл
@@ -53,6 +53,10 @@ pub enum IdeEvent {
root: crate::IpcPath,
status: DirenvStatus,
},
/// The project's `flutter daemon` changed state, or a device came or went.
FlutterDevices {
list: FlutterDeviceList,
},
/// Files or directories changed on disk (after debouncing, ignore rules applied).
FsChanged {
created: Vec<crate::IpcPath>,
@@ -234,6 +238,46 @@ pub enum AskpassKind {
Confirm,
}
/// A target `flutter run -d <id>` can name, or an Android device adb sees but Flutter can't use yet.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct FlutterDevice {
pub id: String,
pub name: String,
/// `android`, `ios`, `macos`, `web`, …
pub platform_type: Option<String>,
/// `mobile`, `desktop` or `web`.
pub category: Option<String>,
pub emulator: bool,
/// The adb state keeping it from being used (`unauthorized`, `offline`, …).
pub unavailable: Option<String>,
}
/// See [`FlutterDeviceList`].
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum FlutterDaemonStatus {
#[default]
Stopped,
/// Started; the first device discovery has not finished.
Starting,
Ready,
/// No `flutter` executable on the search path.
NotInstalled,
/// The daemon could not start or exited: what it printed last. It is not restarted on its own.
Failed {
message: String,
},
}
/// The project's Flutter devices, best default first.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct FlutterDeviceList {
pub status: FlutterDaemonStatus,
pub devices: Vec<FlutterDevice>,
}
/// See [`IdeEvent::Direnv`].
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
@@ -268,6 +312,8 @@ pub enum LspRefreshKind {
InlayHints,
SemanticTokens,
CodeLens,
/// The Dart server published a document's Flutter outline.
FlutterOutline,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
@@ -323,6 +369,21 @@ pub enum DebugEvent {
change_type: String,
message: String,
},
/// `flutter debug_adapter`'s `flutter.appStarted` event (launch and attach): the session is
/// a Flutter app that can take a hot reload now. The plain Dart adapter never sends it.
FlutterAppStarted,
/// The VM Service of a Flutter session's app, which DevTools connects to.
FlutterVmService {
uri: String,
/// The Flutter device the app runs on.
device: Option<String>,
},
/// Flutter's inspector selected a widget: its source, 0-based.
FlutterNavigate {
path: crate::IpcPath,
line: u32,
column: u32,
},
/// The session's capabilities changed after it started: fetch them again.
Capabilities,
/// The adapter's `invalidated` event: what it shows for `areas` (`all`, `stacks`, `threads`,
+21
Переглянути файл
@@ -807,6 +807,27 @@ pub fn find_executable_in(
.find_map(|dir| names.iter().map(|n| dir.join(n)).find(|p| p.is_file()))
}
/// Whether `program` is a script to start as `/bin/sh <program>`: on Unix, a `#!` script
/// without the execute bit — a `mvnw` / `gradlew` committed from Windows or unpacked from a
/// zip — which `exec` refuses with `EACCES`. The file's mode is left alone, as other IDEs do.
pub fn needs_sh(program: &std::path::Path) -> bool {
#[cfg(unix)]
{
use std::io::Read;
use std::os::unix::fs::PermissionsExt;
let mut magic = [0u8; 2];
program.is_absolute()
&& std::fs::metadata(program).is_ok_and(|m| m.is_file() && m.permissions().mode() & 0o111 == 0)
&& std::fs::File::open(program).and_then(|mut f| f.read_exact(&mut magic)).is_ok()
&& &magic == b"#!"
}
#[cfg(not(unix))]
{
let _ = program;
false
}
}
/// [`find_executable_in`] for this platform (`PATHEXT` from the environment).
pub fn find_executable(name: &str, search: &OsStr) -> Option<std::path::PathBuf> {
let pathext = host_var_os("PATHEXT");
+24
Переглянути файл
@@ -50,6 +50,8 @@ pub struct Settings {
/// Per language server, by name (`rust-analyzer`): launch and protocol
/// options on top of the language definition, or a server defined here.
pub language_servers: BTreeMap<String, LanguageServerSettings>,
/// Tools › Download sources: a mirror prefix for the release archives the installer fetches.
pub tool_downloads: ToolDownloadSettings,
/// Editor › Inspections profiles.
pub inspections: InspectionSettings,
/// Editor › Natural Languages › Spelling.
@@ -361,6 +363,22 @@ impl Default for McpServerSettings {
}
}
/// Tools › Download sources: a mirror the installer tries when `github.com` is slow or
/// unreachable.
///
/// The mirror is a proxy prefix: the official URL is appended to it unchanged
/// (`https://mirror.example/https://github.com/o/r/releases/download/…`), which is what the
/// public GitHub proxies speak. Only `github.com` downloads are affected — those proxies
/// hard-code that host, so Eclipse JDT LS and Open VSX keep their official addresses. Empty by
/// default, so every download stays on its official host until the user opts in.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct ToolDownloadSettings {
/// Proxy prefix prepended to `https://github.com/…` archive addresses only; empty keeps
/// every download on its official host.
pub github_mirror: String,
}
/// Absent profiles retain automatic discovery for existing projects.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
@@ -499,6 +517,7 @@ impl Default for Settings {
external_tools: Vec::new(),
tools: BTreeMap::new(),
language_servers: BTreeMap::new(),
tool_downloads: ToolDownloadSettings::default(),
inspections: InspectionSettings::default(),
spelling: SpellingSettings::default(),
ssh: SshSettings::default(),
@@ -1384,6 +1403,8 @@ pub struct GoSettings {
pub goroot: String,
/// Empty = `go env GOPATH`.
pub gopath: String,
/// Format with gofumpt, a stricter gofmt (gopls `gofumpt`).
pub gofumpt: bool,
pub build_tags: GoBuildTags,
pub modules: GoModules,
}
@@ -1514,6 +1535,9 @@ pub struct MavenSettings {
/// project (jdtls `java.maven.downloadSources`). Off: sources are fetched on demand
/// from a library class's Download Sources banner.
pub download_sources: bool,
/// Always update snapshots (`-U`): Maven checks remote repositories for newer SNAPSHOT
/// dependencies on every sync, build and run, and jdtls on import (`java.maven.updateSnapshots`).
pub update_snapshots: bool,
}
impl MavenSettings {
+2
Переглянути файл
@@ -239,6 +239,8 @@ pub enum SymbolKind {
Event,
Operator,
Key,
/// A Flutter widget built in the code (Flutter outline only).
Widget,
Unknown,
}
+16
Переглянути файл
@@ -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(),
}
}
}
@@ -367,6 +376,8 @@ pub struct DebuggerSettings {
pub skip_library_code: bool,
/// JavaScript: debugging a dev server (`vite`, `next dev`) also opens its page in a browser session.
pub debug_server_page: bool,
/// Flutter: saving a Dart file of a running debug session hot reloads the app.
pub flutter_hot_reload_on_save: bool,
pub python: PythonDebuggerSettings,
}
@@ -387,6 +398,7 @@ impl Default for DebuggerSettings {
value_tooltip_delay: 700,
skip_library_code: true,
debug_server_page: false,
flutter_hot_reload_on_save: true,
python: PythonDebuggerSettings::default(),
}
}
@@ -445,6 +457,9 @@ pub struct TerminalSettings {
/// Shell command line; empty = the login shell.
pub shell_path: String,
pub tab_name: String,
/// Title a program sets (OSC 0/2) as the tab's name: `running` (while a command runs),
/// `always`, or `off`.
pub app_title_as_tab_name: String,
pub audible_bell: bool,
pub close_on_exit: bool,
pub mouse_reporting: bool,
@@ -480,6 +495,7 @@ impl Default for TerminalSettings {
env: BTreeMap::new(),
shell_path: String::new(),
tab_name: "Local".into(),
app_title_as_tab_name: "running".into(),
audible_bell: true,
close_on_exit: true,
mouse_reporting: true,
+43 -4
Переглянути файл
@@ -280,6 +280,14 @@ pub struct SessionExceptionFilters {
pub filters: Vec<ExceptionFilter>,
}
/// What triggered a hot reload; `flutter debug_adapter` takes it as `reason`.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum HotReloadReason {
Manual,
Save,
}
/// A live session, as listed by [`DebugManager::sessions`].
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -404,6 +412,30 @@ fn is_flutter_project(dir: &Path, program: Option<&Path>) -> bool {
.any(|s| s.contains("sdk: flutter"))
}
/// `flutter debug_adapter` passes `toolArgs` on to `flutter run` / `flutter attach`.
fn add_flutter_device(arguments: &mut Value, device: Value) {
let args = arguments.as_object_mut().map(|o| o.entry("toolArgs").or_insert_with(|| json!([])));
if let Some(args) = args.and_then(Value::as_array_mut) {
args.extend([json!("-d"), device]);
}
}
/// The source a `navigate` tool event points at (1-based there). A `package:` location comes
/// with the file the adapter resolved it to.
fn flutter_navigation(body: &Value) -> Option<ide_core::event::DebugEvent> {
if body.get("kind")?.as_str()? != "navigate" {
return None;
}
let data = body.get("data")?;
let uri = data.get("resolvedFileUri").or_else(|| data.get("fileUri"))?.as_str()?;
let position = |key| data.get(key)?.as_u64().map(|n| n.saturating_sub(1) as u32);
Some(ide_core::event::DebugEvent::FlutterNavigate {
path: kotlin_lsp::source_path(uri)?.into(),
line: position("line")?,
column: position("column").unwrap_or(0),
})
}
fn no_session(s: DebugSessionId) -> IdeError {
IdeError::not_found(format!("no debug session {}", s.0))
}
@@ -768,6 +800,8 @@ impl DebugManager {
// one regardless of what the working directory holds.
let force_flutter =
arguments.as_object_mut().and_then(|o| o.remove("__flutter")).and_then(|v| v.as_bool()).unwrap_or(false);
// Also IDE-side: the device to run on, should this turn out to be a Flutter session.
let flutter_device = arguments.as_object_mut().and_then(|o| o.remove("__flutterDevice"));
let cwd = config
.cwd
.clone()
@@ -812,10 +846,15 @@ impl DebugManager {
// Flutter: a project depending on the Flutter SDK needs `flutter debug_adapter`
// (the Dart adapter cannot start a program importing `dart:ui`, and hot reload
// is Flutter-only). Plain Dart projects keep the configured `dart`.
if config.adapter == "dart" && spec.command == "dart" {
if config.adapter == "dart" {
let program = arguments.get("program").and_then(Value::as_str).map(Path::new);
if force_flutter || is_flutter_project(&cwd, program) {
spec.command = "flutter".into();
if spec.command == "dart" {
spec.command = "flutter".into();
}
if let Some(device) = flutter_device {
add_flutter_device(&mut arguments, device);
}
}
}
let id = DebugSessionId::next();
@@ -1646,8 +1685,8 @@ impl DebugManager {
/// Flutter's DAP adapter: injects the changed sources into the running app.
/// Not part of the DAP standard; adapters that do not know the request reject it.
pub async fn hot_reload(&self, s: DebugSessionId) -> IdeResult<()> {
self.session(s)?.conn.request_timeout("hotReload", json!({ "reason": "manual" }), REQUEST_TIMEOUT).await?;
pub async fn hot_reload(&self, s: DebugSessionId, reason: HotReloadReason) -> IdeResult<()> {
self.session(s)?.conn.request_timeout("hotReload", json!({ "reason": reason }), REQUEST_TIMEOUT).await?;
Ok(())
}
+34 -2
Переглянути файл
@@ -99,6 +99,9 @@ pub(crate) struct Session {
pub js_overrides: tokio::sync::Mutex<Option<tokio::sync::watch::Sender<Vec<crate::JsResponseRule>>>>,
/// The file js-debug records the page's CPU profile into, while one is being recorded.
pub js_profile: parking_lot::Mutex<Option<std::path::PathBuf>>,
/// The device of the app `flutter debug_adapter` announced, once it did: the Dart adapter
/// sends the same `dart.*` events.
pub flutter_app: std::sync::OnceLock<Option<String>>,
pub jvm_inspector: parking_lot::Mutex<Option<Arc<dyn ide_jvm_inspect::JvmInspector>>>,
/// One inspector request per session at a time.
pub inspect_lock: tokio::sync::Mutex<()>,
@@ -274,6 +277,7 @@ impl Session {
launch_type: std::sync::OnceLock::new(),
js_overrides: tokio::sync::Mutex::new(None),
js_profile: parking_lot::Mutex::new(None),
flutter_app: std::sync::OnceLock::new(),
jvm_inspector: parking_lot::Mutex::new(None),
inspect_lock: tokio::sync::Mutex::default(),
ended: ide_core::CancellationToken::new(),
@@ -504,6 +508,9 @@ impl Session {
/// How long Stop waits for a launched program to exit before reporting the session ended.
pub(crate) const DEBUGGEE_EXIT_WAIT: Duration = Duration::from_secs(10);
/// How long a stop waits for a killed program to be gone (Windows ends processes asynchronously).
#[cfg(windows)]
const DEBUGGEE_KILL_WAIT: Duration = Duration::from_secs(5);
pub(crate) async fn remember_debuggee(s: &Arc<Session>) {
#[cfg(windows)]
@@ -643,14 +650,24 @@ pub(crate) async fn wait_for_debuggee(s: &Arc<Session>, terminate: bool) {
}
#[cfg(windows)]
{
use std::time::Instant;
remember_debuggee(s).await;
let deadline = std::time::Instant::now() + DEBUGGEE_EXIT_WAIT;
let deadline = Instant::now() + DEBUGGEE_EXIT_WAIT;
let mut killed: Option<Instant> = None;
// The captured tree is the oracle when it was captured; otherwise the job (every
// process the launch started) is, so a failed capture can no longer end the wait
// while the program still holds its port.
while launch_running(s) {
if s.stop_force.swap(false, Ordering::AcqRel) || std::time::Instant::now() >= deadline {
let now = Instant::now();
if s.stop_force.swap(false, Ordering::AcqRel) || (killed.is_none() && now >= deadline) {
signal_debuggee(s, true).await;
killed.get_or_insert(now);
}
// Termination is asynchronous, and a process TerminateProcess can't end (stuck in
// the kernel) would hold the stop forever: give up on it, as on Unix.
if killed.is_some_and(|at| now.duration_since(at) >= DEBUGGEE_KILL_WAIT) {
tracing::warn!(session = s.id.0, pid, "stop: the debugged program did not exit after it was killed");
break;
}
tokio::time::sleep(Duration::from_millis(50)).await;
}
@@ -866,6 +883,7 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
change_type: crate::hot_code_replace_type(body.get("changeType")),
message: str_("message").unwrap_or_default(),
}),
"flutter.appStarted" => s.emit(DebugEvent::FlutterAppStarted),
// Sent only by adapters told `supportsInvalidatedEvent` (kotlin-lsp).
"invalidated" => s.emit(DebugEvent::Invalidated {
areas: body
@@ -884,6 +902,20 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
"profileStarted" => {
*s.js_profile.lock() = str_("file").map(std::path::PathBuf::from);
}
// Sent before `dart.debuggerUris`, for `launch` and `attach` alike.
"flutter.appStart" => {
let _ = s.flutter_app.set(str_("deviceId"));
}
"dart.debuggerUris" => {
if let (Some(device), Some(uri)) = (s.flutter_app.get(), str_("vmServiceUri")) {
s.emit(DebugEvent::FlutterVmService { uri, device: device.clone() });
}
}
"dart.toolEvent" if s.flutter_app.get().is_some() => {
if let Some(event) = crate::flutter_navigation(&body) {
s.emit(event);
}
}
_ => tracing::trace!("dap: ignored event {event}"),
}
}
+60
Переглянути файл
@@ -559,6 +559,10 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
}
}
"stepIn" | "stepOut" | "pause" => ok!(msg, Value::Null),
"hotReload" => {
ok!(msg, Value::Null);
send!(json!({"type": "event", "event": "flutter.appStarted", "body": {}}));
}
"redefineClasses" => {
send!(
json!({"type": "event", "event": "hotcodereplace", "body": {"changeType": "STARTING", "message": "Start hot code replacement procedure..."}})
@@ -568,6 +572,20 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
json!({"type": "event", "event": "hotcodereplace", "body": {"changeType": 3, "message": "Build completed"}})
);
}
"hotRestart" => {
ok!(msg, Value::Null);
let uris = json!({"vmServiceUri": "ws://127.0.0.1:1/t=/ws"});
let navigate =
|file: &str| json!({"kind": "navigate", "data": {"fileUri": file, "line": 3, "column": 5}});
// Not Flutter's yet: a plain Dart session sends these too.
send!(json!({"type": "event", "event": "dart.debuggerUris", "body": uris}));
send!(json!({"type": "event", "event": "dart.toolEvent", "body": navigate("file:///early.dart")}));
send!(json!({"type": "event", "event": "flutter.appStart", "body": {"deviceId": "d1"}}));
send!(json!({"type": "event", "event": "dart.debuggerUris", "body": uris}));
send!(json!({"type": "event", "event": "dart.toolEvent", "body": {"kind": "other", "data": {}}}));
send!(json!({"type": "event", "event": "dart.toolEvent", "body": navigate("package:a/a.dart")}));
send!(json!({"type": "event", "event": "dart.toolEvent", "body": navigate("file:///a%20b/main.dart")}));
}
"terminate" => {
ok!(msg, Value::Null);
send!(json!({"type": "event", "event": "terminated"}));
@@ -1891,6 +1909,38 @@ async fn startup_sends_every_file_at_once_and_skips_files_with_nothing_enabled()
);
}
#[tokio::test]
async fn hot_reload_sends_its_reason_and_reports_the_flutter_app() {
let h = harness(Script::default());
let id = h.start(config()).await.unwrap();
h.manager.hot_reload(id, HotReloadReason::Manual).await.unwrap();
h.manager.hot_reload(id, HotReloadReason::Save).await.unwrap();
let reasons: Vec<_> = requests(&h, "hotReload").iter().map(|args| args["reason"].clone()).collect();
assert_eq!(reasons, [json!("manual"), json!("save")]);
h.wait_event(|e| matches!(e, DebugEvent::FlutterAppStarted)).await;
}
#[tokio::test]
async fn flutter_events_need_a_flutter_app() {
let h = harness(Script::default());
let id = h.start(config()).await.unwrap();
h.manager.hot_restart(id).await.unwrap();
let navigate = h.wait_event(|e| matches!(e, DebugEvent::FlutterNavigate { .. })).await;
let DebugEvent::FlutterNavigate { path, line, column } = navigate else { unreachable!() };
assert_eq!((path.as_ref(), line, column), (Path::new("/a b/main.dart"), 2, 4));
let events = h.events.lock();
let count = |want: fn(&DebugEvent) -> bool| {
events.iter().filter(|e| matches!(e, IdeEvent::Debug { event, .. } if want(event))).count()
};
assert_eq!(
count(
|e| matches!(e, DebugEvent::FlutterVmService { uri, device } if uri == "ws://127.0.0.1:1/t=/ws" && device.as_deref() == Some("d1"))
),
1
);
assert_eq!(count(|e| matches!(e, DebugEvent::FlutterNavigate { .. })), 1);
}
#[tokio::test]
async fn hot_swap_only_for_java_debug() {
let h = harness(Script::default());
@@ -2280,6 +2330,16 @@ fn flutter_projects_are_found_from_the_program_or_the_working_directory() {
std::fs::remove_dir_all(&root).unwrap();
}
#[test]
fn the_flutter_device_follows_the_tool_arguments() {
let mut arguments = json!({ "toolArgs": ["--flavor", "dev"] });
add_flutter_device(&mut arguments, json!("macos"));
assert_eq!(arguments["toolArgs"], json!(["--flavor", "dev", "-d", "macos"]));
let mut arguments = json!({});
add_flutter_device(&mut arguments, json!("chrome"));
assert_eq!(arguments["toolArgs"], json!(["-d", "chrome"]));
}
#[test]
fn rdbg_runs_the_debuggee_after_its_options_with_the_configuration_environment() {
let dir = tempfile::tempdir().unwrap();
+3 -1
Переглянути файл
@@ -7,6 +7,9 @@ license.workspace = true
[dependencies]
ide-core.workspace = true
ide-sdk.workspace = true
tempfile.workspace = true
zip.workspace = true
dunce.workspace = true
serde.workspace = true
serde_json = { workspace = true, features = ["raw_value"] }
@@ -38,5 +41,4 @@ open = "5"
[dev-dependencies]
tokio = { workspace = true, features = ["rt-multi-thread", "macros", "net"] }
tempfile.workspace = true
ide-ssh = { workspace = true, features = ["testing"] }
+59 -9
Переглянути файл
@@ -237,6 +237,7 @@ pub enum Pool {
Mysql(ServerPool<MysqlManager>),
SqlServer(Bb8Pool<MssqlConnectionManager>),
Clickhouse(crate::clickhouse::ClickhousePool),
Jdbc(Box<crate::jdbc::JdbcPool>),
Oracle(crate::oracle::OraclePool),
Snowflake(crate::snowflake::SnowflakePool),
}
@@ -247,6 +248,17 @@ fn legacy_eof(e: &sqlx::Error) -> bool {
matches!(e, sqlx::Error::Protocol(msg) if msg.starts_with("OK_Packet too short"))
}
/// A TLS handshake that failed, e.g. with a server limited to TLS 1.0/1.1. SSL mode Prefer means
/// TLS when it works, else a plain connection, as libpq's `sslmode=prefer` and MySQL clients'
/// PREFERRED do; sqlx only goes plain when the server offers no TLS, so such errors are retried.
fn tls_failed(e: &sqlx::Error) -> bool {
match e {
sqlx::Error::Tls(_) => true,
sqlx::Error::Io(io) => io.get_ref().is_some_and(|inner| inner.is::<rustls::Error>()),
_ => false,
}
}
pub(crate) fn db_err(e: sqlx::Error) -> IdeError {
match &e {
sqlx::Error::Database(d) => {
@@ -729,6 +741,7 @@ impl Pool {
Pool::Mysql(_) => DbDriver::Mysql,
Pool::SqlServer(_) => DbDriver::SqlServer,
Pool::Clickhouse(_) => DbDriver::Clickhouse,
Pool::Jdbc(_) => DbDriver::Jdbc,
Pool::Oracle(_) => DbDriver::Oracle,
Pool::Snowflake(_) => DbDriver::Snowflake,
}
@@ -830,9 +843,17 @@ impl Pool {
if let Some(n) = setup.statement_cache {
opts = opts.statement_cache_capacity(n);
}
let manager = PgManager { options: opts, init: init.clone(), timeout };
let mut manager = PgManager { options: opts, init: init.clone(), timeout };
// Open once directly so authentication failures retain their database error.
let first = manager.connect().await.map_err(db_err)?;
let first = match manager.connect().await {
Err(e) if source.ssl == DbSslMode::Prefer && tls_failed(&e) => {
tracing::info!("TLS handshake failed, connecting without TLS (SSL mode Prefer): {e}");
manager.options = manager.options.clone().ssl_mode(PgSslMode::Disable);
manager.connect().await
}
first => first,
}
.map_err(db_err)?;
let pool = Bb8Pool::builder().max_size(MAX).connection_timeout(timeout).build_unchecked(manager);
let _ = pool.add(first);
Ok(Pool::Postgres(ServerPool { inner: pool, closed: AtomicBool::new(false) }))
@@ -881,14 +902,19 @@ impl Pool {
}
let mut manager = MysqlManager { options: opts, init: init.clone(), timeout };
// Open once directly so authentication failures retain their database error.
let first = match manager.connect().await {
Err(e) if legacy_eof(&e) => {
manager.options = manager.options.clone().deprecate_eof(false);
manager.connect().await
let mut first = manager.connect().await;
if source.ssl == DbSslMode::Prefer && first.as_ref().is_err_and(tls_failed) {
if let Err(e) = &first {
tracing::info!("TLS handshake failed, connecting without TLS (SSL mode Prefer): {e}");
}
first => first,
manager.options = manager.options.clone().ssl_mode(MySqlSslMode::Disabled);
first = manager.connect().await;
}
.map_err(db_err)?;
if first.as_ref().is_err_and(legacy_eof) {
manager.options = manager.options.clone().deprecate_eof(false);
first = manager.connect().await;
}
let first = first.map_err(db_err)?;
let pool = Bb8Pool::builder().max_size(MAX).connection_timeout(timeout).build_unchecked(manager);
let _ = pool.add(first);
Ok(Pool::Mysql(ServerPool { inner: pool, closed: AtomicBool::new(false) }))
@@ -919,6 +945,7 @@ impl Pool {
conn.query("SELECT 1", &[]).await.map_err(mssql_err)?.into_results().await.map_err(mssql_err)?;
Ok(Pool::SqlServer(pool))
}
DbDriver::Jdbc => Err(IdeError::invalid("An installed JDBC driver profile is required")),
DbDriver::Clickhouse => unreachable!(),
DbDriver::Oracle | DbDriver::Snowflake => unreachable!(),
}
@@ -928,6 +955,7 @@ impl Pool {
match self {
Pool::SqlServer(_) | Pool::Oracle(_) => {}
Pool::Clickhouse(p) => p.close(),
Pool::Jdbc(p) => p.close().await,
Pool::Snowflake(p) => p.close().await,
Pool::Sqlite(p) => p.close().await,
Pool::Postgres(p) => p.closed.store(true, Ordering::Relaxed),
@@ -940,6 +968,7 @@ impl Pool {
Pool::SqlServer(_) => false,
Pool::Oracle(p) => p.is_closed(),
Pool::Clickhouse(p) => p.is_closed(),
Pool::Jdbc(p) => p.is_closed(),
Pool::Snowflake(p) => p.is_closed(),
Pool::Sqlite(p) => p.is_closed(),
Pool::Postgres(p) => p.closed.load(Ordering::Relaxed),
@@ -949,6 +978,9 @@ impl Pool {
/// Runs `sql` (no row limit beyond `max`), for introspection: cells are text (see [`Cells::Text`]).
pub async fn rows(&self, sql: &str, max: usize) -> IdeResult<Vec<Vec<Option<String>>>> {
if let Pool::Jdbc(p) = self {
return Ok(p.query(sql, 0, max, &CancellationToken::new()).await?.rows);
}
if let Pool::Clickhouse(p) = self {
return Ok(p.execute(sql, max, &CancellationToken::new()).await?.rows);
}
@@ -976,6 +1008,9 @@ impl Pool {
max_rows: usize,
cancel: &CancellationToken,
) -> IdeResult<QueryResult> {
if let Pool::Jdbc(p) = self {
return p.query(sql, skip, max_rows, cancel).await;
}
if let Pool::Clickhouse(p) = self {
return p.execute_from(sql, skip, max_rows, cancel).await;
}
@@ -998,6 +1033,7 @@ impl Pool {
/// row when flagged (table editor submits).
pub async fn transaction(&self, statements: &[(String, bool)]) -> IdeResult<u64> {
match self {
Pool::Jdbc(_) => Err(IdeError::invalid("Custom JDBC table editing is unsupported")),
Pool::Clickhouse(_) => Err(crate::clickhouse::transaction_error()),
Pool::Snowflake(p) => p.transaction(statements).await,
Pool::SqlServer(_) => {
@@ -1088,6 +1124,7 @@ pub enum Held {
impl Held {
pub async fn acquire(pool: &Pool) -> IdeResult<Self> {
Ok(match pool {
Pool::Jdbc(_) => return Err(IdeError::invalid("Custom JDBC manual transactions are unsupported")),
Pool::Sqlite(p) => Held::Sqlite(p.acquire().await.map_err(db_err)?),
Pool::Postgres(p) => Held::Postgres(Box::new(p.get().await?)),
Pool::Mysql(p) => Held::Mysql(Box::new(p.get().await?)),
@@ -1377,7 +1414,7 @@ pub fn begin_statement(driver: DbDriver) -> &'static str {
DbDriver::Mysql => "START TRANSACTION",
DbDriver::SqlServer => "BEGIN TRAN",
DbDriver::Oracle => "", // opens implicitly with autocommit off
DbDriver::Sqlite | DbDriver::Postgres | DbDriver::Clickhouse | DbDriver::Snowflake => "BEGIN",
DbDriver::Sqlite | DbDriver::Postgres | DbDriver::Clickhouse | DbDriver::Snowflake | DbDriver::Jdbc => "BEGIN",
}
}
@@ -1393,6 +1430,19 @@ mod tests {
use super::*;
use crate::source::{DbOptions, DbProperty};
#[test]
fn prefer_retries_without_tls_only_after_a_failed_handshake() {
use std::io;
// What a server limited to old TLS versions gives: rustls's alert inside the I/O error.
let alert = rustls::Error::AlertReceived(rustls::AlertDescription::HandshakeFailure);
assert!(tls_failed(&sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, alert))));
assert!(tls_failed(&sqlx::Error::Tls("bad config".into())));
// Unreachable servers, protocol errors and wrong passwords keep their error.
assert!(!tls_failed(&sqlx::Error::Io(io::ErrorKind::ConnectionRefused.into())));
assert!(!tls_failed(&sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, "eof"))));
assert!(!tls_failed(&sqlx::Error::Protocol("OK_Packet too short".into())));
}
fn sqlserver_debug(ssl: DbSslMode) -> String {
let mut config = tiberius::Config::new();
apply_sqlserver_ssl(&mut config, ssl);
+678
Переглянути файл
@@ -0,0 +1,678 @@
//! A trusted local driver profile is shared by data sources. JDBC URLs and properties
//! can run driver-specific initialization. A project source may connect only with the
//! settings its user last accepted in the dialog; the approval lives outside the project.
use crate::{DataSource, DbManager, QueryResult, ResultColumn};
use ide_core::{CancellationToken, IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::io::{Cursor, Read};
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::time::{Duration, Instant};
use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
use tokio::process::{ChildStdin, ChildStdout, Command};
use tokio::sync::Mutex;
use tokio::time::{Instant as Deadline, timeout_at};
const LIMIT: usize = 16 * 1024 * 1024;
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbJdbcDriver {
pub id: String,
pub name: String,
pub jars: Vec<String>,
pub class_name: String,
pub url_template: String,
}
fn persist_local(path: &Path, data: &[u8]) -> IdeResult<()> {
let dir = path.parent().expect("registry paths have a parent");
std::fs::create_dir_all(dir)?;
let mut tmp = tempfile::NamedTempFile::new_in(dir)?;
std::io::Write::write_all(&mut tmp, data)?;
tmp.persist(path).map_err(|e| IdeError::from(e.error))?;
Ok(())
}
fn local_jar(jar: &str) -> IdeResult<&Path> {
if jar.contains(if cfg!(windows) { ';' } else { ':' }) {
return Err(IdeError::invalid("A JDBC JAR path contains the system classpath separator"));
}
let path = Path::new(jar);
if !path.is_absolute() || !path.is_file() || !path.extension().is_some_and(|ext| ext.eq_ignore_ascii_case("jar")) {
return Err(IdeError::invalid("Choose an existing local .jar file for each JDBC driver file"));
}
Ok(path)
}
/// Read the standard JDBC service descriptors without executing any driver code.
pub fn jdbc_driver_classes(jars: &[String]) -> IdeResult<Vec<String>> {
let mut classes = Vec::new();
if jars.len() > 128 {
return Err(IdeError::invalid("Choose at most 128 JDBC driver files"));
}
for jar in jars {
let file = std::fs::File::open(local_jar(jar)?)?;
let mut archive = zip::ZipArchive::new(file).map_err(|_| IdeError::invalid("Invalid JDBC JAR archive"))?;
let descriptor = match archive.by_name("META-INF/services/java.sql.Driver") {
Ok(entry) => entry,
Err(zip::result::ZipError::FileNotFound) => continue,
Err(_) => return Err(IdeError::invalid("Cannot read the JDBC driver descriptor")),
};
let mut text = String::new();
descriptor.take(65537).read_to_string(&mut text)?;
if text.len() > 65536 {
return Err(IdeError::invalid("JDBC driver descriptor is too large"));
}
for line in text.lines() {
let name = line.split('#').next().unwrap_or_default().trim();
if !name.is_empty()
&& name.split('.').all(|part| {
let mut chars = part.chars();
chars.next().is_some_and(|c| c.is_alphabetic() || matches!(c, '_' | '$'))
&& chars.all(|c| c.is_alphanumeric() || matches!(c, '_' | '$'))
})
&& !classes.iter().any(|s| s == name)
{
classes.push(name.to_owned());
}
}
}
Ok(classes)
}
impl DbJdbcDriver {
fn validate(&self) -> IdeResult<()> {
if self.id.is_empty()
|| self.name.trim().is_empty()
|| self.jars.is_empty()
|| self.class_name.trim().is_empty()
{
return Err(IdeError::invalid("A JDBC driver needs a name, a driver class and at least one JAR"));
}
if !self.url_template.is_empty() && !self.url_template.starts_with("jdbc:") {
return Err(IdeError::invalid("The JDBC URL template must start with jdbc:"));
}
for jar in &self.jars {
local_jar(jar)?;
}
Ok(())
}
}
impl DbManager {
fn jdbc_registry(&self) -> IdeResult<PathBuf> {
self.global
.as_ref()
.map(|(dir, _)| dir.join("jdbc-drivers.json"))
.ok_or_else(|| IdeError::invalid("Global JDBC driver profiles are unavailable here"))
}
pub fn jdbc_drivers(&self) -> IdeResult<Vec<DbJdbcDriver>> {
let path = self.jdbc_registry()?;
match std::fs::File::open(path) {
Ok(file) => {
serde_json::from_reader(file).map_err(|e| IdeError::invalid(format!("JDBC driver profiles: {e}")))
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(vec![]),
Err(e) => Err(e.into()),
}
}
fn update_jdbc_driver(&self, id: &str, driver: Option<DbJdbcDriver>) -> IdeResult<()> {
let _guard = crate::plugin::EDIT.lock();
let path = self.jdbc_registry()?;
let mut list = self.jdbc_drivers()?;
list.retain(|d| d.id != id);
list.extend(driver);
let data = serde_json::to_vec_pretty(&list).map_err(|e| IdeError::internal(e.to_string()))?;
persist_local(&path, &data)
}
pub fn save_jdbc_driver(&self, driver: DbJdbcDriver) -> IdeResult<()> {
driver.validate()?;
self.update_jdbc_driver(&driver.id.clone(), Some(driver))
}
pub fn remove_jdbc_driver(&self, id: &str) -> IdeResult<()> {
if self.global_sources().iter().any(|s| s.driver == crate::DbDriver::Jdbc && s.jdbc_driver == id) {
return Err(IdeError::invalid("This JDBC driver is in use by a data source"));
}
self.update_jdbc_driver(id, None)
}
fn jdbc_approval(&self, source: &DataSource) -> IdeResult<(PathBuf, String)> {
let registry = self.jdbc_registry()?;
let key = serde_json::to_vec(&(&self.root, &source.id)).map_err(|e| IdeError::internal(e.to_string()))?;
let settings = serde_json::to_vec(&(
&source.jdbc_driver,
&source.url,
&source.user,
source.read_only,
&source.properties,
&source.options,
))
.map_err(|e| IdeError::internal(e.to_string()))?;
Ok((
registry.with_file_name("jdbc-approvals").join(blake3::hash(&key).to_hex().as_str()),
blake3::hash(&settings).to_hex().to_string(),
))
}
/// Called only for the source the user explicitly saved in the connection dialog.
pub fn approve_jdbc_source(&self, source: &DataSource) -> IdeResult<()> {
if source.driver != crate::DbDriver::Jdbc || source.plugin_owner.is_some() {
return Err(IdeError::invalid("Expected a user-managed JDBC data source"));
}
let (path, fingerprint) = self.jdbc_approval(source)?;
persist_local(&path, fingerprint.as_bytes())
}
pub(crate) async fn open_pool(
&self,
source: &DataSource,
password: Option<&str>,
testing: bool,
) -> IdeResult<crate::Pool> {
if source.driver != crate::DbDriver::Jdbc {
return crate::Pool::connect(source, password, Some(&self.root)).await;
}
if source.plugin_owner.is_some() {
return Err(IdeError::invalid("Plugins cannot start custom JDBC drivers"));
}
if !testing && !source.global {
let (path, expected) = self.jdbc_approval(source)?;
if std::fs::read_to_string(path).ok().as_deref() != Some(&expected) {
return Err(IdeError::invalid(
"Review this project's JDBC URL and properties, then save the data source before connecting",
));
}
}
let driver = self
.jdbc_drivers()?
.into_iter()
.find(|d| d.id == source.jdbc_driver)
.ok_or_else(|| IdeError::invalid("Select an installed JDBC driver profile"))?;
JdbcPool::connect(source, password, driver, self.jdbc_registry()?.with_file_name("jdbc"))
.await
.map(Box::new)
.map(crate::Pool::Jdbc)
}
}
struct Bridge {
stop: tokio::sync::oneshot::Sender<()>,
exited: tokio::task::JoinHandle<()>,
sequence: u64,
input: ChildStdin,
output: ChildStdout,
}
pub struct JdbcPool {
bridge: Mutex<Option<Bridge>>,
closed: CancellationToken,
pub(crate) version: String,
pub(crate) identifier_quote: String,
}
impl Bridge {
fn start(cache: &Path, jars: &[String]) -> IdeResult<Self> {
let jdks = ide_sdk::java::installed_jdks();
let java = ide_sdk::java::java_runtime(&jdks, 17)
.ok_or_else(|| IdeError::invalid("Install a Java 17 or newer runtime to use custom JDBC drivers"))?;
let jar = ide_sdk::java::jdbc_bridge_jar(cache)
.ok_or_else(|| IdeError::invalid("Cannot install the JDBC bridge in the application data directory"))?;
let classpath = std::env::join_paths(std::iter::once(jar.as_path()).chain(jars.iter().map(Path::new)))
.map_err(|_| IdeError::invalid("A JDBC JAR path contains the system classpath separator"))?;
// Embedded databases can resolve file URLs against the JVM's working directory.
let files = cache.join("files");
std::fs::create_dir_all(&files)?;
let mut command = Command::new(ide_sdk::java::java_executable(&java.home));
command.current_dir(files);
ide_core::process::prepare(command.as_std_mut());
let mut child = command
.args(["-Xms8m", "-Xmx192m", "--enable-native-access=ALL-UNNAMED", "-cp"])
.arg(classpath)
.arg("ai.openidea.jdbc.OpenIdeaJdbc")
.env_remove("CLASSPATH")
.env_remove("JDK_JAVA_OPTIONS")
.env_remove("JAVA_TOOL_OPTIONS")
.env_remove("_JAVA_OPTIONS")
.kill_on_drop(true)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::null())
.spawn()?;
let input = child.stdin.take().expect("piped");
let output = child.stdout.take().expect("piped");
let (stop, stopped) = tokio::sync::oneshot::channel();
let exited = tokio::spawn(async move {
tokio::select! {
stop = stopped => {
// Disconnect closes stdin so a file-backed driver can flush. A dropped
// request or an unresponsive driver must be reaped without waiting.
if stop.is_err() || tokio::time::timeout(Duration::from_secs(2), child.wait()).await.is_err() {
let _ = child.kill().await;
}
}
_ = child.wait() => {}
}
});
Ok(Self { input, output, stop, exited, sequence: 0 })
}
async fn close(self) {
drop(self.input);
let _ = self.stop.send(());
let _ = self.exited.await;
}
}
// Request: u64 request id, u32 field count, then length-prefixed UTF-8 fields.
// Zero fields cancels that id. Replies have a u32 length; zero acknowledges Cancel.
fn encode(id: u64, fields: &[&str]) -> IdeResult<Vec<u8>> {
if fields.is_empty() || fields.len() > 8192 {
return Err(IdeError::invalid("Invalid JDBC field count"));
}
let size = fields
.iter()
.try_fold(12usize, |n, s| n.checked_add(4)?.checked_add(s.len()).filter(|n| *n <= LIMIT))
.ok_or_else(|| IdeError::invalid("JDBC request exceeds 16 MiB"))?;
let mut data = Vec::with_capacity(size);
data.extend_from_slice(&id.to_be_bytes());
data.extend_from_slice(&(fields.len() as u32).to_be_bytes());
for field in fields {
data.extend_from_slice(&(field.len() as u32).to_be_bytes());
data.extend_from_slice(field.as_bytes());
}
Ok(data)
}
async fn read_frame(output: &mut (impl AsyncRead + Unpin)) -> IdeResult<Vec<u8>> {
let n = output.read_u32().await? as usize;
if n > LIMIT {
return Err(IdeError::invalid("JDBC response exceeds 16 MiB"));
}
let mut data = vec![0; n];
output.read_exact(&mut data).await?;
Ok(data)
}
const CANCEL_GRACE: Duration = Duration::from_secs(3);
fn cancel_timeout() -> IdeError {
IdeError::invalid("The JDBC driver did not stop in time. The session was closed. Reconnect to continue.")
}
async fn exchange(
input: &mut (impl AsyncWrite + Unpin),
output: &mut (impl AsyncRead + Unpin),
frame: Vec<u8>,
cancel: &CancellationToken,
) -> IdeResult<Option<Vec<u8>>> {
let mut stop = [0; 12];
stop[..8].copy_from_slice(&frame[..8]);
let early_deadline = {
let send = input.write_all(&frame);
tokio::pin!(send);
tokio::select! {
result = &mut send => { result?; None },
() = cancel.cancelled() => {
let end = Deadline::now() + CANCEL_GRACE;
timeout_at(end, send).await.map_err(|_| cancel_timeout())??;
Some(end)
}
}
};
drop(frame);
let (first, deadline) = {
let reply = read_frame(output);
tokio::pin!(reply);
let end = tokio::select! {
biased;
() = cancel.cancelled() => early_deadline.unwrap_or_else(|| Deadline::now() + CANCEL_GRACE),
data = &mut reply => {
let data = data?;
if data.is_empty() { return Err(IdeError::invalid("Unexpected JDBC cancellation acknowledgement")); }
return Ok(Some(data));
}
};
let first = timeout_at(end, async {
input.write_all(&stop).await?;
reply.await
})
.await
.map_err(|_| cancel_timeout())??;
(first, end)
};
// Drain both frames before the next statement can use this session. The driver
// may complete the statement before or after the control thread acknowledges it.
let data = if first.is_empty() {
timeout_at(deadline, read_frame(output)).await.map_err(|_| cancel_timeout())??
} else {
if timeout_at(deadline, output.read_u32()).await.map_err(|_| cancel_timeout())?? != 0 {
return Err(IdeError::invalid("Invalid JDBC cancellation acknowledgement"));
}
first
};
match data.first() {
// A committed statement may have finished before the control thread received Cancel.
Some(1) => Ok(Some(data)),
Some(0) => Ok(None),
_ => Err(IdeError::invalid("Invalid JDBC cancellation response")),
}
}
impl JdbcPool {
async fn connect(
source: &DataSource,
password: Option<&str>,
driver: DbJdbcDriver,
cache: PathBuf,
) -> IdeResult<Self> {
driver.validate()?;
let mut fields = vec![
"open".to_string(),
driver.class_name,
source.url.clone(),
source.user.clone(),
password.unwrap_or_default().to_owned(),
source.read_only.to_string(),
];
for p in &source.properties {
if p.name.eq_ignore_ascii_case("password") {
return Err(IdeError::invalid("Enter the JDBC password in the password field"));
}
fields.extend([p.name.clone(), p.value.clone()]);
}
let bridge = tokio::task::spawn_blocking(move || Bridge::start(&cache, &driver.jars))
.await
.map_err(|e| IdeError::internal(e.to_string()))??;
let mut pool = Self {
bridge: Mutex::new(Some(bridge)),
closed: CancellationToken::new(),
version: String::new(),
identifier_quote: String::new(),
};
let args: Vec<_> = fields.iter().map(String::as_str).collect();
let cancel = CancellationToken::new();
let result = tokio::time::timeout(Duration::from_secs(30), pool.request(&args, "", &cancel))
.await
.map_err(|_| IdeError::new(ide_core::error::ErrorKind::TimedOut, "JDBC connection timed out"))??;
let mut metadata = result.rows.into_iter().next().unwrap_or_default().into_iter();
pool.version = metadata.next().flatten().unwrap_or_else(|| "Connected".into());
pool.identifier_quote = metadata.next().flatten().unwrap_or_default().trim().into();
Ok(pool)
}
pub(crate) async fn close(&self) {
self.closed.cancel();
if let Some(bridge) = self.bridge.lock().await.take() {
bridge.close().await;
}
}
pub(crate) fn is_closed(&self) -> bool {
self.closed.is_cancelled()
}
pub(crate) async fn query(
&self,
sql: &str,
skip: usize,
max: usize,
cancel: &CancellationToken,
) -> IdeResult<QueryResult> {
self.query_in_schema(sql, skip, max, cancel, None).await
}
pub(crate) async fn query_in_schema(
&self,
sql: &str,
skip: usize,
max: usize,
cancel: &CancellationToken,
schema: Option<&str>,
) -> IdeResult<QueryResult> {
self.request(
&["query", sql, &skip.to_string(), &max.min(i32::MAX as usize).to_string(), schema.unwrap_or_default()],
sql,
cancel,
)
.await
}
pub(crate) async fn page(
&self,
sql: &str,
offset: u64,
limit: u64,
cancel: &CancellationToken,
) -> IdeResult<QueryResult> {
self.request(&["page", sql, &offset.to_string(), &limit.min(i32::MAX as u64).to_string()], sql, cancel).await
}
pub(crate) async fn metadata(&self, fields: &[&str]) -> IdeResult<Vec<Vec<Option<String>>>> {
Ok(self.request(fields, "", &CancellationToken::new()).await?.rows)
}
async fn request(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
let mut slot = tokio::select! {
biased;
() = cancel.cancelled() => return Err(IdeError::cancelled()),
() = self.closed.cancelled() => return Err(IdeError::invalid("JDBC connection is closed")),
slot = self.bridge.lock() => slot,
};
let bridge = slot
.as_mut()
.ok_or_else(|| IdeError::invalid("JDBC connection is closed; reconnect to start a new session"))?;
bridge.sequence = bridge.sequence.wrapping_add(1);
let frame = encode(bridge.sequence, fields)?;
let mut bridge = slot.take().expect("checked above");
// Dropping an in-flight request must discard its process and partially consumed frame.
let interrupted = self.closed.clone().drop_guard();
let start = Instant::now();
let response = tokio::select! {
biased;
() = self.closed.cancelled() => Err(IdeError::cancelled()),
response = exchange(&mut bridge.input, &mut bridge.output, frame, cancel) => response,
};
let data = match response {
Ok(data) => {
*slot = Some(bridge);
interrupted.disarm();
data
}
Err(e) => {
drop(bridge.stop);
let _ = bridge.exited.await;
return Err(e);
}
};
decode(&data.ok_or_else(IdeError::cancelled)?, sql, start.elapsed().as_secs_f64() * 1000.0)
}
}
fn decode(data: &[u8], sql: &str, elapsed_ms: f64) -> IdeResult<QueryResult> {
let mut input = Cursor::new(data);
fn bytes<const N: usize>(input: &mut Cursor<&[u8]>) -> IdeResult<[u8; N]> {
let mut buf = [0; N];
Read::read_exact(input, &mut buf)?;
Ok(buf)
}
fn flag(input: &mut Cursor<&[u8]>) -> IdeResult<bool> {
match bytes::<1>(input)? {
[0] => Ok(false),
[1] => Ok(true),
_ => Err(IdeError::invalid("Invalid JDBC flag")),
}
}
fn field(input: &mut Cursor<&[u8]>) -> IdeResult<Option<String>> {
let n = i32::from_be_bytes(bytes(input)?);
if n == -1 {
return Ok(None);
}
let start = input.position() as usize;
let end = start
.checked_add(n as usize)
.filter(|end| *end <= input.get_ref().len())
.ok_or_else(|| IdeError::invalid("Invalid JDBC field length"))?;
let value = String::from_utf8_lossy(&input.get_ref()[start..end]).into_owned();
input.set_position(end as u64);
Ok(Some(value))
}
if !flag(&mut input)? {
return Err(IdeError::invalid(field(&mut input)?.unwrap_or_else(|| "JDBC request failed".into())));
}
let count = u32::from_be_bytes(bytes(&mut input)?) as usize;
if count > data.len() / 8 {
return Err(IdeError::invalid("Invalid JDBC column count"));
}
let mut columns = Vec::new();
for _ in 0..count {
columns.push(ResultColumn {
name: field(&mut input)?.unwrap_or_default(),
type_name: field(&mut input)?.unwrap_or_default(),
});
}
let mut rows = vec![];
while flag(&mut input)? {
if count == 0 {
return Err(IdeError::invalid("JDBC returned a row with no columns"));
}
rows.push((0..count).map(|_| field(&mut input)).collect::<IdeResult<_>>()?);
}
let has_more = flag(&mut input)?;
let affected = i64::from_be_bytes(bytes(&mut input)?);
if input.position() != data.len() as u64 {
return Err(IdeError::invalid("Invalid trailing JDBC response data"));
}
Ok(QueryResult {
statement: sql.into(),
columns,
rows,
has_more,
affected: (affected >= 0).then_some(affected as f64),
elapsed_ms,
execution_ms: elapsed_ms,
})
}
impl DbManager {
pub(crate) async fn jdbc_completion(&self, id: &str, pool: &JdbcPool) -> IdeResult<crate::CompletionModel> {
let mut tables = vec![];
let schemas = self.schemas(id).await?;
for schema in &schemas {
for table in self.tables(id, schema).await? {
tables.push(crate::CompletionTable {
schema: schema.clone(),
name: table.name,
kind: table.kind,
columns: vec![],
});
if tables.len() >= crate::MAX_META_ROWS {
break;
}
}
if tables.len() >= crate::MAX_META_ROWS {
break;
}
}
Ok(crate::CompletionModel {
default_schema: pool
.metadata(&["namespace"])
.await?
.into_iter()
.flatten()
.flatten()
.next()
.unwrap_or_default(),
tables,
foreign_keys: vec![],
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn frame_codec_checks_both_16_mib_boundaries() {
assert_eq!(encode(7, &["a"]).unwrap(), [0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 1, b'a']);
let mut field = "x".repeat(LIMIT - 16);
assert_eq!(encode(1, &[&field]).unwrap().len(), LIMIT);
field.push('x');
assert!(encode(1, &[&field]).is_err());
let mut framed = vec![0u8; LIMIT + 4];
framed[..4].copy_from_slice(&(LIMIT as u32).to_be_bytes());
assert_eq!(read_frame(&mut framed.as_slice()).await.unwrap().len(), LIMIT);
assert!(read_frame(&mut &((LIMIT + 1) as u32).to_be_bytes()[..]).await.is_err());
assert!(read_frame(&mut &[0, 0, 0, 2, 1u8][..]).await.is_err());
}
#[tokio::test]
async fn cancel_drains_partial_replies_in_either_order() {
for ack_first in [true, false] {
let (mut input, mut peer_input) = tokio::io::duplex(1);
let (mut output, mut peer_output) = tokio::io::duplex(1);
let cancel = CancellationToken::new();
let frame = encode(42, &["query"]).unwrap();
let peer = async {
let mut request = vec![0; frame.len()];
peer_input.read_exact(&mut request).await.unwrap();
assert_eq!(request, frame);
// The one-byte pipe forces the reader to consume part of the header before Cancel.
peer_output.write_all(&[0, 0]).await.unwrap();
cancel.cancel();
let mut stop = [0; 12];
peer_input.read_exact(&mut stop).await.unwrap();
assert_eq!(&stop[..8], &42u64.to_be_bytes());
assert_eq!(&stop[8..], &[0; 4]);
let frames = if ack_first { [0, 0, 0, 0, 0, 1, 0] } else { [0, 1, 1, 0, 0, 0, 0] };
peer_output.write_all(&frames).await.unwrap();
};
let (result, ()) = tokio::join!(exchange(&mut input, &mut output, frame.clone(), &cancel), peer);
assert_eq!(result.unwrap(), (!ack_first).then(|| vec![1]));
}
}
#[tokio::test]
async fn exchange_rejects_unexpected_acknowledgements() {
let cancel = CancellationToken::new();
let mut sink = tokio::io::sink();
let mut reply = &[0, 0, 0, 1, 1u8][..];
assert_eq!(
exchange(&mut sink, &mut reply, encode(1, &["query"]).unwrap(), &cancel).await.unwrap(),
Some(vec![1])
);
for cancelled in [false, true] {
if cancelled {
cancel.cancel();
}
let mut duplicate_ack = &[0u8; 8][..];
assert!(exchange(&mut sink, &mut duplicate_ack, encode(1, &["query"]).unwrap(), &cancel).await.is_err());
}
let (mut peer, mut output) = tokio::io::duplex(4);
peer.write_u32(0).await.unwrap();
let error = exchange(&mut sink, &mut output, encode(1, &["query"]).unwrap(), &cancel).await.unwrap_err();
assert_eq!(error.message, cancel_timeout().message);
}
#[test]
fn result_codec_preserves_null_and_rejects_incomplete_frames() {
let mut frame =
vec![1, 0, 0, 0, 1, 0, 0, 0, 1, b'n', 0, 0, 0, 3, b'i', b'n', b't', 1, 255, 255, 255, 255, 0, 0];
frame.extend_from_slice(&(-1i64).to_be_bytes());
let result = decode(&frame, "select", 0.).unwrap();
assert_eq!(result.columns[0].name, "n");
assert_eq!(result.rows, [vec![None]]);
for end in 0..frame.len() {
assert!(decode(&frame[..end], "", 0.).is_err());
}
frame.push(0);
assert!(decode(&frame, "", 0.).is_err());
assert!(decode(&[2], "", 0.).is_err());
}
}
+62 -11
Переглянути файл
@@ -4,6 +4,8 @@
pub mod catalog;
mod clickhouse;
mod jdbc;
pub use jdbc::{DbJdbcDriver, jdbc_driver_classes};
pub mod conn;
pub mod history;
mod oracle;
@@ -339,7 +341,7 @@ fn group_foreign_keys(rows: Vec<Vec<Option<String>>>, tables: &[CompletionTable]
/// never contain `:`.
/// Snowflake is HTTPS to a named host: a tunnel's local end cannot pass its certificate check.
fn tunneled(driver: DbDriver) -> bool {
!matches!(driver, DbDriver::Sqlite | DbDriver::Snowflake)
!matches!(driver, DbDriver::Sqlite | DbDriver::Snowflake | DbDriver::Jdbc)
}
/// The database host and port the SSH host forwards to.
@@ -759,7 +761,7 @@ impl DbManager {
};
let (target, tunnel) = self.endpoint(source, ssh_secret, false).await?;
self.restore_sso(source).await;
let connected = Pool::connect(&target, password.as_deref(), Some(&self.root)).await;
let connected = self.open_pool(&target, password.as_deref(), true).await;
self.keep_sso(source).await;
let pool = connected.map_err(|e| {
through_tunnel(
@@ -768,7 +770,13 @@ impl DbManager {
tunnel.is_some().then(|| self.ssh_label(source.ssh.as_ref().expect("tunneled"))).as_deref(),
)
})?;
if let Pool::Jdbc(p) = &pool {
let version = p.version.clone();
pool.close().await;
return Ok(version);
}
let version = match source.driver {
DbDriver::Jdbc => unreachable!("JDBC uses driver metadata"),
DbDriver::Sqlite => "SELECT 'SQLite ' || sqlite_version()",
DbDriver::Postgres | DbDriver::Clickhouse => "SELECT version()",
DbDriver::Mysql => "SELECT CONCAT(@@version_comment, ' ', VERSION())",
@@ -861,7 +869,7 @@ impl DbManager {
let password = self.password(&source).await;
let (target, tunnel) = self.endpoint(&source, None, true).await?;
self.restore_sso(&source).await;
let connected = Pool::connect(&target, password.as_deref(), Some(&self.root)).await;
let connected = self.open_pool(&target, password.as_deref(), false).await;
self.keep_sso(&source).await;
let pool = match connected {
Ok(p) => Arc::new(p),
@@ -1071,7 +1079,10 @@ impl DbManager {
if let Pool::Snowflake(p) = &*pool {
return snowflake::meta::schemas(p, system).await;
}
let rows = pool.rows(sql::schemas(pool.driver(), system), MAX_META_ROWS).await?;
let rows = match &*pool {
Pool::Jdbc(p) => p.metadata(&["schemas"]).await?,
_ => pool.rows(sql::schemas(pool.driver(), system), MAX_META_ROWS).await?,
};
Ok(rows.into_iter().filter_map(|r| r.into_iter().next().flatten()).collect())
}
@@ -1080,7 +1091,10 @@ impl DbManager {
if let Pool::Snowflake(p) = &*pool {
return snowflake::meta::tables(p, schema).await;
}
let rows = pool.rows(&sql::tables(pool.driver(), schema), MAX_META_ROWS).await?;
let rows = match &*pool {
Pool::Jdbc(p) => p.metadata(&["tables", schema]).await?,
_ => pool.rows(&sql::tables(pool.driver(), schema), MAX_META_ROWS).await?,
};
Ok(rows
.into_iter()
.filter_map(|r| {
@@ -1097,9 +1111,11 @@ impl DbManager {
return snowflake::meta::table_details(p, schema, table).await;
}
let driver = pool.driver();
let columns = pool
.rows(&sql::columns(driver, schema, table), MAX_META_ROWS)
.await?
let rows = match &*pool {
Pool::Jdbc(p) => p.metadata(&["columns", schema, table]).await?,
_ => pool.rows(&sql::columns(driver, schema, table), MAX_META_ROWS).await?,
};
let columns = rows
.into_iter()
.filter_map(|r| {
let mut it = r.into_iter();
@@ -1111,6 +1127,9 @@ impl DbManager {
Some(ColumnInfo { name, data_type, nullable, default, primary_key })
})
.collect();
if driver == DbDriver::Jdbc {
return Ok(TableDetails { columns, indexes: vec![], foreign_keys: vec![], triggers: vec![] });
}
let mut indexes: Vec<IndexInfo> = Vec::new();
for r in pool.rows(&sql::indexes(driver, schema, table), MAX_META_ROWS).await? {
let mut it = r.into_iter();
@@ -1271,6 +1290,7 @@ impl DbManager {
rows.into_iter().filter_map(|r| r.into_iter().nth(i).flatten()).collect()
};
match driver {
DbDriver::Jdbc => Err(IdeError::invalid("Custom JDBC sources do not provide vendor-specific DDL")),
DbDriver::Sqlite => {
let stmts = cells(pool.rows(&sql::sqlite_ddl(schema, name), MAX_META_ROWS).await?, 0);
if stmts.is_empty() {
@@ -1395,6 +1415,7 @@ impl DbManager {
let driver = pool.driver();
let mut tables: Vec<CompletionTable> = Vec::new();
let rows = match &*pool {
Pool::Jdbc(p) => return self.jdbc_completion(id, p).await,
Pool::Snowflake(p) => {
tables = snowflake::meta::completion(p).await?;
Vec::new()
@@ -1515,6 +1536,9 @@ impl DbManager {
schema: Option<&str>,
) -> IdeResult<Vec<PlanNode>> {
let driver = self.pool(id).await?.driver();
if driver == DbDriver::Jdbc {
return Err(IdeError::invalid("Custom JDBC execution plans are unsupported"));
}
if driver == DbDriver::Oracle {
// EXPLAIN PLAN writes PLAN_TABLE; the plan is read (and cleaned up) separately.
let plan_id = format!(
@@ -1554,6 +1578,9 @@ impl DbManager {
schema: Option<&str>,
) -> IdeResult<QueryResult> {
let pool = self.pool(id).await?;
if let Pool::Jdbc(p) = &*pool {
return p.query_in_schema(statement, skip, max_rows, cancel, schema).await;
}
let session = self.sessions.lock().get(id).cloned();
let Some(session) = session else {
if schema.is_none() {
@@ -1595,6 +1622,9 @@ impl DbManager {
/// Switches `id` between auto-commit and manual commit. Leaving manual
/// mode rolls back what was not committed.
pub async fn set_manual_commit(&self, id: &str, manual: bool) -> IdeResult<()> {
if manual && self.source(id)?.driver == DbDriver::Jdbc {
return Err(IdeError::invalid("Custom JDBC manual transactions are unsupported"));
}
if manual {
if self.source(id)?.driver == DbDriver::Clickhouse {
return Err(IdeError::invalid("ClickHouse manual transactions are unsupported"));
@@ -1614,6 +1644,9 @@ impl DbManager {
if self.source(id).is_ok_and(|s| s.driver == DbDriver::Clickhouse) {
return Err(IdeError::invalid("ClickHouse manual transactions are unsupported"));
}
if self.source(id).is_ok_and(|s| s.driver == DbDriver::Jdbc) {
return Err(IdeError::invalid("Custom JDBC manual transactions are unsupported"));
}
let session = self.sessions.lock().get(id).cloned();
let Some(session) = session else { return Ok(()) };
let mut held = session.lock().await;
@@ -1649,8 +1682,22 @@ impl DbManager {
) -> IdeResult<TablePage> {
let details = self.table_details(id, schema, table).await?;
let pool = self.pool(id).await?;
let sql = sql::table_page(pool.driver(), schema, table, filter, sort, offset, limit);
let mut result = pool.execute(&sql, limit as usize, cancel).await?;
let mut result = if let Pool::Jdbc(p) = &*pool {
let q = &p.identifier_quote;
let names = [schema, table].into_iter().chain(sort.iter().map(|k| k.column.as_str()));
if q.is_empty()
&& names.into_iter().any(|name| !name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_'))
{
return Err(IdeError::invalid("This JDBC driver cannot quote the selected identifier"));
}
let quote = |s: &str| format!("{q}{}{q}", s.replace(q, &format!("{q}{q}")));
let name = if schema.is_empty() { quote(table) } else { format!("{}.{}", quote(schema), quote(table)) };
let sql = sql::table_select(&name, filter, sort, quote);
p.page(&sql, offset, limit, cancel).await?
} else {
let sql = sql::table_page(pool.driver(), schema, table, filter, sort, offset, limit);
pool.execute(&sql, limit as usize, cancel).await?
};
if result.columns.is_empty() {
result.columns = details
.columns
@@ -1663,7 +1710,11 @@ impl DbManager {
/// Applies the table editor's pending changes in one transaction.
pub async fn apply_edits(&self, id: &str, schema: &str, table: &str, edits: &[DbRowEdit]) -> IdeResult<u64> {
if self.source(id)?.driver == DbDriver::Clickhouse {
let source = self.source(id)?;
if source.read_only {
return Err(IdeError::new(ErrorKind::PermissionDenied, "the data source is read-only"));
}
if source.driver == DbDriver::Clickhouse {
return Err(IdeError::invalid("ClickHouse table editing is unsupported"));
}
let pool = self.pool(id).await?;
+2 -1
Переглянути файл
@@ -36,7 +36,7 @@ pub fn explain_statement(driver: DbDriver, statement: &str) -> String {
DbDriver::Sqlite => format!("EXPLAIN QUERY PLAN {s}"),
DbDriver::Postgres => format!("EXPLAIN (FORMAT JSON) {s}"),
DbDriver::Clickhouse => format!("EXPLAIN json = 1 {s}"),
DbDriver::Mysql => format!("EXPLAIN {s}"),
DbDriver::Mysql | DbDriver::Jdbc => format!("EXPLAIN {s}"),
DbDriver::SqlServer => format!("SET SHOWPLAN_TEXT ON; {s}"),
DbDriver::Oracle => format!("EXPLAIN PLAN FOR {s}"),
DbDriver::Snowflake => format!("EXPLAIN USING TABULAR {s}"),
@@ -77,6 +77,7 @@ pub fn parse(driver: DbDriver, result: &QueryResult) -> IdeResult<Vec<PlanNode>>
let names: Vec<&str> = result.columns.iter().map(|c| c.name.as_str()).collect();
Ok(mysql(&names, &result.rows))
}
DbDriver::Jdbc => Err(IdeError::invalid("Custom JDBC execution plans are unsupported")),
DbDriver::SqlServer => Ok(Vec::new()),
DbDriver::Snowflake => {
let names: Vec<&str> = result.columns.iter().map(|c| c.name.as_str()).collect();
+18 -3
Переглянути файл
@@ -23,12 +23,13 @@ pub enum DbDriver {
/// Oracle Database (pure-Rust thin driver, no client library).
Oracle,
Snowflake,
Jdbc,
}
impl DbDriver {
pub fn default_port(self) -> Option<u16> {
match self {
DbDriver::Sqlite => None,
DbDriver::Sqlite | DbDriver::Jdbc => None,
DbDriver::Postgres => Some(5432),
DbDriver::Mysql => Some(3306),
DbDriver::SqlServer => Some(1433),
@@ -191,6 +192,9 @@ pub struct DataSource {
pub id: String,
pub name: String,
pub driver: DbDriver,
/// An app-wide driver profile id; classpaths never come from a project.
#[serde(skip_serializing_if = "String::is_empty")]
pub jdbc_driver: String,
pub host: String,
pub port: Option<u16>,
pub database: String,
@@ -237,6 +241,7 @@ impl Default for DataSource {
id: String::new(),
name: String::new(),
driver: DbDriver::Sqlite,
jdbc_driver: String::new(),
host: "localhost".into(),
port: None,
database: String::new(),
@@ -390,6 +395,12 @@ impl DataSource {
/// database, user, SSL and driver properties come from the URL (properties
/// of the Advanced tab still apply after the URL's).
pub fn resolved(&self) -> IdeResult<DataSource> {
if self.driver == DbDriver::Jdbc {
if !self.url.starts_with("jdbc:") {
return Err(IdeError::invalid("Enter a JDBC URL starting with jdbc:"));
}
return Ok(self.clone());
}
if !self.url_only {
return Ok(self.clone());
}
@@ -476,7 +487,7 @@ impl DataSource {
/// The password written in the URL of a [`DataSource::url_only`] data source.
pub fn url_password(&self) -> Option<String> {
if !self.url_only {
if self.driver == DbDriver::Jdbc || !self.url_only {
return None;
}
parse_url(&self.url).ok()?.password
@@ -491,7 +502,11 @@ struct SourcesFile {
/// The project's data sources.
pub fn load(root: &Path) -> IdeResult<Vec<DataSource>> {
read(&project_dir::path(root, FILE))
let mut sources = read(&project_dir::path(root, FILE))?;
for source in &mut sources {
source.global = false;
}
Ok(sources)
}
/// Saves the project's data sources.
+34 -15
Переглянути файл
@@ -70,6 +70,7 @@ pub fn sqlserver_databases() -> &'static str {
pub fn schemas(driver: DbDriver, system: bool) -> &'static str {
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Sqlite => "SELECT name FROM pragma_database_list WHERE name <> 'temp' ORDER BY seq",
DbDriver::Clickhouse if system => "SELECT name FROM system.databases ORDER BY name",
DbDriver::Clickhouse => {
@@ -114,6 +115,7 @@ pub fn schemas(driver: DbDriver, system: bool) -> &'static str {
/// Rows: `name, kind` where kind is `table`, `view` or `materialized view`.
pub fn tables(driver: DbDriver, schema: &str) -> String {
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse => format!(
"SELECT name, CASE engine WHEN 'View' THEN 'view' WHEN 'MaterializedView' THEN 'materialized view' \
WHEN 'WindowView' THEN 'view' ELSE 'table' END FROM system.tables \
@@ -164,6 +166,7 @@ const SNOWFLAKE_TYPE: &str = "CASE WHEN data_type = 'NUMBER' THEN 'NUMBER(' || n
pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse => format!(
"SELECT name, type, CASE WHEN startsWith(type, 'Nullable(') \
OR startsWith(type, 'LowCardinality(Nullable(') THEN 'YES' ELSE 'NO' END, \
@@ -225,6 +228,7 @@ pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {
pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse => format!(
"SELECT * FROM (SELECT 'PRIMARY KEY' AS index_name, 0 AS is_unique, primary_key AS expression \
FROM system.tables WHERE database = {s} AND name = {t} AND primary_key != '' \
@@ -269,6 +273,7 @@ pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
/// for SQL completion, grouped by table in column order.
pub fn completion_columns(driver: DbDriver) -> &'static str {
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse => {
"SELECT c.database, c.table, CASE t.engine WHEN 'View' THEN 'view' \
WHEN 'MaterializedView' THEN 'materialized view' WHEN 'WindowView' THEN 'view' ELSE 'table' END, \
@@ -357,6 +362,7 @@ pub fn completion_columns(driver: DbDriver) -> &'static str {
/// when the key references the primary key implicitly.
pub fn foreign_keys(driver: DbDriver) -> &'static str {
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse => "SELECT '', '', '', '', '', '', '' WHERE 0",
DbDriver::Snowflake => "SELECT '', '', '', '', '', '', '' WHERE 1 = 0",
DbDriver::Sqlite => {
@@ -409,6 +415,7 @@ pub fn foreign_keys(driver: DbDriver) -> &'static str {
pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String {
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse | DbDriver::Snowflake => foreign_keys(driver).to_owned(),
DbDriver::Sqlite => format!(
"SELECT {s}, {t}, f.id, f.\"from\", {s}, f.\"table\", f.\"to\" FROM pragma_foreign_key_list({t}, {s}) f ORDER BY f.id, f.seq"
@@ -432,7 +439,7 @@ pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String
pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
match driver {
DbDriver::Clickhouse => Some("SELECT currentDatabase()"),
DbDriver::Sqlite => None,
DbDriver::Sqlite | DbDriver::Jdbc => None,
DbDriver::Postgres => Some("SELECT current_schema()"),
DbDriver::Mysql => Some("SELECT DATABASE()"),
DbDriver::SqlServer => Some("SELECT DB_NAME()"),
@@ -446,7 +453,7 @@ pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
/// has no schema to switch — SQLite's `main`, ClickHouse's `USE` differs).
pub fn use_schema(driver: DbDriver, schema: &str) -> Option<String> {
match driver {
DbDriver::Sqlite | DbDriver::Clickhouse => None,
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc => None,
DbDriver::Postgres => Some(format!("SET search_path TO {}", quote_ident(driver, schema))),
DbDriver::Mysql | DbDriver::SqlServer => Some(format!("USE {}", quote_ident(driver, schema))),
DbDriver::Oracle => Some(format!("ALTER SESSION SET CURRENT_SCHEMA = {}", quote_ident(driver, schema))),
@@ -462,17 +469,13 @@ pub struct SortKey {
pub descending: bool,
}
/// One page of a table: `limit + 1` rows so the caller knows whether more exist.
pub fn table_page(
driver: DbDriver,
schema: &str,
table: &str,
pub(crate) fn table_select(
qualified_name: &str,
filter: Option<&str>,
sort: &[SortKey],
offset: u64,
limit: u64,
quote: impl Fn(&str) -> String,
) -> String {
let mut sql = format!("SELECT * FROM {}", qualified(driver, schema, table));
let mut sql = format!("SELECT * FROM {}", qualified_name);
if let Some(f) = filter.map(str::trim).filter(|f| !f.is_empty()) {
let mut f = f.strip_prefix("WHERE ").or_else(|| f.strip_prefix("where ")).unwrap_or(f);
if let Some(i) = f.find(';') {
@@ -484,12 +487,24 @@ pub fn table_page(
}
}
if !sort.is_empty() {
let keys: Vec<String> = sort
.iter()
.map(|k| format!("{}{}", quote_ident(driver, &k.column), if k.descending { " DESC" } else { "" }))
.collect();
let keys: Vec<String> =
sort.iter().map(|k| format!("{}{}", quote(&k.column), if k.descending { " DESC" } else { "" })).collect();
sql.push_str(&format!(" ORDER BY {}", keys.join(", ")));
}
sql
}
/// One page of a table: `limit + 1` rows so the caller knows whether more exist.
pub fn table_page(
driver: DbDriver,
schema: &str,
table: &str,
filter: Option<&str>,
sort: &[SortKey],
offset: u64,
limit: u64,
) -> String {
let mut sql = table_select(&qualified(driver, schema, table), filter, sort, |name| quote_ident(driver, name));
if driver == DbDriver::SqlServer {
if sort.is_empty() {
sql.push_str(" ORDER BY (SELECT 1)");
@@ -535,6 +550,9 @@ fn where_key(driver: DbDriver, key: &[CellValue]) -> String {
/// The DML statement for `edit`. Values are written as quoted literals, which
/// every supported database coerces to the column type.
pub fn edit_statement(driver: DbDriver, schema: &str, table: &str, edit: &DbRowEdit) -> Result<String, String> {
if driver == DbDriver::Jdbc {
return Err("Custom JDBC table editing is unsupported".into());
}
if driver == DbDriver::Clickhouse {
return Err("ClickHouse table editing is unsupported: primary keys do not uniquely identify rows and edits require transactions".into());
}
@@ -631,6 +649,7 @@ pub fn postgres_ddl_indexes(oid: u32) -> String {
pub fn triggers(driver: DbDriver, schema: &str, table: &str) -> String {
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
match driver {
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
DbDriver::Clickhouse => "SELECT '', '', '' WHERE 0".to_owned(),
DbDriver::Snowflake => "SELECT '', '', '' WHERE 1 = 0".to_owned(),
DbDriver::Sqlite => format!(
@@ -691,7 +710,7 @@ pub fn postgres_legacy(sql: &str) -> Option<String> {
pub fn routines(driver: DbDriver, schema: &str) -> Option<String> {
let s = quote_literal(driver, schema);
match driver {
DbDriver::Sqlite | DbDriver::Clickhouse => None,
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc => None,
// Functions of extensions are left out, as in IDEA.
DbDriver::Postgres => Some(format!(
"SELECT p.proname, CASE WHEN p.prokind = 'p' THEN 'procedure' ELSE 'function' END, \
+215
Переглянути файл
@@ -0,0 +1,215 @@
use ide_core::{CancellationToken, IdeResult};
use ide_db::{DataSource, DbDriver, DbJdbcDriver, DbManager, SortKey};
use std::{path::Path, sync::Arc};
fn manager(dir: &Path) -> DbManager {
let ssh = Arc::new(ide_ssh::SshManager::new(dir.join("ssh.json")));
DbManager::new(dir.join("project"), dir.join("passwords.json"), dir.join("history.json"), ssh)
.with_global_sources(dir.join("global"))
}
#[tokio::test]
async fn jdbc_profiles_persist_and_project_files_cannot_start_drivers() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let jar = tmp.path().join("fixture.jar");
std::fs::write(&jar, [])?;
let db = manager(tmp.path());
db.save_jdbc_driver(DbJdbcDriver {
id: "fixture".into(),
name: "Test".into(),
jars: vec![jar.display().to_string()],
class_name: "test.Driver".into(),
url_template: "jdbc:test:".into(),
})?;
let reopened = manager(tmp.path());
assert_eq!(reopened.jdbc_drivers()?[0].class_name, "test.Driver");
let source = DataSource {
id: "local".into(),
name: "local".into(),
driver: DbDriver::Jdbc,
jdbc_driver: "fixture".into(),
url: "jdbc:test:".into(),
..Default::default()
};
reopened.save_sources(vec![source.clone()]).await?;
let denied = reopened.pool("local").await.err().expect("project JDBC requires explicit approval");
assert!(denied.message.contains("Review this project"));
let readonly = DataSource { read_only: true, ..source.clone() };
reopened.save_sources(vec![readonly]).await?;
let err = reopened.apply_edits("local", "main", "sample", &[]).await.unwrap_err();
assert_eq!(err.kind, ide_core::error::ErrorKind::PermissionDenied);
reopened.approve_jdbc_source(&source)?;
let mut changed = source.clone();
changed.url.push_str("changed");
reopened.save_sources(vec![changed]).await?;
assert!(reopened.pool("local").await.err().unwrap().message.contains("Review this project"));
let mut global = source;
global.global = true;
reopened.save_sources(vec![global]).await?;
assert!(reopened.remove_jdbc_driver("fixture").is_err());
reopened.save_sources(vec![]).await?;
reopened.remove_jdbc_driver("fixture")?;
assert!(manager(tmp.path()).jdbc_drivers()?.is_empty());
Ok(())
}
#[tokio::test]
#[ignore = "requires DUCKDB_JDBC_JAR and a local Java 17+ runtime"]
async fn duckdb_custom_driver_through_database_manager() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let db = manager(tmp.path());
let jar = std::env::var("DUCKDB_JDBC_JAR").expect("DUCKDB_JDBC_JAR");
assert_eq!(ide_db::jdbc_driver_classes(std::slice::from_ref(&jar))?, ["org.duckdb.DuckDBDriver"]);
db.save_jdbc_driver(DbJdbcDriver {
id: "duck".into(),
name: "DuckDB".into(),
jars: vec![jar],
class_name: "org.duckdb.DuckDBDriver".into(),
url_template: "jdbc:duckdb:".into(),
})?;
let source = DataSource {
id: "test".into(),
name: "DuckDB".into(),
driver: DbDriver::Jdbc,
global: true,
jdbc_driver: "duck".into(),
url: "jdbc:duckdb:local.duckdb".into(),
..Default::default()
};
assert!(db.test(&source, None, None).await?.to_lowercase().contains("duckdb"));
db.save_sources(vec![source]).await?;
let db = manager(tmp.path());
let c = CancellationToken::new();
db.execute("test", "create table items(id int primary key, label varchar)", 1, &c).await?;
db.execute("test", "insert into items values (1, NULL), (2, 'row')", 1, &c).await?;
assert!(db.schemas("test").await?.iter().any(|v| v == "main"));
assert!(db.tables("test", "main").await?.iter().any(|v| v.name == "items"));
let details = db.table_details("test", "main", "items").await?;
assert_eq!(details.columns.len(), 2);
let result = db.execute("test", "select id, label from items order by id", 1, &c).await?;
assert!(result.has_more);
assert_eq!(result.rows, vec![vec![Some("1".into()), None]]);
assert_eq!(result.columns[1].name, "label");
assert_eq!(db.completion("test").await?.default_schema, "main");
db.execute("test", "create temporary table session_marker as select 42 as id", 1, &c).await?;
let stop = CancellationToken::new();
let (cancelled, ()) =
tokio::join!(db.execute("test", "select sum(sin(i)) from range(1000000000) t(i)", 1, &stop), async {
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
stop.cancel();
},);
assert_eq!(cancelled.unwrap_err().kind, ide_core::error::ErrorKind::Cancelled);
let marker = db.execute("test", "select id from session_marker", 1, &c).await?;
assert_eq!(marker.rows, [vec![Some("42".into())]]);
let sort = [SortKey { column: "id".into(), descending: false }];
let first = db.table_page("test", "main", "items", None, &sort, 0, 1, &c).await?.result;
assert_eq!(first.rows, result.rows);
assert!(first.has_more);
let last = db.table_page("test", "main", "items", None, &sort, 1, 1, &c).await?.result;
assert_eq!(last.rows, vec![vec![Some("2".into()), Some("row".into())]]);
assert!(!last.has_more);
let past = db.table_page("test", "main", "items", None, &sort, 2, 1, &c).await?.result;
assert!(past.rows.is_empty() && !past.has_more);
db.disconnect("test").await;
let reopened = manager(tmp.path());
assert_eq!(reopened.execute("test", "select count(*) from items", 1, &c).await?.rows, [vec![Some("2".into())]]);
reopened.disconnect("test").await;
Ok(())
}
#[tokio::test]
#[ignore = "requires CLICKHOUSE_JDBC_CLASSPATH and a loopback ClickHouse fixture on CLICKHOUSE_JDBC_TEST_PORT"]
async fn clickhouse_vendor_driver_reads_catalog_and_results() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let db = manager(tmp.path());
let jars: Vec<String> =
std::env::split_paths(&std::env::var_os("CLICKHOUSE_JDBC_CLASSPATH").expect("CLICKHOUSE_JDBC_CLASSPATH"))
.map(|p| p.display().to_string())
.collect();
let classes = ide_db::jdbc_driver_classes(&jars)?;
assert_eq!(classes.first().map(String::as_str), Some("com.clickhouse.jdbc.ClickHouseDriver"));
let port: u16 = std::env::var("CLICKHOUSE_JDBC_TEST_PORT").unwrap().parse().unwrap();
db.save_jdbc_driver(DbJdbcDriver {
id: "clickhouse".into(),
name: "ClickHouse JDBC".into(),
jars,
class_name: "com.clickhouse.jdbc.ClickHouseDriver".into(),
url_template: "jdbc:clickhouse://".into(),
})?;
let source = DataSource {
id: "test".into(),
name: "ClickHouse JDBC".into(),
driver: DbDriver::Jdbc,
jdbc_driver: "clickhouse".into(),
url: format!("jdbc:clickhouse://127.0.0.1:{port}/default"),
user: "fixture".into(),
read_only: true,
..Default::default()
};
let password = "local-fixture";
assert!(db.test(&source, Some(password.into()), None).await?.contains("ClickHouse"));
db.approve_jdbc_source(&source)?;
db.save_sources(vec![source]).await?;
db.set_password("test", Some(password.into()), false).await?;
assert!(db.schemas("test").await?.iter().any(|v| v == "system"));
assert!(db.tables("test", "system").await?.iter().any(|v| v.name == "one"));
let cols = db.table_details("test", "system", "one").await?.columns;
assert!(cols.iter().any(|col| col.name == "dummy"));
let r = db.execute("test", "SELECT number FROM numbers(3) ORDER BY number", 2, &CancellationToken::new()).await?;
assert_eq!(r.rows.len(), 2);
assert!(r.has_more);
let c = CancellationToken::new();
let page = db.table_page("test", "system", "one", None, &[], 0, 1, &c).await?.result;
assert_eq!(page.rows.len(), 1);
assert!(!page.has_more);
let past = db.table_page("test", "system", "one", None, &[], 1, 1, &c).await?.result;
assert!(past.rows.is_empty() && !past.has_more);
db.disconnect("test").await;
Ok(())
}
#[tokio::test]
#[ignore = "requires JDBC_FIXTURE_JAR (java/jdbc-bridge/build.py --test --out fixture.jar) and Java 17+"]
async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
use std::time::Duration;
let tmp = tempfile::tempdir()?;
let db = manager(tmp.path());
let started = tmp.path().join("started");
db.save_jdbc_driver(DbJdbcDriver {
id: "fixture".into(),
name: "Fixture".into(),
jars: vec![std::env::var("JDBC_FIXTURE_JAR").unwrap()],
class_name: "ai.openidea.jdbc.SelfTest$Fixture".into(),
url_template: String::new(),
})?;
let source = DataSource {
id: "test".into(),
name: "Fixture".into(),
driver: DbDriver::Jdbc,
global: true,
read_only: true,
jdbc_driver: "fixture".into(),
url: format!("jdbc:fixture:{}", started.display()),
..Default::default()
};
db.test(&source, None, None).await?;
db.save_sources(vec![source]).await?;
let normal = CancellationToken::new();
assert!(db.execute("test", "write", 1, &normal).await.unwrap_err().message.contains("read-only"));
let stop = CancellationToken::new();
let (result, ()) = tokio::time::timeout(Duration::from_secs(12), async {
tokio::join!(db.execute("test", "ignore cancel", 1, &stop), async {
while !started.is_file() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
stop.cancel();
})
})
.await
.expect("driver cancellation must be bounded");
assert!(result.unwrap_err().message.contains("Reconnect"));
db.disconnect("test").await;
assert_eq!(db.execute("test", "after reconnect", 1, &normal).await?.affected, Some(1.0));
db.disconnect("test").await;
Ok(())
}
+15
Переглянути файл
@@ -0,0 +1,15 @@
[package]
name = "ide-flutter"
description = "Flutter devices from the `flutter daemon` protocol, and the project's DevTools server"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
ide-android = { path = "../ide-android" }
ide-core.workspace = true
parking_lot.workspace = true
serde_json.workspace = true
[dev-dependencies]
tempfile.workspace = true
+299
Переглянути файл
@@ -0,0 +1,299 @@
//! One `dart devtools` server per project window, started when first asked for. In `--machine`
//! mode it reports its port as a `server.started` line on stdout. A server that fails or exits
//! is not restarted on its own: the next request starts a new one.
use crate::{KILL_GRACE, OUTPUT_TAIL, keep_output, read_lines, spawn_watched};
use ide_core::process::{kill_tree, terminate_tree};
use ide_core::tool_path::{find_command, search_path_in};
use parking_lot::{Condvar, Mutex};
use serde_json::Value;
use std::collections::VecDeque;
use std::path::{Path, PathBuf};
use std::process::Child;
use std::sync::Arc;
use std::time::{Duration, Instant};
const START_TIMEOUT: Duration = Duration::from_secs(60);
/// The address embedded pages are allowed to come from, so never `localhost`.
const HOST: &str = "127.0.0.1";
const ARGS: [&str; 7] = ["devtools", "--machine", "--allow-embedding", "--host", HOST, "--port", "0"];
fn started_port(line: &str) -> Option<u16> {
let message: Value = serde_json::from_str(line.trim()).ok()?;
if message.get("event")?.as_str()? != "server.started" {
return None;
}
u16::try_from(message.get("params")?.get("port")?.as_u64()?).ok()
}
/// The `dart` of the SDK `flutter` belongs to, so that DevTools matches the debugged app.
fn dart_executable(root: &Path) -> Option<PathBuf> {
let path = search_path_in(root);
find_command("flutter", &path, root)
.and_then(|flutter| {
// On the search path `flutter` is often a link into the SDK.
let flutter = if cfg!(unix) { std::fs::canonicalize(&flutter).unwrap_or(flutter) } else { flutter };
let dart = flutter.with_file_name(if cfg!(windows) { "dart.bat" } else { "dart" });
dart.is_file().then_some(dart)
})
.or_else(|| find_command("dart", &path, root))
}
#[derive(Default)]
enum Status {
#[default]
Stopped,
Starting,
Ready(String),
Failed(String),
}
#[derive(Default)]
struct State {
/// Bumped by every start and stop: a reader of an older process no longer has a say.
generation: u64,
child: Option<Child>,
status: Status,
}
impl State {
fn shut_down(&mut self) {
self.generation += 1;
if let Some(mut child) = self.child.take() {
std::thread::spawn(move || terminate_tree(&mut child, KILL_GRACE));
}
}
}
struct Shared {
root: PathBuf,
/// Replaces the lookup on the search path (tests).
executable: Option<PathBuf>,
timeout: Duration,
state: Mutex<State>,
changed: Condvar,
}
impl Shared {
/// Applies `status` unless this process was replaced or stopped; false if it was.
fn set(&self, generation: u64, status: Status) -> bool {
let mut state = self.state.lock();
if state.generation != generation {
return false;
}
state.status = status;
self.changed.notify_all();
true
}
}
pub struct DevToolsServer(Arc<Shared>);
impl DevToolsServer {
pub fn new(root: PathBuf) -> Self {
Self::with_executable(root, None, START_TIMEOUT)
}
fn with_executable(root: PathBuf, executable: Option<PathBuf>, timeout: Duration) -> Self {
Self(Arc::new(Shared { root, executable, timeout, state: Mutex::default(), changed: Condvar::new() }))
}
/// The server's address, starting it if none runs. Blocks until it is known.
pub fn url(&self) -> Result<String, String> {
let shared = &self.0;
let deadline = Instant::now() + shared.timeout;
let mut state = shared.state.lock();
if matches!(state.status, Status::Stopped | Status::Failed(_)) {
state.generation += 1;
state.status = Status::Starting;
let (shared, generation) = (shared.clone(), state.generation);
std::thread::spawn(move || run(&shared, generation));
}
loop {
match &state.status {
Status::Ready(url) => return Ok(url.clone()),
Status::Failed(message) => return Err(message.clone()),
Status::Stopped => return Err("Flutter DevTools was stopped".into()),
Status::Starting => {}
}
if shared.changed.wait_until(&mut state, deadline).timed_out() {
state.shut_down();
let message = "Flutter DevTools did not start in time".to_owned();
state.status = Status::Failed(message.clone());
shared.changed.notify_all();
return Err(message);
}
}
}
/// Ends the server (project closed, or no longer trusted).
pub fn stop(&self) {
let mut state = self.0.state.lock();
state.shut_down();
state.status = Status::Stopped;
self.0.changed.notify_all();
}
/// Ends the server before returning, for a process about to exit.
pub fn kill(&self) {
let mut state = self.0.state.lock();
state.generation += 1;
state.status = Status::Stopped;
if let Some(mut child) = state.child.take() {
kill_tree(&mut child);
}
self.0.changed.notify_all();
}
}
/// One server's whole life, on its own thread.
fn run(shared: &Arc<Shared>, generation: u64) {
let fail = |message: String| {
shared.set(generation, Status::Failed(message));
};
let Some(executable) = shared.executable.clone().or_else(|| dart_executable(&shared.root)) else {
return fail("Dart SDK not found: install Flutter or add it to PATH".into());
};
let mut child = match spawn_watched(&executable, &ARGS, &shared.root) {
Ok(child) => child,
Err(e) => return fail(format!("could not run {}: {e}", executable.display())),
};
let (Some(stdout), Some(stderr)) = (child.stdout.take(), child.stderr.take()) else {
terminate_tree(&mut child, Duration::ZERO);
return fail("no output pipe".into());
};
{
let mut state = shared.state.lock();
if state.generation != generation {
drop(state);
terminate_tree(&mut child, KILL_GRACE);
return;
}
state.child = Some(child);
}
let tail = Arc::new(Mutex::new(VecDeque::with_capacity(OUTPUT_TAIL)));
let errors = {
let tail = tail.clone();
std::thread::spawn(move || {
read_lines(stderr, |line| {
keep_output(&tail, line);
true
});
})
};
read_lines(stdout, |line| match started_port(line) {
Some(port) => shared.set(generation, Status::Ready(format!("http://{HOST}:{port}"))),
None => {
keep_output(&tail, line);
true
}
});
let _ = errors.join();
let mut state = shared.state.lock();
if state.generation != generation {
return;
}
let child = state.child.take();
state.status = if matches!(state.status, Status::Ready(_)) {
Status::Stopped
} else {
let message = Vec::from(std::mem::take(&mut *tail.lock())).join("\n");
Status::Failed(if message.is_empty() { "dart devtools exited".into() } else { message })
};
shared.changed.notify_all();
drop(state);
if let Some(mut child) = child {
std::thread::spawn(move || terminate_tree(&mut child, Duration::ZERO));
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_server_started_gives_a_port() {
let line =
r#"{"event":"server.started","method":"server.started","params":{"host":"127.0.0.1","port":9100,"pid":1}}"#;
assert_eq!(started_port(line), Some(9100));
assert_eq!(started_port(r#"{"event":"server.dtdStarted","params":{"uri":"ws://x"}}"#), None);
assert_eq!(started_port("Serving DevTools"), None);
}
#[cfg(unix)]
mod process {
use super::*;
use std::os::unix::fs::PermissionsExt;
const STARTED: &str = r#"echo '{"event":"server.started","params":{"port":4242}}'"#;
fn server(dir: &Path, script: &str, timeout: Duration) -> DevToolsServer {
let path = dir.join("dart");
std::fs::write(&path, format!("#!/bin/sh\necho run >> runs\n{script}")).unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
DevToolsServer::with_executable(dir.to_owned(), Some(path), timeout)
}
fn runs(dir: &Path) -> usize {
std::fs::read_to_string(dir.join("runs")).map_or(0, |s| s.lines().count())
}
fn wait_for(what: &str, done: impl Fn() -> bool) {
let deadline = Instant::now() + Duration::from_secs(10);
while !done() {
assert!(Instant::now() < deadline, "timed out waiting for {what}");
std::thread::sleep(Duration::from_millis(10));
}
}
#[test]
fn a_running_server_is_shared_and_stop_ends_it() {
let dir = tempfile::tempdir().unwrap();
let script = format!("echo \"$*\" > args\necho $$ > pid\n{STARTED}\nexec sleep 30");
let devtools = server(dir.path(), &script, Duration::from_secs(10));
assert_eq!(devtools.url().unwrap(), "http://127.0.0.1:4242");
assert_eq!(devtools.url().unwrap(), "http://127.0.0.1:4242");
assert_eq!(runs(dir.path()), 1);
let args = std::fs::read_to_string(dir.path().join("args")).unwrap();
assert_eq!(args.trim(), ARGS.join(" "));
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap();
devtools.stop();
let alive = || {
let mut probe = std::process::Command::new("kill");
probe.args(["-0", pid.trim()]).stderr(std::process::Stdio::null()).status().unwrap().success()
};
wait_for("the server to end", || !alive());
}
#[test]
fn a_failure_is_reported_and_only_a_new_request_retries() {
let dir = tempfile::tempdir().unwrap();
let devtools = server(dir.path(), "echo boom >&2\nexit 3", Duration::from_secs(10));
assert_eq!(devtools.url().unwrap_err(), "boom");
std::thread::sleep(Duration::from_millis(100));
assert_eq!(runs(dir.path()), 1);
assert_eq!(devtools.url().unwrap_err(), "boom");
assert_eq!(runs(dir.path()), 2);
}
#[test]
fn a_server_that_exits_is_not_restarted_until_asked() {
let dir = tempfile::tempdir().unwrap();
let devtools = server(dir.path(), STARTED, Duration::from_secs(10));
devtools.url().unwrap();
wait_for("the exit to be noticed", || matches!(devtools.0.state.lock().status, Status::Stopped));
assert_eq!(runs(dir.path()), 1);
devtools.url().unwrap();
assert_eq!(runs(dir.path()), 2);
}
#[test]
fn a_server_that_never_reports_times_out() {
let dir = tempfile::tempdir().unwrap();
let devtools = server(dir.path(), "exec sleep 30", Duration::from_millis(200));
assert_eq!(devtools.url().unwrap_err(), "Flutter DevTools did not start in time");
}
}
}
+569
Переглянути файл
@@ -0,0 +1,569 @@
//! The devices a Flutter project can run on, from one `flutter daemon` per project window.
//!
//! The daemon speaks JSON-RPC over stdio, one bracketed message per line. After
//! `daemon.connected` it is asked for `device.enable`, which makes it report `device.added` /
//! `device.removed`, and once for `device.getDevices`, whose answer ends the "discovering" state.
//!
//! The daemon keeps running after its stdin closes, so closing the pipe does not end it: on Unix
//! a watcher in its process group ends the group once the IDE is gone, even after a crash. A
//! daemon that fails stays failed until the user restarts it.
mod devtools;
pub use devtools::DevToolsServer;
use ide_android::AndroidDevice;
use ide_core::event::{FlutterDaemonStatus, FlutterDevice, FlutterDeviceList};
use ide_core::process::{kill_tree, own_group, prepare, terminate_tree};
use ide_core::tool_path::{find_command, search_path_in};
use ide_core::{IdeEvent, SharedSink};
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::collections::{BTreeMap, VecDeque};
use std::io::{BufRead, BufReader, Read, Write};
use std::path::{Path, PathBuf};
use std::process::{Child, ChildStdin, Command, Stdio};
use std::sync::Arc;
use std::time::Duration;
const ENABLE: u64 = 1;
const GET_DEVICES: u64 = 2;
/// How long the daemon gets to exit on `SIGTERM`.
const KILL_GRACE: Duration = Duration::from_millis(200);
/// Lines of unrecognised output kept to explain a failure.
const OUTPUT_TAIL: usize = 8;
#[derive(Debug, PartialEq, Eq)]
enum Message {
Connected,
Added(FlutterDevice),
Removed(String),
Devices(Vec<FlutterDevice>),
Other,
}
fn device(value: &Value) -> Option<FlutterDevice> {
let text = |key| value.get(key).and_then(Value::as_str).map(str::to_owned);
Some(FlutterDevice {
id: text("id")?,
name: text("name")?,
platform_type: text("platformType"),
category: text("category"),
emulator: value.get("emulator").and_then(Value::as_bool).unwrap_or(false),
unavailable: None,
})
}
/// The messages of one stdout line; `None` for anything outside the protocol (the tool's own
/// chatter, such as waiting for the startup lock).
fn parse_line(line: &str) -> Option<Vec<Message>> {
let line = line.trim();
if !line.starts_with('[') {
return None;
}
let messages: Vec<Value> = serde_json::from_str(line).ok()?;
Some(messages.iter().map(parse_message).collect())
}
fn parse_message(message: &Value) -> Message {
let params = message.get("params").unwrap_or(&Value::Null);
match message.get("event").and_then(Value::as_str) {
Some("daemon.connected") => Message::Connected,
Some("device.added") => device(params).map_or(Message::Other, Message::Added),
Some("device.removed") => {
params.get("id").and_then(Value::as_str).map_or(Message::Other, |id| Message::Removed(id.to_owned()))
}
Some(_) => Message::Other,
None if message.get("id").and_then(Value::as_u64) == Some(GET_DEVICES) => {
let result = message.get("result").and_then(Value::as_array);
Message::Devices(result.into_iter().flatten().filter_map(device).collect())
}
None => Message::Other,
}
}
fn request(id: u64, method: &str) -> String {
format!("{}\n", json!([{ "id": id, "method": method }]))
}
/// The daemon's devices, plus the Android devices adb sees that Flutter leaves out until they
/// are usable. A daemon Android device's id is its adb serial.
fn merged(daemon: &BTreeMap<String, FlutterDevice>, adb: &[AndroidDevice]) -> Vec<FlutterDevice> {
let mut devices: Vec<FlutterDevice> = daemon.values().cloned().collect();
devices.extend(adb.iter().filter(|d| !d.is_online() && !daemon.contains_key(&d.serial)).map(|d| FlutterDevice {
id: d.serial.clone(),
name: d.label().replace('_', " "),
platform_type: Some("android".into()),
category: Some("mobile".into()),
emulator: d.serial.starts_with("emulator-"),
unavailable: Some(d.state.clone()),
}));
let rank = |d: &FlutterDevice| match d.category.as_deref() {
Some("mobile") => 0,
Some("desktop") => 1,
Some("web") => 2,
_ => 3,
};
devices.sort_by_cached_key(|d| (d.unavailable.is_some(), rank(d), d.emulator, d.name.to_lowercase(), d.id.clone()));
devices
}
struct Running {
child: Child,
stdin: Option<ChildStdin>,
}
#[derive(Default)]
struct State {
/// Bumped by every start and stop: a reader of an older process no longer has a say.
generation: u64,
running: Option<Running>,
status: FlutterDaemonStatus,
devices: BTreeMap<String, FlutterDevice>,
adb: Vec<AndroidDevice>,
}
impl State {
fn list(&self) -> FlutterDeviceList {
FlutterDeviceList { status: self.status.clone(), devices: merged(&self.devices, &self.adb) }
}
fn shut_down(&mut self) {
self.generation += 1;
if let Some(Running { mut child, stdin }) = self.running.take() {
drop(stdin);
// Off the caller's thread: closing a window must not wait for the grace period.
std::thread::spawn(move || terminate_tree(&mut child, KILL_GRACE));
}
}
}
struct Shared {
root: PathBuf,
sink: SharedSink,
/// Replaces the lookup on the search path (tests).
executable: Option<PathBuf>,
state: Mutex<State>,
}
impl Shared {
fn emit(&self, list: FlutterDeviceList) {
self.sink.emit(IdeEvent::FlutterDevices { list });
}
}
/// One project window's `flutter daemon`, started on first use.
pub struct FlutterDaemon(Arc<Shared>);
impl FlutterDaemon {
pub fn new(root: PathBuf, sink: SharedSink) -> Self {
Self::with_executable(root, sink, None)
}
fn with_executable(root: PathBuf, sink: SharedSink, executable: Option<PathBuf>) -> Self {
Self(Arc::new(Shared { root, sink, executable, state: Mutex::default() }))
}
/// The current list; starts the daemon unless it already ran. Never blocks on the process.
pub fn devices(&self) -> FlutterDeviceList {
let mut state = self.0.state.lock();
if state.status == FlutterDaemonStatus::Stopped {
start(&self.0, &mut state);
}
state.list()
}
/// Replaces the daemon with a new one (the user's way out of a failure).
pub fn restart(&self) -> FlutterDeviceList {
let mut state = self.0.state.lock();
state.shut_down();
start(&self.0, &mut state);
state.list()
}
/// Reads adb again: a device awaiting authorization changes no daemon event.
pub fn refresh(&self) {
let generation = self.0.state.lock().generation;
refresh_adb(&self.0, generation);
}
/// Ends the daemon (project closed, or no longer trusted).
pub fn stop(&self) {
let mut state = self.0.state.lock();
state.shut_down();
state.status = FlutterDaemonStatus::Stopped;
state.devices.clear();
state.adb.clear();
}
/// Ends the daemon before returning, for a process about to exit.
pub fn kill(&self) {
let mut state = self.0.state.lock();
state.generation += 1;
if let Some(mut running) = state.running.take() {
kill_tree(&mut running.child);
}
}
}
fn start(shared: &Arc<Shared>, state: &mut State) {
state.generation += 1;
state.status = FlutterDaemonStatus::Starting;
state.devices.clear();
state.adb.clear();
let (shared, generation) = (shared.clone(), state.generation);
std::thread::spawn(move || run(&shared, generation));
}
fn refresh_adb(shared: &Arc<Shared>, generation: u64) {
let shared = shared.clone();
std::thread::spawn(move || {
// Without adb there is simply nothing to add.
let adb = ide_android::devices().unwrap_or_default();
let mut state = shared.state.lock();
if state.generation != generation || state.adb == adb {
return;
}
state.adb = adb;
let list = state.list();
drop(state);
shared.emit(list);
});
}
/// A tool that does not end with its stdin, ended with its whole process group when process
/// `parent` is gone.
#[cfg(unix)]
fn watched_command(executable: &Path, args: &[&str], parent: u32) -> Command {
const WATCHED: &str = r#"(while kill -0 "$1" 2>/dev/null; do sleep 5; done; kill -KILL 0) </dev/null >/dev/null 2>&1 &
shift
exec "$@""#;
let mut cmd = Command::new("/bin/sh");
cmd.args(["-c", WATCHED, "sh"]).arg(parent.to_string()).arg(executable).args(args);
cmd
}
// No watcher on Windows, so a crashed IDE leaves the tool; a Job Object would cover it.
#[cfg(not(unix))]
fn watched_command(executable: &Path, args: &[&str], _parent: u32) -> Command {
let mut cmd = Command::new(executable);
cmd.args(args);
cmd
}
fn spawn_watched(executable: &Path, args: &[&str], root: &Path) -> std::io::Result<Child> {
let mut cmd = watched_command(executable, args, std::process::id());
cmd.current_dir(root).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped());
prepare(own_group(&mut cmd));
cmd.spawn()
}
/// Sets the final status of a daemon that is gone, unless it was replaced or stopped meanwhile.
fn finish(shared: &Shared, generation: u64, status: FlutterDaemonStatus) {
let mut state = shared.state.lock();
if state.generation != generation {
return;
}
let running = state.running.take();
state.status = status;
let list = state.list();
drop(state);
if let Some(Running { mut child, .. }) = running {
std::thread::spawn(move || terminate_tree(&mut child, Duration::ZERO));
}
shared.emit(list);
}
fn keep_output(tail: &Mutex<VecDeque<String>>, line: &str) {
if line.trim().is_empty() {
return;
}
let mut tail = tail.lock();
if tail.len() == OUTPUT_TAIL {
tail.pop_front();
}
tail.push_back(line.trim_end().to_owned());
}
fn read_lines(pipe: impl Read, mut on_line: impl FnMut(&str) -> bool) {
let mut reader = BufReader::new(pipe);
let mut bytes = Vec::new();
loop {
bytes.clear();
match reader.read_until(b'\n', &mut bytes) {
Ok(0) | Err(_) => return,
Ok(_) if !on_line(&String::from_utf8_lossy(&bytes)) => return,
Ok(_) => {}
}
}
}
/// One daemon's whole life, on its own thread.
fn run(shared: &Arc<Shared>, generation: u64) {
let executable =
shared.executable.clone().or_else(|| find_command("flutter", &search_path_in(&shared.root), &shared.root));
let Some(executable) = executable else {
return finish(shared, generation, FlutterDaemonStatus::NotInstalled);
};
let mut child = match spawn_watched(&executable, &["daemon"], &shared.root) {
Ok(child) => child,
Err(e) => {
let message = format!("could not run {}: {e}", executable.display());
return finish(shared, generation, FlutterDaemonStatus::Failed { message });
}
};
let (Some(stdout), Some(stderr)) = (child.stdout.take(), child.stderr.take()) else {
return finish(shared, generation, FlutterDaemonStatus::Failed { message: "no output pipe".into() });
};
let stdin = child.stdin.take();
{
let mut state = shared.state.lock();
if state.generation != generation {
drop(state);
drop(stdin);
terminate_tree(&mut child, KILL_GRACE);
return;
}
state.running = Some(Running { child, stdin });
}
let tail = Arc::new(Mutex::new(VecDeque::new()));
let errors = {
let tail = tail.clone();
std::thread::spawn(move || {
read_lines(stderr, |line| {
keep_output(&tail, line);
true
});
})
};
read_lines(stdout, |line| match parse_line(line) {
Some(messages) => messages.into_iter().all(|message| handle(shared, generation, message)),
None => {
keep_output(&tail, line);
true
}
});
let _ = errors.join();
let message = Vec::from(std::mem::take(&mut *tail.lock())).join("\n");
let message = if message.is_empty() { "flutter daemon exited".to_owned() } else { message };
finish(shared, generation, FlutterDaemonStatus::Failed { message });
}
/// Applies one message; false once this daemon has been replaced or stopped.
fn handle(shared: &Arc<Shared>, generation: u64, message: Message) -> bool {
let mut state = shared.state.lock();
if state.generation != generation {
return false;
}
match message {
Message::Other => return true,
Message::Connected => {
if let Some(stdin) = state.running.as_mut().and_then(|r| r.stdin.as_mut()) {
let requests = request(ENABLE, "device.enable") + &request(GET_DEVICES, "device.getDevices");
let _ = stdin.write_all(requests.as_bytes()).and_then(|()| stdin.flush());
}
return true;
}
Message::Added(device) => {
state.devices.insert(device.id.clone(), device);
}
Message::Removed(id) => {
state.devices.remove(&id);
}
// Merged, not replaced: events may have overtaken this answer.
Message::Devices(devices) => {
state.devices.extend(devices.into_iter().map(|d| (d.id.clone(), d)));
state.status = FlutterDaemonStatus::Ready;
}
}
let list = state.list();
drop(state);
shared.emit(list);
refresh_adb(shared, generation);
true
}
#[cfg(test)]
mod tests {
use super::*;
fn dev(id: &str, name: &str, category: &str, emulator: bool) -> FlutterDevice {
FlutterDevice {
id: id.into(),
name: name.into(),
platform_type: None,
category: Some(category.into()),
emulator,
unavailable: None,
}
}
fn adb(serial: &str, state: &str) -> AndroidDevice {
AndroidDevice {
serial: serial.into(),
state: state.into(),
model: None,
product: None,
device: None,
transport_id: None,
}
}
#[test]
fn reads_the_daemon_protocol() {
assert_eq!(
parse_line(r#"[{"event":"daemon.connected","params":{"version":"0.6.1","pid":7}}]"#),
Some(vec![Message::Connected])
);
let added = parse_line(
r#"[{"event":"device.added","params":{"id":"emulator-5554","name":"Pixel","platform":"android-arm64",
"emulator":true,"category":"mobile","platformType":"android","ephemeral":true}}]"#
.replace('\n', " ")
.as_str(),
);
let Some([Message::Added(device)]) = added.as_deref() else { panic!("{added:?}") };
assert_eq!(device.id, "emulator-5554");
assert_eq!(device.platform_type.as_deref(), Some("android"));
assert!(device.emulator);
assert_eq!(
parse_line(r#"[{"event":"device.removed","params":{"id":"macos","name":"macOS"}}]"#),
Some(vec![Message::Removed("macos".into())])
);
let answer = parse_line(r#"[{"id":2,"result":[{"id":"chrome","name":"Chrome","category":null}]}]"#);
let Some([Message::Devices(devices)]) = answer.as_deref() else { panic!("{answer:?}") };
assert_eq!((devices[0].id.as_str(), devices[0].category.as_deref()), ("chrome", None));
assert_eq!(parse_line(r#"[{"id":1,"result":null}]"#), Some(vec![Message::Other]));
}
#[test]
fn output_outside_the_protocol_is_not_a_message() {
assert_eq!(parse_line("Waiting for another flutter command to release the startup lock..."), None);
assert_eq!(parse_line("[not json"), None);
}
#[test]
fn lists_usable_devices_first_and_adds_what_only_adb_sees() {
let daemon: BTreeMap<_, _> = [
dev("chrome", "Chrome", "web", false),
dev("macos", "macOS", "desktop", false),
dev("emulator-5554", "Pixel", "mobile", true),
dev("R5C", "Galaxy", "mobile", false),
]
.into_iter()
.map(|d| (d.id.clone(), d))
.collect();
let adb = [adb("R5C", "device"), adb("emulator-5554", "offline"), adb("X1", "unauthorized")];
let list = merged(&daemon, &adb);
let ids: Vec<_> = list.iter().map(|d| d.id.as_str()).collect();
assert_eq!(ids, ["R5C", "emulator-5554", "macos", "chrome", "X1"]);
assert_eq!(list[4].unavailable.as_deref(), Some("unauthorized"));
assert_eq!(list[1].unavailable, None, "what the daemon lists is usable");
}
#[cfg(unix)]
mod process {
use super::super::*;
use ide_core::EventSink;
use std::os::unix::fs::PermissionsExt;
use std::time::Instant;
#[derive(Default)]
struct Lists(Mutex<Vec<FlutterDeviceList>>);
impl EventSink for Lists {
fn emit(&self, event: IdeEvent) {
if let IdeEvent::FlutterDevices { list } = event {
self.0.lock().push(list);
}
}
}
fn daemon(dir: &Path, script: &str) -> (FlutterDaemon, Arc<Lists>) {
let path = dir.join("flutter");
std::fs::write(&path, format!("#!/bin/sh\n{script}")).unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
let lists = Arc::new(Lists::default());
(FlutterDaemon::with_executable(dir.to_owned(), lists.clone(), Some(path)), lists)
}
fn wait_for(what: &str, done: impl Fn() -> bool) {
let deadline = Instant::now() + Duration::from_secs(10);
while !done() {
assert!(Instant::now() < deadline, "timed out waiting for {what}");
std::thread::sleep(Duration::from_millis(10));
}
}
const SESSION: &str = r#"
echo $$ > pid
echo 'Waiting for another flutter command to release the startup lock...'
echo '[{"event":"daemon.connected","params":{"version":"0.6.1","pid":1}}]'
read enable; read get; echo "$enable$get" > requests
echo '[{"id":1,"result":null}]'
echo '[{"id":2,"result":[{"id":"macos","name":"macOS","category":"desktop","emulator":false}]}]'
echo '[{"event":"device.added","params":{"id":"chrome","name":"Chrome","category":"web","emulator":false}}]'
echo '[{"event":"device.removed","params":{"id":"macos","name":"macOS"}}]'
cat > /dev/null
"#;
#[test]
fn follows_devices_and_ends_with_the_project() {
let dir = tempfile::tempdir().unwrap();
let (daemon, lists) = daemon(dir.path(), SESSION);
assert_eq!(daemon.devices().status, FlutterDaemonStatus::Starting);
wait_for("the removal", || {
let list = daemon.devices();
list.status == FlutterDaemonStatus::Ready
&& list.devices.iter().map(|d| d.id.as_str()).collect::<Vec<_>>() == ["chrome"]
});
let requests = std::fs::read_to_string(dir.path().join("requests")).unwrap();
assert!(requests.contains("device.enable") && requests.contains("device.getDevices"), "{requests}");
assert!(lists.0.lock().iter().any(|l| l.devices.iter().any(|d| d.id == "macos")));
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap();
let alive =
|| Command::new("kill").args(["-0", pid.trim()]).stderr(Stdio::null()).status().unwrap().success();
assert!(alive());
daemon.stop();
wait_for("the process to end", || !alive());
assert_eq!(daemon.0.state.lock().status, FlutterDaemonStatus::Stopped);
}
#[test]
fn the_daemon_does_not_outlive_the_ide() {
let dir = tempfile::tempdir().unwrap();
let flutter = dir.path().join("flutter");
std::fs::write(&flutter, "#!/bin/sh\necho $$ > pid\nexec sleep 60\n").unwrap();
std::fs::set_permissions(&flutter, std::fs::Permissions::from_mode(0o755)).unwrap();
let mut ide = Command::new("sleep").arg("60").spawn().unwrap();
let mut cmd = watched_command(&flutter, &["daemon"], ide.id());
cmd.current_dir(dir.path()).stdin(Stdio::piped());
let mut daemon = own_group(&mut cmd).spawn().unwrap();
wait_for("the daemon", || dir.path().join("pid").is_file());
assert_eq!(daemon.try_wait().unwrap(), None);
ide.kill().unwrap();
ide.wait().unwrap();
let deadline = Instant::now() + Duration::from_secs(10);
while daemon.try_wait().unwrap().is_none() {
assert!(Instant::now() < deadline, "the daemon outlived its parent");
std::thread::sleep(Duration::from_millis(50));
}
}
#[test]
fn a_crash_is_reported_and_not_restarted_until_asked() {
let dir = tempfile::tempdir().unwrap();
let (daemon, _lists) = daemon(dir.path(), "echo run >> runs\necho 'SDK is broken' >&2\nexit 3\n");
daemon.devices();
let failed = || matches!(daemon.0.state.lock().status, FlutterDaemonStatus::Failed { .. });
wait_for("the failure", failed);
let FlutterDaemonStatus::Failed { message } = daemon.devices().status else { panic!("still failed") };
assert_eq!(message, "SDK is broken");
std::thread::sleep(Duration::from_millis(100));
let runs = || std::fs::read_to_string(dir.path().join("runs")).unwrap().lines().count();
assert_eq!(runs(), 1);
daemon.restart();
wait_for("the second run", || runs() == 2);
}
}
}
+1
Переглянути файл
@@ -58,6 +58,7 @@ ide-plugin.workspace = true
ide-tools = { path = "../ide-tools" }
ide-scaffold.workspace = true
ide-docker = { path = "../ide-docker" }
ide-flutter = { path = "../ide-flutter" }
semver = "1"
serde.workspace = true
jsonschema = { version = "0.33", default-features = false }
+19 -4
Переглянути файл
@@ -11,7 +11,12 @@ use std::path::PathBuf;
use std::sync::{Arc, OnceLock};
fn main() {
let args: Vec<String> = std::env::args().skip(1).collect();
let raw_args: Vec<String> = std::env::args().collect();
if let Some(project) = ide_mcp::stdio_request(&raw_args) {
let base = server_home();
std::process::exit(ide_mcp::stdio::run(&ide_mcp::discovery_path(&base.join("data")), project));
}
let args: Vec<String> = raw_args.into_iter().skip(1).collect();
if args.iter().any(|a| a == "--version") {
println!("openidea-server {} (protocol {})", env!("CARGO_PKG_VERSION"), rpc::PROTOCOL_VERSION);
return;
@@ -31,7 +36,9 @@ fn main() {
std::process::exit(code);
}
if !args.iter().any(|a| a == "--stdio") {
eprintln!("usage: openidea-server --stdio | --connect <host> <port> | --version");
eprintln!(
"usage: openidea-server --stdio | --mcp-stdio [--project <path>] | --connect <host> <port> | --version"
);
std::process::exit(2);
}
// stdout carries the protocol: logs go to stderr.
@@ -39,8 +46,7 @@ fn main() {
.with_writer(std::io::stderr)
.with_env_filter(tracing_subscriber::EnvFilter::try_from_env("OPENIDEA_LOG").unwrap_or_else(|_| "info".into()))
.init();
let home = dirs::home_dir().unwrap_or_default();
let base = std::env::var_os("OPENIDEA_SERVER_HOME").map(PathBuf::from).unwrap_or_else(|| home.join(".openidea"));
let base = server_home();
// An SSH exec channel gets a minimal environment: take the login shell's, read
// afresh on every start, plus the IDE-managed tools. Before any other thread starts.
ide_host::shell_env::inherit_login_shell_env("openidea-server");
@@ -53,6 +59,11 @@ fn main() {
std::process::exit(code);
}
fn server_home() -> PathBuf {
let home = dirs::home_dir().unwrap_or_default();
std::env::var_os("OPENIDEA_SERVER_HOME").map(PathBuf::from).unwrap_or_else(|| home.join(".openidea"))
}
async fn run(base: PathBuf) -> i32 {
let (config_dir, data_dir) = (base.join("config"), base.join("data"));
for dir in [&config_dir, &data_dir] {
@@ -85,6 +96,9 @@ async fn run(base: PathBuf) -> i32 {
runtime: tokio::runtime::Handle::current(),
project_environment: true,
}));
// A stable path for `--mcp-stdio` client configurations across server upgrades.
host.mcp.set_stdio_link(base.join("bin").join("openidea-server"));
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()) {
Ok(p) => Some(p),
@@ -112,6 +126,7 @@ async fn run(base: PathBuf) -> i32 {
}
});
rpc::serve(host.clone(), dispatcher, peer, tokio::io::stdin(), tokio::io::stdout()).await;
host.mcp.stop(&host);
if let Some(plugins) = &plugins {
plugins.host().shutdown();
}
+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");
+14 -4
Переглянути файл
@@ -59,7 +59,8 @@ pub struct HostConfig {
}
pub struct Host {
pub(crate) mcp_executable: RwLock<Option<PathBuf>>,
pub(crate) mcp_executable: Arc<RwLock<Option<PathBuf>>>,
pub mcp: mcp::McpService,
plugin_host: RwLock<std::sync::Weak<plugins::PluginHost>>,
/// Every `Diagnostics` event the host ever emitted, per file and producer:
/// the snapshot plugins read (`problems`), independent of windows and reports.
@@ -152,7 +153,8 @@ impl Host {
ssh.set_configs(global_settings.effective().ssh.configs);
let host = Self {
plugin_host: RwLock::default(),
mcp_executable: RwLock::default(),
mcp_executable: Arc::default(),
mcp: Default::default(),
diagnostics,
mcp_reports: Default::default(),
mcp_requests: Default::default(),
@@ -222,12 +224,12 @@ impl Host {
}
}
/// Associates the plugin runtime that executes this host's project operations.
/// Publishes only the executable of the running built-in MCP service.
/// Publishes the executable of the running built-in MCP service (`None` while it is off).
pub fn set_mcp_executable(&self, executable: Option<PathBuf>) {
*self.mcp_executable.write() = executable;
}
/// Associates the plugin runtime that executes this host's project operations.
pub fn set_plugin_host(&self, plugins: &Arc<plugins::PluginHost>) {
*self.plugin_host.write() = Arc::downgrade(plugins);
}
@@ -341,6 +343,8 @@ impl Host {
}
project.documents.clear_workspace_edit_history();
project.agents.shutdown();
project.flutter.stop();
project.devtools.stop();
project.notebooks.stop_admission();
// What the closing window started goes with it — the builds and searches it
// asked for, its runs, its shells and its debug sessions — and its language
@@ -459,6 +463,10 @@ impl Host {
pub fn stop_processes_on_exit(&self) {
self.processes.kill_all();
self.terminals.kill_all();
for project in self.projects() {
project.flutter.kill();
project.devtools.kill();
}
}
/// Called before desktop exit, which may bypass document destructors.
@@ -480,6 +488,8 @@ impl Host {
let projects: Vec<_> = self.projects.write().drain().map(|(_, p)| p).collect();
for project in &projects {
project.files_events_active.store(false, std::sync::atomic::Ordering::Release);
project.flutter.kill();
project.devtools.kill();
}
for project in &projects {
project.plugin_diagnostics.close();
+3 -1
Переглянути файл
@@ -11,6 +11,7 @@ mod http;
mod page;
pub mod reports;
mod search;
pub mod service;
mod symbols;
mod tool;
mod util;
@@ -22,6 +23,7 @@ pub use reports::{
FileProblems, FocusedEditor, Reports, mcp_report_problems, mcp_set_focused_editor, mcp_set_open_editors,
};
pub use run::agent::{AGENT_PARAM, AgentRun, AgentRuns, NAME_PREFIX, SHELL_PARAM};
pub use service::{McpServerStatus, McpService};
use std::path::{Path, PathBuf};
use std::sync::Arc;
@@ -55,7 +57,7 @@ fn allowed(tool: &ide_mcp::Tool, trusted: bool) -> bool {
impl Registry {
fn target(&self, root: &Path) -> Result<(String, Arc<crate::Project>), String> {
if self.0.mcp_reports.remote_roots().iter().any(|p| p == root) {
return Err("not supported for remote projects yet".into());
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);
+296
Переглянути файл
@@ -0,0 +1,296 @@
//! Agents › IDE MCP Server: runs `ide_mcp::McpServer` over built-in host tools
//! while `mcpServer.enabled` is on, and reports where it listens.
use crate::Host;
use ide_command::command;
use ide_core::{IdeResult, IpcPath};
use parking_lot::{Mutex, RwLock};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::net::IpAddr;
use std::path::PathBuf;
use std::sync::Arc;
/// The server while it runs, or why it doesn't.
#[derive(Default)]
pub struct McpService {
server: Mutex<Option<ide_mcp::McpServer>>,
/// The address, port and token settings the running server was started with.
running_with: Mutex<Option<Listen>>,
error: Mutex<Option<String>>,
/// A link to this executable advertised for `--mcp-stdio` instead of `current_exe()`.
stdio_link: RwLock<Option<PathBuf>>,
}
/// What the address, port and token settings ask the server for.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct Listen {
/// `mcpServer.address`.
address: IpAddr,
/// `mcpServer.port` with `mcpServer.fixedPort`; otherwise a free port.
port: Option<u16>,
fixed_token: bool,
}
impl McpService {
/// Advertises `link` in `--mcp-stdio` client configs and agent sessions, pointed at this
/// executable whenever the server starts. Without one (or where it can't be written),
/// `current_exe()` is advertised.
pub fn set_stdio_link(&self, link: PathBuf) {
*self.stdio_link.write() = Some(link);
}
pub(crate) fn stdio_executable(&self) -> PathBuf {
self.stdio_link.read().clone().or_else(|| std::env::current_exe().ok()).unwrap_or_default()
}
fn update_stdio_link(&self) {
let mut link = self.stdio_link.write();
if let Some(path) = link.as_deref()
&& let Err(e) = point_at_current_exe(path)
{
tracing::warn!("MCP server: cannot link {} ({e}); advertising this executable", path.display());
*link = None;
}
}
/// 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>) {
let settings = host.global_settings.effective().mcp_server;
let mut server = self.server.lock();
if !settings.enabled {
let was_running = server.take();
let stopped = was_running.is_some();
if let Some(running) = was_running {
running.stop();
}
*self.running_with.lock() = None;
host.set_mcp_executable(None);
*self.error.lock() = None;
drop(server);
if stopped {
for project in host.projects() {
project.agents.notify_mcp_servers_changed();
}
}
return;
}
let Ok(address) = settings.address.trim().parse::<IpAddr>() else {
let stopped = server.take().map(|running| running.stop()).is_some();
*self.running_with.lock() = None;
host.set_mcp_executable(None);
*self.error.lock() = Some(format!("the listen address `{}` is not an IP address", settings.address.trim()));
drop(server);
if stopped {
for project in host.projects() {
project.agents.notify_mcp_servers_changed();
}
}
return;
};
let wanted = Listen {
address,
port: settings.fixed_port.then_some(settings.port).filter(|p| *p != 0),
fixed_token: settings.fixed_token,
};
if server.is_some() && *self.running_with.lock() == Some(wanted) {
return;
}
// Another address, port or token: clients connect anew.
if let Some(running) = server.take() {
let held = (running.address(), running.port());
running.stop();
if let Some(port) = port_to_wait_for(held, wanted.port) {
wait_until_free(address, port);
}
}
let token = if wanted.fixed_token {
match ide_mcp::kept_token(&ide_mcp::token_path(&host.data_dir)) {
Ok(token) => Some(token),
Err(e) => {
tracing::warn!("MCP server: cannot keep the token ({e}); using a new one for this run");
None
}
}
} else {
None
};
let discovery = ide_mcp::discovery_path(&host.data_dir);
match ide_mcp::McpServer::start_with(
Arc::new(crate::mcp::Registry::new(host.clone())),
Some(discovery),
&host.runtime,
ide_mcp::ServerOptions { address: Some(address), port: wanted.port, token },
) {
Ok(started) => {
self.update_stdio_link();
host.set_mcp_executable(Some(self.stdio_executable()));
*server = Some(started);
*self.running_with.lock() = Some(wanted);
*self.error.lock() = None;
drop(server);
for project in host.projects() {
project.agents.notify_mcp_servers_changed();
}
}
Err(e) => {
tracing::warn!("MCP server: {e}");
host.set_mcp_executable(None);
*self.running_with.lock() = None;
*self.error.lock() = Some(e.to_string());
}
}
}
/// Stops the server on exit (its discovery file goes with it).
pub fn stop(&self, host: &Host) {
host.set_mcp_executable(None);
if let Some(server) = self.server.lock().take() {
server.stop();
}
*self.running_with.lock() = None;
}
}
/// Replaces the symlink `link` with one to this executable.
fn point_at_current_exe(link: &std::path::Path) -> std::io::Result<()> {
#[cfg(unix)]
{
let exe = std::env::current_exe()?;
let dir = link.parent().ok_or_else(|| std::io::Error::other("no parent directory"))?;
std::fs::create_dir_all(dir)?;
let tmp = dir.join(format!(".openidea-server.{}", std::process::id()));
let _ = std::fs::remove_file(&tmp);
std::os::unix::fs::symlink(&exe, &tmp)?;
std::fs::rename(&tmp, link).inspect_err(|_| {
let _ = std::fs::remove_file(&tmp);
})
}
#[cfg(not(unix))]
{
let _ = link;
Err(std::io::ErrorKind::Unsupported.into())
}
}
/// The port a restart listening on `wanted` waits for after stopping the server that listened
/// on `held`: only its own, at any address (`127.0.0.1` and `0.0.0.0` overlap). A port another
/// program holds (the run fell back to a free one) stays taken, and waiting for it would block
/// the window.
fn port_to_wait_for(held: (IpAddr, u16), wanted: Option<u16>) -> Option<u16> {
wanted.filter(|port| held.1 == *port)
}
/// Waits briefly for a stopped server's port to close, so the restart gets it again.
fn wait_until_free(address: IpAddr, port: u16) {
for _ in 0..100 {
if std::net::TcpListener::bind((address, port)).is_ok() {
return;
}
std::thread::sleep(std::time::Duration::from_millis(20));
}
}
/// What Settings › Agents › IDE MCP Server shows.
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpServerStatus {
pub running: bool,
/// Why it isn't running though turned on.
pub error: Option<String>,
/// The address listened on (`0.0.0.0` / `::`: every address).
pub address: Option<String>,
pub port: Option<u16>,
/// Why the fixed port (`mcpServer.port`) isn't the one listened on: it was in use or
/// reserved, so a free port was taken for this run.
pub port_unavailable: Option<String>,
/// The window's project, which the URL and command below are for.
pub project: Option<IpcPath>,
/// `http://<address>:<port>/mcp?project=<root>`, with loopback for every address.
pub url: Option<String>,
/// Bearer token of `url` (changes with every run unless `mcpServer.fixedToken` is on).
pub token: Option<String>,
/// The stdio bridge: this host's executable and its arguments.
pub stdio_command: Vec<String>,
}
#[command(trust = outside_restricted)]
pub fn mcp_server_status(host: &Host, window: &str) -> IdeResult<McpServerStatus> {
let root: Option<PathBuf> = host.project(window).ok().filter(|p| !p.light).map(|p| p.root.clone());
let server = host.mcp.server.lock();
let exe = host.mcp.stdio_executable();
Ok(McpServerStatus {
running: server.is_some(),
error: host.mcp.error.lock().clone(),
address: server.as_ref().map(|s| s.address().to_string()),
port: server.as_ref().map(|s| s.port()),
port_unavailable: server.as_ref().and_then(|s| s.port_unavailable().map(str::to_owned)),
url: server.as_ref().zip(root.as_ref()).map(|(s, r)| s.url(r)),
token: server.as_ref().map(|s| s.token().to_owned()),
stdio_command: root.as_ref().map(|r| ide_mcp::stdio_command(&exe, r)).unwrap_or_default(),
project: root.map(IpcPath::from),
})
}
/// Settings › Agents › IDE MCP Server › Regenerate Token: forgets the kept token, and restarts the
/// server with a new one. Clients configured with the old token stop working.
#[command(trust = outside_restricted)]
pub fn mcp_regenerate_token(host: &Arc<Host>) -> IdeResult<()> {
match std::fs::remove_file(ide_mcp::token_path(&host.data_dir)) {
Ok(()) => {}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(e) => return Err(e.into()),
}
*host.mcp.running_with.lock() = None;
host.mcp.apply(host);
Ok(())
}
#[command(trust = trusted)]
pub fn mcp_ui_ready(host: &Host, window: &str, ready: bool) -> IdeResult<()> {
let window = host.owner_window(window);
host.project(window)?;
host.mcp_requests.set_ready(window, ready);
Ok(())
}
/// The user closed the Run tool window tab of an agent command (`run_command`).
#[command(trust = trusted)]
pub fn mcp_agent_run_closed(host: &Host, window: &str, name: String) -> IdeResult<()> {
let project = host.project(window)?;
host.mcp_agent_runs.closed(&project.root, &name);
Ok(())
}
#[command(trust = trusted)]
pub fn mcp_respond(host: &Host, window: &str, id: u32, allow: bool, error: Option<String>) -> IdeResult<()> {
host.mcp_requests.answer(host.owner_window(window), id, allow, error)
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::Ipv4Addr;
#[test]
fn a_restart_waits_only_for_the_port_the_stopped_server_held() {
let local = IpAddr::V4(Ipv4Addr::LOCALHOST);
let any = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
assert_eq!(port_to_wait_for((local, 64342), Some(64342)), Some(64342));
// Another address on the same port overlaps the old listener: wait for it too.
assert_eq!(port_to_wait_for((any, 64342), Some(64342)), Some(64342));
// The fixed port was taken by another program: the server ran on a free one.
assert_eq!(port_to_wait_for((local, 51234), Some(64342)), None);
assert_eq!(port_to_wait_for((local, 64342), None), None);
}
}
ide_command::domain!(
mcp:
mcp_agent_run_closed,
mcp_regenerate_token,
mcp_respond,
mcp_server_status,
mcp_ui_ready,
);
+9 -4
Переглянути файл
@@ -245,6 +245,7 @@ pub async fn build_sync(
return Err(IdeError::not_found("Build project is no longer linked"));
}
let mut profiles_changed = false;
let mut offline_changed = false;
for scope in selected {
if token.is_cancelled() {
return Err(IdeError::cancelled());
@@ -260,6 +261,10 @@ pub async fn build_sync(
p.sink.emit(IdeEvent::ProjectRootsChanged { root: p.root.clone().into() });
}
profiles_changed |= changed;
offline_changed |= ide_build::save_maven_offline(cache, offline).unwrap_or_else(|e| {
tracing::warn!("Maven offline mode not saved: {e}");
false
});
}
let env = current
.maven
@@ -306,12 +311,12 @@ pub async fn build_sync(
let scopes = workspace::scopes(&p, &config)?;
let model = workspace::load_scopes(&p.root, &scopes);
let updates = workspace::update_files(&p.root, &scopes, &model, tool);
Ok::<_, IdeError>((model, profiles_changed, updates))
Ok::<_, IdeError>((model, profiles_changed, offline_changed, updates))
})
.await
.map_err(join_err);
host.end_request(request);
let (model, profiles_changed, updates) = result??;
let (model, profiles_changed, offline_changed, updates) = result??;
if completion_token.is_cancelled() {
return Err(IdeError::cancelled());
}
@@ -336,8 +341,8 @@ pub async fn build_sync(
let lsp = project.lsp.clone();
let documents = project.documents.clone();
tokio::spawn(async move {
if profiles_changed {
// jdtls takes the profiles from its Maven settings (see `ide_sdk::maven_profiles`).
if profiles_changed || offline_changed {
// jdtls takes the profiles and offline mode from its Maven settings (see `ide_sdk::maven_profiles`).
lsp.reconfigure().await;
}
let first = updates.first().cloned();
+33
Переглянути файл
@@ -24,6 +24,34 @@ pub struct StatementOutcome {
pub error: Option<String>,
}
#[command(trust = trusted)]
pub fn db_approve_jdbc_source(host: &Host, window: &str, source: DataSource) -> IdeResult<()> {
host.project(window)?.db.approve_jdbc_source(&source)
}
#[command(trust = trusted)]
pub async fn db_jdbc_driver_classes(host: &Host, window: &str, jars: Vec<String>) -> IdeResult<Vec<String>> {
host.project(window)?;
tokio::task::spawn_blocking(move || ide_db::jdbc_driver_classes(&jars))
.await
.map_err(|e| IdeError::internal(e.to_string()))?
}
#[command(trust = trusted)]
pub fn db_jdbc_drivers(host: &Host, window: &str) -> IdeResult<Vec<ide_db::DbJdbcDriver>> {
host.project(window)?.db.jdbc_drivers()
}
#[command(trust = trusted)]
pub fn db_save_jdbc_driver(host: &Host, window: &str, driver: ide_db::DbJdbcDriver) -> IdeResult<()> {
host.project(window)?.db.save_jdbc_driver(driver)
}
#[command(trust = trusted)]
pub fn db_remove_jdbc_driver(host: &Host, window: &str, id: String) -> IdeResult<()> {
host.project(window)?.db.remove_jdbc_driver(&id)
}
#[command(trust = trusted)]
pub fn db_sources(host: &Host, window: &str) -> IdeResult<Vec<DataSource>> {
// The data sources configured for the project (the tree's roots).
@@ -514,6 +542,11 @@ ide_command::domain!(
db_explain,
db_finish_transaction,
db_history,
db_jdbc_driver_classes,
db_jdbc_drivers,
db_approve_jdbc_source,
db_save_jdbc_driver,
db_remove_jdbc_driver,
db_object_ddl,
db_remove_history,
db_retain_catalog,
+2 -2
Переглянути файл
@@ -357,8 +357,8 @@ pub async fn debug_send_input(host: &Host, session: DebugSessionId, text: String
host.debugger.send_input(session, &text)
}
pub async fn debug_hot_reload(host: &Host, session: DebugSessionId) -> IdeResult<()> {
host.debugger.hot_reload(session).await
pub async fn debug_hot_reload(host: &Host, session: DebugSessionId, reason: HotReloadReason) -> IdeResult<()> {
host.debugger.hot_reload(session, reason).await
}
pub async fn debug_hot_restart(host: &Host, session: DebugSessionId) -> IdeResult<()> {
+8
Переглянути файл
@@ -127,6 +127,13 @@ pub async fn doc_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec
.await
}
/// Structure view of a Flutter file: its declarations with the widgets they build. `None`
/// when the Dart server published no widgets for it; `doc_outline` then applies.
#[command(trust = always)]
pub async fn doc_flutter_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Option<Vec<OutlineItem>>> {
Ok(host.project(window)?.lsp.flutter_outline(doc))
}
#[command(trust = always)]
pub async fn doc_folding(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<FoldRange>> {
let project = host.project(window)?;
@@ -227,6 +234,7 @@ pub async fn history_content(host: &Host, window: &str, id: String) -> IdeResult
ide_command::domain!(
doc_commands:
doc_flutter_outline,
doc_folding,
doc_highlights,
doc_language,
+19 -8
Переглянути файл
@@ -6,14 +6,13 @@ use ide_core::{IdeError, IdeResult};
use ide_docker::DockerEndpoint;
use ide_ssh::Tunnel;
use std::collections::{BTreeMap, HashMap};
use std::sync::Arc;
/// What each tunnelled connection runs on the SSH host, as the Docker CLI's `ssh://` does.
const DIAL: &str = "docker system dial-stdio";
/// Open tunnels of [`DockerEndpoint::Ssh`] connections, by SSH configuration id.
#[derive(Default)]
pub struct DockerTunnels(tokio::sync::Mutex<HashMap<String, Arc<Tunnel>>>);
pub struct DockerTunnels(tokio::sync::Mutex<HashMap<String, Tunnel>>);
/// `endpoint` as docker can use it: an SSH configuration becomes the local end of a tunnel to its
/// host's daemon (opened on first use, reopened when the SSH connection dropped).
@@ -21,8 +20,8 @@ pub async fn resolve(host: &Host, endpoint: DockerEndpoint) -> IdeResult<DockerE
let DockerEndpoint::Ssh { config } = endpoint else { return Ok(endpoint) };
let id = config.trim().to_owned();
let mut tunnels = host.docker_tunnels.0.lock().await;
let tunnel = match tunnels.get(&id).filter(|t| !t.is_closed()) {
Some(t) => t.clone(),
let port = match tunnels.get(&id).filter(|t| !t.is_closed()) {
Some(t) => t.port(),
None => {
let session = host.ssh.session(&id).await?;
// Fail with the reason here: a missing docker only shows as a dropped connection later.
@@ -35,12 +34,24 @@ pub async fn resolve(host: &Host, endpoint: DockerEndpoint) -> IdeResult<DockerE
if why.is_empty() { String::new() } else { format!(": {why}") }
)));
}
let t = Arc::new(Tunnel::command(session, DIAL).await?);
tunnels.insert(id, t.clone());
t
let t = Tunnel::command(session, DIAL).await?;
let port = t.port();
tunnels.insert(id, t);
port
}
};
Ok(DockerEndpoint::Tcp { host: format!("tcp://127.0.0.1:{}", tunnel.port()), tls_cert_dir: None })
Ok(DockerEndpoint::Tcp { host: format!("tcp://127.0.0.1:{port}"), tls_cert_dir: None })
}
/// Closes what [`resolve`] opened for `endpoint`: an SSH configuration's tunnel, and then its SSH
/// connection unless something else (a terminal, a transfer) holds it. The next [`resolve`] opens
/// them again; other endpoints keep nothing open.
pub async fn disconnect(host: &Host, endpoint: &DockerEndpoint) {
let DockerEndpoint::Ssh { config } = endpoint else { return };
let id = config.trim();
let Some(tunnel) = host.docker_tunnels.0.lock().await.remove(id) else { return };
tunnel.close().await;
host.ssh.release(id);
}
/// Environment for a Docker run configuration's command line: selects `endpoint`'s
+39
Переглянути файл
@@ -0,0 +1,39 @@
//! Flutter's devices. The daemon runs on the project host, where `flutter run` and the debug
//! adapter run too, so a remote project lists the devices of its remote machine.
use crate::Host;
use ide_command::command;
use ide_core::event::FlutterDeviceList;
use ide_core::{IdeError, IdeResult};
/// The project's Flutter devices, starting its `flutter daemon` on first use. Changes arrive as
/// `IdeEvent::FlutterDevices`.
#[command(trust = trusted)]
pub fn flutter_devices(host: &Host, window: &str) -> IdeResult<FlutterDeviceList> {
Ok(host.project(window)?.flutter.devices())
}
/// Looks at adb again, for Android devices Flutter doesn't report (awaiting authorization, offline).
#[command(trust = trusted)]
pub fn flutter_devices_refresh(host: &Host, window: &str) -> IdeResult<()> {
host.project(window)?.flutter.refresh();
Ok(())
}
/// Replaces the project's `flutter daemon`, after a failure or an SDK change.
#[command(trust = trusted)]
pub fn flutter_daemon_restart(host: &Host, window: &str) -> IdeResult<FlutterDeviceList> {
Ok(host.project(window)?.flutter.restart())
}
/// The address of the project's DevTools server, started on first use. A server that failed or
/// exited is only started again by the next request.
#[command(trust = trusted)]
pub async fn flutter_devtools_url(host: &Host, window: &str) -> IdeResult<String> {
let project = host.project(window)?;
tokio::task::spawn_blocking(move || project.devtools.url())
.await
.map_err(|e| IdeError::internal(e.to_string()))?
.map_err(IdeError::unavailable)
}
ide_command::domain!(flutter: flutter_devices, flutter_devices_refresh, flutter_daemon_restart, flutter_devtools_url);
+3
Переглянути файл
@@ -15,6 +15,7 @@ pub mod deploy;
pub mod doc;
pub mod docker;
pub mod env;
pub mod flutter;
pub mod fs;
pub mod heap;
pub mod history;
@@ -85,12 +86,14 @@ ide_command::domains!(
doc_commands: crate::ops::doc::commands,
docker: crate::ops::docker,
env: crate::ops::env,
flutter: crate::ops::flutter,
fs: crate::ops::fs,
heap: crate::ops::heap,
history: crate::ops::history,
java: crate::ops::java,
jvm_icons: crate::ops::jvm_icons,
lsp: crate::ops::lsp,
mcp: crate::mcp::service,
mcp_reports: crate::mcp::reports,
nav: crate::ops::nav,
notebook: crate::ops::notebook,
+12 -1
Переглянути файл
@@ -80,6 +80,13 @@ pub fn settings_get(host: &Host, window: &str) -> Settings {
})
}
/// Defaults plus the global layer, without any project's values: what new
/// projects (and projects without their own value) get.
#[command(trust = always)]
pub fn settings_get_global(host: &Host) -> Settings {
host.with_proxy_password(host.global_settings.effective())
}
/// The removed built-in theme id a settings file of this window still names, if any:
/// `settings_get` reports the built-in that stands in for it, so the notice about
/// a theme that moved to a plugin can address the installs it concerns.
@@ -96,13 +103,16 @@ pub fn settings_removed_theme(host: &Host, window: &str) -> Option<String> {
/// re-reads its effective settings.
#[command(trust = always, desktop_body = sync)]
pub fn settings_set(
host: &Host,
host: &Arc<Host>,
window: &str,
scope: SettingsScope,
key: String,
value: String,
) -> IdeResult<Settings> {
let applied = set_settings(host, window, scope, &key, &value)?;
if key == "mcpServer" || key.starts_with("mcpServer.") {
host.mcp.apply(host);
}
let sink = host.window_sink(window);
sink.emit(IdeEvent::SettingsChanged { key });
if let Some(root) = applied.roots_changed {
@@ -386,6 +396,7 @@ ide_command::domain!(
project_trust_set,
project_trust_status,
settings_get,
settings_get_global,
settings_removed_theme,
settings_set,
);
+8 -1
Переглянути файл
@@ -17,16 +17,23 @@ fn tools(host: &Host, window: &str) -> IdeResult<Tools> {
Ok(project) => (project.settings.effective(), project.root.clone()),
Err(_) => (host.global_settings.effective(), Default::default()),
};
let custom = settings
let mut custom: std::collections::BTreeMap<_, _> = settings
.tools
.iter()
.filter_map(|(command, t)| Some((command.clone(), ide_sdk::apply::setting_path(&root, &t.path)?)))
.collect();
let langs = host.languages.all();
custom.extend(ide_sdk::apply::server_command_paths(
langs.iter().flat_map(|l| &l.language_servers),
&root,
&settings,
));
// Godot is usually an app bundle / Flatpak outside the search path.
let found = ide_sdk::godot::find(None).map(|p| (ide_sdk::godot::COMMAND.to_owned(), p));
let runtime = ide_sdk::apply::tool_install_environment(&root, &settings);
let work_dir = (!root.as_os_str().is_empty()).then_some(root);
Ok(Tools::new(&data)
.with_downloads(settings.tool_downloads.clone())
.with_runtime(runtime.commands, runtime.env)
.with_custom_paths(custom)
.with_found_paths(found.into_iter().collect())
+27 -5
Переглянути файл
@@ -214,10 +214,6 @@ pub enum RemoteOp {
tag: String,
remote: String,
},
/// Fast-forwards local `branch` (not checked out) to its upstream.
UpdateBranch {
branch: String,
},
/// Pull dialog: `branches` of `remote` (none = the configured merge branch).
PullFrom {
remote: String,
@@ -947,7 +943,6 @@ pub async fn vcs_remote(
&cancel,
&out,
),
RemoteOp::UpdateBranch { branch } => r.update_branch(&branch, &cancel, &out),
RemoteOp::PushTag { tag, remote } => r.push_tag(&tag, &remote, &cancel, &out),
RemoteOp::DeleteRemoteTag { tag, remote } => r.delete_remote_tag(&tag, &remote, &cancel, &out),
RemoteOp::PullFrom { remote, branches, rebase, options } => {
@@ -961,6 +956,32 @@ pub async fn vcs_remote(
result
}
/// Branches › Update Selected: fast-forwards local `branches` to their upstreams, one
/// fetch per remote; the result says what happened to each. Cancellable.
#[command(trust = trusted)]
pub async fn vcs_update_branches(
host: &Host,
window: &str,
repo: Option<PathBuf>,
request: RequestId,
branches: Vec<String>,
on_output: Channel<String>,
) -> IdeResult<Vec<BranchUpdate>> {
host.require_trust(window)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = tokio::task::spawn_blocking(move || {
let out = |line: String| {
let _ = on_output.send(line);
};
project.with_repo_recorded(repo.as_deref(), Some("Git pull"), |r| r.update_branches(&branches, &cancel, &out))
})
.await
.map_err(|e| ide_core::IdeError::internal(e.to_string()))?;
host.end_request(request);
result
}
/// The user's side is `ours` (sides swapped during a rebase, as in IDEA).
#[command(trust = always)]
pub async fn vcs_conflict_versions(host: &Host, window: &str, path: PathBuf) -> IdeResult<ide_vcs::MergeVersions> {
@@ -1630,6 +1651,7 @@ ide_command::domain!(
vcs_rebase,
vcs_rebase_with,
vcs_remote,
vcs_update_branches,
vcs_remotes,
vcs_remove_worktree,
vcs_rename_branch,
+13
Переглянути файл
@@ -61,6 +61,10 @@ pub struct Project {
pub agents: Arc<ide_agent::AgentManager>,
/// Native notebooks and owned kernels, scoped to this project incarnation.
pub notebooks: Arc<crate::notebook::NotebookService>,
/// Flutter's devices; its daemon starts when the UI first asks for them.
pub(crate) flutter: ide_flutter::FlutterDaemon,
/// Flutter DevTools; its server starts when the UI first asks for it.
pub(crate) devtools: ide_flutter::DevToolsServer,
pub(crate) kotlin_bridge: Option<Arc<crate::kotlin_bridge::KotlinBridge>>,
pub(crate) phpstan: Option<Arc<crate::phpstan::Phpstan>>,
pub(crate) watcher: Arc<Watcher>,
@@ -200,6 +204,7 @@ impl Host {
};
let profiles = ide_build::maven_profiles(&cache);
ide_sdk::maven_profiles::configure_jdtls(cfg, root, &effective, &profiles, &cache);
ide_sdk::maven_profiles::configure_offline(cfg, ide_build::maven_offline(&cache));
}
ide_sdk::java::cap_java_home(cfg, &ide_sdk::java::installed_jdks());
if cfg.name == "jdtls" {
@@ -601,6 +606,8 @@ impl Host {
let project = Arc::new(Project {
plugin_diagnostics,
trusted,
flutter: ide_flutter::FlutterDaemon::new(root.clone(), sink.clone()),
devtools: ide_flutter::DevToolsServer::new(root.clone()),
root,
sink,
languages,
@@ -731,6 +738,10 @@ impl Host {
agents.set_mcp_servers_hook(Box::new(move || {
crate::ops::agent::session_mcp_servers(&settings, &approvals, &secrets, &root)
}));
{
let mcp_executable = self.mcp_executable.clone();
agents.set_mcp_executable_hook(Box::new(move || mcp_executable.read().clone()));
}
(db, http_history, agents)
}
}
@@ -809,6 +820,8 @@ impl Host {
let project = Arc::new(Project {
plugin_diagnostics,
trusted: Arc::new(AtomicBool::new(false)),
flutter: ide_flutter::FlutterDaemon::new(dir.clone(), sink.clone()),
devtools: ide_flutter::DevToolsServer::new(dir.clone()),
sink,
languages,
settings,
+24 -9
Переглянути файл
@@ -171,20 +171,21 @@ pub fn event_sink(peer: Arc<OnceLock<Peer>>, window: Option<String>) -> ide_core
}
/// Whether a desktop shows an `event` notification of its server in the window. A server reports
/// on its project; what this machine answers or owns itself (MCP approvals, app updates, window
/// groups, its own connection to the server) never comes from it.
pub fn client_accepts(event: &IdeEvent) -> bool {
/// on its project; what this machine owns itself (app updates, window groups, its own connection
/// to the server) never comes from it, and MCP UI requests are accepted only when this machine
/// trusts the remote project (their answers route back to the server, never locally).
pub fn client_accepts(event: &IdeEvent, trusted: bool) -> bool {
match event {
IdeEvent::McpRequest { .. }
| IdeEvent::McpRequestClosed { .. }
| IdeEvent::WindowGroupsChanged
IdeEvent::WindowGroupsChanged
| IdeEvent::WindowFullscreenChanged
| IdeEvent::RemoteConnectionLost { .. }
| IdeEvent::UpdateStatusChanged { .. }
| IdeEvent::UpdateAvailable { .. } => false,
IdeEvent::McpRequest { .. } | IdeEvent::McpRequestClosed { .. } => trusted,
IdeEvent::DbSourcesChanged
| IdeEvent::ProjectTrustChanged { .. }
| IdeEvent::Direnv { .. }
| IdeEvent::FlutterDevices { .. }
| IdeEvent::FsChanged { .. }
| IdeEvent::ExcludedDirsChanged { .. }
| IdeEvent::DocPatched { .. }
@@ -301,8 +302,21 @@ mod tests {
date: None,
};
for event in [
IdeEvent::McpRequest { id: 1, request: confirm },
IdeEvent::McpRequest { id: 1, request: confirm.clone() },
IdeEvent::McpRequestClosed { id: 1 },
IdeEvent::UpdateAvailable { update: update.clone() },
IdeEvent::UpdateStatusChanged {
status: ide_core::updates::UpdateStatus { last_checked: None, checking: true },
},
IdeEvent::WindowGroupsChanged,
IdeEvent::WindowFullscreenChanged,
] {
assert!(!client_accepts(&event, false), "{event:?}");
}
// Even for a trusted remote project, desktop-owned events stay blocked while remote MCP prompts pass.
assert!(client_accepts(&IdeEvent::McpRequest { id: 1, request: confirm }, true));
assert!(client_accepts(&IdeEvent::McpRequestClosed { id: 1 }, true));
for event in [
IdeEvent::UpdateAvailable { update },
IdeEvent::UpdateStatusChanged {
status: ide_core::updates::UpdateStatus { last_checked: None, checking: true },
@@ -310,7 +324,7 @@ mod tests {
IdeEvent::WindowGroupsChanged,
IdeEvent::WindowFullscreenChanged,
] {
assert!(!client_accepts(&event), "{event:?}");
assert!(!client_accepts(&event, true), "{event:?}");
}
}
@@ -328,7 +342,8 @@ mod tests {
IdeEvent::Askpass { id: 1, prompt: "Password".into(), kind: AskpassKind::Secret, remember: false },
IdeEvent::ProjectTrustChanged { root: "/srv/app".into(), trusted: true },
] {
assert!(client_accepts(&event), "{event:?}");
assert!(client_accepts(&event, false), "{event:?}");
assert!(client_accepts(&event, true), "{event:?}");
}
}
}
+2
Переглянути файл
@@ -282,6 +282,8 @@ impl crate::Host {
self.environment.project_closed();
self.environment.direnv_closed(&project.root);
project.agents.shutdown();
project.flutter.stop();
project.devtools.stop();
self.processes.kill_project(&project.root);
project.notebooks.restrict().await;
let windows: Vec<_> = self
+4 -1
Переглянути файл
@@ -185,7 +185,10 @@ async fn restricted_projects_have_only_read_tools_and_remote_projects_explain_th
assert!(registry.tools(&h.root).unwrap().iter().all(|t| t.read_only && !t.destructive));
assert!(!h.host.global_settings.effective().mcp_server.enabled);
h.host.mcp_reports.set_remote("remote", PathBuf::from("/remote/project"));
assert_eq!(registry.tools(Path::new("/remote/project")).unwrap_err(), "not supported for remote projects yet");
assert_eq!(
registry.tools(Path::new("/remote/project")).unwrap_err(),
"project is on a remote host; connect to the MCP server on that host"
);
h.host.close_project_detached("remote");
assert!(!registry.projects().contains(&PathBuf::from("/remote/project")));
}
+2 -1
Переглянути файл
@@ -471,7 +471,8 @@ async fn run_target_validation_gates_launches_and_preserves_selection() {
f._tmp.path().join("plugins"),
Arc::new(|_: Option<&str>, _| {}),
Limits {
timeout: Duration::from_millis(200),
// Room for a reclaimed instance to start again on a slow runner.
timeout: Duration::from_millis(750),
idle_timeout: Some(Duration::from_millis(20)),
restart_backoff: Duration::ZERO,
..Default::default()
+5 -1
Переглянути файл
@@ -1560,7 +1560,11 @@ fn edit_path_calls_have_soft_and_hard_deadlines() {
// Past the hard deadline: interrupted; the next call gets a new instance.
assert!(provider.highlights(&mis, "spin").is_none());
std::thread::sleep(Duration::from_millis(450));
host.tick();
// A slow runner may interrupt the spinning call a little after its deadline.
assert!(eventually(|| {
host.tick();
host.info_of("misbehave").unwrap().stats.crashes > 0
}));
let info = host.info_of("misbehave").unwrap();
assert_eq!(info.stats.crashes, 1, "{:?}", info.error);
assert!(info.error.as_deref().is_some_and(|e| e.contains("timed out after 400ms")), "{:?}", info.error);
+128
Переглянути файл
@@ -522,3 +522,131 @@ async fn renames_a_branch_with_the_clients_argument_names() {
invoke(&peer, "close_project", json!({})).await.unwrap();
peer.kill();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn serves_builtin_mcp_over_remote_dispatch_and_routes_ui_requests() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("remote-mcp");
std::fs::create_dir_all(root.join("src")).unwrap();
std::fs::write(root.join("src/hello.txt"), "from remote mcp\n").unwrap();
let root = dunce::canonicalize(root).unwrap();
let base = tmp.path().join("server");
let data_dir = base.join("data");
let peer_slot = Arc::new(OnceLock::new());
let sink_peer = peer_slot.clone();
let host = Arc::new(Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: data_dir.clone(),
local_data_dir: data_dir.clone(),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(move |w| rpc::event_sink(sink_peer.clone(), Some(w.to_owned()))),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
}));
let server_exe = base.join("bin/openidea-server");
host.mcp.set_stdio_link(server_exe.clone());
host.mcp.apply(&host);
let (client_io, server_io) = tokio::io::duplex(1 << 20);
let (sr, sw) = tokio::io::split(server_io);
let serve_host = host.clone();
tokio::spawn(rpc::serve(serve_host, Dispatcher::standard(), peer_slot, sr, sw));
let (cr, cw) = tokio::io::split(client_io);
let client = Arc::new(Client::default());
let peer = Peer::connect(cr, cw, client.clone());
invoke(&peer, "open_project", json!({ "path": root })).await.unwrap();
for cmd in ["mcp_server_status", "mcp_regenerate_token", "mcp_ui_ready", "mcp_respond", "mcp_agent_run_closed"] {
let err = invoke(&peer, cmd, json!({})).await.unwrap_err();
assert!(err.message.contains("Restricted Mode"), "{cmd}: {err:?}");
}
invoke(&peer, "project_trust_set", json!({ "path": root, "trusted": true, "folder": false })).await.unwrap();
let initial = invoke(&peer, "mcp_server_status", json!({})).await.unwrap();
assert_eq!(initial["running"], false);
assert!(!server_exe.exists(), "the stdio link is written only once the server runs");
invoke(&peer, "settings_set", json!({ "scope": "global", "key": "mcpServer.fixedPort", "value": "false" }))
.await
.unwrap();
invoke(&peer, "settings_set", json!({ "scope": "global", "key": "mcpServer.fixedToken", "value": "true" }))
.await
.unwrap();
invoke(&peer, "settings_set", json!({ "scope": "global", "key": "mcpServer.enabled", "value": "true" }))
.await
.unwrap();
let global = invoke(&peer, "settings_get_global", json!({})).await.unwrap();
assert_eq!(global["mcpServer"]["enabled"], true);
let status = invoke(&peer, "mcp_server_status", json!({})).await.unwrap();
assert_eq!(status["running"], true);
assert_eq!(status["project"], json!(ide_core::IpcPath::from(&root)));
#[cfg(unix)]
{
assert_eq!(status["stdioCommand"][0], server_exe.to_string_lossy().as_ref());
assert_eq!(std::fs::read_link(&server_exe).unwrap(), std::env::current_exe().unwrap());
}
let first_token = status["token"].as_str().unwrap().to_owned();
assert!(status["url"].as_str().unwrap().starts_with("http://127.0.0.1:"));
invoke(&peer, "mcp_ui_ready", json!({ "ready": true })).await.unwrap();
let discovery = ide_mcp::discovery_path(&data_dir);
let read_call = json!({
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": { "name": "read_file", "arguments": { "file_path": "src/hello.txt" } }
});
let mut out = Vec::new();
ide_mcp::stdio::bridge(&discovery, &root, format!("{read_call}\n").as_bytes(), &mut out).await.unwrap();
let reply: Value = serde_json::from_slice(&out).unwrap();
assert_eq!(reply["result"]["content"][0]["text"], "L1: from remote mcp\nL2: ");
// UI-bound MCP requests stream over RPC events and are answered via routed `mcp_respond`.
let open_call = json!({
"jsonrpc": "2.0",
"id": 2,
"method": "tools/call",
"params": { "name": "open_file_in_editor", "arguments": { "filePath": "src/hello.txt", "line": 1, "column": 1 } }
});
let (disc2, root2) = (discovery.clone(), root.clone());
let call_task = tokio::spawn(async move {
let mut out = Vec::new();
ide_mcp::stdio::bridge(&disc2, &root2, format!("{open_call}\n").as_bytes(), &mut out).await.unwrap();
serde_json::from_slice::<Value>(&out).unwrap()
});
until("remote MCP UI request", || {
client.events.lock().iter().any(|m| matches!(m.event, ide_core::IdeEvent::McpRequest { .. }))
})
.await;
let req_id = client
.events
.lock()
.iter()
.find_map(|m| match &m.event {
event @ ide_core::IdeEvent::McpRequest { id, .. } => {
assert!(!rpc::client_accepts(event, false));
assert!(rpc::client_accepts(event, true));
Some(*id)
}
_ => None,
})
.unwrap();
invoke(&peer, "mcp_respond", json!({ "id": req_id, "allow": true, "error": null })).await.unwrap();
let opened = call_task.await.unwrap();
assert_eq!(opened["result"]["isError"], false, "{opened}");
invoke(&peer, "mcp_regenerate_token", json!({})).await.unwrap();
let rotated = invoke(&peer, "mcp_server_status", json!({})).await.unwrap();
assert_eq!(rotated["running"], true);
assert_ne!(rotated["token"].as_str().unwrap(), first_token);
host.mcp.stop(&host);
invoke(&peer, "close_project", json!({})).await.unwrap();
peer.kill();
}
+69 -8
Переглянути файл
@@ -1,7 +1,10 @@
use ide_core::remote_settings::{SshAuth, SshConfiguration};
use ide_core::{IdeEvent, SharedSink};
use ide_docker::DockerEndpoint;
use ide_host::ops::docker;
use ide_host::{Host, HostConfig};
use ide_ssh::{SshFiles, SshManager};
use std::path::Path;
use std::sync::{Arc, Mutex, mpsc};
use std::time::Duration;
@@ -16,14 +19,12 @@ fn read_until(rx: &mpsc::Receiver<String>, needle: &str) -> String {
all
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn ssh_session_opens_a_shell_with_the_saved_password() {
let tmp = tempfile::tempdir().unwrap();
let port =
ide_ssh::testing::sshd(tmp.path().join("server"), Arc::new(|cmd| panic!("unexpected exec: {cmd}"))).await;
/// A host whose SSH configuration `box` reaches an in-process server answering `exec`.
async fn host_with_ssh_box(tmp: &Path, exec: ide_ssh::testing::ExecFn) -> (Arc<Host>, mpsc::Receiver<IdeEvent>) {
let port = ide_ssh::testing::sshd(tmp.join("server"), exec).await;
let ssh = Arc::new(SshManager::with_files(
tmp.path().join("secrets.json"),
SshFiles { known_hosts: tmp.path().join("known_hosts"), config: None },
tmp.join("secrets.json"),
SshFiles { known_hosts: tmp.join("known_hosts"), config: None },
));
ssh.set_configs(vec![SshConfiguration {
id: "box".into(),
@@ -44,7 +45,7 @@ async fn ssh_session_opens_a_shell_with_the_saved_password() {
let sink: SharedSink = Arc::new(move |e: IdeEvent| {
let _ = events_tx.lock().unwrap().send(e);
});
let base = tmp.path().join("app");
let base = tmp.join("app");
let mut host = Arc::new(Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
@@ -58,6 +59,14 @@ async fn ssh_session_opens_a_shell_with_the_saved_password() {
}));
Arc::get_mut(&mut host).unwrap().ssh = ssh;
(host, events)
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn ssh_session_opens_a_shell_with_the_saved_password() {
let tmp = tempfile::tempdir().unwrap();
let (host, events) = host_with_ssh_box(tmp.path(), Arc::new(|cmd| panic!("unexpected exec: {cmd}"))).await;
let (tx, output) = mpsc::channel();
let tx = Mutex::new(tx);
let info = ide_host::ops::term::spawn_ssh(
@@ -100,3 +109,55 @@ async fn ssh_session_opens_a_shell_with_the_saved_password() {
assert_eq!(code, None);
host.shutdown().await;
}
/// Reads what a connection to the local end of a Docker tunnel gets back.
async fn dial(port: u16) -> std::io::Result<String> {
use tokio::io::AsyncReadExt;
let mut socket = tokio::net::TcpStream::connect(("127.0.0.1", port)).await?;
let mut out = String::new();
socket.read_to_string(&mut out).await?;
Ok(out)
}
fn tunnel_port(endpoint: &DockerEndpoint) -> u16 {
let DockerEndpoint::Tcp { host, .. } = endpoint else { panic!("not a tunnel: {endpoint:?}") };
host.rsplit(':').next().unwrap().parse().unwrap()
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn disconnecting_a_docker_connection_closes_its_tunnel_and_unused_ssh_session() {
let tmp = tempfile::tempdir().unwrap();
let (host, _events) = host_with_ssh_box(
tmp.path(),
Arc::new(|cmd| match cmd {
"docker version --format {{.Client.Version}}" => ("27.0.3\n".into(), 0),
"docker system dial-stdio" => ("daemon".into(), 0),
other => panic!("unexpected exec: {other}"),
}),
)
.await;
let ssh = DockerEndpoint::Ssh { config: "box".into() };
let port = tunnel_port(&docker::resolve(&host, ssh.clone()).await.unwrap());
assert_eq!(dial(port).await.unwrap(), "daemon");
assert_eq!(host.ssh.connected(), ["box"]);
docker::disconnect(&host, &ssh).await;
assert!(dial(port).await.is_err(), "the tunnel stopped listening");
assert!(host.ssh.connected().is_empty(), "nothing else used the SSH connection");
// Connecting again opens a new tunnel; a terminal on the same host keeps the session open.
let port = tunnel_port(&docker::resolve(&host, ssh.clone()).await.unwrap());
assert_eq!(dial(port).await.unwrap(), "daemon");
let terminal = host.ssh.session("box").await.unwrap();
docker::disconnect(&host, &ssh).await;
assert!(dial(port).await.is_err());
assert_eq!(host.ssh.connected(), ["box"]);
assert!(!terminal.is_closed());
// Nothing to close: a second disconnect and other endpoints are no-ops.
docker::disconnect(&host, &ssh).await;
docker::disconnect(&host, &DockerEndpoint::Default).await;
assert_eq!(host.ssh.connected(), ["box"]);
host.shutdown().await;
}
+1 -1
Переглянути файл
@@ -690,7 +690,7 @@ mod tests {
for (lang, servers) in [
("python", vec!["basedpyright", "pyright", "ty", "pyrefly"]),
("typescript", vec!["vtsls", "typescript-language-server"]),
("java", vec!["jdtls", "kmp-lsp"]),
("java", vec!["jdtls", "java-analyzer", "kmp-lsp"]),
("kotlin", vec!["kotlin-lsp", "kotlin-language-server", "kmp-lsp"]),
] {
let cfg = reg.get(&LanguageId::new(lang)).unwrap();
+196
Переглянути файл
@@ -0,0 +1,196 @@
//! The Dart analysis server's Flutter outline (`dart/textDocument/publishFlutterOutline`):
//! a file's declarations with the widgets built inside them, in source order.
use crate::convert::Conv;
use ide_core::{OutlineItem, SymbolKind};
use lsp_types as lsp;
use serde::Deserialize;
use std::path::Path;
#[derive(Deserialize)]
pub(crate) struct Params {
pub uri: String,
pub outline: Node,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct Node {
kind: String,
label: Option<String>,
class_name: Option<String>,
variable_name: Option<String>,
attributes: Option<Vec<Attribute>>,
dart_element: Option<Element>,
range: lsp::Range,
children: Option<Vec<Node>>,
}
#[derive(Deserialize)]
struct Attribute {
name: String,
label: String,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Element {
name: String,
kind: String,
range: Option<lsp::Range>,
parameters: Option<String>,
type_parameters: Option<String>,
return_type: Option<String>,
}
/// The items below the compilation unit; `None` when no widget is built in the file, whose
/// structure is then the ordinary one.
pub(crate) fn items(conv: &Conv, path: &Path, root: Node) -> Option<Vec<OutlineItem>> {
let children = root.children?;
children.iter().any(has_widget).then(|| children.into_iter().map(|n| item(conv, path, n)).collect())
}
fn has_widget(node: &Node) -> bool {
node.dart_element.is_none() || node.children.iter().flatten().any(has_widget)
}
fn item(conv: &Conv, path: &Path, node: Node) -> OutlineItem {
let range = conv.range(path, node.range);
let detail = widget_detail(&node);
let children = node.children.unwrap_or_default().into_iter().map(|n| item(conv, path, n)).collect();
let (name, detail, kind, selection_range) = match node.dart_element {
Some(e) => (
format!("{}{}{}", e.name, e.type_parameters.unwrap_or_default(), e.parameters.unwrap_or_default()),
e.return_type.filter(|t| !t.is_empty()).map(|t| format!("→ {t}")),
element_kind(&e.kind),
e.range.map_or(range, |r| conv.range(path, r)),
),
None => (node.class_name.or(node.label).unwrap_or(node.kind), detail, SymbolKind::Widget, range),
};
OutlineItem { name, detail, kind, range, selection_range, children, visibility: None }
}
/// What follows a widget's class, as the Flutter plugin's outline shows it: the variable holding
/// it, a generic node's expression, then its attributes (`Text 'Hi'`, `Icon icon: add, size: 24`).
fn widget_detail(node: &Node) -> Option<String> {
let mut parts: Vec<String> = node.variable_name.iter().cloned().collect();
if node.kind == "GENERIC" {
parts.extend(node.label.iter().cloned());
}
match node.attributes.as_deref().unwrap_or_default() {
[only] if matches!(only.name.as_str(), "text" | "icon") => parts.push(only.label.clone()),
attributes if !attributes.is_empty() => parts.push(
attributes
.iter()
.map(|a| if a.name == "data" { a.label.clone() } else { format!("{}: {}", a.name, a.label) })
.collect::<Vec<_>>()
.join(", "),
),
_ => {}
}
(!parts.is_empty()).then(|| parts.join(" "))
}
fn element_kind(kind: &str) -> SymbolKind {
match kind {
"CLASS" | "CLASS_TYPE_ALIAS" | "EXTENSION" | "EXTENSION_TYPE" => SymbolKind::Class,
"MIXIN" => SymbolKind::Interface,
"ENUM" => SymbolKind::Enum,
"ENUM_CONSTANT" => SymbolKind::EnumMember,
"CONSTRUCTOR" => SymbolKind::Constructor,
"METHOD" => SymbolKind::Method,
"FUNCTION" => SymbolKind::Function,
"FIELD" => SymbolKind::Field,
"GETTER" | "SETTER" => SymbolKind::Property,
"TOP_LEVEL_VARIABLE" => SymbolKind::Variable,
"FUNCTION_TYPE_ALIAS" | "TYPE_ALIAS" => SymbolKind::TypeAlias,
_ => SymbolKind::Unknown,
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::text::{DocText, Encoding};
use ide_core::{Pos, Range};
use serde_json::{Value, json};
use std::sync::Arc;
fn range(line: u32, from: u32, to: u32) -> Value {
json!({ "start": { "line": line, "character": from }, "end": { "line": line, "character": to } })
}
fn element(kind: &str, name: &str, extra: Value, children: Value) -> Value {
let mut e = json!({ "kind": kind, "name": name, "range": range(1, 9, 14) });
e.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
json!({ "kind": "DART_ELEMENT", "dartElement": e, "range": range(0, 0, 40), "codeRange": range(0, 0, 40), "children": children })
}
fn widget(kind: &str, class: &str, extra: Value) -> Value {
let mut w = json!({ "kind": kind, "className": class, "range": range(3, 4, 12), "codeRange": range(3, 4, 12) });
w.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
w
}
fn convert(conv: &Conv, children: Value) -> Option<Vec<OutlineItem>> {
let root: Node = serde_json::from_value(element("COMPILATION_UNIT", "<unit>", json!({}), children)).unwrap();
items(conv, Path::new("/p/a.dart"), root)
}
fn utf16() -> Conv<'static> {
Conv::new(Encoding::Utf16, |_: &Path| None)
}
#[test]
fn declarations_keep_their_widgets_in_source_order() {
let outline = json!([element(
"METHOD",
"build",
json!({ "parameters": "(BuildContext context)", "returnType": "Widget" }),
json!([widget("NEW_INSTANCE", "Scaffold", json!({})), widget("NEW_INSTANCE", "Align", json!({}))]),
)]);
let items = convert(&utf16(), outline).unwrap();
let build = &items[0];
assert_eq!(build.name, "build(BuildContext context)");
assert_eq!(build.detail.as_deref(), Some("→ Widget"));
assert_eq!(build.kind, SymbolKind::Method);
assert_eq!(build.selection_range, Range::new(Pos::new(1, 9), Pos::new(1, 14)));
let names: Vec<_> = build.children.iter().map(|c| c.name.as_str()).collect();
assert_eq!(names, ["Scaffold", "Align"]);
assert_eq!(build.children[0].kind, SymbolKind::Widget);
assert_eq!(build.children[0].selection_range, build.children[0].range);
}
#[test]
fn widget_details_read_like_the_flutter_plugin() {
let attr = |name: &str, label: &str| json!({ "name": name, "label": label });
let detail = |w: Value| convert(&utf16(), json!([w])).unwrap().remove(0).detail;
let w = widget("NEW_INSTANCE", "Text", json!({ "attributes": [attr("data", "'Hi'")] }));
assert_eq!(detail(w).as_deref(), Some("'Hi'"));
let w = widget("NEW_INSTANCE", "Icon", json!({ "attributes": [attr("icon", "Icons.add")] }));
assert_eq!(detail(w).as_deref(), Some("Icons.add"));
let w =
widget("NEW_INSTANCE", "Icon", json!({ "attributes": [attr("icon", "Icons.add"), attr("size", "24")] }));
assert_eq!(detail(w).as_deref(), Some("icon: Icons.add, size: 24"));
assert_eq!(detail(widget("VARIABLE", "Text", json!({ "variableName": "title" }))).as_deref(), Some("title"));
assert_eq!(detail(widget("GENERIC", "Widget", json!({ "label": "_footer()" }))).as_deref(), Some("_footer()"));
assert_eq!(detail(widget("NEW_INSTANCE", "Column", json!({}))), None);
}
#[test]
fn a_file_without_widgets_has_no_flutter_outline() {
let plain =
json!([element("CLASS", "Plain", json!({}), json!([element("METHOD", "run", json!({}), json!([]))]))]);
assert!(convert(&utf16(), plain).is_none());
assert!(convert(&utf16(), json!([])).is_none());
}
#[test]
fn positions_become_utf16_columns() {
let text = Arc::new(DocText::new("\n\n\n🙂🙂 Text('x')\n"));
let conv = Conv::new(Encoding::Utf8, move |_: &Path| Some(text.clone()));
let w = json!({ "kind": "NEW_INSTANCE", "className": "Text", "range": range(3, 9, 13), "codeRange": range(3, 9, 13) });
let item = convert(&conv, json!([w])).unwrap().remove(0);
assert_eq!(item.range, Range::new(Pos::new(3, 5), Pos::new(3, 9)));
}
}
+19
Переглянути файл
@@ -355,6 +355,24 @@ impl ClientHandler {
mgr.emit_diagnostics(&self.server, path, shown, self.encoding());
}
fn publish_flutter_outline(&self, mgr: &LspManager, params: Value) {
let params: crate::flutter_outline::Params = match serde_json::from_value(params) {
Ok(p) => p,
Err(e) => {
tracing::debug!("{}: bad publishFlutterOutline: {e}", self.server.name);
return;
}
};
let Some(path) = uri_to_path(&params.uri) else { return };
if !self.server.is_live(self.generation) {
return;
}
let items = crate::flutter_outline::items(&mgr.conv(self.encoding()), &path, params.outline);
if mgr.set_flutter_outline(&path, &self.server, self.generation, items) {
mgr.sink().emit(IdeEvent::LspRefresh { server: self.server.id, kind: LspRefreshKind::FlutterOutline });
}
}
/// Once per unresolved plugin, whether m2e marked a `pom.xml` or only logged it.
fn build_plan_failure(&self, mgr: &LspManager, (plugin, body): (String, String)) {
if mgr.first_message(&self.server.name, &format!("build plan: {plugin}")) {
@@ -562,6 +580,7 @@ impl Handler for ClientHandler {
}
}
"textDocument/publishDiagnostics" => self.publish_diagnostics(&mgr, params),
"dart/textDocument/publishFlutterOutline" => self.publish_flutter_outline(&mgr, params),
"window/showMessage" => self.show_message(&mgr, &params),
"window/logMessage" => {
let text = params.get("message").and_then(Value::as_str).unwrap_or_default();
+38
Переглянути файл
@@ -15,6 +15,7 @@ mod convert;
mod external_project;
mod file_ops;
mod file_watch;
mod flutter_outline;
mod go_mod;
mod go_scope;
mod handler;
@@ -131,6 +132,15 @@ struct DocState {
notebook: Option<PathBuf>,
/// When the servers last got new text (open or change): diagnostics published before are stale.
changed: std::time::Instant,
flutter_outline: Option<FlutterOutline>,
}
/// The widget tree last published for a document, valid while that server instance runs.
/// ponytail: positions lag edits until the server's next publish, which follows each analysis.
struct FlutterOutline {
server: ide_core::ServerId,
generation: u64,
items: Vec<OutlineItem>,
}
impl DocState {
@@ -1268,6 +1278,7 @@ impl LspManager {
compose_detected,
notebook: None,
changed: std::time::Instant::now(),
flutter_outline: None,
};
let compose_added = {
let mut docs = self.docs.lock();
@@ -2406,6 +2417,33 @@ impl LspManager {
out.finish(None)
}
/// The document's widget tree, when its running Dart server published one.
pub fn flutter_outline(&self, doc: DocId) -> Option<Vec<OutlineItem>> {
let docs = self.docs.lock();
let d = docs.get(&doc)?;
let outline = d.flutter_outline.as_ref()?;
d.servers
.iter()
.any(|a| a.server.id == outline.server && a.server.is_live(outline.generation))
.then(|| outline.items.clone())
}
/// Records a published outline; whether what the open documents of `path` show changed.
fn set_flutter_outline(
&self,
path: &Path,
server: &Server,
generation: u64,
items: Option<Vec<OutlineItem>>,
) -> bool {
let mut changed = false;
for d in self.docs.lock().values_mut().filter(|d| d.path == path) {
changed |= d.flutter_outline.is_some() || items.is_some();
d.flutter_outline = items.clone().map(|items| FlutterOutline { server: server.id, generation, items });
}
changed
}
pub async fn workspace_symbols(&self, query: &str, cancel: CancellationToken) -> IdeResult<Vec<WorkspaceSymbol>> {
let servers: Vec<Arc<Server>> = self.servers.lock().clone();
let targets = self.ready_targets(&servers, |c| c.has("workspaceSymbolProvider")).await;
+1
Переглянути файл
@@ -236,6 +236,7 @@ impl LspManager {
compose_detected: false,
notebook: Some(path.to_owned()),
changed: std::time::Instant::now(),
flutter_outline: None,
},
);
state.cells.push((cell.id.clone(), doc));
+60 -1
Переглянути файл
@@ -1,6 +1,6 @@
//! Protocol tests against in-memory mock language servers.
use ide_core::event::ServerStatus;
use ide_core::event::{LspRefreshKind, ServerStatus};
use ide_core::{
CancellationToken, DocId, FileEdit, IdeEvent, LanguageId, Pos, Range, ServerId, Severity, WorkspaceEdit,
};
@@ -1459,6 +1459,65 @@ async fn unsupported_feature_names_the_running_servers_that_lack_it() {
assert_eq!(e.message, "plain, other doesn't support type hierarchy");
}
#[tokio::test(flavor = "multi_thread")]
async fn flutter_outline_follows_the_document_and_the_server_instance() {
let h = harness(&[("mock", incremental_caps())]);
let (doc, path) = h.open("a.mk", "Text('x')\n");
h.wait_status("mock", ServerStatus::Ready).await;
let refreshes = || {
h.events
.lock()
.iter()
.filter(|e| matches!(e, IdeEvent::LspRefresh { kind: LspRefreshKind::FlutterOutline, .. }))
.count()
};
let at = json!({"start":{"line":0,"character":0},"end":{"line":0,"character":9}});
let unit = |children: Value| {
json!({ "uri": uri_of(&path), "outline": {
"kind": "DART_ELEMENT", "range": at, "codeRange": at,
"dartElement": { "kind": "COMPILATION_UNIT", "name": "<unit>" },
"children": children,
}})
};
let widgets = json!([{ "kind": "NEW_INSTANCE", "className": "Text", "range": at, "codeRange": at }]);
let peer = h.launcher.state("mock").peer();
assert!(h.mgr.flutter_outline(doc).is_none());
peer.notify("dart/textDocument/publishFlutterOutline", unit(widgets.clone())).unwrap();
eventually(|| refreshes() == 1).await;
assert_eq!(h.mgr.flutter_outline(doc).unwrap()[0].name, "Text");
// The widgets are gone from the file: the ordinary structure applies again.
peer.notify("dart/textDocument/publishFlutterOutline", unit(json!([]))).unwrap();
eventually(|| refreshes() == 2).await;
assert!(h.mgr.flutter_outline(doc).is_none());
peer.notify("dart/textDocument/publishFlutterOutline", unit(widgets.clone())).unwrap();
eventually(|| refreshes() == 3).await;
// Reopening starts without the closed document's tree.
h.mgr.did_close(doc);
assert!(h.mgr.flutter_outline(doc).is_none());
let (reopened, _) = h.open("a.mk", "Text('x')\n");
assert!(h.mgr.flutter_outline(reopened).is_none());
peer.notify("dart/textDocument/publishFlutterOutline", unit(widgets)).unwrap();
eventually(|| refreshes() == 4).await;
assert!(h.mgr.flutter_outline(reopened).is_some());
// A restarted server has analysed nothing yet.
let server = h
.events
.lock()
.iter()
.find_map(|e| match e {
IdeEvent::LanguageServer { server, name, .. } if name == "mock" => Some(*server),
_ => None,
})
.unwrap();
h.mgr.restart(server).await.unwrap();
assert!(h.mgr.flutter_outline(reopened).is_none());
}
#[tokio::test(flavor = "multi_thread")]
async fn diagnostics_become_events_and_feed_code_actions() {
let h = harness(&[("mock", incremental_caps())]);
+81 -3
Переглянути файл
@@ -61,18 +61,96 @@ impl Discovery {
serde_json::from_slice(&bytes).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
}
/// Writes the file atomically, readable only by the user.
/// Writes the file atomically, readable only by the user, and records a per-server
/// entry alongside it so multiple `openidea-server` processes sharing one data
/// directory remain discoverable by project.
pub fn write(&self, path: &Path) -> io::Result<()> {
let bytes = serde_json::to_vec_pretty(self).map_err(io::Error::other)?;
write_atomic(path, &bytes)
write_atomic(path, &bytes)?;
if let Some(entry) = server_entry_path(path, self.pid, self.port) {
let _ = write_atomic(&entry, &bytes);
}
// Entries of servers that ended without removing theirs (a crash) go now, so bridges
// stop trying them.
for (file, other) in sibling_entry_files(path) {
if (other.pid, other.port) != (self.pid, self.port) && !other.listening() {
let _ = std::fs::remove_file(file);
}
}
Ok(())
}
fn listening(&self) -> bool {
let addr = std::net::SocketAddr::new(self.address, self.port);
std::net::TcpStream::connect_timeout(&addr, std::time::Duration::from_millis(50)).is_ok()
}
/// Removes the file at `path` if it still describes this process's server.
pub fn remove_if_ours(path: &Path) {
if Self::read(path).is_ok_and(|d| d.pid == std::process::id()) {
if let Ok(d) = Self::read(path)
&& d.pid == std::process::id()
{
Self::remove_server(path, d.port);
}
}
/// Removes this server's entry and updates `path` to another live entry when one exists.
pub fn remove_server(path: &Path, port: u16) {
let pid = std::process::id();
if let Some(entry) = server_entry_path(path, pid, port) {
let _ = std::fs::remove_file(entry);
}
if Self::read(path).is_ok_and(|d| d.pid == pid && d.port == port) {
for (file, other) in sibling_entry_files(path) {
if other.pid == pid && other.port == port {
continue;
}
if other.listening() {
if let Ok(bytes) = serde_json::to_vec_pretty(&other)
&& write_atomic(path, &bytes).is_ok()
{
return;
}
} else {
let _ = std::fs::remove_file(file);
}
}
let _ = std::fs::remove_file(path);
}
}
/// Running server entries recorded for `path`, starting with `path` itself.
pub fn candidates(path: &Path) -> Vec<Self> {
let mut out = Vec::new();
if let Ok(primary) = Self::read(path) {
out.push(primary);
}
for (_, item) in sibling_entry_files(path) {
if !out.iter().any(|d| d.address == item.address && d.port == item.port) {
out.push(item);
}
}
out
}
}
fn servers_dir(path: &Path) -> Option<PathBuf> {
path.parent().map(|dir| dir.join("servers"))
}
fn server_entry_path(path: &Path, pid: u32, port: u16) -> Option<PathBuf> {
servers_dir(path).map(|dir| dir.join(format!("{pid}-{port}.json")))
}
fn sibling_entry_files(path: &Path) -> Vec<(PathBuf, Discovery)> {
let Some(dir) = servers_dir(path) else { return Vec::new() };
let Ok(entries) = std::fs::read_dir(dir) else { return Vec::new() };
let mut files: Vec<PathBuf> = entries
.filter_map(|e| e.ok().map(|e| e.path()))
.filter(|p| p.extension().is_some_and(|ext| ext == "json"))
.collect();
files.sort();
files.into_iter().filter_map(|p| Discovery::read(&p).ok().map(|d| (p, d))).collect()
}
/// Writes `bytes` to `path` atomically, readable only by the user.
+1 -1
Переглянути файл
@@ -185,7 +185,7 @@ impl Drop for McpServer {
self.cancel.cancel();
let _ = self.shutdown.send(true);
if let Some(path) = &self.discovery {
Discovery::remove_if_ours(path);
Discovery::remove_server(path, self.port);
}
}
}
+113 -8
Переглянути файл
@@ -9,9 +9,19 @@ use bytes::Bytes;
use http_body_util::{BodyExt, Full};
use hyper::{Request, StatusCode, header};
use serde_json::Value;
use std::collections::HashSet;
use std::net::SocketAddr;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
use tokio::io::{AsyncBufRead, AsyncBufReadExt, AsyncWrite, AsyncWriteExt};
#[derive(Default)]
struct BridgeState {
preferred: Option<SocketAddr>,
init_message: Option<Value>,
initialized_on: HashSet<SocketAddr>,
}
/// Runs the bridge on this process's stdin and stdout until stdin closes.
/// `project` defaults to the current directory. Returns the exit code.
pub fn run(discovery: &Path, project: Option<PathBuf>) -> i32 {
@@ -43,6 +53,7 @@ where
W: AsyncWrite + Unpin,
{
let scope = crate::server::new_token()?;
let state = Arc::new(Mutex::new(BridgeState::default()));
let mut lines = input.lines();
let mut pending = tokio::task::JoinSet::new();
let (sent, mut received) = tokio::sync::mpsc::unbounded_channel::<Value>();
@@ -57,10 +68,13 @@ where
if line.trim().is_empty() { continue; }
match serde_json::from_str::<Value>(&line) {
Ok(message) => {
let (discovery, project, scope, sent) =
(discovery.to_owned(), project.to_owned(), scope.clone(), sent.clone());
if is_initialize(&message) {
state.lock().unwrap().init_message = Some(message.clone());
}
let (discovery, project, scope, sent, state) =
(discovery.to_owned(), project.to_owned(), scope.clone(), sent.clone(), state.clone());
pending.spawn(async move {
if let Some(reply) = relay(&discovery, &project, &message, &scope, &sent).await {
if let Some(reply) = relay(&discovery, &project, &message, &scope, &sent, &state).await {
let _ = sent.send(reply);
}
});
@@ -86,6 +100,10 @@ where
Ok(())
}
fn is_initialize(message: &Value) -> bool {
message.get("method").and_then(Value::as_str) == Some("initialize")
}
/// The IDE's answer to `message`, or an error response for each request in
/// it when the IDE can't be reached. An answer on an event stream goes to `sent`
/// with the messages before it.
@@ -95,8 +113,9 @@ async fn relay(
message: &Value,
scope: &str,
sent: &tokio::sync::mpsc::UnboundedSender<Value>,
state: &Mutex<BridgeState>,
) -> Option<Value> {
let failure = match post(discovery, project, message, scope, sent).await {
let failure = match post(discovery, project, message, scope, sent, state).await {
Ok(Answer::Streamed { answered: true }) => return None,
Ok(Answer::Streamed { answered: false }) => "OpenIDEA's answer ended early".to_owned(),
Ok(Answer::Body(StatusCode::ACCEPTED, _)) => return None,
@@ -132,14 +151,101 @@ enum Answer {
},
}
/// POSTs `message` to the server in the discovery file; a message for the
/// user when that fails.
/// POSTs `message` to the server in the discovery file; when several servers share a data
/// directory (multiple remote windows on one host), picks the one where `project` is open.
async fn post(
discovery: &Path,
project: &Path,
message: &Value,
scope: &str,
sent: &tokio::sync::mpsc::UnboundedSender<Value>,
state: &Mutex<BridgeState>,
) -> Result<Answer, String> {
let not_running = || {
format!(
"OpenIDEA's MCP server is not running. Start OpenIDEA, open {} in it, and turn on Settings › Agents › MCP Server",
project.display()
)
};
let mut candidates = Discovery::candidates(discovery);
if candidates.is_empty() {
return Err(not_running());
}
if let Some(preferred) = state.lock().unwrap().preferred
&& let Some(pos) = candidates.iter().position(|c| SocketAddr::new(c.address, c.port) == preferred)
{
let chosen = candidates.remove(pos);
candidates.insert(0, chosen);
}
let initializing = is_initialize(message);
let mut fallback: Option<(SocketAddr, Answer)> = None;
let mut last_error: Option<String> = None;
let total = candidates.len();
for (idx, info) in candidates.into_iter().enumerate() {
let at = SocketAddr::new(info.address, info.port);
if !initializing {
let init = {
let guard = state.lock().unwrap();
(!guard.initialized_on.contains(&at)).then(|| guard.init_message.clone()).flatten()
};
if let Some(mut init_msg) = init {
if let Some(obj) = init_msg.as_object_mut() {
obj.insert("id".into(), Value::String(format!("__openidea_init_{idx}__")));
}
if post_one(&info, project, &init_msg, scope, sent).await.is_ok() {
state.lock().unwrap().initialized_on.insert(at);
}
}
}
match post_one(&info, project, message, scope, sent).await {
Ok(answer) => {
if initializing {
state.lock().unwrap().initialized_on.insert(at);
if total > 1 && !serves_project(&info, project, scope).await {
fallback.get_or_insert((at, answer));
continue;
}
} else if idx + 1 < total && is_not_open_reply(&answer) {
fallback = Some((at, answer));
continue;
}
state.lock().unwrap().preferred = Some(at);
return Ok(answer);
}
Err(err) => last_error = Some(err),
}
}
if let Some((at, answer)) = fallback {
state.lock().unwrap().preferred = Some(at);
return Ok(answer);
}
Err(last_error.unwrap_or_else(not_running))
}
/// Whether the server of `info` has `project` open: its `tools/list` doesn't answer "not open".
async fn serves_project(info: &Discovery, project: &Path, scope: &str) -> bool {
let probe = serde_json::json!({ "jsonrpc": "2.0", "id": "__openidea_probe__", "method": "tools/list" });
let (discard, _) = tokio::sync::mpsc::unbounded_channel();
match post_one(info, project, &probe, scope, &discard).await {
Ok(answer @ Answer::Body(StatusCode::OK, _)) => !is_not_open_reply(&answer),
_ => false,
}
}
fn is_not_open_reply(answer: &Answer) -> bool {
let Answer::Body(StatusCode::OK, body) = answer else { return false };
serde_json::from_slice::<Value>(body)
.ok()
.and_then(|v| v.pointer("/error/code").and_then(Value::as_i64))
.is_some_and(|code| code == NOT_OPEN)
}
async fn post_one(
info: &Discovery,
project: &Path,
message: &Value,
scope: &str,
sent: &tokio::sync::mpsc::UnboundedSender<Value>,
) -> Result<Answer, String> {
let not_running = || {
format!(
@@ -147,8 +253,7 @@ async fn post(
project.display()
)
};
let info = Discovery::read(discovery).map_err(|_| not_running())?;
let at = std::net::SocketAddr::new(info.address, info.port);
let at = SocketAddr::new(info.address, info.port);
let stream = tokio::net::TcpStream::connect(at).await.map_err(|_| not_running())?;
let (mut sender, conn) = hyper::client::conn::http1::handshake(hyper_util::rt::TokioIo::new(stream))
.await
+49
Переглянути файл
@@ -424,3 +424,52 @@ async fn another_listen_address_is_used_and_one_not_on_this_computer_fails() {
let error = McpServer::start_with(registry, None, &runtime, elsewhere).err().expect("no such address here");
assert!(error.to_string().contains("192.0.2.1"), "{error}");
}
#[tokio::test(flavor = "multi_thread")]
async fn multiple_servers_sharing_app_data_route_by_project_and_survive_one_closing() {
let tmp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(tmp.path()).unwrap();
let (proj_a, proj_b) = (base.join("proj-a"), base.join("proj-b"));
std::fs::create_dir_all(&proj_a).unwrap();
std::fs::create_dir_all(&proj_b).unwrap();
let discovery = discovery_path(&base.join("app-data"));
let runtime = tokio::runtime::Handle::current();
let server_a =
McpServer::start(Arc::new(Registry { project: proj_a.clone() }), Some(discovery.clone()), &runtime).unwrap();
let server_b =
McpServer::start(Arc::new(Registry { project: proj_b.clone() }), Some(discovery.clone()), &runtime).unwrap();
let session = |text: &str| {
[
json!({ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "protocolVersion": "2025-06-18", "clientInfo": { "name": "agent", "version": "1" } } }),
json!({ "jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": { "name": "echo", "arguments": { "text": text } } }),
]
.iter()
.map(|m| format!("{m}\n"))
.collect::<String>()
};
for (proj, tag) in [(&proj_a, "alpha"), (&proj_b, "beta")] {
let mut out = Vec::new();
stdio::bridge(&discovery, proj, session(tag).as_bytes(), &mut out).await.unwrap();
let mut replies: Vec<Value> =
String::from_utf8(out).unwrap().lines().map(|l| serde_json::from_str(l).unwrap()).collect();
replies.sort_by_key(|r| r["id"].as_i64());
assert!(replies[0]["result"]["instructions"].as_str().unwrap().contains(&proj.display().to_string()));
assert_eq!(replies[1]["result"]["content"][0]["text"], format!("{tag} in {}", proj.display()));
}
// Closing the newer server promotes the remaining server back to server.json.
server_b.stop();
assert_eq!(Discovery::read(&discovery).unwrap().port, server_a.port());
let mut out = Vec::new();
stdio::bridge(&discovery, &proj_a, session("still-here").as_bytes(), &mut out).await.unwrap();
let mut replies: Vec<Value> =
String::from_utf8(out).unwrap().lines().map(|l| serde_json::from_str(l).unwrap()).collect();
replies.sort_by_key(|r| r["id"].as_i64());
assert_eq!(replies[1]["result"]["content"][0]["text"], format!("still-here in {}", proj_a.display()));
server_a.stop();
assert!(!discovery.exists());
}
+12
Переглянути файл
@@ -88,6 +88,7 @@ pub(crate) fn detect_with_profiles(
detect_projects(root, &["Makefile", "makefile", "GNUmakefile"], detect_make, &mut out);
detect_projects(root, &["justfile", "Justfile", ".justfile"], detect_just, &mut out);
detect_godot(root, &mut out);
detect_projects(root, &["pubspec.yaml"], detect_flutter, &mut out);
crate::external::detect(root, &mut out);
let mut seen = HashSet::new();
@@ -1545,6 +1546,17 @@ fn detect_godot(root: &Path, out: &mut Vec<RunConfig>) {
}
}
/// A Flutter app: depends on the SDK and has the conventional entry point (packages have none).
fn detect_flutter(root: &Path, out: &mut Vec<RunConfig>) {
if root.join("lib/main.dart").is_file()
&& read(&root.join("pubspec.yaml")).is_some_and(|pubspec| pubspec.contains("sdk: flutter"))
{
out.push(
config("flutter:run", "flutter run", "flutter", "flutter", &["run", "-t", "lib/main.dart"]).debug("dart"),
);
}
}
fn detect_just(root: &Path, out: &mut Vec<RunConfig>) {
let Some(path) = first_existing(root, &["justfile", "Justfile", ".justfile"]) else { return };
let Some(src) = read(&path) else { return };
+31 -3
Переглянути файл
@@ -4,15 +4,15 @@
//! than one place is taken from the first, in that order.
//!
//! Python, Django server, Django tests, pytest, npm, Jest, Vitest, Node.js, Shell Script,
//! Application, JAR Application, Spring Boot, Go Application / Go Test and compound configurations become the
//! Application, JAR Application, Spring Boot, Go Application / Go Test, Flutter and compound configurations become the
//! matching kinds; other types are skipped with their type.
//! `$PROJECT_DIR$` (and `$MODULE_DIR$`, `$MODULE_WORKING_DIR$`, `$ContentRoot$`,
//! `$ProjectFileDir$`, all the project directory here) and `$USER_HOME$` are replaced; another
//! path variable skips the configuration.
use super::{
Entry, Found, SkipReason, command_name, config, env_var, normalize, path_from, project_python, relative_to,
working_dir,
Entry, Found, SkipReason, command_name, config, dart_package, env_var, flutter_run, normalize, path_from,
project_python, relative_to, working_dir,
};
use crate::RunConfig;
use ide_core::IdeResult;
@@ -168,6 +168,7 @@ const JAR_APPLICATION: &str = "JarApplication";
const SPRING_BOOT: &str = "SpringBootApplicationConfigurationType";
const GO_APPLICATION: &str = "GoApplicationRunConfiguration";
const GO_TEST: &str = "GoTestRunConfiguration";
const FLUTTER: &str = "FlutterRunConfigurationType";
type Res<T> = Result<T, SkipReason>;
@@ -349,6 +350,7 @@ impl Cx<'_> {
SPRING_BOOT => self.java_app(name, c, true, &mut ignored)?,
GO_APPLICATION => self.go_config(name, c, false, &mut ignored)?,
GO_TEST => self.go_config(name, c, true, &mut ignored)?,
FLUTTER => self.flutter(name, c, &mut ignored)?,
COMPOUND => {
members = c.children_named("toRun").filter_map(|t| t.attr("name")).map(str::to_owned).collect();
config(name, "compound", String::new(), Vec::new(), None)
@@ -437,6 +439,32 @@ impl Cx<'_> {
Ok(rc)
}
/// The Flutter plugin's configuration (its `SdkFields`): `flutter run` in the entry's package,
/// `additionalArgs` then `--flavor=<buildFlavor>` after the entry, as the plugin passes them.
fn flutter(&self, name: &str, c: &El, ignored: &mut Vec<String>) -> Res<RunConfig> {
let Some(entry) = self.path(c.option("filePath"))? else {
return Err(SkipReason::NothingToRun);
};
let entry = normalize(&self.root.join(entry));
let Some((package, _)) = dart_package(self.root, &entry) else {
return Err(SkipReason::MissingFile { file: "pubspec.yaml".into() });
};
let mut extra = self.words(c.option("additionalArgs"))?;
extra.extend(self.text(c.option("buildFlavor"))?.map(|f| format!("--flavor={f}")));
let mut rc = flutter_run(name, self.root, &package, &entry, extra);
// `<option name="envs"><map><entry key=… value=…/></map></option>`.
let envs = c.children_named("option").filter(|o| o.attr("name") == Some("envs"));
for e in envs.flat_map(|o| o.children.iter()).flat_map(|m| m.children_named("entry")) {
if let Some(key) = e.attr("key").filter(|k| !k.is_empty()) {
rc.env.insert(key.to_owned(), e.attr("value").unwrap_or_default().to_owned());
}
}
if self.text(c.option("attachArgs"))?.is_some() {
ignored.push("attachArgs".into());
}
Ok(rc)
}
// ------------------------------------------------------------- Python
/// The interpreter (`SDK_HOME` when the configuration doesn't use the module's), its
+41
Переглянути файл
@@ -73,6 +73,8 @@ pub struct SkippedRunConfig {
pub enum SkipReason {
/// A configuration with this name already exists.
NameTaken,
/// An existing configuration (a detected one, say) runs the same command.
SameAs { existing: String },
/// The configuration type has no equivalent here: a VS Code debugger (`cppdbg`), a JetBrains type (`Application`).
UnsupportedType {
#[serde(rename = "type")]
@@ -174,6 +176,13 @@ pub(crate) fn finish(source: RunImportSource, entries: Vec<Entry>, existing: &[R
compounds.push((i, e.name, found));
}
Ok(mut found) => {
// ponytail: only against the project's configurations; entries of one file may differ in ignored keys.
if let Some(same) = existing.iter().find(|c| same_run(c, &found.config)) {
// A compound naming it starts the one there is.
by_name.insert(e.name.clone(), same.id.clone());
skipped.push((i, skip(e.name, SkipReason::SameAs { existing: same.name.clone() })));
continue;
}
found.config.id = unique_id(&e.name, &mut ids);
by_name.insert(e.name.clone(), found.config.id.clone());
imported.push((i, ImportedRunConfig { config: found.config, ignored: found.ignored }));
@@ -205,8 +214,40 @@ pub(crate) fn finish(source: RunImportSource, entries: Vec<Entry>, existing: &[R
}
}
/// `a` and `b` start the same process (`flutter run -t lib/main.dart` detected and imported as `main.dart`).
fn same_run(a: &RunConfig, b: &RunConfig) -> bool {
a.kind == b.kind
&& a.command == b.command
&& a.args == b.args
&& a.cwd == b.cwd
&& a.is_test == b.is_test
&& a.debug_adapter == b.debug_adapter
&& a.env == b.env
&& a.extras.params == b.extras.params
&& a.extras.env_files == b.extras.env_files
}
// ------------------------------------------------------------- shared by the sources
/// The Dart package `file` belongs to (the closest directory with a `pubspec.yaml`, inside the
/// project) and whether it is a Flutter app.
pub(crate) fn dart_package(root: &Path, file: &Path) -> Option<(PathBuf, bool)> {
let dir =
file.ancestors().skip(1).take_while(|d| d.starts_with(root)).find(|d| d.join("pubspec.yaml").is_file())?;
let flutter = std::fs::read_to_string(dir.join("pubspec.yaml")).is_ok_and(|p| p.contains("sdk: flutter"));
Some((dir.to_path_buf(), flutter))
}
/// `flutter run -t <entry>` in `package` (absolute), as detection writes it; `extra` after the entry.
pub(crate) fn flutter_run(name: &str, root: &Path, package: &Path, entry: &Path, extra: Vec<String>) -> RunConfig {
let entry = relative_to(entry, package).unwrap_or_else(|| entry.to_string_lossy().into_owned());
let mut args = vec!["run".to_owned(), "-t".to_owned(), entry];
args.extend(extra);
let mut c = config(name, "flutter", "flutter".into(), args, Some("dart"));
c.cwd = working_dir(root, &package.to_string_lossy()).1.map(Into::into);
c
}
/// The variable `name` of `env`; Windows names ignore case (`${env:PATH}` finds `Path`).
pub(crate) fn env_var(env: &BTreeMap<String, String>, name: &str, windows: bool) -> Option<String> {
match env.get(name) {
+45 -4
Переглянути файл
@@ -8,8 +8,8 @@
//! `${input:…}`, `${command:…}`) is skipped.
use super::{
Entry, Found, SkipReason, command_name, config, env_var, normalize, path_from, project_python, split_args,
working_dir,
Entry, Found, SkipReason, command_name, config, dart_package, env_var, flutter_run, normalize, path_from,
project_python, split_args, working_dir,
};
use crate::RunConfig;
use ide_core::{IdeError, IdeResult};
@@ -48,6 +48,7 @@ const NODE_LAUNCH: &[&str] = &["program", "args", "runtimeExecutable", "runtimeA
const NODE_ATTACH: &[&str] = &["address", "port", "localRoot", "remoteRoot"];
const NODE_TERMINAL: &[&str] = &["command"];
const BROWSER_LAUNCH: &[&str] = &["url", "webRoot"];
const DART_LAUNCH: &[&str] = &["program", "args", "toolArgs", "deviceId", "flutterMode"];
const COMPOUND: &[&str] = &["configurations"];
const PACKAGE_MANAGERS: &[&str] = &["npm", "pnpm", "yarn", "bun"];
@@ -226,9 +227,10 @@ impl Cx<'_> {
("chrome" | "pwa-chrome" | "msedge" | "pwa-msedge", "launch") => {
(self.browser_launch(name, obj, ty)?, BROWSER_LAUNCH)
}
("dart", "launch") => (self.dart_launch(name, obj)?, DART_LAUNCH),
(
"debugpy" | "python" | "node" | "pwa-node" | "node-terminal" | "chrome" | "pwa-chrome" | "msedge"
| "pwa-msedge",
| "pwa-msedge" | "dart",
other,
) => {
return Err(SkipReason::UnsupportedRequest { request: other.to_owned() });
@@ -236,7 +238,9 @@ impl Cx<'_> {
(other, _) => return Err(SkipReason::UnsupportedType { type_: other.to_owned() }),
};
if request == "launch" {
config.cwd = self.cwd(obj)?.1.map(Into::into);
if config.cwd.is_none() {
config.cwd = self.cwd(obj)?.1.map(Into::into);
}
self.environment(obj, &mut config)?;
}
let mut ignored: Vec<String> = obj
@@ -366,6 +370,43 @@ impl Cx<'_> {
Ok(c)
}
/// Dart Code's launch: `flutter run` in a Flutter app's package, as the Flutter debug adapter
/// starts it (`args` go to the app), else `dart run`.
fn dart_launch(&self, name: &str, obj: &Map<String, Value>) -> Res<RunConfig> {
let (dir, _) = self.cwd(obj)?;
let program = self.string(obj, "program")?;
// Relative to `cwd`, or to the workspace folder as Dart Code resolves it.
let file = |p: &str| {
let base = [&dir, self.root].into_iter().find(|b| b.join(p).is_file()).unwrap_or(&dir);
normalize(&base.join(p))
};
let entry = file(program.as_deref().unwrap_or("lib/main.dart"));
let tool_args = self.words(obj, "toolArgs")?;
let args = self.words(obj, "args")?;
match dart_package(self.root, &entry) {
Some((package, true)) => {
let mut extra = Vec::new();
if let Some(device) = self.string(obj, "deviceId")? {
extra.extend(["-d".to_owned(), device]);
}
if let Some(mode @ ("profile" | "release")) = self.string(obj, "flutterMode")?.as_deref() {
extra.push(format!("--{mode}"));
}
extra.extend(tool_args);
extra.extend(args.into_iter().flat_map(|a| ["--dart-entrypoint-args".to_owned(), a]));
Ok(flutter_run(name, self.root, &package, &entry, extra))
}
_ if program.is_none() => Err(SkipReason::NothingToRun),
_ => {
let mut words = vec!["run".to_owned()];
words.extend(tool_args);
words.push(self.path_from(entry.to_string_lossy().into_owned(), &dir));
words.extend(args.into_iter().map(|a| self.path_from(a, &dir)));
Ok(config(name, "dart", "dart".into(), words, Some("dart")))
}
}
}
/// `localRoot` (relative to the project root, empty for the root itself) and `remoteRoot`.
fn roots(&self, obj: &Map<String, Value>, c: &mut RunConfig) -> Res<()> {
if let Some(local) = self.string(obj, "localRoot")? {
+42
Переглянути файл
@@ -229,6 +229,15 @@ fn match_console_encoding(
fix.notice
}
/// A script without the execute bit as `/bin/sh <script>` (see [`ide_core::process::needs_sh`]).
/// Applied last, so the encoding and Java fixes above still see the script itself.
fn sh_for_unexecutable(inv: &mut Invocation) {
if !inv.shell && ide_core::process::needs_sh(&inv.program) {
let script = std::mem::replace(&mut inv.program, "/bin/sh".into());
inv.args.insert(0, script.to_string_lossy().into_owned());
}
}
/// A launch's pathing jar / argfile, deleted when dropped (the process exited, or never started).
struct TempFile(Option<PathBuf>);
@@ -382,6 +391,7 @@ impl ProcessManager {
let notice =
if extras.emulate_terminal { None } else { match_console_encoding(&mut inv, &mut env, config, options) };
let temp = shorten_java(&mut inv, config, &cwd)?;
sh_for_unexecutable(&mut inv);
if extras.emulate_terminal && followup.is_some() {
return Err(IdeError::invalid("Go build and run requires the output console"));
}
@@ -1397,6 +1407,38 @@ fn input_writer(
mod tests {
use super::*;
#[cfg(unix)]
#[test]
fn scripts_without_the_execute_bit_run_through_sh() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().unwrap();
let script = dir.path().join("gradlew");
std::fs::write(&script, "#!/bin/sh\n").unwrap();
std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o644)).unwrap();
let inv = || Invocation {
program: script.clone(),
args: vec!["build".into()],
raw_args: false,
shell: false,
display: "./gradlew build".into(),
};
let mut plain = inv();
sh_for_unexecutable(&mut plain);
assert_eq!(plain.program, PathBuf::from("/bin/sh"));
assert_eq!(plain.args, [script.to_string_lossy().as_ref(), "build"]);
assert_eq!(plain.display, "./gradlew build");
std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
let mut executable = inv();
sh_for_unexecutable(&mut executable);
assert_eq!(executable.program, script);
// Not a `#!` script (a binary that lost its mode): left to fail as it is.
std::fs::write(&script, b"\x7fELF").unwrap();
std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o644)).unwrap();
let mut binary = inv();
sh_for_unexecutable(&mut binary);
assert_eq!(binary.program, script);
}
#[test]
fn shell_lines_use_cmd_verbatim_on_windows() {
let line = r#"(if not exist "C:\T\openidea-run" mkdir "C:\T\openidea-run") && "C:\Program Files\rustc.exe" -o "C:\T\openidea-run\hi.exe" hi.rs"#;
+14
Переглянути файл
@@ -627,6 +627,20 @@ fn godot_projects_run_their_main_scene() {
assert!(detect(project(&[("main.gd", "extends Node\n")]).path()).is_empty());
}
#[test]
fn flutter_apps_run_their_entry_point() {
let pubspec = "name: app\ndependencies:\n flutter:\n sdk: flutter\n";
let dir = project(&[("pubspec.yaml", pubspec), ("lib/main.dart", "void main() {}\n")]);
let c = detect(dir.path());
let app = find(&c, "flutter:run");
assert_eq!(app.kind, "flutter");
assert_eq!(cmdline(app), "flutter run -t lib/main.dart");
assert_eq!(app.debug_adapter.as_deref(), Some("dart"));
// A Flutter package has no app to start, and a Dart package no Flutter.
assert!(detect(project(&[("pubspec.yaml", pubspec), ("lib/widgets.dart", "")]).path()).is_empty());
assert!(detect(project(&[("pubspec.yaml", "name: tool\n"), ("lib/main.dart", "")]).path()).is_empty());
}
#[test]
fn just_recipes() {
let justfile = "\
+64
Переглянути файл
@@ -1150,3 +1150,67 @@ fn imports_go_application_and_test_configurations() {
assert_eq!(test.extras.params["pattern"], "TestLogin");
assert_eq!(test.extras.params["module"], "pkg");
}
// What `flutter create` writes to `.idea/runConfigurations/main_dart.xml`; the Flutter plugin's
// `SdkFields` serializes `filePath`, `additionalArgs`, `buildFlavor`, `attachArgs` and `envs` as options:
// https://github.com/flutter/flutter-intellij/blob/main/src/io/flutter/run/SdkFields.java
const FLUTTER_MAIN: &str = r#"<configuration default="false" name="NAME" type="FlutterRunConfigurationType" factoryName="Flutter">
<option name="filePath" value="$PROJECT_DIR$/lib/main.dart" />
<method v="2" />
</configuration>"#;
const PUBSPEC_FLUTTER: &str = "name: my_app\ndependencies:\n flutter:\n sdk: flutter\n";
#[test]
fn flutter_main_dart_from_flutter_create_is_the_detected_configuration() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
write(root, "pubspec.yaml", PUBSPEC_FLUTTER);
write(root, "lib/main.dart", "void main() {}\n");
write(root, ".idea/runConfigurations/main_dart.xml", &run_file("main.dart", FLUTTER_MAIN));
let alone = import_from(root, &[]);
let c = get(&alone, "main.dart");
assert_eq!((c.kind.as_str(), c.command.as_str()), ("flutter", "flutter"));
assert_eq!(c.args, s(&["run", "-t", "lib/main.dart"]));
assert_eq!((cwd(c), c.debug_adapter.as_deref()), (None, Some("dart")));
// Next to the detected `flutter run`, the same run is not listed twice.
let r = import_from(root, &ide_run::detect(root));
assert!(r.imported.is_empty(), "{r:#?}");
assert_eq!(reason(&r, "main.dart"), &SkipReason::SameAs { existing: "flutter run".into() });
}
#[test]
fn flutter_flavors_entry_points_arguments_and_envs() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
write(root, "app/pubspec.yaml", PUBSPEC_FLUTTER);
write(root, "app/lib/main_dev.dart", "void main() {}\n");
let dev = r#"<configuration name="Dev" type="FlutterRunConfigurationType" factoryName="Flutter">
<option name="additionalArgs" value="--dart-define=API=&quot;https://dev.example&quot; --verbose" />
<option name="attachArgs" value="--debug-port 9000" />
<option name="buildFlavor" value="dev" />
<option name="envs"><map><entry key="FLUTTER_LOG" value="1" /></map></option>
<option name="filePath" value="$PROJECT_DIR$/app/lib/main_dev.dart" />
<method v="2" />
</configuration>
<configuration name="Gone" type="FlutterRunConfigurationType" factoryName="Flutter">
<option name="filePath" value="$PROJECT_DIR$/elsewhere/main.dart" />
</configuration>
<configuration name="No entry" type="FlutterRunConfigurationType" factoryName="Flutter" />"#;
write(root, ".idea/workspace.xml", &workspace(dev));
let r = import_from(root, &ide_run::detect(root));
let c = get(&r, "Dev");
assert_eq!(c.kind, "flutter");
assert_eq!(
c.args,
s(&["run", "-t", "lib/main_dev.dart", "--dart-define=API=https://dev.example", "--verbose", "--flavor=dev"])
);
assert_eq!(cwd(c), Some(PathBuf::from("app")));
assert_eq!(c.env, BTreeMap::from([("FLUTTER_LOG".into(), "1".into())]));
assert_eq!(ignored(&r, "Dev"), ["attachArgs"]);
assert_eq!(reason(&r, "Gone"), &SkipReason::MissingFile { file: "pubspec.yaml".into() });
assert_eq!(reason(&r, "No entry"), &SkipReason::NothingToRun);
}
+105
Переглянути файл
@@ -555,3 +555,108 @@ fn existing_names_match_without_surrounding_spaces() {
let r = import_from(dir.path(), &[existing]);
assert_eq!(reason(&r, "Django"), &SkipReason::NameTaken);
}
const PUBSPEC_FLUTTER: &str = "name: my_app\ndependencies:\n flutter:\n sdk: flutter\n";
fn write(root: &Path, rel: &str, text: &str) {
let path = root.join(rel);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, text).unwrap();
}
// The configurations Dart Code adds to a Flutter app's launch.json.
const FLUTTER: &str = r#"{
"version": "0.2.0",
"configurations": [
{ "name": "my_app", "request": "launch", "type": "dart" },
{ "name": "my_app (profile mode)", "request": "launch", "type": "dart", "flutterMode": "profile" },
{ "name": "my_app (release mode)", "request": "launch", "type": "dart", "flutterMode": "release" },
{ "name": "Attach", "request": "attach", "type": "dart" }
],
"compounds": [{ "name": "Both", "configurations": ["my_app", "my_app (profile mode)"] }]
}"#;
#[test]
fn flutter_launches_from_dart_code_next_to_the_detected_configuration() {
let dir = project(FLUTTER);
let root = dir.path();
write(root, "pubspec.yaml", PUBSPEC_FLUTTER);
write(root, "lib/main.dart", "void main() {}\n");
let r = import_from(root, &ide_run::detect(root));
assert_eq!(reason(&r, "my_app"), &SkipReason::SameAs { existing: "flutter run".into() });
for (name, mode) in [("my_app (profile mode)", "--profile"), ("my_app (release mode)", "--release")] {
let c = get(&r, name);
assert_eq!(
(c.kind.as_str(), c.command.as_str(), c.debug_adapter.as_deref()),
("flutter", "flutter", Some("dart"))
);
assert_eq!(c.args, s(&["run", "-t", "lib/main.dart", mode]));
assert_eq!(cwd(c), None);
}
assert_eq!(reason(&r, "Attach"), &SkipReason::UnsupportedRequest { request: "attach".into() });
// A compound naming the left-out entry starts the detected configuration.
assert_eq!(
get(&r, "Both").extras.compound,
["flutter:run".to_owned(), get(&r, "my_app (profile mode)").id.clone()]
);
}
#[test]
fn flutter_entry_device_tool_and_app_arguments_in_a_subfolder() {
let dir = project(
r#"{ "configurations": [
{ "name": "Dev", "request": "launch", "type": "dart", "cwd": "${workspaceFolder}/app",
"program": "lib/main_dev.dart", "deviceId": "chrome", "args": ["--seed", "1"],
"toolArgs": ["--flavor", "dev", "--dart-define=ENV=dev"], "vmAdditionalArgs": ["--x"] },
{ "name": "From the root", "request": "launch", "type": "dart", "program": "app/lib/main_dev.dart" }
] }"#,
);
let root = dir.path();
write(root, "app/pubspec.yaml", PUBSPEC_FLUTTER);
write(root, "app/lib/main_dev.dart", "void main() {}\n");
let r = import_from(root, &[]);
let c = get(&r, "Dev");
assert_eq!(
c.args,
s(&[
"run",
"-t",
"lib/main_dev.dart",
"-d",
"chrome",
"--flavor",
"dev",
"--dart-define=ENV=dev",
"--dart-entrypoint-args",
"--seed",
"--dart-entrypoint-args",
"1",
])
);
assert_eq!(cwd(c), Some(PathBuf::from("app")));
assert_eq!(ignored(&r, "Dev"), ["vmAdditionalArgs"]);
// A program path from the workspace folder runs in its package too.
let c = get(&r, "From the root");
assert_eq!((c.args.clone(), cwd(c)), (s(&["run", "-t", "lib/main_dev.dart"]), Some(PathBuf::from("app"))));
}
#[test]
fn dart_programs_outside_flutter_run_with_dart() {
let dir = project(
r#"{ "configurations": [
{ "name": "Server", "request": "launch", "type": "dart", "program": "bin/server.dart",
"args": ["--port", "8080"], "toolArgs": ["--enable-asserts"] },
{ "name": "Server (absolute)", "request": "launch", "type": "dart", "program": "${workspaceFolder}/bin/server.dart" },
{ "name": "Nothing", "request": "launch", "type": "dart" }
] }"#,
);
let root = dir.path();
write(root, "pubspec.yaml", "name: server\n");
write(root, "bin/server.dart", "void main() {}\n");
let r = import_from(root, &[]);
let c = get(&r, "Server");
assert_eq!((c.kind.as_str(), c.command.as_str(), c.debug_adapter.as_deref()), ("dart", "dart", Some("dart")));
assert_eq!(c.args, s(&["run", "--enable-asserts", "bin/server.dart", "--port", "8080"]));
assert_eq!(get(&r, "Server (absolute)").args, s(&["run", "bin/server.dart"]));
assert_eq!(reason(&r, "Nothing"), &SkipReason::NothingToRun);
}
+147 -42
Переглянути файл
@@ -537,18 +537,21 @@ pub fn configure_gradle_runtime(cfg: &mut LanguageServerConfig, root: &Path, bui
merge(cfg.settings.get_or_insert_with(|| json!({})), json!({"java": {"import": {"gradle": gradle}}}));
}
/// Settings › Build Tools › Maven › Automatically download sources → jdtls
/// `java.maven.downloadSources`.
/// Settings › Build Tools › Maven › Automatically download sources and Always update
/// snapshots → jdtls `java.maven.downloadSources` / `java.maven.updateSnapshots`.
pub fn configure_maven_sources(cfg: &mut LanguageServerConfig, s: &Settings) {
if cfg.name != "jdtls" {
return;
}
let download = s.languages.java.maven.download_sources;
merge(cfg.settings.get_or_insert_with(|| json!({})), json!({"java": {"maven": {"downloadSources": download}}}));
let m = &s.languages.java.maven;
merge(
cfg.settings.get_or_insert_with(|| json!({})),
json!({"java": {"maven": {"downloadSources": m.download_sources, "updateSnapshots": m.update_snapshots}}}),
);
}
/// Maven options from settings, placed before the goals: `-s <settings.xml>`,
/// `-t <toolchains.xml>`, `-Dmaven.repo.local=<dir>`, `-T <count>` and `-P <profiles>`.
/// `-t <toolchains.xml>`, `-Dmaven.repo.local=<dir>`, `-T <count>`, `-P <profiles>` and `-U`.
pub fn maven_options(root: &Path, s: &Settings) -> Vec<String> {
let m = &s.languages.java.maven;
let mut out = Vec::new();
@@ -567,6 +570,9 @@ pub fn maven_options(root: &Path, s: &Settings) -> Vec<String> {
if let Some(profiles) = non_empty(&m.active_profiles) {
out.extend(["-P".to_owned(), profiles.to_owned()]);
}
if m.update_snapshots {
out.push("-U".to_owned());
}
out
}
@@ -680,17 +686,50 @@ fn xml_escape(text: &str) -> String {
text.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;")
}
/// Inserts `<localRepository>` right after the `<settings>` open tag.
fn inject_local_repository(settings_xml: &str, repo: &str) -> Option<String> {
let start = settings_xml.find("<settings")?;
let end = settings_xml[start..].find('>')? + start;
let mut out = String::with_capacity(settings_xml.len() + repo.len() + 40);
out.push_str(&settings_xml[..=end]);
out.push_str("<localRepository>");
out.push_str(&xml_escape(repo));
out.push_str("</localRepository>");
out.push_str(&settings_xml[end + 1..]);
Some(out)
/// `settings_xml` with `<localRepository>` set to `repo`: an existing one is replaced, else
/// one goes right after the `<settings>` open tag. `None` without a `<settings>` element.
pub(crate) fn with_local_repository(settings_xml: &str, repo: &str) -> Option<String> {
use crate::maven_profiles::{find_tag, mask_comments};
let masked = mask_comments(settings_xml);
let element = format!("<localRepository>{}</localRepository>", xml_escape(repo));
if let Some(start) = find_tag(&masked, "<localRepository", 0) {
let open_end = start + masked[start..].find('>')?;
let end = if masked[..open_end].ends_with('/') {
open_end + 1
} else {
let close = open_end + masked[open_end..].find("</localRepository")?;
close + masked[close..].find('>')? + 1
};
return Some(format!("{}{element}{}", &settings_xml[..start], &settings_xml[end..]));
}
let start = find_tag(&masked, "<settings", 0)?;
let end = start + masked[start..].find('>')?;
if masked[..end].ends_with('/') {
return None;
}
Some(format!("{}{element}{}", &settings_xml[..=end], &settings_xml[end + 1..]))
}
/// The user settings m2e (the JDTLS Maven import) reads, as a file and its text: the
/// configured `settings.xml`, else `~/.m2/settings.xml`, with the configured local
/// repository as its `<localRepository>`. m2e reads mirrors, servers and the local
/// repository from this file only, never from `-Dmaven.repo.local`, which is how the IDE's
/// own `mvn` runs get the configured repository (#1739). The file is `None` when there is none.
pub(crate) fn m2e_user_settings(root: &Path, s: &Settings, home: &Path) -> (Option<PathBuf>, String) {
let m = &s.languages.java.maven;
let file = setting_path(root, &m.user_settings)
.or_else(|| Some(home.join(".m2").join("settings.xml")).filter(|f| f.is_file()));
let text = file
.as_ref()
.and_then(|f| std::fs::read_to_string(f).ok())
.unwrap_or_else(|| "<settings>\n</settings>\n".into());
match setting_path(root, &m.local_repository) {
Some(repo) => {
let merged = with_local_repository(&text, &repo.to_string_lossy());
(file, merged.unwrap_or(text))
}
None => (file, text),
}
}
fn write_m2e_settings(root: &Path, text: &str) -> Option<PathBuf> {
@@ -705,32 +744,36 @@ fn write_m2e_settings(root: &Path, text: &str) -> Option<PathBuf> {
Some(file)
}
/// The user settings file m2e (the JDTLS Maven import) should read: the
/// configured `settings.xml` when it already declares `<localRepository>`,
/// else a derived copy under `<root>/.openidea/` with the configured local
/// repository injected. m2e resolves the local repository from the settings
/// XML, not from `-Dmaven.repo.local`, so without this the import downloads
/// into `~/.m2/repository` even when the IDE's own `mvn` runs honor the
/// configured path (#1739). `None` = m2e's default applies.
/// The user settings file m2e should read (see [`m2e_user_settings`]): the configured
/// `settings.xml` as it is when no local repository is configured or it already names that
/// one, else a derived copy under `<root>/.openidea/`. `None` = m2e's default applies.
pub fn maven_user_settings_for_m2e(root: &Path, s: &Settings) -> Option<PathBuf> {
maven_user_settings_for_m2e_in(root, s, &crate::home_dir().unwrap_or_default())
}
pub(crate) fn maven_user_settings_for_m2e_in(root: &Path, s: &Settings, home: &Path) -> Option<PathBuf> {
let m = &s.languages.java.maven;
if let Some(file) = setting_path(root, &m.user_settings) {
let text = std::fs::read_to_string(&file).ok()?;
if crate::java::xml_value(&crate::lombok::strip_xml_comments(&text), "localRepository").is_some() {
return Some(file);
}
if let Some(repo) = setting_path(root, &m.local_repository) {
let merged = inject_local_repository(&text, &repo.to_string_lossy())?;
if let Some(derived) = write_m2e_settings(root, &merged) {
return Some(derived);
}
}
return Some(file);
let configured = setting_path(root, &m.user_settings);
setting_path(root, &m.local_repository)?;
let (file, text) = m2e_user_settings(root, s, home);
if file.as_ref().and_then(|f| std::fs::read_to_string(f).ok()).is_some_and(|original| original == text) {
return file;
}
let repo = setting_path(root, &m.local_repository)?;
let minimal =
format!("<settings><localRepository>{}</localRepository></settings>", xml_escape(&repo.to_string_lossy()));
write_m2e_settings(root, &minimal)
write_m2e_settings(root, &text).or(configured)
}
/// `conf/settings.xml` of the Maven installation the IDE's `mvn` runs use (Settings ›
/// Maven home, a version manager's pin, else `mvn` on `PATH`; none with a project wrapper):
/// `mvn` reads its mirrors and repositories as global settings, m2e only when told to.
pub fn maven_global_settings(root: &Path, s: &Settings) -> Option<PathBuf> {
let mvn = match maven_command(root, s) {
Some(mvn) => mvn,
None if root.join("mvnw").is_file() || root.join("mvnw.cmd").is_file() => return None,
None => crate::exec::which("mvn")?,
};
let mvn = dunce::canonicalize(&mvn).unwrap_or(mvn);
let file = mvn.parent()?.parent()?.join("conf").join("settings.xml");
file.is_file().then_some(file)
}
/// TypeScript `lib` directory for the selected version; `None` = the server's bundled one.
@@ -1070,6 +1113,13 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
}
cfg.command = custom.to_string_lossy().into_owned();
}
// `java -jar` servers run on the project JDK when there is one, like JAR Application runs.
if cfg.command == "java"
&& let Some(java) =
project_jdk(root, s).map(|jdk| crate::java::java_executable(&jdk.home)).filter(|j| j.is_file())
{
cfg.command = java.to_string_lossy().into_owned();
}
let name = cfg.name.clone();
let name = name.as_str();
@@ -1187,13 +1237,19 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
for (key, value) in module_env {
build["env"][key] = json!(value);
}
if s.languages.go.gofumpt {
build["gofumpt"] = json!(true);
}
let mut settings = cfg.settings.take().unwrap_or_else(|| json!({}));
// gopls retains omitted keys on reconfiguration. Explicit empty values
// restore defaults when the last project constraint is cleared.
// Settings › Language Servers options are merged later, so look at them too.
let init = cfg.initialization_options.as_ref().and_then(|v| serde_json::to_value(v).ok());
for (key, default) in [("buildFlags", json!([])), ("env", json!({}))] {
let user_init = s.language_servers.get(&cfg.name).and_then(|ls| ls.initialization_options.as_ref());
for (key, default) in [("buildFlags", json!([])), ("env", json!({})), ("gofumpt", json!(false))] {
if settings.get(key).is_none() {
settings[key] = init.as_ref().and_then(|v| v.get(key)).cloned().unwrap_or(default);
let explicit = user_init.and_then(|v| v.get(key)).or_else(|| init.as_ref()?.get(key));
settings[key] = explicit.cloned().unwrap_or(default);
}
}
merge(&mut settings, build);
@@ -1224,6 +1280,13 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
json!({ "settings": { "java": { "configuration": { "maven": { "userSettings": file } } } } }),
);
}
if let Some(file) = maven_global_settings(root, s) {
let file = file.to_string_lossy();
merge_init_options(
cfg,
json!({ "settings": { "java": { "configuration": { "maven": { "globalSettings": file } } } } }),
);
}
// The JVM system property is still forwarded for JVM-level consumers,
// but it is the settings file above that m2e honors. A
// `-Dmaven.repo.local` the user put in their own jdtls VM options wins.
@@ -1241,6 +1304,21 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
}
}
if name == "java-analyzer" {
// Unset, java-analyzer finds a JDK and the Maven local repository the way Maven does;
// the server's own `initializationOptions` in settings are merged later and win.
let mut layer = serde_json::Map::new();
if let Some(jdk) = project_jdk(root, s) {
layer.insert("jdkHome".into(), json!(jdk.home.to_string_lossy()));
}
if let Some(repo) = maven_local_repository(root, s) {
layer.insert("maven".into(), json!({ "localRepository": repo.to_string_lossy() }));
}
if !layer.is_empty() {
merge_init_options(cfg, Value::Object(layer));
}
}
if let Some(lib) = tsdk(server_root, s).or_else(|| tsdk(root, s)) {
let lib_s = lib.to_string_lossy().into_owned();
match name {
@@ -1399,6 +1477,23 @@ pub fn language_servers(language: &str, defined: &[LanguageServerConfig], s: &Se
out
}
/// Built-in servers given an executable path in Settings › Language Servers, as
/// (definition's command, path): they run that executable (see [`server_launch_overrides`]).
pub fn server_command_paths<'a>(
servers: impl IntoIterator<Item = &'a LanguageServerConfig>,
root: &Path,
s: &Settings,
) -> Vec<(String, PathBuf)> {
servers
.into_iter()
.filter_map(|server| {
let command = s.language_servers.get(&server.name)?.command.trim();
let path = command.contains(['/', '\\']).then(|| setting_path(root, command))??;
Some((server.command.clone(), path))
})
.collect()
}
/// Adds the servers defined in settings to the languages they serve (to list
/// them with the tools); disabled ones stay so they can be turned back on.
pub fn with_custom_servers(langs: &mut [LanguageConfig], s: &Settings) {
@@ -1453,6 +1548,12 @@ pub fn server_launch_overrides(cfg: &mut LanguageServerConfig, s: &Settings) {
if let Some(args) = &ls.args {
cfg.args = args.clone();
}
// A server shipped as a runnable jar (groovy-language-server-all.jar) runs on `java -jar`;
// `configure_server` then picks the project JDK's `java`.
if Path::new(&cfg.command).extension().is_some_and(|e| e.eq_ignore_ascii_case("jar")) {
let jar = std::mem::replace(&mut cfg.command, "java".to_owned());
cfg.args.splice(0..0, ["-jar".to_owned(), jar]);
}
}
/// Environment, features, `initializationOptions` and `workspace/configuration`
@@ -1552,6 +1653,9 @@ fn maven_option_flag(arg: &str) -> Option<&'static str> {
return Some(short);
}
}
if arg == "-U" || arg == "--update-snapshots" {
return Some("-U");
}
arg.starts_with("-Dmaven.repo.local=").then_some("-Dmaven.repo.local")
}
@@ -2371,8 +2475,9 @@ mod maven_linkage_tests {
Some(json!({"java": {"maven": {"downloadSources": false, "updateSnapshots": false}}}))
);
settings.languages.java.maven.download_sources = true;
settings.languages.java.maven.update_snapshots = true;
configure_maven_sources(&mut cfg, &settings);
assert_eq!(cfg.settings.unwrap()["java"]["maven"]["downloadSources"], json!(true));
assert_eq!(cfg.settings.unwrap()["java"]["maven"], json!({"downloadSources": true, "updateSnapshots": true}));
let mut other = custom_server("kotlin", &LanguageServerSettings::default());
configure_maven_sources(&mut other, &settings);
+25
Переглянути файл
@@ -86,6 +86,11 @@ pub(crate) fn java_runs(java: &Path) -> bool {
runnable
}
/// First runnable Java installation in discovery order, including standalone JREs.
pub fn java_runtime(jdks: &[Jdk], min_java: u32) -> Option<&Jdk> {
jdks.iter().find(|j| j.major >= min_java && java_runs(&java_executable(&j.home)))
}
fn project_jdk_is_usable(jdk: &Jdk) -> bool {
jdk.home.join("bin").join(crate::exe("javac")).is_file()
&& (jdk.major < 9 || ide_core::java_runtime::supports_java_bundles(&jdk.home))
@@ -748,6 +753,16 @@ pub(crate) fn write_test_java(home: &Path) {
mod tests {
use super::*;
#[test]
fn java_runtime_accepts_a_jre_without_a_compiler() {
let tmp = tempfile::tempdir().unwrap();
let jre = test_jdk(tmp.path(), 17, "jre");
std::fs::remove_file(jre.home.join("bin").join(crate::exe("javac"))).unwrap();
let jdks = [test_jdk(tmp.path(), 11, "old"), jre.clone()];
assert_eq!(java_runtime(&jdks, 17), Some(&jre));
assert_eq!(java_runtime(&jdks, 21), None);
}
fn test_jdk(root: &Path, major: u32, name: &str) -> Jdk {
let home = root.join(name.trim_start_matches('/'));
std::fs::create_dir_all(home.join("bin")).unwrap();
@@ -1619,6 +1634,16 @@ pub fn usages_bundle(data_dir: &Path) -> Option<PathBuf> {
)
}
/// Extracts the JDBC bridge into the application's data directory.
pub fn jdbc_bridge_jar(data_dir: &Path) -> Option<PathBuf> {
install_bundle(
data_dir,
"jdbc-bridge",
"1.0.0",
include_bytes!("../../../java/jdbc-bridge/openidea-jdbc-bridge.jar"),
)
}
/// Installs the app-owned JDT LS bundle that inspects java-debug's JVMs.
pub fn jvm_inspect_bundle(data_dir: &Path) -> Option<PathBuf> {
install_bundle(
+46 -9
Переглянути файл
@@ -3,7 +3,6 @@
//! user `settings.xml`. The profiles chosen in the Maven tool window are therefore
//! passed as a copy of the user's settings with those profiles activated.
use crate::apply::setting_path;
use ide_core::settings::Settings;
use ide_language::LanguageServerConfig;
use serde_json::{Value, json};
@@ -32,13 +31,24 @@ pub fn configure_jdtls(cfg: &mut LanguageServerConfig, root: &Path, s: &Settings
}
}
/// The user's settings (Settings › Maven, else `~/.m2/settings.xml`) with `active`
/// added to `<activeProfiles>`. Named after its content: m2e reloads a settings file
/// only when the configured path changes.
/// The Maven tool window's offline mode of the last sync, for jdtls (m2e) too: without it the
/// import keeps downloading from the repositories while `mvn` runs with `-o`.
pub fn configure_offline(cfg: &mut LanguageServerConfig, offline: bool) {
if cfg.name != "jdtls" {
return;
}
let layer = json!({ "java": { "import": { "maven": { "offline": { "enabled": offline } } } } });
match &mut cfg.settings {
Some(settings) => merge(settings, layer),
None => cfg.settings = Some(layer),
}
}
/// The user settings m2e reads (Settings › Maven, else `~/.m2/settings.xml`, with the
/// configured local repository) with `active` added to `<activeProfiles>`. Named after its
/// content: m2e reloads a settings file only when the configured path changes.
fn write_settings(root: &Path, s: &Settings, active: &[&str], dir: &Path) -> Option<PathBuf> {
let user = setting_path(root, &s.languages.java.maven.user_settings)
.or_else(|| crate::home_dir().map(|h| h.join(".m2").join("settings.xml")));
let base = user.and_then(|f| std::fs::read_to_string(f).ok()).unwrap_or_else(|| "<settings>\n</settings>\n".into());
let (_, base) = crate::apply::m2e_user_settings(root, s, &crate::home_dir().unwrap_or_default());
let Some(text) = with_active_profiles(&base, active) else {
tracing::warn!("Maven profiles not passed to jdtls: the user settings.xml has no <settings> element");
return None;
@@ -91,7 +101,7 @@ pub fn with_active_profiles(text: &str, ids: &[&str]) -> Option<String> {
}
/// Start of the element `open` (`<name`), not a longer name sharing its prefix.
fn find_tag(masked: &str, open: &str, from: usize) -> Option<usize> {
pub(crate) fn find_tag(masked: &str, open: &str, from: usize) -> Option<usize> {
let mut at = from;
while let Some(i) = masked[at..].find(open) {
let start = at + i;
@@ -105,7 +115,7 @@ fn find_tag(masked: &str, open: &str, from: usize) -> Option<usize> {
}
/// `text` with comments and CDATA blanked out, byte offsets unchanged.
fn mask_comments(text: &str) -> String {
pub(crate) fn mask_comments(text: &str) -> String {
let mut out = text.as_bytes().to_vec();
let mut at = 0;
while at < text.len() {
@@ -216,6 +226,24 @@ mod tests {
assert!(text.contains("<activeProfile>c</activeProfile>"));
}
#[test]
fn jdtls_imports_offline_when_the_last_sync_was_offline() {
let offline = |cfg: &LanguageServerConfig| {
cfg.settings.as_ref().and_then(|s| s.pointer("/java/import/maven/offline/enabled")).cloned()
};
for value in [true, false] {
let mut cfg = jdtls();
cfg.settings = Some(json!({ "java": { "import": { "maven": { "enabled": true } } } }));
configure_offline(&mut cfg, value);
assert_eq!(offline(&cfg), Some(json!(value)), "explicit, so turning it off reaches a running server");
assert_eq!(cfg.settings.as_ref().unwrap().pointer("/java/import/maven/enabled"), Some(&json!(true)));
}
let mut other: LanguageServerConfig =
serde_json::from_value(json!({ "name": "kotlin-lsp", "command": "kotlin-lsp" })).unwrap();
configure_offline(&mut other, true);
assert_eq!(other.settings, None);
}
#[test]
fn jdtls_imports_with_the_synced_profiles() {
let tmp = tempfile::tempdir().unwrap();
@@ -255,6 +283,15 @@ mod tests {
}
assert!(!Path::new(&second).exists());
// The local repository of Settings › Maven stays in the copy (#1739).
s.languages.java.maven.local_repository = tmp.path().join("configured").to_string_lossy().into_owned();
let mut cfg = jdtls();
configure_jdtls(&mut cfg, tmp.path(), &s, &profiles(&["native"]), &dir);
let text = std::fs::read_to_string(user_settings(&cfg).unwrap()).unwrap();
let expected =
format!("<localRepository>{}</localRepository>", tmp.path().join("configured").to_string_lossy());
assert!(text.contains(&expected) && !text.contains("/repo<"), "{text}");
let mut other_server: LanguageServerConfig =
serde_json::from_value(json!({ "name": "kotlin-lsp", "command": "kotlin-lsp" })).unwrap();
configure_jdtls(&mut other_server, tmp.path(), &s, &profiles(&["native"]), &dir);
+237 -8
Переглянути файл
@@ -1,7 +1,8 @@
use crate::apply::{
apply_to_run_configs, apply_to_run_configs_in, configure_python_extra_paths, configure_server,
configure_vue_module_resolution, jdtls_jdk, maven_command, maven_options, project_jdk, python_interpreter,
ruff_configuration, terminal_activation, tool_install_environment, tsdk, without_derived, without_derived_in,
ruff_configuration, server_command_paths, server_protocol_overrides, terminal_activation, tool_install_environment,
tsdk, without_derived, without_derived_in,
};
use crate::python::parse_pip_list;
use crate::{bin_dir, exe, venv_of};
@@ -340,6 +341,39 @@ fn jdtls_honors_the_configured_maven_local_repository() {
assert!(cfg.args.iter().all(|a| !a.contains("maven.repo.local")));
}
#[test]
fn java_analyzer_gets_the_project_jdk_and_maven_local_repository() {
let tmp = tempfile::tempdir().unwrap();
let configured = |s: &Settings| {
let mut cfg = server("java-analyzer");
configure_server(&mut cfg, tmp.path(), tmp.path(), s);
server_protocol_overrides(&mut cfg, s);
cfg.initialization_options.map(|v| serde_json::to_value(v).unwrap())
};
// Unset: the server discovers both itself.
assert_eq!(configured(&Settings::default()), None);
let jdk = tmp.path().join("jdk17");
fake_jdk(&jdk);
let repo = tmp.path().join("m2-repo");
let mut s = Settings::default();
s.languages.java.jdk = jdk.to_string_lossy().into_owned();
s.languages.java.maven.local_repository = repo.to_string_lossy().into_owned();
let options = configured(&s).unwrap();
assert_eq!(options["jdkHome"], dunce::canonicalize(&jdk).unwrap().to_string_lossy().as_ref());
assert_eq!(options["maven"]["localRepository"], repo.to_string_lossy().as_ref());
// A `jdkHome` in the server's own settings wins.
s.language_servers.insert(
"java-analyzer".into(),
ide_core::settings::LanguageServerSettings {
initialization_options: Some(serde_json::json!({ "jdkHome": "/opt/jdk21" })),
..Default::default()
},
);
let options = configured(&s).unwrap();
assert_eq!(options["jdkHome"], "/opt/jdk21");
assert_eq!(options["maven"]["localRepository"], repo.to_string_lossy().as_ref());
}
#[test]
fn jdtls_m2e_gets_effective_settings_with_local_repository() {
fn user_settings(cfg: &LanguageServerConfig) -> Option<std::path::PathBuf> {
@@ -375,18 +409,96 @@ fn jdtls_m2e_gets_effective_settings_with_local_repository() {
assert!(text.contains("<mirror><id>m</id></mirror>"));
assert!(text.contains(&format!("<localRepository>{}</localRepository>", repo.to_string_lossy())));
// User settings already declaring `<localRepository>`: passed through untouched.
std::fs::write(&settings, "<settings><localRepository>/user/repo</localRepository></settings>").unwrap();
// User settings already naming the configured repository: passed through untouched.
let own = format!("<settings><localRepository>{}</localRepository></settings>", repo.to_string_lossy());
std::fs::write(&settings, &own).unwrap();
let mut cfg = server("jdtls");
configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
assert_eq!(user_settings(&cfg), Some(settings.clone()));
// Another repository: the configured one wins, as `-Dmaven.repo.local` does for `mvn`.
std::fs::write(&settings, "<settings>\n <localRepository>/user/repo</localRepository><mirrors/></settings>")
.unwrap();
let mut cfg = server("jdtls");
configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
assert_eq!(user_settings(&cfg), Some(derived.clone()));
let text = std::fs::read_to_string(&derived).unwrap();
assert!(text.contains("<mirrors/>") && !text.contains("/user/repo"), "{text}");
assert_eq!(text.matches("<localRepository>").count(), 1, "{text}");
// Settings user settings unset: the configured repository has no settings file
// replacing `~/.m2/settings.xml` without its mirrors.
let home = tmp.path().join("home");
std::fs::create_dir_all(home.join(".m2")).unwrap();
std::fs::write(
home.join(".m2/settings.xml"),
"<settings><mirrors><mirror><id>corp</id></mirror></mirrors></settings>",
)
.unwrap();
let mut only_repo = Settings::default();
only_repo.languages.java.maven.local_repository = repo.to_string_lossy().into_owned();
let file = crate::apply::maven_user_settings_for_m2e_in(tmp.path(), &only_repo, &home).unwrap();
let text = std::fs::read_to_string(file).unwrap();
assert!(text.contains("<mirror><id>corp</id></mirror>"), "{text}");
assert!(text.contains(&format!("<localRepository>{}</localRepository>", repo.to_string_lossy())));
// Neither a local repository nor user settings: `~/.m2/settings.xml` is m2e's own default.
assert_eq!(crate::apply::maven_user_settings_for_m2e_in(tmp.path(), &Settings::default(), &home), None);
// Neither configured: no userSettings at all.
let mut cfg = server("jdtls");
configure_server(&mut cfg, tmp.path(), tmp.path(), &Settings::default());
assert_eq!(user_settings(&cfg), None);
}
#[test]
fn local_repository_goes_into_every_shape_of_settings_xml() {
use crate::apply::with_local_repository;
let element = "<localRepository>/r&amp;d</localRepository>";
for (text, expected) in [
("<settings>\n</settings>", format!("<settings>{element}\n</settings>")),
("<settings><localRepository>/old</localRepository></settings>", format!("<settings>{element}</settings>")),
("<settings><localRepository /></settings>", format!("<settings>{element}</settings>")),
(
"<settings xmlns=\"x\"><!-- <localRepository>/c</localRepository> --></settings>",
format!("<settings xmlns=\"x\">{element}<!-- <localRepository>/c</localRepository> --></settings>"),
),
(
"<?xml version=\"1.0\"?>\n<!-- <settings> --><settings>\n <localRepository>\n /old\n </localRepository>\n</settings>",
format!("<?xml version=\"1.0\"?>\n<!-- <settings> --><settings>\n {element}\n</settings>"),
),
] {
assert_eq!(with_local_repository(text, "/r&d").as_deref(), Some(expected.as_str()), "{text}");
}
assert_eq!(with_local_repository("<settings/>", "/r"), None);
}
#[test]
fn jdtls_m2e_reads_the_global_settings_of_the_maven_home() {
fn global_settings(cfg: &LanguageServerConfig) -> Option<String> {
let opts = serde_json::to_value(cfg.initialization_options.clone()?).ok()?;
opts.pointer("/settings/java/configuration/maven/globalSettings")?.as_str().map(Into::into)
}
let tmp = tempfile::tempdir().unwrap();
let home = tmp.path().join("apache-maven-3.9.9");
let mvn = home.join("bin").join(if cfg!(windows) { "mvn.cmd" } else { "mvn" });
std::fs::create_dir_all(mvn.parent().unwrap()).unwrap();
std::fs::write(&mvn, "").unwrap();
let mut s = Settings::default();
s.languages.java.maven.home = home.to_string_lossy().into_owned();
let configured = |s: &Settings| {
let mut cfg = server("jdtls");
configure_server(&mut cfg, tmp.path(), tmp.path(), s);
global_settings(&cfg)
};
// No `conf/settings.xml`: nothing to pass.
assert_eq!(configured(&s), None);
let conf = home.join("conf").join("settings.xml");
std::fs::create_dir_all(conf.parent().unwrap()).unwrap();
std::fs::write(&conf, "<settings><mirrors/></settings>").unwrap();
let expected = dunce::canonicalize(&conf).unwrap();
assert_eq!(configured(&s).map(std::path::PathBuf::from), Some(expected));
}
#[test]
fn rust_analyzer_check_command_and_toolchain() {
if cfg!(windows) {
@@ -775,6 +887,28 @@ fn maven_options_carry_active_profiles_into_the_command_line() {
assert_eq!(configured[0].args, ["-P", "prod", "package"]);
}
#[test]
fn always_update_snapshots_adds_dash_u_once() {
let tmp = tempfile::tempdir().unwrap();
let mut s = Settings::default();
s.languages.java.maven.update_snapshots = true;
assert_eq!(maven_options(tmp.path(), &s), ["-U"]);
let mut configs = vec![run("maven", "./mvnw", &["package"])];
for _ in 0..2 {
apply_to_run_configs(&mut configs, tmp.path(), &s);
assert_eq!(configs[0].args, ["-U", "package"]);
}
let mut own = vec![run("maven", "./mvnw", &["--update-snapshots", "package"])];
apply_to_run_configs(&mut own, tmp.path(), &s);
assert_eq!(own[0].args, ["--update-snapshots", "package"]);
// Settings apply to the stored configuration at each launch, so turning it off drops -U.
s.languages.java.maven.update_snapshots = false;
let mut stored = vec![run("maven", "./mvnw", &["package"])];
apply_to_run_configs(&mut stored, tmp.path(), &s);
assert_eq!(stored[0].args, ["package"]);
}
#[test]
fn maven_profile_and_toolchain_overrides_accept_every_option_form() {
let tmp = tempfile::tempdir().unwrap();
@@ -1160,6 +1294,34 @@ fn language_server_settings_disable_add_and_override() {
assert_eq!(parsed.code_action_kinds, Some(vec!["refactor".to_string()]));
}
#[test]
fn a_server_path_to_a_jar_runs_with_java_jar() {
use crate::apply::server_launch_overrides;
use ide_core::settings::LanguageServerSettings;
let mut s = Settings::default();
let jar = "/opt/groovy/build/libs/groovy-language-server-all.JAR";
s.language_servers.insert(
"groovy-language-server".into(),
LanguageServerSettings { command: jar.into(), args: Some(vec!["--verbose".into()]), ..Default::default() },
);
let mut groovy = server("groovy-language-server");
server_launch_overrides(&mut groovy, &s);
assert_eq!(groovy.command, "java");
assert_eq!(groovy.args, ["-jar", jar, "--verbose"]);
// A project JDK is the one that runs it.
let tmp = tempfile::tempdir().unwrap();
let home = tmp.path().join("jdk");
let java = crate::java::java_executable(&home);
std::fs::create_dir_all(java.parent().unwrap()).unwrap();
std::fs::write(&java, "").unwrap();
std::fs::write(home.join("release"), "JAVA_VERSION=\"21.0.2\"\n").unwrap();
s.languages.java.jdk = home.to_string_lossy().into_owned();
configure_server(&mut groovy, tmp.path(), tmp.path(), &s);
assert!(groovy.command.ends_with(&*Path::new("jdk").join(java.strip_prefix(&home).unwrap()).to_string_lossy()));
assert!(Path::new(&groovy.command).is_file(), "{}", groovy.command);
}
#[test]
fn ruff_configuration_directory_resolves_files_and_validates_pyproject() {
let tmp = tempfile::tempdir().unwrap();
@@ -2452,7 +2614,10 @@ fn go_constraints_change_only_protocol_settings() {
original.settings = Some(json!({"analyses":{"unusedparams":true}}));
let mut defaults = original.clone();
configure_server(&mut defaults, tmp.path(), tmp.path(), &settings);
assert_eq!(defaults.settings, Some(json!({"analyses":{"unusedparams":true}, "buildFlags":[], "env":{}})));
assert_eq!(
defaults.settings,
Some(json!({"analyses":{"unusedparams":true}, "buildFlags":[], "env":{}, "gofumpt":false}))
);
defaults.settings = original.settings.clone();
assert_eq!(defaults, original);
settings.languages.go.build_tags.custom = "integration".into();
@@ -2462,7 +2627,8 @@ fn go_constraints_change_only_protocol_settings() {
assert_eq!(
configured.settings.take(),
Some(json!({
"analyses":{"unusedparams":true}, "buildFlags":["-tags=integration"], "env":{"GOOS":"linux"}
"analyses":{"unusedparams":true}, "buildFlags":["-tags=integration"], "env":{"GOOS":"linux"},
"gofumpt":false
}))
);
configured.settings = original.settings.clone();
@@ -2477,10 +2643,50 @@ fn go_empty_constraints_preserve_explicit_server_defaults() {
use serde_json::json;
let tmp = tempfile::tempdir().unwrap();
let mut cfg = server("gopls");
cfg.initialization_options =
Some(toml::Value::try_from(json!({"buildFlags":["-tags=legacy"], "env":{"GOPROXY":"direct"}})).unwrap());
cfg.initialization_options = Some(
toml::Value::try_from(json!({"buildFlags":["-tags=legacy"], "env":{"GOPROXY":"direct"}, "gofumpt":true}))
.unwrap(),
);
configure_server(&mut cfg, tmp.path(), tmp.path(), &Settings::default());
assert_eq!(cfg.settings, Some(json!({"buildFlags":["-tags=legacy"], "env":{"GOPROXY":"direct"}})));
assert_eq!(cfg.settings, Some(json!({"buildFlags":["-tags=legacy"], "env":{"GOPROXY":"direct"}, "gofumpt":true})));
}
#[test]
fn go_gofumpt_setting_reaches_gopls_and_turns_off_in_place() {
use crate::apply::server_protocol_overrides;
use serde_json::json;
let tmp = tempfile::tempdir().unwrap();
let mut settings = Settings::default();
settings.languages.go.gofumpt = true;
let mut on = server("gopls");
configure_server(&mut on, tmp.path(), tmp.path(), &settings);
assert_eq!(on.settings.as_ref().unwrap()["gofumpt"], json!(true));
assert_eq!(on.initialization_options, server("gopls").initialization_options);
// The setting wins over the language definition's value.
let mut explicit = server("gopls");
explicit.settings = Some(json!({"gofumpt": false}));
configure_server(&mut explicit, tmp.path(), tmp.path(), &settings);
assert_eq!(explicit.settings.unwrap()["gofumpt"], json!(true));
// Turned off: an explicit false, because gopls keeps omitted keys on reconfiguration.
let mut off = server("gopls");
configure_server(&mut off, tmp.path(), tmp.path(), &Settings::default());
assert_eq!(off.settings.unwrap()["gofumpt"], json!(false));
// Off leaves a server-level value alone.
let mut own = server("gopls");
own.settings = Some(json!({"gofumpt": true}));
configure_server(&mut own, tmp.path(), tmp.path(), &Settings::default());
assert_eq!(own.settings.unwrap()["gofumpt"], json!(true));
// Off doesn't shadow gofumpt in Settings › Language Servers initializationOptions.
let mut user = Settings::default();
user.language_servers
.insert("gopls".into(), serde_json::from_value(json!({"initializationOptions": {"gofumpt": true}})).unwrap());
let mut from_user = server("gopls");
configure_server(&mut from_user, tmp.path(), tmp.path(), &user);
server_protocol_overrides(&mut from_user, &user);
assert_eq!(from_user.settings.unwrap()["gofumpt"], json!(true));
let mut other = server("rust-analyzer");
configure_server(&mut other, tmp.path(), tmp.path(), &settings);
assert_eq!(other.settings, None);
}
#[test]
@@ -2918,3 +3124,26 @@ fn without_the_vue_plugin_the_module_resolution_plugin_stays_out() {
assert!(!configure_vue_module_resolution(&mut cfg, tmp.path()));
assert!(cfg.initialization_options.is_none());
}
#[test]
fn server_command_paths_report_executables_set_for_built_in_servers() {
let servers = [server("java-analyzer"), server("jdtls"), server("kmp-lsp")];
let mut s = Settings::default();
let entry = |command: &str| ide_core::settings::LanguageServerSettings {
command: command.into(),
languages: vec!["java".into()],
..Default::default()
};
s.language_servers.insert("java-analyzer".into(), entry("/opt/java-analyzer/bin/java-analyzer"));
s.language_servers.insert("jdtls".into(), entry("bin/jdtls"));
// A bare name is looked up like the definition's command.
s.language_servers.insert("kmp-lsp".into(), entry("kmp-lsp-nightly"));
let root = Path::new("/work");
assert_eq!(
server_command_paths(&servers, root, &s),
[
("java-analyzer".to_owned(), "/opt/java-analyzer/bin/java-analyzer".into()),
("jdtls".to_owned(), root.join("bin/jdtls")),
]
);
}
+11
Переглянути файл
@@ -190,6 +190,17 @@ impl SshManager {
self.sessions.lock().remove(id);
}
/// Closes the shared session of configuration `id` when nothing but this manager holds it
/// right now (no terminal, tunnel or transfer in progress); returns whether it did.
pub fn release(&self, id: &str) -> bool {
let mut sessions = self.sessions.lock();
let unused = sessions.get(id).is_some_and(|s| Arc::strong_count(s) == 1);
if unused {
sessions.remove(id);
}
unused
}
/// Ids of the configurations with an open session.
pub fn connected(&self) -> Vec<String> {
self.sessions.lock().iter().filter(|(_, s)| !s.is_closed()).map(|(k, _)| k.clone()).collect()
+23 -8
Переглянути файл
@@ -6,6 +6,7 @@ use crate::session::Session;
use ide_core::{IdeError, IdeResult, error::ErrorKind};
use std::sync::Arc;
use tokio::net::TcpListener;
use tokio::sync::Notify;
use tokio::task::JoinHandle;
/// An open tunnel; dropping it stops forwarding (the session stays open while
@@ -14,6 +15,7 @@ pub struct Tunnel {
port: u16,
session: Arc<Session>,
accept: JoinHandle<()>,
stop: Arc<Notify>,
}
impl Tunnel {
@@ -40,19 +42,21 @@ impl Tunnel {
},
None => TcpListener::bind(("127.0.0.1", 0)).await?,
};
let local = listener.local_addr()?.port();
let target = Target::Tcp(host.to_owned(), port);
let accept = tokio::spawn(forward(listener, session.clone(), target));
Ok(Tunnel { port: local, session, accept })
Self::spawn(listener, session, Target::Tcp(host.to_owned(), port))
}
/// Listens on a free local port; each connection runs `command` on the SSH host and talks
/// to its stdin / stdout (`docker system dial-stdio`, as the Docker CLI's `ssh://` does).
pub async fn command(session: Arc<Session>, command: &str) -> IdeResult<Tunnel> {
let listener = TcpListener::bind(("127.0.0.1", 0)).await?;
let local = listener.local_addr()?.port();
let accept = tokio::spawn(forward(listener, session.clone(), Target::Command(command.to_owned())));
Ok(Tunnel { port: local, session, accept })
Self::spawn(listener, session, Target::Command(command.to_owned()))
}
fn spawn(listener: TcpListener, session: Arc<Session>, target: Target) -> IdeResult<Tunnel> {
let port = listener.local_addr()?.port();
let stop = Arc::new(Notify::new());
let accept = tokio::spawn(forward(listener, session.clone(), target, stop.clone()));
Ok(Tunnel { port, session, accept, stop })
}
/// The local port to connect to instead of the target.
@@ -63,6 +67,13 @@ impl Tunnel {
pub fn is_closed(&self) -> bool {
self.session.is_closed()
}
/// Stops forwarding like dropping it does, but returns only once the listener and every
/// forwarded connection are gone, so the session is no longer held by this tunnel.
pub async fn close(mut self) {
self.stop.notify_one();
let _ = (&mut self.accept).await;
}
}
impl Drop for Tunnel {
@@ -77,12 +88,16 @@ enum Target {
Command(String),
}
async fn forward(listener: TcpListener, session: Arc<Session>, target: Target) {
async fn forward(listener: TcpListener, session: Arc<Session>, target: Target, stop: Arc<Notify>) {
let target = Arc::new(target);
let mut connections = tokio::task::JoinSet::new();
loop {
let accepted = tokio::select! {
Some(_) = connections.join_next(), if !connections.is_empty() => continue,
() = stop.notified() => {
connections.shutdown().await;
return;
}
accepted = listener.accept() => accepted,
};
let Ok((mut socket, _)) = accepted else { return };
+30
Переглянути файл
@@ -272,6 +272,36 @@ async fn dropping_a_tunnel_closes_active_connections() {
assert!(!session.is_closed());
}
#[tokio::test]
async fn closing_a_tunnel_lets_go_of_the_session_and_its_connections() {
let env = env().await;
let session = Arc::new(env.connect_trusted(&env.target(SshAuth::Password), Some("secret")).await.ok().unwrap());
let tunnel = Tunnel::listen(session.clone(), "127.0.0.1", env.echo_port).await.unwrap();
let port = tunnel.port();
let mut socket = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
socket.write_all(b"ping").await.unwrap();
let mut reply = [0; 4];
socket.read_exact(&mut reply).await.unwrap();
assert!(Arc::strong_count(&session) > 2, "the tunnel and its connection hold the session");
tunnel.close().await;
// Nothing is left behind to wait for: only this test holds the session now.
assert_eq!(Arc::strong_count(&session), 1);
let mut byte = [0];
assert_eq!(socket.read(&mut byte).await.unwrap(), 0);
assert!(TcpStream::connect(("127.0.0.1", port)).await.is_err());
assert!(!session.is_closed());
}
#[tokio::test]
async fn closing_an_idle_tunnel_returns_at_once() {
let env = env().await;
let session = Arc::new(env.connect_trusted(&env.target(SshAuth::Password), Some("secret")).await.ok().unwrap());
let tunnel = Tunnel::command(session.clone(), "docker system dial-stdio").await.unwrap();
tokio::time::timeout(std::time::Duration::from_secs(5), tunnel.close()).await.unwrap();
assert_eq!(Arc::strong_count(&session), 1);
}
#[tokio::test]
async fn key_pair_authentication_with_and_without_passphrase() {
let env = env().await;
+1 -1
Переглянути файл
@@ -317,7 +317,7 @@ impl Tools {
let _ = std::fs::remove_dir_all(&staging);
std::fs::create_dir_all(&staging)?;
let result = (|| {
let archive = fetch_verified(&http, &dl, &staging, cancel, emit)?;
let archive = fetch_verified(&self.downloads, &http, &dl, &staging, cancel, emit)?;
emit(InstallEvent::Line { text: "Extracting…".into() });
let pkg = staging.join("pkg");
archive::extract(&archive, archive::ArchiveKind::from_name(&dl.name), &pkg, "java", cancel)?;
+101 -26
Переглянути файл
@@ -19,6 +19,7 @@ pub mod archive;
mod bundled;
pub mod formatter;
pub mod jdk;
pub mod mirror;
mod moved_venv;
pub mod platform;
#[cfg(any(windows, test))]
@@ -29,6 +30,7 @@ pub mod server;
pub mod sources;
use ide_core::error::ErrorKind;
use ide_core::settings::ToolDownloadSettings;
use ide_core::{CancellationToken, IdeError, IdeResult};
use ide_language::LanguageConfig;
use parking_lot::Mutex;
@@ -468,6 +470,8 @@ pub struct Tools {
/// The project the tools are used for: tools that install into "the active runtime" (gems) run here,
/// so a version manager picks the project's Ruby.
work_dir: Option<PathBuf>,
/// Tools › Download sources: the mirror prefix and its fallback behaviour.
downloads: ToolDownloadSettings,
}
impl Tools {
@@ -492,9 +496,16 @@ impl Tools {
runtime_env: BTreeMap::new(),
version_timeout: Duration::from_secs(4),
work_dir: None,
downloads: ToolDownloadSettings::default(),
}
}
/// [`Self::downloads`] from Tools › Download sources.
pub fn with_downloads(mut self, downloads: ToolDownloadSettings) -> Self {
self.downloads = downloads;
self
}
/// Applies the project's SDKs to prerequisite lookup, probes and installer children.
pub fn with_runtime(mut self, commands: BTreeMap<String, PathBuf>, env: BTreeMap<String, String>) -> Self {
self.runtime_commands = commands;
@@ -1470,7 +1481,7 @@ impl Tools {
cancel: &CancellationToken,
emit: Emit,
) -> IdeResult<()> {
let archive = fetch_verified(http, dl, staging, cancel, emit)?;
let archive = fetch_verified(&self.downloads, http, dl, staging, cancel, emit)?;
emit(InstallEvent::Line { text: "Extracting…".into() });
let pkg = staging.join("pkg");
let kind = archive::ArchiveKind::from_name(&dl.name);
@@ -1703,9 +1714,14 @@ impl Tools {
}
}
/// Downloads `dl` into `staging` and checks its SHA-256 when one is published;
/// returns the downloaded file.
/// Downloads `dl` from the best source that answers (Tools › Download sources) and checks its
/// SHA-256 when one is published; returns the downloaded file.
///
/// A mirror may only deliver bytes that can be checked: when neither the release nor its
/// checksum file gives a hash, an archive from a mirror is discarded and the official host is
/// tried, because a third party must not be the only word on what gets installed.
fn fetch_verified(
downloads: &ToolDownloadSettings,
http: &Http,
dl: &sources::Download,
staging: &Path,
@@ -1713,33 +1729,92 @@ fn fetch_verified(
emit: Emit,
) -> IdeResult<PathBuf> {
let archive = staging.join(&dl.name);
http.download(&dl.url, &archive, dl.size, cancel, emit)?;
let expected = match (&dl.sha256, &dl.checksum_url) {
(Some(h), _) => Some(h.clone()),
(None, Some(url)) => match http.get_text(url, cancel) {
Ok(text) => sources::parse_checksum(&text, &dl.name),
let candidates = mirror::candidates(&dl.url, downloads);
let expected = expected_sha256(http, dl, cancel)?;
let mut failures: Vec<String> = Vec::new();
for (index, candidate) in candidates.iter().enumerate() {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
// Bytes a failed source left behind must not be resumed or mistaken for this one's.
if index > 0 {
let _ = std::fs::remove_file(&archive);
}
// Only worth saying when there is a choice of source: with one candidate the line
// would just repeat the download message that follows.
if candidates.len() > 1 {
emit(InstallEvent::Line {
text: format!("Trying {} ({} of {})…", candidate.describe(), index + 1, candidates.len()),
});
}
let attempt = http.download(&candidate.url, &archive, dl.size, cancel, emit);
match attempt {
Ok(()) => match check_sha256(&archive, dl, expected.as_deref(), candidate.mirror.is_some(), emit) {
Ok(()) => {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
return Ok(archive);
}
// A mismatch from a mirror is that mirror's failure: the official host below
// still gets its chance. From the official host it is the download's failure.
Err(e) if candidate.mirror.is_some() => {
failures.push(format!("{}: {}", candidate.describe(), e.message))
}
Err(e) => return Err(e),
},
// Cancelling stops the install: the remaining sources are not tried.
Err(e) if e.kind == ErrorKind::Cancelled => return Err(e),
Err(_) => None,
},
(None, None) => None,
};
match expected {
Some(expected) => {
let actual = sources::sha256_file(&archive)?;
if actual != expected {
return Err(IdeError::new(
ErrorKind::Io,
format!("checksum mismatch for {}: expected {expected}, got {actual}", dl.name),
));
}
emit(InstallEvent::Line { text: "Checksum verified (SHA-256)".into() });
Err(e) => failures.push(format!("{}: {}", candidate.describe(), e.message)),
}
None => emit(InstallEvent::Line { text: "No checksum published; skipping verification".into() }),
}
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
Err(IdeError::new(ErrorKind::Io, format!("could not download {} ({})", dl.name, failures.join("; "))))
}
/// The SHA-256 `dl` must match, when one is published.
///
/// The checksum file is read from its official URL, never through the mirror: otherwise a
/// mirror could vouch for bytes it chose itself.
fn expected_sha256(http: &Http, dl: &sources::Download, cancel: &CancellationToken) -> IdeResult<Option<String>> {
match (&dl.sha256, &dl.checksum_url) {
(Some(h), _) => Ok(Some(h.clone())),
(None, Some(url)) => match http.get_text(url, cancel) {
Ok(text) => Ok(sources::parse_checksum(&text, &dl.name)),
Err(e) if e.kind == ErrorKind::Cancelled => Err(e),
Err(_) => Ok(None),
},
(None, None) => Ok(None),
}
Ok(archive)
}
/// Checks `archive` against `expected`, if any. `via_mirror` refuses an archive nothing can
/// vouch for rather than installing unverifiable bytes from a third party.
fn check_sha256(
archive: &Path,
dl: &sources::Download,
expected: Option<&str>,
via_mirror: bool,
emit: Emit,
) -> IdeResult<()> {
let Some(expected) = expected else {
if via_mirror {
return Err(IdeError::new(
ErrorKind::Io,
format!("{} has no published checksum, so the mirror's copy is not trusted", dl.name),
));
}
emit(InstallEvent::Line { text: "No checksum published; skipping verification".into() });
return Ok(());
};
let actual = sources::sha256_file(archive)?;
if actual != expected {
return Err(IdeError::new(
ErrorKind::Io,
format!("checksum mismatch for {}: expected {expected}, got {actual}", dl.name),
));
}
emit(InstallEvent::Line { text: "Checksum verified (SHA-256)".into() });
Ok(())
}
/// Removes the quarantine flag archives may carry, so macOS runs what was unpacked.
+127
Переглянути файл
@@ -0,0 +1,127 @@
//! Download mirrors: a user-configured proxy prefix the installer tries when an official host
//! is slow or unreachable (Tools › Download sources).
//!
//! The official URL is appended to the prefix unchanged, which is what the public GitHub
//! proxies speak. Only `github.com` is mirrored: those proxies hard-code that host, so an
//! Eclipse or Open VSX address through one answers 502. Hosts that carry credentials are
//! never mirrored either — the GitHub token must not reach a third party.
use ide_core::settings::ToolDownloadSettings;
/// The only host a mirror prefix may be prepended to.
const MIRRORED_PREFIX: &str = "https://github.com/";
/// Where one download is fetched from.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Candidate {
pub url: String,
/// The mirror this URL goes through; `None` for the official host.
pub mirror: Option<String>,
}
impl Candidate {
/// The source shown to the user in install messages.
pub fn describe(&self) -> &str {
match &self.mirror {
Some(mirror) => mirror,
None => "the official source",
}
}
}
/// The mirror prefix, normalised to end in `/`; `None` when none is set or it is not an
/// `http(s)://` URL.
pub fn prefix(mirror: &str) -> Option<String> {
let trimmed = mirror.trim();
let rest = trimmed.strip_prefix("https://").or_else(|| trimmed.strip_prefix("http://"))?;
if rest.split('/').next().unwrap_or("").is_empty() {
return None;
}
Some(if trimmed.ends_with('/') { trimmed.to_owned() } else { format!("{trimmed}/") })
}
/// `url` through `mirror`, or `None` when it is not a source a prefix can carry.
pub fn through(url: &str, mirror: &str) -> Option<String> {
let prefix = prefix(mirror)?;
if !url.starts_with(MIRRORED_PREFIX) {
return None;
}
Some(format!("{prefix}{url}"))
}
/// The URLs to try for `url`: the mirror when one is set, then the official host.
///
/// A configured mirror is tried first — the user set it because the official host is slow, so
/// waiting for that host to fail first would defeat the point. The official host stays last as
/// the fallback, and with no mirror the list is exactly `[url]`, so an unconfigured IDE
/// downloads as it always did.
pub fn candidates(url: &str, settings: &ToolDownloadSettings) -> Vec<Candidate> {
let official = Candidate { url: url.to_owned(), mirror: None };
match through(url, &settings.github_mirror) {
Some(mirrored) => vec![Candidate { url: mirrored, mirror: Some(settings.github_mirror.clone()) }, official],
None => vec![official],
}
}
#[cfg(test)]
mod tests {
use super::*;
const ASSET: &str = "https://github.com/LuaLS/lua-language-server/releases/download/3.13.5/x.zip";
fn settings(mirror: &str) -> ToolDownloadSettings {
ToolDownloadSettings { github_mirror: mirror.into() }
}
#[test]
fn no_mirror_keeps_the_official_url_only() {
assert_eq!(candidates(ASSET, &settings("")), vec![Candidate { url: ASSET.into(), mirror: None }]);
}
#[test]
fn the_prefix_gets_one_trailing_slash() {
for mirror in ["https://gh-proxy.com", "https://gh-proxy.com/", " https://gh-proxy.com "] {
assert_eq!(
through(ASSET, mirror).as_deref(),
Some(
"https://gh-proxy.com/https://github.com/LuaLS/lua-language-server/releases/download/3.13.5/x.zip"
),
);
}
}
#[test]
fn hosts_a_prefix_cannot_carry_stay_official() {
for url in [
// The public proxies only answer for github.com; these answer 502 through them.
"https://download.eclipse.org/jdtls/milestones/1.63.0/x.tar.gz",
"https://open-vsx.org/api/vscjava/vscode-java-debug/0.60.0/file/x.vsix",
"https://api.github.com/repos/cli/cli/releases/latest",
"https://repo1.maven.org/maven2/org/eclipse/lsp4j/1.0.0/x.jar",
] {
assert_eq!(through(url, "https://gh-proxy.com"), None, "{url}");
assert_eq!(candidates(url, &settings("https://gh-proxy.com")).len(), 1, "{url}");
}
}
#[test]
fn a_configured_mirror_goes_first() {
let candidates = candidates(ASSET, &settings("https://gh-proxy.com"));
assert_eq!(candidates[0].mirror.as_deref(), Some("https://gh-proxy.com"));
assert_eq!(candidates[1].mirror, None, "the official host is the fallback");
}
#[test]
fn a_prefix_that_is_not_a_url_is_ignored() {
for mirror in ["gh-proxy.com", "ftp://x", "https://", " "] {
assert_eq!(prefix(mirror), None, "{mirror}");
assert_eq!(through(ASSET, mirror), None, "{mirror}");
}
}
#[test]
fn an_already_prefixed_url_is_not_prefixed_twice() {
let once = through(ASSET, "https://gh-proxy.com").unwrap();
assert_eq!(through(&once, "https://gh-proxy.com"), None);
}
}
+25
Переглянути файл
@@ -222,6 +222,31 @@ mod tests {
assert_eq!(select_asset(&names[5..8], rules, WIN), None);
}
#[test]
fn java_analyzer_assets() {
let names = [
"java-analyzer-macos-aarch64.gz",
"java-analyzer-macos-x86_64.gz",
"java-analyzer-linux-aarch64.gz",
"java-analyzer-linux-x86_64.gz",
"java-analyzer-windows-aarch64.zip",
"java-analyzer-windows-x86_64.zip",
"java-analyzer-macos-aarch64.gz.sha256",
"java-analyzer-windows-x86_64.zip.sha256",
];
let rules = crate::registry::find("java-analyzer").unwrap().asset_rules();
for (os, arch, expected) in [
(Os::Mac, Arch::Arm64, names[0]),
(Os::Mac, Arch::X64, names[1]),
(Os::Linux, Arch::Arm64, names[2]),
(Os::Linux, Arch::X64, names[3]),
(Os::Windows, Arch::Arm64, names[4]),
(Os::Windows, Arch::X64, names[5]),
] {
assert_eq!(select_asset(&names, rules, Platform { os, arch }), Some(expected));
}
}
#[test]
fn rosetta_fallback_and_missing() {
let names = ["zls-x86_64-macos.tar.xz", "zls-x86_64-linux.tar.xz", "zls-x86_64-windows.zip"];
+22
Переглянути файл
@@ -793,6 +793,28 @@ pub static TOOLS: &[ToolSpec] = &[
homepage: "https://github.com/eclipse-jdtls/eclipse.jdt.ls",
needs: &[],
},
ToolSpec {
name: "java-analyzer",
display: "java-analyzer",
kind: LanguageServer,
commands: &["java-analyzer"],
method: Method::Release {
source: ReleaseSource::GitHub { repo: "l0ng-ai/java-analyzer" },
assets: &[
rule(Mac, Arm64, "java-analyzer-macos-aarch64.gz"),
rule(Mac, X64, "java-analyzer-macos-x86_64.gz"),
rule(Linux, Arm64, "java-analyzer-linux-aarch64.gz"),
rule(Linux, X64, "java-analyzer-linux-x86_64.gz"),
rule(Windows, Arm64, "java-analyzer-windows-aarch64.zip"),
rule(Windows, X64, "java-analyzer-windows-x86_64.zip"),
],
locate: &["java-analyzer"],
},
fallback: None,
version: ver("java-analyzer"),
homepage: "https://github.com/l0ng-ai/java-analyzer",
needs: &[],
},
ToolSpec {
name: "kmp-lsp",
display: "kmp-lsp",
+3 -1
Переглянути файл
@@ -59,7 +59,9 @@ pub fn fetch(
size: None,
sha256: Some(sha256),
};
let archive = fetch_verified(&http, &dl, &staging, cancel, emit)?;
// The remote server binary is not part of Tools › Download sources: it always comes
// from its own release.
let archive = fetch_verified(&Default::default(), &http, &dl, &staging, cancel, emit)?;
let unpacked = staging.join("openidea-server");
let mut gz = flate2::read::GzDecoder::new(std::fs::File::open(&archive)?);
std::io::copy(&mut gz, &mut std::fs::File::create(&unpacked)?)?;
+102 -2
Переглянути файл
@@ -193,8 +193,8 @@ fn interchangeable_servers_list_their_alternatives() {
assert_eq!(find(&list, name).alternatives, python);
}
assert_eq!(find(&list, "vtsls").alternatives, ["vtsls", "typescript-language-server"]);
for name in ["jdtls", "kmp-lsp"] {
assert_eq!(find(&list, name).alternatives, ["jdtls", "kmp-lsp"]);
for name in ["jdtls", "java-analyzer", "kmp-lsp"] {
assert_eq!(find(&list, name).alternatives, ["jdtls", "java-analyzer", "kmp-lsp"]);
assert_eq!(find(&list, name).languages, if name == "kmp-lsp" { &["Java", "Kotlin"][..] } else { &["Java"] });
}
for name in ["kotlin-lsp", "kotlin-language-server"] {
@@ -1131,3 +1131,103 @@ fn npm_tools_report_a_newer_registry_version() {
);
assert_eq!(tools("5.4.0").updates(&cancel).unwrap(), vec![]);
}
/// Tools › Download sources: a configured mirror serves a GitHub release the official host
/// cannot, and the official host is kept as the fallback.
#[cfg(unix)]
#[test]
fn a_mirror_serves_what_the_official_host_cannot() {
let env = Env::new();
let fixtures = env.root.parent().unwrap().join("fixtures");
fs::create_dir_all(&fixtures).unwrap();
let archive = fixtures.join("lls.tar.gz");
{
let gz = flate2::write::GzEncoder::new(fs::File::create(&archive).unwrap(), flate2::Compression::fast());
let mut b = tar::Builder::new(gz);
let body = b"#!/bin/sh\necho 3.13.5\n";
let mut h = tar::Header::new_gnu();
h.set_size(body.len() as u64);
h.set_mode(0o755);
h.set_cksum();
b.append_data(&mut h, "bin/lua-language-server", &body[..]).unwrap();
b.into_inner().unwrap().finish().unwrap();
}
let digest = sources::sha256_file(&archive).unwrap();
// Release assets live on github.com: only those addresses are mirrored.
let assets: Vec<String> = ["darwin-arm64.tar.gz", "darwin-x64.tar.gz", "linux-x64.tar.gz", "linux-arm64.tar.gz"]
.iter()
.map(|s| {
format!(
r#"{{"name":"lua-language-server-3.13.5-{s}","browser_download_url":"https://github.com/LuaLS/lua-language-server/releases/download/3.13.5/{s}","size":{},"digest":"sha256:{digest}"}}"#,
fs::metadata(&archive).unwrap().len()
)
})
.collect();
let json = fixtures.join("release.json");
fs::write(&json, format!(r#"{{"tag_name":"3.13.5","assets":[{}]}}"#, assets.join(","))).unwrap();
// The mirror serves the asset; the official host is unreachable.
let log = fixtures.join("asked.log");
env.script(
&env.sys,
"curl",
&format!(
r#"out=""; url=""
while [ $# -gt 0 ]; do case "$1" in -o) out="$2"; shift 2;; -A|-H|--retry|--connect-timeout) shift 2;; -*) shift;; *) url="$1"; shift;; esac; done
/bin/echo "$url" >> '{log}'
case "$url" in
https://api.github.com/*) /bin/cat '{json}';;
https://mirror.test/https://github.com/*) /bin/cp '{archive}' "$out";;
*) exit 22;;
esac"#,
log = log.display(),
json = json.display(),
archive = archive.display()
),
);
let downloads = ToolDownloadSettings { github_mirror: "https://mirror.test/".into() };
let emit = |_: InstallEvent| {};
env.tools()
.with_downloads(downloads)
.install("lua-language-server", &langs(), &CancellationToken::new(), &emit)
.unwrap();
let asked = fs::read_to_string(&log).unwrap();
// A configured mirror is tried first — waiting for a slow official host would defeat it.
let mirror_at = asked.find("https://mirror.test/https://github.com/").expect("the mirror is tried");
assert!(!asked[..mirror_at].contains("releases/download"), "the mirror goes first: {asked}");
}
/// A mirror may only deliver bytes something can vouch for; the official host may not.
#[test]
fn a_mirror_never_installs_what_it_alone_vouches_for() {
let tmp = tempfile::tempdir().unwrap();
let archive = tmp.path().join("tool.tar.gz");
fs::write(&archive, b"bytes").unwrap();
let digest = sources::sha256_file(&archive).unwrap();
let dl = |sha256: Option<&str>| sources::Download {
version: "1.0.0".into(),
name: "tool.tar.gz".into(),
url: "https://github.com/o/r/releases/download/v1/tool.tar.gz".into(),
size: None,
sha256: sha256.map(str::to_owned),
checksum_url: None,
};
let lines = Mutex::new(Vec::new());
let emit = |e: InstallEvent| {
if let InstallEvent::Line { text } = e {
lines.lock().push(text);
}
};
// Nothing published: the official host is trusted, a mirror is not.
check_sha256(&archive, &dl(None), None, false, &emit).unwrap();
let err = check_sha256(&archive, &dl(None), None, true, &emit).unwrap_err();
assert!(err.message.contains("no published checksum"), "{}", err.message);
// A matching hash passes from either source.
check_sha256(&archive, &dl(Some(&digest)), Some(&digest), true, &emit).unwrap();
assert!(lines.lock().iter().any(|l| l.contains("Checksum verified")));
// A mismatch is refused whoever served it.
let err = check_sha256(&archive, &dl(Some(&digest)), Some(&"0".repeat(64)), true, &emit).unwrap_err();
assert!(err.message.contains("checksum mismatch"), "{}", err.message);
}
+61 -14
Переглянути файл
@@ -306,7 +306,7 @@ pub(crate) fn run_raw_env(
env: &[(&str, &std::ffi::OsStr)],
) -> IdeResult<Output> {
let first = run_raw_env_once(root, args, stdin, env)?;
if !retryable_index_lock(args, &first) {
if !retryable_index_conflict(args, &first) {
return Ok(first);
}
let deadline = Instant::now() + Duration::from_secs(2);
@@ -320,13 +320,17 @@ pub(crate) fn run_raw_env(
return Ok(first);
}
let out = run_raw_env_once(root, args, stdin, env)?;
if !retryable_index_lock(args, &out) {
if !retryable_index_conflict(args, &out) {
return Ok(out);
}
}
}
fn retryable_index_lock(args: &[&str], out: &Output) -> bool {
/// git reporting that it could not replace `.git/index`: on Windows the file cannot be
/// renamed over while another process still has it open, which is no `index.lock` conflict.
const INDEX_WRITE_BLOCKED: &str = "fatal: Could not write new index file.";
fn retryable_index_conflict(args: &[&str], out: &Output) -> bool {
// These builtins take the index lock before changing the index, worktree or refs.
// switch folds post-checkout hook failures to exit 1, unlike checkout/restore
// path operations, whose hooks can return 128 after files have already changed.
@@ -345,11 +349,24 @@ fn retryable_index_lock(args: &[&str], out: &Output) -> bool {
return false;
}
let stderr = String::from_utf8_lossy(&out.stderr);
let Some(path) = stderr.lines().next().and_then(|line| line.strip_prefix("fatal: Unable to create '")) else {
return false;
};
path.strip_suffix("': File exists.")
.is_some_and(|path| path.ends_with("/index.lock") || path.ends_with("\\index.lock"))
let Some(first) = stderr.lines().next() else { return false };
if let Some(path) = first.strip_prefix("fatal: Unable to create '") {
return path
.strip_suffix("': File exists.")
.is_some_and(|path| path.ends_with("/index.lock") || path.ends_with("\\index.lock"));
}
// `.git/index` keeps its previous entries when the new file could not replace it, so
// rerunning is safe for the builtins that take the lock before changing anything.
// switch may already have updated the worktree by then, and `rm` without `--cached`
// has deleted the files before it writes the index.
if first == INDEX_WRITE_BLOCKED {
return match *sub {
"switch" => false,
"rm" => options.contains(&"--cached"),
_ => true,
};
}
false
}
fn run_raw_env_once(
@@ -977,15 +994,15 @@ mod index_lock_tests {
code: Some(128),
};
for args in [&["switch", "other"][..], &["--literal-pathspecs", "add", "-A", "--"], &["rm"], &["reset"]] {
assert!(retryable_index_lock(args, &out));
assert!(retryable_index_conflict(args, &out));
}
for sub in ["merge", "rebase", "stash", "commit", "update-index", "checkout", "restore", "pull", "status"] {
assert!(!retryable_index_lock(&[sub], &out));
assert!(!retryable_index_conflict(&[sub], &out));
}
assert!(!retryable_index_lock(&["add", "--patch"], &out));
assert!(!retryable_index_lock(&["reset", "--soft"], &out));
assert!(!retryable_index_conflict(&["add", "--patch"], &out));
assert!(!retryable_index_conflict(&["reset", "--soft"], &out));
out.code = Some(1); // switch's post-checkout hook can fail after the switch succeeded.
assert!(!retryable_index_lock(&["switch"], &out));
assert!(!retryable_index_conflict(&["switch"], &out));
out.code = Some(128);
for message in [
"fatal: Unable to create '/repo/.git/HEAD.lock': File exists.",
@@ -994,7 +1011,37 @@ mod index_lock_tests {
"warning: partial work\nfatal: Unable to create '/repo/.git/index.lock': File exists.",
] {
out.stderr = message.as_bytes().to_vec();
assert!(!retryable_index_lock(&["switch"], &out));
assert!(!retryable_index_conflict(&["switch"], &out));
}
}
#[test]
fn retries_an_index_the_worktree_scan_keeps_open_on_windows() {
// Windows cannot rename over `.git/index` while the IDE's own status scan has it
// open: git then reports a write failure instead of an index.lock conflict.
let mut out = Output { stdout: Vec::new(), stderr: INDEX_WRITE_BLOCKED.as_bytes().to_vec(), code: Some(128) };
for args in [
&["--literal-pathspecs", "reset", "-q", "HEAD", "--", "a.md"][..],
&["--literal-pathspecs", "add", "-A", "--"],
&["--literal-pathspecs", "rm", "--cached", "-r", "-q", "--ignore-unmatch", "--"],
] {
assert!(retryable_index_conflict(args, &out), "{args:?}");
}
// The worktree may already be updated by switch, and `rm` deletes its files before
// it writes the index, so neither is repeated.
out.code = Some(128);
for args in [&["switch", "other"][..], &["rm"]] {
assert!(!retryable_index_conflict(args, &out), "{args:?}");
}
for sub in ["commit", "merge", "rebase", "update-index", "restore"] {
assert!(!retryable_index_conflict(&[sub], &out));
}
// The same failure with output on stdout is not this message alone; and a
// different exit code is not git's fatal.
out.stdout = b"partial".to_vec();
assert!(!retryable_index_conflict(&["reset"], &out));
out.stdout.clear();
out.code = Some(1);
assert!(!retryable_index_conflict(&["reset"], &out));
}
}
+30 -4
Переглянути файл
@@ -259,6 +259,27 @@ pub struct Branch {
pub commit: String,
}
/// What Update Selected did to one local branch.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum BranchUpdateStatus {
Updated,
UpToDate,
/// Diverged from its upstream: left as it is.
NotFastForward,
NoUpstream,
Failed,
}
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct BranchUpdate {
pub branch: String,
pub status: BranchUpdateStatus,
/// Why it failed.
pub message: Option<String>,
}
/// Commit Options (IDEA's commit options popup).
#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -1458,11 +1479,16 @@ impl Repo {
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
write::reset_to_upstream(self, cancel, on_output)
}
/// Fast-forwards a local branch that is not checked out to its upstream (Branches ›
/// Update). Fails when the branch has diverged.
pub fn update_branch(&self, branch: &str, cancel: &CancellationToken, on_output: &dyn Fn(String)) -> IdeResult<()> {
/// Branches › Update Selected: fetches each remote once and fast-forwards every
/// branch to its upstream, reporting the branches it could not update.
pub fn update_branches(
&self,
branches: &[String],
cancel: &CancellationToken,
on_output: &dyn Fn(String),
) -> IdeResult<Vec<BranchUpdate>> {
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
write::update_branch(self, branch, cancel, on_output)
write::update_branches(self, branches, cancel, on_output)
}
// ---- in-progress operations, history rewriting, tags ----
+73 -11
Переглянути файл
@@ -5,10 +5,11 @@ use crate::cli::{self, run};
use crate::repo::{gx, resolve};
use crate::text_encoding::{decode, encode, has_bom, is_binary};
use crate::{
BlameLine, CheckoutMode, CheckoutOptions, CheckoutOutcome, CommitOptions, DeletedBranch, DivergedLocal,
PushBranchOptions, Repo,
BlameLine, BranchUpdate, BranchUpdateStatus, CheckoutMode, CheckoutOptions, CheckoutOutcome, CommitOptions,
DeletedBranch, DivergedLocal, PushBranchOptions, Repo,
};
use gix::bstr::{BStr, ByteSlice};
use ide_core::error::ErrorKind;
use ide_core::{CancellationToken, IdeError, IdeResult};
use std::path::{Path, PathBuf};
@@ -1392,18 +1393,79 @@ pub(crate) fn push_branch(
cli::run_streaming(r.root(), &argv, cancel, on_output)
}
/// Fast-forwards local `branch` (not checked out) to its upstream, fetching it first.
pub(crate) fn update_branch(
/// Update Selected (IDEA's Git.Update.Selected): fetches the remote of each branch once,
/// then fast-forwards the branch to its tracked branch: the checked-out one with
/// `merge --ff-only`, the others with a local fetch, which refuses branches checked out
/// in another worktree. Diverged branches are left alone.
pub(crate) fn update_branches(
r: &Repo,
branch: &str,
branches: &[String],
cancel: &CancellationToken,
on_output: &dyn Fn(String),
) -> IdeResult<()> {
check_local_branch(r, branch)?;
let (remote, name) =
branch_upstream(r, branch).ok_or_else(|| IdeError::invalid(format!("'{branch}' has no tracked branch")))?;
let refspec = format!("refs/heads/{name}:refs/heads/{branch}");
cli::run_streaming(r.root(), &["fetch", "--progress", &remote, &refspec], cancel, on_output)
) -> IdeResult<Vec<BranchUpdate>> {
let head =
run(r.root(), &["symbolic-ref", "-q", "--short", "HEAD"], None).ok().map(|o| o.stdout_str().trim().to_string());
let mut fetched: Vec<(String, Result<(), String>)> = Vec::new();
let mut out = Vec::with_capacity(branches.len());
for branch in branches {
check_local_branch(r, branch)?;
let result = |status, message| BranchUpdate { branch: branch.clone(), status, message };
let Some((remote, _)) = branch_upstream(r, branch) else {
out.push(result(BranchUpdateStatus::NoUpstream, None));
continue;
};
let fetch = match fetched.iter().find(|(name, _)| *name == remote) {
Some((_, done)) => done.clone(),
None => {
let done = match cli::run_streaming(r.root(), &["fetch", "--progress", &remote], cancel, on_output) {
Err(e) if e.kind == ErrorKind::Cancelled => return Err(e),
done => done.map_err(|e| e.message),
};
fetched.push((remote, done.clone()));
done
}
};
let (status, message) = match fetch {
Err(message) => (BranchUpdateStatus::Failed, Some(message)),
Ok(()) => fast_forward(r, branch, head.as_deref() == Some(branch.as_str()), cancel, on_output)?,
};
out.push(result(status, message));
}
Ok(out)
}
fn fast_forward(
r: &Repo,
branch: &str,
current: bool,
cancel: &CancellationToken,
on_output: &dyn Fn(String),
) -> IdeResult<(BranchUpdateStatus, Option<String>)> {
let rev = |args: &[&str]| run(r.root(), args, None).ok().map(|o| o.stdout_str().trim().to_string());
let ancestor = |a: &str, b: &str| {
cli::run_raw(r.root(), &["merge-base", "--is-ancestor", a, b], None).is_ok_and(|o| o.code == Some(0))
};
let local = format!("refs/heads/{branch}");
let tracked =
rev(&["rev-parse", "--symbolic-full-name", &format!("{branch}@{{upstream}}")]).filter(|t| !t.is_empty());
let target = tracked.as_deref().and_then(|t| rev(&["rev-parse", "-q", "--verify", &format!("{t}^{{commit}}")]));
let (Some(tracked), Some(target), Some(tip)) = (tracked, target, rev(&["rev-parse", "-q", "--verify", &local]))
else {
return Ok((BranchUpdateStatus::Failed, Some(format!("the tracked branch of '{branch}' was not found"))));
};
if tip == target || ancestor(&target, &tip) {
return Ok((BranchUpdateStatus::UpToDate, None));
}
if !ancestor(&tip, &target) {
return Ok((BranchUpdateStatus::NotFastForward, None));
}
let refspec = format!("{tracked}:{local}");
let args: &[&str] = if current { &["merge", "--ff-only", &tracked] } else { &["fetch", ".", &refspec] };
match cli::run_streaming(r.root(), args, cancel, on_output) {
Ok(()) => Ok((BranchUpdateStatus::Updated, None)),
Err(e) if e.kind == ErrorKind::Cancelled => Err(e),
Err(e) => Ok((BranchUpdateStatus::Failed, Some(e.message))),
}
}
/// Update Project › Reset to the Remote Branch: fetches the current branch's tracked
+94 -12
Переглянути файл
@@ -560,7 +560,7 @@ fn push_branch_and_up_to_revision() {
}
#[test]
fn update_branch_fast_forwards_a_branch_not_checked_out() {
fn update_branches_fast_forwards_each_selected_branch() {
let fx = Fixture::new();
let bare = fx._tmp.path().join("origin.git");
git_in(fx._tmp.path(), &["init", "-q", "--bare", bare.to_str().unwrap()]);
@@ -568,22 +568,104 @@ fn update_branch_fast_forwards_a_branch_not_checked_out() {
fx.commit_all("one");
fx.git(&["remote", "add", "origin", bare.to_str().unwrap()]);
fx.git(&["push", "-q", "-u", "origin", "main"]);
fx.git(&["checkout", "-q", "-b", "work"]);
// Someone else advances origin/main.
for b in ["behind", "diverged", "ahead", "same", "elsewhere"] {
fx.git(&["push", "-q", "origin", &format!("main:{b}")]);
fx.git(&["branch", "-q", "--track", b, &format!("origin/{b}")]);
}
fx.git(&["branch", "-q", "local-only"]);
// Someone else advances main, behind, diverged and elsewhere on the remote.
let other = fx._tmp.path().join("other");
git_in(fx._tmp.path(), &["clone", "-q", bare.to_str().unwrap(), other.to_str().unwrap()]);
std::fs::write(other.join("a.txt"), "2\n").unwrap();
git_in(&other, &["-c", "user.name=O", "-c", "user.email=o@x", "commit", "-q", "-am", "two"]);
git_in(&other, &["push", "-q", "origin", "main"]);
let tip = git_in(&other, &["rev-parse", "HEAD"]);
let mut tips = std::collections::HashMap::new();
for b in ["main", "behind", "diverged", "elsewhere"] {
git_in(&other, &["checkout", "-q", b]);
std::fs::write(other.join("a.txt"), format!("{b}\n")).unwrap();
git_in(&other, &["-c", "user.name=O", "-c", "user.email=o@x", "commit", "-q", "-am", b]);
git_in(&other, &["push", "-q", "origin", b]);
tips.insert(b, git_in(&other, &["rev-parse", "HEAD"]));
}
// Local commits: `diverged` can't be fast-forwarded, `ahead` has nothing to take.
for b in ["diverged", "ahead"] {
fx.git(&["checkout", "-q", b]);
fx.write("b.txt", b);
fx.commit_all(b);
}
fx.git(&["checkout", "-q", "main"]);
// A branch checked out in another worktree is refused rather than moved under it.
let wt = fx._tmp.path().join("wt");
fx.git(&["worktree", "add", "-q", wt.to_str().unwrap(), "elsewhere"]);
let ahead = fx.git(&["rev-parse", "ahead"]);
let repo = fx.repo();
let (cancel, out) = quiet();
repo.update_branch("main", &cancel, &out).unwrap();
assert_eq!(fx.git(&["rev-parse", "main"]), tip);
assert_eq!(fx.git(&["rev-parse", "origin/main"]), tip);
// The checked-out branch and branches without upstream are refused.
assert!(repo.update_branch("work", &cancel, &out).is_err());
let names = ["main", "behind", "diverged", "ahead", "same", "local-only", "elsewhere"].map(String::from);
let result = repo.update_branches(&names, &cancel, &out).unwrap();
let status: Vec<_> = result.iter().map(|u| (u.branch.as_str(), u.status)).collect();
use BranchUpdateStatus::*;
assert_eq!(
status,
[
("main", Updated),
("behind", Updated),
("diverged", NotFastForward),
("ahead", UpToDate),
("same", UpToDate),
("local-only", NoUpstream),
("elsewhere", Failed),
]
);
assert!(result[6].message.as_deref().is_some_and(|m| m.contains("checked out")), "{:?}", result[6].message);
// The checked-out branch is fast-forwarded with its working tree.
assert_eq!(fx.git(&["rev-parse", "main"]), tips["main"]);
assert_eq!(fx.read("a.txt"), "main\n");
assert_eq!(fx.git(&["rev-parse", "behind"]), tips["behind"]);
assert_eq!(fx.git(&["rev-parse", "origin/diverged"]), tips["diverged"]);
assert_ne!(fx.git(&["rev-parse", "diverged"]), tips["diverged"]);
assert_eq!(fx.git(&["rev-parse", "ahead"]), ahead);
assert_ne!(fx.git(&["rev-parse", "elsewhere"]), tips["elsewhere"]);
assert!(repo.update_branches(&["origin/main".into()], &cancel, &out).is_err());
}
#[test]
fn update_branches_fetches_each_remote_once_and_reports_its_failure() {
let fx = Fixture::new();
let bare = fx._tmp.path().join("origin.git");
git_in(fx._tmp.path(), &["init", "-q", "--bare", bare.to_str().unwrap()]);
fx.write("a.txt", "1\n");
fx.commit_all("one");
fx.git(&["remote", "add", "origin", bare.to_str().unwrap()]);
fx.git(&["remote", "add", "gone", fx._tmp.path().join("missing.git").to_str().unwrap()]);
fx.git(&["push", "-q", "-u", "origin", "main", "main:a", "main:b"]);
for b in ["a", "b"] {
fx.git(&["branch", "-q", "--track", b, &format!("origin/{b}")]);
}
fx.git(&["branch", "-q", "c"]);
fx.git(&["config", "branch.c.remote", "gone"]);
fx.git(&["config", "branch.c.merge", "refs/heads/c"]);
// Counts the fetches from origin.
#[cfg(unix)]
let counter = {
use std::os::unix::fs::PermissionsExt;
let counter = fx._tmp.path().join("fetches");
let script = fx._tmp.path().join("upload-pack.sh");
std::fs::write(&script, format!("#!/bin/sh\necho >> '{}'\nexec git-upload-pack \"$@\"\n", counter.display()))
.unwrap();
std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
fx.git(&["config", "remote.origin.uploadpack", script.to_str().unwrap()]);
counter
};
let repo = fx.repo();
let (cancel, out) = quiet();
let names = ["a", "b", "c"].map(String::from);
let result = repo.update_branches(&names, &cancel, &out).unwrap();
let status: Vec<_> = result.iter().map(|u| u.status).collect();
use BranchUpdateStatus::*;
assert_eq!(status, [UpToDate, UpToDate, Failed]);
assert!(result[2].message.is_some());
#[cfg(unix)]
assert_eq!(std::fs::read_to_string(counter).unwrap().lines().count(), 1);
}
/// `"` and tabs are illegal in Windows file names, and only they make Git quote a path.
+6 -1
Переглянути файл
@@ -366,7 +366,7 @@ const HTML: &str = "text/html; charset=utf-8";
fn content_type(path: &Path) -> &'static str {
let ext = path.extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default();
match ext.as_str() {
"html" | "htm" | "xhtml" => HTML,
"html" | "htm" | "xhtml" | "shtml" => HTML,
"css" => "text/css; charset=utf-8",
"js" | "mjs" | "cjs" => "text/javascript; charset=utf-8",
"json" | "map" | "webmanifest" => "application/json; charset=utf-8",
@@ -415,6 +415,11 @@ mod tests {
out
}
#[test]
fn shtml_files_are_html_by_name() {
assert_eq!(content_type(Path::new("page.SHTML")), HTML);
}
#[tokio::test]
async fn a_page_is_html_whatever_its_name() {
let dir = tempfile::tempdir().unwrap();
+3
Переглянути файл
@@ -847,6 +847,9 @@ mod tests {
"disabledPluginChecks": [],
"doubleClickOpensDiff": null,
"agentInstructions": "",
"agent": "",
"agentModel": "",
"agentEffort": "",
})
);
}
+7 -7
Переглянути файл
@@ -38,7 +38,7 @@ flowchart LR
## The server
```text
openidea-server --stdio | --connect <host> <port> | --version
openidea-server --stdio | --mcp-stdio [--project <path>] | --connect <host> <port> | --version
```
- `--stdio` serves one desktop client over stdin/stdout. stdout carries the protocol, so logs go to stderr (filter with `OPENIDEA_LOG`).
@@ -78,12 +78,12 @@ A few commands are always local even if the server knows them: `open_project` an
### What runs where
| On the remote machine | On the desktop |
| -------------------------------------------------------- | ------------------------------------ |
| The project: files, documents, settings | Windows, menus, the webview |
| Language servers, index, search | Client UI settings, keymaps, themes |
| Git, terminals, runs, debug adapters | The SSH connection and port forwards |
| Code plugins of the project, their processes and fetches | Plugin secrets (keychain) |
| On the remote machine | On the desktop |
| --------------------------------------------------------- | ------------------------------------ |
| The project: files, documents, settings | Windows, menus, the webview |
| Language servers, index, search | Client UI settings, keymaps, themes |
| Git, terminals, runs, debug adapters, built-in MCP server | The SSH connection and port forwards |
| Code plugins of the project, their processes and fetches | Plugin secrets (keychain) |
## Port forwarding
+34 -2
Переглянути файл
@@ -29,7 +29,13 @@ pnpm perf -- --only typing --profile --unminified # CPU profile and top functi
Other options: `--warmup <n>` (default 1), `--headed`, `--no-build` (reuse the last build), `--channel <browser>` (default `chromium`, or `OPENIDEA_PERF_CHANNEL`), `--fail-on-regression`.
Scenarios (`perf/scenarios.ts`): `typing`, `typingLarge`, `typingAngular`, `completion`, `consoleOutput`, `terminalTui`, `keyRepeat`, `scroll`, `gitLog`, `gitLogScrollbar`, `resizePanels`, `startup`, `tabs`, `agentTabs`, `popups`, `toolWindows`, `projectTree`, `leaks`. Bundle size (`bundle.initialJsKb`, `bundle.initialCssKb`) is checked on every run.
`--runs` must be a positive integer, `--warmup` a nonnegative integer, and `--cpu` a finite number of at least 1. Empty or unknown `--only` entries fail before building or launching a browser. Every declared selected scenario must return exactly one result; missing budgeted metrics and nonfinite metrics fail even when CPU throttling disables timing-budget enforcement. Unminified profiling builds intentionally omit bundle-size checks.
Every attempted repetition, including warmups, is retained in `target/perf/report.json` with status, metrics and failure reason. Markdown shows valid/planned and attempted counts. Missing or nonfinite repetitions are not filtered out of medians; invalid warmups also fail the scenario. Build, browser and cleanup failures replace the previous report with a fresh failure.
UI builds and individual trials have five-minute wall-clock deadlines independent of renderer animation frames. Browser startup is bounded to 30 seconds; context/HTTP cleanup to five seconds, with bounded forced browser termination. The owned Playwright browser server adds a local WebSocket command hop; in-page timing clocks are unchanged.
Scenarios (`perf/scenarios.ts`): `typing`, `typingLarge`, `typingAngular`, `completion`, `consoleOutput`, `terminalTui`, `keyRepeat`, `scroll`, `gitLog`, `gitLogScrollbar`, `resizePanels`, `startup`, `tabs`, `agentTabs`, `popups`, `toolWindows`, `projectTree`, `leaks`. Bundle size (`bundle.initialJsKb`, `bundle.initialCssKb`) is checked except with `--unminified`.
Latencies are measured from input to the start of the first frame that shows the result, so about 16.7 ms means "next frame".
@@ -42,9 +48,17 @@ Latencies are measured from input to the start of the first frame that shows the
A scenario in `perf/scenarios.ts` has an `id`, a `title` and a `run(h)` that drives the page through the harness (`perf/lib/harness.ts`: open files, set the cursor, type and measure, read editor state) and returns metrics. Add a budget for each metric you want enforced as `"<scenario>.<metric>"` in `budgets.json`.
### Current-operation checks
An already-visible result is not evidence that the measured action worked. Interaction waits require a current input and the requested state transition; file opening checks the active full path, typing checks the resulting text/caret and key-sample count, and scroll/completion navigation checks its destination.
Code-intelligence evals also wait for successful action completion. Rename correctness uses the current matching request only: multi-file previews validate proposed edits, while applied local renames validate the edited document. Incomplete answers are degraded results. Clean-file diagnostics require a fresh backend publication for that document, including an explicitly empty publication; a quiet empty UI alone cannot pass.
Diagnostics acknowledgements match the path, backend source and local opening token. Backend publications carry no document version, so a delayed same-path publication after reopening cannot be distinguished from a newly computed one.
## Backend: `pnpm perf:rust`
`perf/rust.ts` runs `cargo bench` for `ide-text`, `ide-language`, `ide-index`, `ide-search` and `ide-host`, reads the Criterion results from `target/criterion`, and checks each bench's mean (in µs).
`perf/rust.ts` runs `cargo bench` for `ide-text`, `ide-language`, `ide-index`, `ide-search`, `ide-host` and `ide-heap`, reads the Criterion results, and checks each bench's mean (in µs).
```sh
pnpm perf:rust # run the benches, then check
@@ -62,6 +76,22 @@ The benches live in `crates/<crate>/benches/`:
| `search_5k/…` | `ide-search` | literal, regex and dense-match search over 5k files |
| `plugins/…` | `ide-host` | loading 50 plugins, cold activation, syntax highlights of a 2k-line file |
Expected IDs and package ownership are declared independently of collected artifacts in `perf/lib/rust.ts`. A selected package must produce every expected ID, including observe-only measurements. `--package` scopes both collection and required budgets, also with `--no-run`; unknown packages fail before Cargo starts.
Six IDs are observe-only (required finite measurements, without an absolute budget): `syntax_2mb/outline_uncached`, `syntax_2mb/folding_uncached`, `index_100k/find_files/zzzz`, `index_100k/find_symbols/renderView`, `startup_20k/reopen_wait_idle`, and `search_excluded_subtrees/5k_dependencies`. New IDs need an explicit budget or observe-only classification.
Normal runs write isolated `<Criterion root>/runs/run-*/criterion` artifacts, a `run.json` manifest and Cargo logs. `CRITERION_HOME` and `CARGO_TARGET_DIR` are passed consistently to Cargo. Both artifact files must fall within the recorded run window; future timestamps fail. `--no-run` inspects the newest recorded run covering the selected packages, retaining original artifact dates and any recorded failure; pre-manifest output is explicitly labelled legacy inspection, not current execution.
Cargo has a 60-minute deadline including cold compilation (`PERF_RUST_TIMEOUT_MS` overrides milliseconds), followed by bounded process-tree termination. Cargo, artifact and manifest failures write fresh `report-rust.json` and Markdown with partial evidence.
## Code intelligence: `pnpm eval`
Use `pnpm eval --list` for scenario IDs and supported conditions. `--only` accepts comma-separated IDs or dot-prefix groups; every entry must match executable work. `--condition` accepts only `warm` or `cold`, and a selection incompatible with that condition is rejected before building or launching. Repetition counts follow the UI runner's integer requirements.
The selected scenario/condition plan defines the required outcomes independently of collected results. Missing, duplicate or unexpected outcomes fail; an empty workload cannot pass. Required timing and correctness metrics must be present and finite, rather than silently skipped by the judge.
Raw attempts, warmups, results and partial timeout timings remain in `target/eval/report.json`; invalid trials cannot disappear into an otherwise valid median. Startup/build failures also produce a fresh failing report. Session startup, fixture setup and each trial have five-minute wall-clock bounds; renderer measurements additionally have a Node deadline one second beyond their configured timeout. Server initialization is limited to 30 seconds, individual stdio requests to five minutes, release compilation to 60 minutes. Cleanup errors fail the run.
## Budgets and baselines
[`perf/budgets.json`](https://github.com/l0ng-ai/openidea/blob/main/perf/budgets.json) holds upper bounds (lower is better):
@@ -92,4 +122,6 @@ python perf/compare/bench.py ~/src/some-project --runs 5 --wipe-caches # cold
Each run launches the app on the project, waits until it is ready (the process tree's CPU stays low after the window and the log markers appear), idles, closes it, and records time to window and to ready, peak and idle memory summed over every process the app started (webview, language servers, JVMs), CPU time, exit time and cache size. Apps run interleaved after warmup runs; output goes to `results/<time>-<project>/` (`report.md`, `results.json`).
Reports retain failed trials and warmups, display per-cell valid/attempted counts, and distinguish unsupported metrics from missing required values. Startup timeouts, crashes, forced shutdowns and interruptions fail the command. Quit/cache commands have explicit deadlines; cleanup runs even after observation failures. See the comparison README for the unchanged CPU-settled readiness proxy and daemon exclusions.
Use release builds only; the script refuses to run while another instance of the same executable is running. See [`perf/compare/README.md`](https://github.com/l0ng-ai/openidea/blob/main/perf/compare/README.md) for fair-run rules and platform notes.
+1 -1
Переглянути файл
@@ -78,7 +78,7 @@ The task tab shows the conversation: your messages, the agent's replies, its rea
On your own messages you can **Edit** (the messages after it are replaced; files already changed stay as they are) or **Retract Message**. On replies you can **Copy Markdown**, **Quote Reply**, **Regenerate Response** and **Branch Conversation from Here**, which starts a new task from that point.
In an existing chat, open **Model › Refresh models** to discover newly available models without sending a message or changing the selection. If the agent can't switch in place, the choice stays pending until your next message reopens the same session. If the session can't be reopened or doesn't accept the model, OpenIDEA restores the previous selection and reports the error without sending the message.
In an existing chat, open **Model › Refresh models** to discover newly available models without sending a message or changing the selection. If the agent can't switch in place, the choice stays pending. You can choose an effort level as soon as the provider reports the new model's options. On your next message, OpenIDEA reopens the same session and applies the model and any effort you selected before sending. If the session can't be reopened or rejects either choice, OpenIDEA restores the previous selection and reports the error without sending the message.
**Focus Agent Input** defaults to `⌘L` on macOS and `Ctrl+L` on Windows / Linux in every built-in keymap. When focus is inside your writable task conversation, in either an editor tab or the tool window, it returns focus to the message input without changing your draft, caret position or selection—even when pressed repeatedly. It does not send a message or jump through message history.
+12 -2
Переглянути файл
@@ -3,7 +3,7 @@ title: "Databases"
description: "Connect to SQL databases, browse schemas, run queries in a console, and view, edit, import and export data."
---
The **Database** tool window connects to SQLite, PostgreSQL, MySQL/MariaDB, Microsoft SQL Server, Oracle, ClickHouse and Snowflake, plus databases that speak one of their protocols. Drivers are built into the IDE; there are no JDBC drivers to download.
The **Database** tool window connects to SQLite, PostgreSQL, MySQL/MariaDB, Microsoft SQL Server, Oracle, ClickHouse and Snowflake, plus databases that speak one of their protocols. These presets use built-in drivers. You can also connect with a vendor JDBC driver installed locally.
Open it from **Tools › Database** or **View › Tool Windows › Database**. The **Tools** menu also has **New Data Source…** and **Open Query Console**.
@@ -23,6 +23,16 @@ Open it from **Tools › Database** or **View › Tool Windows › Database**. T
Presets set the default port and, where needed, SSL (for example Redshift, Neon and Supabase require SSL).
## Custom JDBC drivers
Choose **New › Data Source › Custom JDBC**, then **Manage Drivers…**. Add a named profile with the vendor's driver JAR, any dependency JARs, the fully qualified driver class, and an optional JDBC URL template. OpenIDEA reads the driver classes declared in the selected JARs. You can choose a different class or enter its full name manually. Use `{host}`, `{port}`, `{database}` or `{file}` in a template to get matching connection fields, or edit the JDBC URL directly. Only import drivers you trust. OpenIDEA loads their code in a separate process using an installed Java 17 or newer runtime.
Select the profile, enter the vendor's JDBC URL, and use the **User**, **Password**, and **Advanced** fields for credentials and driver properties. The URL and Advanced properties are stored in the data source configuration. Put credentials in the password field to use the existing OS credential store. On Linux, saving a password requires a running Secret Service. You can also enter the password for the current session. The **Read-only** option asks the JDBC driver for a read-only connection. Use a database account with read-only privileges to enforce it. Cancelling a query keeps the session and its temporary tables when the driver stops the statement. If the driver does not respond within three seconds, OpenIDEA closes the session. A submitted statement can still finish on the server. **Test Connection** reports the database product and version. Schema, table and column browsing use JDBC metadata; the SQL console supports auto-commit queries and updates. Vendor-specific DDL, execution plans and table-grid writes are unavailable for custom drivers.
For a file-backed database, use an absolute path to choose its location. Relative paths start in the persistent `jdbc/files` folder inside OpenIDEA’s application data directory.
Profiles are reused across projects. If a project file changes a connection's URL or properties outside the IDE, review the settings in the data source dialog and save them before reconnecting.
## Add a data source
Click **+** in the Database tool window (or press `⌘N` / `Alt+Insert` there) and choose:
@@ -205,7 +215,7 @@ Limits: `TIMESTAMP_LTZ` values are shown in UTC; SSH tunnels are not offered; re
## Not supported
- MongoDB, Redis, BigQuery and other non-listed databases; JDBC drivers.
- Native drivers for MongoDB, Redis and BigQuery.
- SQL Server `GO` batch separators.
- A "run the whole console" action (use a selection, or **Run SQL Script…**).
- Exporting more than the loaded page.
+1 -1
Переглянути файл
@@ -163,7 +163,7 @@ Each form has **Host** and **Port** fields and shows the command to start the re
- **Java HotSwap**: **Run › Debugging Actions › Reload Changed Classes** compiles your changes and reloads the changed classes into the running Java debug session. Active frames keep running the old code until they return. When JDT LS finishes a build after a save, the IDE offers the reload.
- **Maven and Gradle**: debugging a Maven or Gradle configuration starts the JVM with a JDWP agent and attaches java-debug to it.
- **Dart / Flutter**: **Hot Reload** and **Hot Restart** are available while a Dart session is running.
- **Dart / Flutter**: **Hot Reload** and **Hot Restart** are available while a Dart session is running. In a Flutter project, the device selector next to the run configuration chooses where Run and Debug start the app; a run configuration's **Device** field pins it to one device. Saving a Dart file of a running Flutter debug session also hot reloads the app, unless the file has errors. Turn this off with **Hot reload on save** in **Settings › Build, Execution, Deployment › Debugger**.
- **PHP**: if the PHP interpreter does not load Xdebug, breakpoints are skipped; the IDE warns about this when the session starts.
- **Python**: **Settings › Build, Execution, Deployment › Python Debugger** has **Attach to subprocess automatically while debugging** and **Gevent compatible**.
+4 -1
Переглянути файл
@@ -132,8 +132,11 @@ Plugins can add more tools; they appear in the same list. A plugin tool marked a
- **Running and building ask first.** `execute_run_configuration`, `build_project`, `run_command` and `http_run_request` show a dialog in OpenIDEA naming the client, the project, the tool and what will run. Choose **Allow** or **Deny**; several requests queue up.
- Tools that write refuse paths outside the project.
## Remote development
In a remote window ([SSH](/en/guide/remote/ssh), WSL or [Dev Containers](/en/guide/remote/containers)), `openidea-server` runs its own MCP server on the remote host, configured independently in **Settings › Agents › IDE MCP Server** while that remote window is focused. Coding agents started inside the remote window connect to it automatically; external CLI clients on the remote host can use **Copy Stdio Config** (`~/.openidea/bin/openidea-server --mcp-stdio`) or **Copy HTTP Config**, and clients on your desktop can reach it by forwarding its port in the **Ports** tool window.
## Limits
- Remote projects (opened over SSH, on a server or in a container) are not supported by the MCP server yet.
- The server serves only projects open in OpenIDEA. Closing the project's window makes its tools unavailable.
- Responses are plain JSON; the server does not stream over SSE.
Loaded 100 of 498 files, more files were not shown because too many files have changed in this diff. Show more