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

..
Автор SHA1 Повідомлення Дата
l0ng-ai f1ca1fc7a2 feat(vcs): choose the agent, model and effort for Generate Commit Message
Settings › Version Control › Commit › Commit Message Generation gets Agent,
Model and Effort dropdowns (vcs.commit.agent / agentModel / agentEffort,
global or per project). Automatic keeps the current behaviour: the agent of
the latest task on its model. A chosen agent runs on the chosen model and
thinking level when it offers them, and the chat's model is no longer
involved. The lists come from the agent's model catalog.

Closes #4467
2026-11-19 19:15:22 +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
Deng Liu 958b3db122 Merge pull request #4376 from dengliu/fix/npm-public-registry-fallback
fix(tools): retry npm installs against registry.npmjs.org on mirror misses
2026-11-18 13:45:40 -08:00
Deng Liu 8620fae5d5 Merge pull request #4375 from dengliu/feat/copilot-release-binaries
feat(agent): install GitHub Copilot from verified GitHub Release binaries
2026-11-18 13:45:10 -08:00
Deng Liu c216818c08 Merge pull request #4374 from dengliu/fix/agents-live-registry-update-state
fix(agents): prefer live ACP Registry update state in Coding Agents settings
2026-11-18 13:34:54 -08:00
Deng Liu e4f98bca3d fix(tools): retry npm installs against registry.npmjs.org on mirror misses 2026-11-18 12:54:12 -08:00
Deng Liu 0f727b47bc feat(agent): install GitHub Copilot from verified GitHub Release binaries 2026-11-18 12:54:10 -08:00
Deng Liu f03fabfa5f fix(agents): prefer live ACP Registry update state in Coding Agents settings 2026-11-18 12:54:07 -08:00
DeH40таDeH40 d21a4ca9d9 feat(plugins): custom Search Everywhere categories (API 1.13) (#3974)
Plugins can add their own tabs to the double-Shift search dialog: `[[contributes.searchCategories]]` declares a stable id and a title, and the optional `search-provider` export (SDK `search::SearchProvider`) answers the category's queries. Queries keep their raw text (at most 1024 bytes, 1–200 results), are cancellable and time-boxed, and run without prompts. Results open a validated location in the current project or run one of the plugin's own declared commands. Custom tabs stay out of All, so endpoint search and the other tabs are unchanged; disabling, uninstalling or reloading the plugin withdraws its tabs. Plugin API 1.13 (WIT, engine and SDK versions, docs); `plugin_search` is a cancellable command. Every plugin component is rebuilt.

Closes #3966

Co-authored-by: DeH40 <[email protected]>
2026-11-19 04:48:15 +08:00
Mansur Akhmadiтаmansur-akhmadi f6490426f3 feat(vcs): choose the repository in the Git Remotes dialog when the project has several (#4373)
Git › Manage Remotes… worked only on the repository selected in the branch widget. With two or more repositories the Git Remotes dialog now shows the Repository combo the Pull, Merge, Rebase, Tag and Stash dialogs use; picking another repository loads its remotes in a fresh list (late answers for the previous pick are dropped), and Add / Remove / Edit act on it. The choice stays local to the dialog. With a single repository the dialog is unchanged.

Closes #4372

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-19 04:33:33 +08:00
Vadim LazukтаInf1mum 669ea49e3d fix(docker): reach the daemon over the Engine API when the docker CLI is missing (#4371)
Docker connections (SSH, TCP, socket, default) failed with "docker not installed" on a machine without the docker CLI. ide-docker now has a small Engine API client (HTTP/1.1 over a unix socket or TCP, std only) used when the CLI is missing: availability, the Services snapshot (containers, images, volumes, networks), container start/stop/restart/pause/kill, remove and inspect. SSH connections already resolve to a local TCP tunnel, so they work the same way. TLS endpoints, contexts and Windows named pipes still need the CLI, as do compose, logs, pull, prune, events and stats. The Services panel shows "Engine <version>" when there is no CLI version. Ports are printed as docker ps does (80/tcp) so the dashboard still turns them into links.

Closes #4168

Co-authored-by: Inf1mum <[email protected]>
2026-11-19 04:30:10 +08:00
l0ng-ai c57a52348b feat(run): run and debug Java programs when jdtls does not serve the module (#4240)
With jdtls disabled and another Java language server (java-analyzer) serving the module, Run and Test failed with "no Java language server (jdtls) is configured". Launches of such modules now build with Maven or Gradle and take the classpath and JDK from the server's java-analyzer/projectClasspath request, falling back to Maven's resolved classpath; JDK selection, command-line shortening and Lombok hints are shared with the jdtls path, which is unchanged. Debugging those modules uses java-analyzer's own debug adapter (`java-analyzer dap`). Java no longer colours JDK symbols (defaultLibrary) differently from library and workspace ones.
2026-11-19 04:26:58 +08:00
l0ng-ai 431cfafab3 test: fix three tests failing on main (#4370)
- e2e/toolwindows expected ew-resize while dragging a tool window splitter; splitters lock col-resize since #4334.
- trust_vcs_sweep: vcs_detected_roots (Directory Mappings, #4351) is allowed in Restricted Mode but wasn't swept; it is now checked to start no program of the repository.
- acp::e2e resume test raced on slow runners (Ready before the resumed turn started); it now waits for the turn's entries first.
2026-11-19 03:09:35 +08:00
Mansur Akhmadiтаmansur-akhmadi dfd7a177f5 feat(vcs): Options submenu in the annotate gutter (date, author, revision) (#4367)
The annotate gutter's context menu gets Options with Date, Author and Revision check items; Revision shows the 8-character commit hash. Date and Author stay on by default, the last shown column can't be turned off, and the choice is remembered and applied to every annotated editor, including other windows. Options also shows on uncommitted lines.

Closes #4366

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-19 02:40:20 +08:00
Gabriel Gondim 5c3b144db9 feat(project): Open In › Associated Application (#4365)
Project view and editor tab menus get Open In › Associated Application, and Find Action gets Open in Associated Application: the selected files open in the application the OS associates with them, through the existing fs_open_with_system command (trusted local projects only; hidden in remote windows).

Closes #4352

Co-authored-by: GGVidal <[email protected]>
2026-11-19 02:03:24 +08:00
Vadim LazukтаInf1mum 7492bebeef feat(java): module-level incremental Build Project for multi-module Maven projects (#4361)
Build Project on a Maven reactor records per-module input fingerprints after each successful project build. The next Build Project finds the changed modules, spreads the change to the modules that depend on them (test-scoped consumers included, version-matched) and runs `mvn -pl <modules> -am` over just that set; an unchanged reactor is skipped, and a missing or unreadable record or unresolvable inputs fall back to the full build. Baselines are recorded only after a project build, so modules changed but not built by Build Module are still built next time. Content edits with preserved mtimes are re-stamped so Maven recompiles them.

Refs #4078

Co-authored-by: Inf1mum <[email protected]>
2026-11-19 01:55:34 +08:00
l0ng-ai 9673a704a2 feat(agents): run ! commands from the agent composer (#4364)
A composer message starting with `!` runs as a shell command in the task's folder instead of starting an agent turn. The command and its output appear as an execute tool entry, Stop kills it, and the command with its output is sent ahead of the next message (once) so the agent sees what was run. New cancellable command agent_shell.

Closes #4339
2026-11-19 01:39:55 +08:00
Deng Liuтаdengliu a6569552b1 perf(settings): single-IPC local bootstrap snapshot and lazy page bodies (#4056)
The Settings window starts from one window_take_settings_init snapshot (launch, project, global settings, remote, updates) instead of several startup calls; on a remote session it paints with the client settings and reconciles with the host's projectCurrent() afterwards, rebasing without touching staged edits. Seven heavy pages (Color Scheme, Inspections, Scopes, Updates, Deployment, Run Targets, SSH) are split into a spec module (metadata and search labels, loaded with the registry) and a lazily loaded body; lazyComponent gains preload() so the target page is warmed before it is revealed. A launch that arrives between the snapshot and the event listener is still applied.

Co-authored-by: dengliu <[email protected]>
2026-11-19 01:28:28 +08:00
l0ng-ai 437e8b747e fix(i18n): translate the terminal refresh-rate options into Chinese (#4360)
The zh catalog carried the English "60 FPS" etc. for the Maximum refresh rate options from #4358, which i18n.test.ts rejects for a locale with its own script; they are now "60 帧/秒" etc.
2026-11-19 01:23:09 +08:00
Gabriel Gondim a4f2f5ef3d fix(terminal): cap PTY paint rate and slow down when hidden (#4358)
PTY output goes through a gate before xterm instead of being written chunk by chunk. While the window is hidden it flushes at most every 250 ms, so terminals running btop or agent animations stop burning CPU in background windows. Tools | Terminal | Maximum refresh rate (Unlimited by default; 60/30/15/10 FPS) optionally caps painting while visible.

Closes #4216

Co-authored-by: GGVidal <[email protected]>
2026-11-19 01:21:27 +08:00
l0ng-ai 2c7eebb35f fix(diff): run editor text actions on the diff's focused side (#4359)
Text actions that need only the view (Comment Line, Duplicate/Move Line, Join Lines, Toggle Case, Add Selection for Next Occurrence, Clone Caret and the like) also run while a diff or merge editor has focus: editing ones on its editable side, caret and selection ones on either side. They were enabled only by editorTextFocus, which the diff never sets, so their keys did nothing or fell through as typed text. Diff panes now allow several selections and keep the occurrence-search state, and ⌘D duplicates the line there instead of opening Show Diff.

Closes #4343
2026-11-19 01:16:22 +08:00
Mr0Bread 160ecf4693 fix(index): find files inside git-ignored folders (#4034)
Files inside git-ignored folders are listed in the file index by name only, so Go to File and Search Everywhere find them in the default scope; their contents are not read or parsed. Project-model exclusions, files.exclude, VCS metadata and symlink boundaries stay pruned. Incremental watcher updates follow the same rule (including new ignored subtrees and the polling/per-directory backends), and a stamp bump invalidates old directory snapshots so existing caches pick up the folders they left out.

Measured cold index on macOS: this repository 1.53s / 6,432 files before vs 1.55s / 6,440 after (its large ignored folders are detected exclusions); a synthetic project with 2,000 sources and a git-ignored folder of 50,000 files 0.2s / 2,001 files before vs 0.68s / 52,001 after.

Closes #3972

Co-authored-by: Mr0Bread <[email protected]>
2026-11-19 01:05:09 +08:00
Bert Verhelstтаbertyhell cb087fff48 feat(plugins): console highlight rules for Run/Debug output (API 1.12) (#4164)
Plugin API 1.12 adds workspace set-console-rules: a plugin replaces its list of highlight rules (regex in the Rust/JS common subset, validated on the host and bounded to 512 bytes and 100 rules; palette foreground/background, styles, whole-line or match-only, enabled). Every window applies the rules to the stdout and stderr lines of its Run and Debug consoles; the plugin never sees the output, and the rules go away when the plugin stops. Components rebuilt for 1.12.

Closes #3304

Co-authored-by: bertyhell <[email protected]>
2026-11-19 00:34:55 +08:00
GuoYuтаguoyucode 70e0215f46 feat(mcp): paths on every query tool, includeExcluded for the searches (#4299)
The query tools narrow their results one way: `paths` (project-relative globs, `!` excludes, absolute for a project attached outside the project) replaces `scope` on find_references, get_call_hierarchy, get_project_problems, git_status, get_all_open_file_paths, get_run_configurations and list_runs. `paths` only narrows: git-ignored and project-excluded content stays out unless `includeExcluded` is set, which search_text and search_regex now accept too (SearchQuery::include_excluded turns the ignore rules off for that search). search_file walks only the folders the globs lie in instead of the whole project, and list_directory_tree marks git-ignored and IDE-excluded entries once, at the top. An old client's `scope` is ignored and gets whole-project results.

Co-authored-by: guoyucode <[email protected]>
2026-11-19 00:20:38 +08:00
Mansur Akhmadiтаmansur-akhmadi 460d30030e feat(vcs): Show Diff in the annotate gutter's context menu (#4355)
The annotate gutter's context menu gains Show Diff after Show Commit in Git Log. It opens what the line's commit changed in the file against the commit's first parent: an added file shows (does not exist) on the left, a renamed one its old path, and a file renamed later is diffed under its name at that commit (from its --follow history; a merge the history doesn't list is read directly).

Closes #4354

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-19 00:16:57 +08:00
dervarex edf9affa8e feat(appearance): Smooth scrolling setting for Linux web views (#4330)
Adds Appearance | Smooth scrolling (shown on Linux only). It toggles WebKitGTK's enable-smooth-scrolling on every web view: applied when a web view is created and when the setting changes. It stays on by default; turning it off removes the stutter some Linux setups see when scrolling with the mouse wheel.

Co-authored-by: dervarex <[email protected]>
2026-11-19 00:13:31 +08:00
Vladislav Kuzmin 070c795de5 fix(database): preserve the ClickHouse account default and explain reconnects (#4346)
A source without a configured database no longer sends database=default on its HTTP requests, so stateless requests honour the account's own default database. A lost HTTP session (code 372) now tells the user to reconnect and explains that both expiry and load-balancer routing cause it.

Co-authored-by: principalwater <[email protected]>
2026-11-19 00:10:46 +08:00
l0ng-ai 5c9290fefd feat(deployment): use a server group as the default deployment target (#4357)
A server group can be marked as the default deployment target. Upload to <group> uploads to each of its servers in turn; automatic upload and remote deletes on save reach every server of the default group, with their results merged into one report.

Closes #4322
2026-11-19 00:09:06 +08:00
l0ng-ai 0527ff4218 feat(project-view): show user scopes as Project view panes (#4356)
Scopes defined in Settings > Scopes were only used by File Colors and Find in Files. The Project view's pane switcher now lists them after the built-in panes. Choosing one shows only that scope's files under their folders, like Open Files and All Changed Files. The pane updates as files are created or removed and as the scopes change. The new scope_files command lists a scope's files, at most 20000.

Closes #4315
2026-11-19 00:01:47 +08:00
l0ng-ai e5b2f4dfc7 feat(toolwindows): remember size for each tool window (#4353)
Tool windows on one side shared a single size, so switching from a resized Terminal to Debug and back lost the Terminal's height. The new Appearance option "Remember size for each tool window" (off by default) keeps each window's last size along its side and restores it when the window shows again. The size comes from dragging or from the Resize Tool Window actions. It is saved with the project layout and in saved tool window layouts.

Closes #4326
2026-11-18 23:53:47 +08:00
l0ng-ai a3617aa3e9 fix(structure): keep File Structure from jumping on unmatched queries (#4329)
With Narrow down on typing off, a query that matched nothing selected the first symbol, and Enter jumped to it. The popup now clears the selection when nothing matches and shows No matches next to the field, so Enter leaves the caret where it is. Adds Tree.clearSelection.

Closes #4212
2026-11-18 23:51:40 +08:00
l0ng-ai bd7d4c475b fix(keymap): record double-modifier shortcuts (#4328)
The shortcut recorder (Find Actions by Shortcut and Add Keyboard Shortcut) only saw single keystrokes, so it ignored double-modifier gestures such as Shift, Shift or Ctrl, Ctrl that the dispatcher supports. Double-modifier recognition moves out of the dispatcher into a recognizer that the recorder now shares. A double tap records the gesture. Holding the second tap with a key records Modifier Modifier+Key. Focus loss, a mouse press or a trackpad swipe resets it.

Closes #4225
2026-11-18 23:51:33 +08:00
l0ng-ai 15e32d5af6 feat(vcs): edit Directory Mappings to exclude or add Git repositories (#4351)
Directory Mappings listed only the project root, read-only. It now lists the detected repositories and those added by hand. Setting a repository to <none> removes it from the Git and Commit tool windows and from IDE-wide Git operations, while its files stay in the project. + adds a repository root that detection does not reach, and - removes an added one. The mappings are saved per project (vcs.mappings) and apply on every rescan. Adds Repos::mapped and the vcs_detected_roots command.

Closes #4157
2026-11-18 23:43:10 +08:00
l0ng-ai 3de76f1a63 fix(search): Find Action hides actions that cannot run (#4327)
Find Action only checked an action's when clause, not its enabled() check, so Annotate with Git Blame on an untracked file, Show Current Revision, or Set NULL with no data grid focused were listed as enabled and did nothing. Matching now uses isActionEnabled, the same check menus and shortcuts use. When Include disabled actions is unchecked, unavailable actions are hidden, also from the recent list. The database cell actions are enabled only while a grid has focus (a popup opened from the grid keeps the grid it captured). An empty Actions tab says Nothing found.

Closes #4223
2026-11-18 23:41:40 +08:00
l0ng-ai 262b91d89a fix(bookmarks): keep bookmarks when files and folders are renamed (#4325)
A rename in the Project view reached the bookmark store as a removal: the watcher's fsChanged event dropped the bookmarks of the old path before the rename's own mapping arrived. Bookmarks now follow explicit moves through onFilesMoved. A watcher removal waits for any move in progress in the same project, and drops a bookmark only when its path is really gone (an Undo or rollback may already have restored it).

Closes #4210
2026-11-18 23:38:57 +08:00
l0ng-ai 4d6a21c695 fix(terminal): keep the active ConPTY prompt when a terminal resizes (#4324)
When a ConPTY terminal got narrower (for example, a split opened and then closed), xterm dropped the end of the active PowerShell prompt. PowerShell then echoed input at absolute columns without printing the prompt again, so it came back garbled. Local terminals and embedded Run consoles now turn on xterm's cursor-line reflow on Windows builds whose ConPTY needs it. Remote and non-Windows sessions are unchanged.

Closes #4155
2026-11-18 23:32:50 +08:00
l0ng-ai 7de8fb850e fix(bookmarks): keep bookmarks on surviving lines after edits (#4323)
Deleting a bookmarked line next to another bookmark mapped both gutter markers onto the same line and re-matched the stored bookmarks by index. The surviving bookmark lost its mnemonic, description and list. The gutter now carries each bookmark through the edit. A bookmark is dropped only when its own line was removed, and the others keep their metadata, also across Undo and Redo.

Closes #4207
2026-11-18 23:30:45 +08:00
l0ng-ai acb850758a feat(vcs): option to detect changes with the Git command line (#4350)
Encryption or file protection layers can make the file metadata gitoxide reads differ from what the system git sees, so unchanged files showed as modified while git status was clean. The new Git setting "Detect changes with the Git command line" (vcs.git.cliStatus, off by default) reads the full working-tree status with git status, the same reader the partial refresh already used.

Closes #4124
2026-11-18 23:30:30 +08:00
l0ng-ai 6bf69cfb2a feat(java): strike out deprecated classes in the Project view and editor tabs (#4349)
The JVM file presentation now reports whether a file's primary type is deprecated: annotated @Deprecated (Java and Kotlin), or a Java type whose Javadoc has a @deprecated tag. The Project view and editor tabs strike the name out, and an error marker on the same file still shows.

Closes #4151
2026-11-18 23:21:04 +08:00
l0ng-ai 6829022b71 feat(vcs): ask for the Git user name and email before committing without them (#4348)
Committing in a repository without user.name or user.email failed with Git's error. Commit now first opens the Git User Name Is Not Defined dialog. The dialog proposes the identity the other repositories share and validates the name and email. It sets them globally by default, or in each repository that lacks them when the box is unchecked, and then the commit continues. Adds Repo::set_user_identity and the trusted vcs_set_user_identity command.

Closes #4175
2026-11-18 23:14:15 +08:00
l0ng-ai 54611ff80a fix(lsp): launch Windows npm language servers with an overlong PATH (#4314)
cmd.exe drops an inherited PATH over 8,191 UTF-16 code units, so npm launchers such as vtsls.cmd could not find Node. Before a Windows batch launch, missing absolute drive paths are pruned from an overlong PATH when that makes it fit, keeping the order of the rest. Explicit environment variables are now set before process preparation so they take precedence.
2026-11-18 23:05:05 +08:00
l0ng-ai cacfc4142f fix(vfs): reject ambiguous Windows file destinations (#4312)
Windows strips a trailing period or space from a path component, so the project tree and the editor ended up with different names for one file. The name editor now explains the rule, and the VFS rejects such destinations before creating, copying or renaming (verbatim paths excepted).
2026-11-18 23:04:28 +08:00
l0ng-ai 237f7ee5a5 fix(templates): expand live templates across matching carets (#4313)
Live templates expand at every caret sharing the same eligible prefix, in one undo step, keeping the primary caret and linking fields across the expansions. Mixed prefixes or syntax contexts fall back to the normal Tab edit.
2026-11-18 23:03:29 +08:00
l0ng-ai 2321929709 fix(terminal): keep the terminal from sliding sideways while composing (#4347)
A TUI that leaves the cursor in the last column pushed xterm's input textarea and IME composition past the right edge, and Chromium (WebView2) scrolled the clipping pane to keep the caret visible. The xterm element now clips its overflow, so no ancestor can scroll.
2026-11-18 23:02:51 +08:00
l0ng-ai 6d788cb6f8 fix(project-view): restore the contents of the last deletion (#4309)
Project View Undo restores the snapshot taken by that specific Delete, including empty folders and the files' exact bytes (BOM, line endings); earlier deletions stay deleted. Entries that cannot be restored (contents not captured, path now occupied) are named in the warning, which points to the system Trash.
2026-11-18 22:59:48 +08:00
l0ng-ai 662c32eb05 fix(editor): discard gutter color previews on Escape (#4285)
The gutter color picker previews a color without editing the document. Escape or Cancel dismisses the preview; Apply or clicking outside commits the color, and one Undo restores the original.
2026-11-18 22:56:41 +08:00
l0ng-ai 82ff84e69e fix(vcs): activate diff hunk buttons with the keyboard (#4311)
Diff hunk buttons (arrows, hover Revert, unified Revert) apply the change on click, so Enter and Space work as well as the pointer; a pointer press still keeps editor focus. The unified Revert test added since now activates the button with a click.
2026-11-18 22:55:57 +08:00
l0ng-ai 7ec0d3dbec fix(workbench): restore focus before running main-menu actions (#4310)
The custom main menu returns focus to the editor or field that opened it before running an action, so Edit › Undo / Redo reach the editor and workspace history (e.g. after Rename) instead of running while the menu button holds focus.
2026-11-18 22:54:23 +08:00
l0ng-ai 466556603d fix(editor): keep completion open inside an identifier (#4304)
Basic Completion no longer auto-inserts a sole suggestion when the caret is inside an identifier; the lookup stays open so Tab replaces the whole identifier (including a Unicode suffix). A sole suggestion at the end of a prefix still inserts at once.
2026-11-18 22:54:05 +08:00
l0ng-ai 3b2deb6ad8 fix(java): keep a Maven build's processor output away from jdtls (#4344)
jdtls runs annotation processors itself and writes to the same generated-sources/annotations folder as javac. A Maven build's rewrite of those files reached jdtls as a watched-file change; jdtls compiled javac's copy, failed to resolve the mapper and overwrote target/classes with an 'Unresolved compilation problems' class. Changes under generated-sources/annotations and generated-test-sources/test-annotations are no longer sent to jdtls.
2026-11-18 22:53:28 +08:00
l0ng-ai f2429a8c14 docs: suggest XWayland first for a Linux window that stops responding (#4342)
XWayland keeps the GPU renderer and stayed responsive on the setup in #4244, so the troubleshooting entry suggests GDK_BACKEND=x11 before turning the DMA-BUF renderer off.
2026-11-18 22:44:01 +08:00
798 змінених файлів з 30133 додано та 5406 видалено

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:
Створено
+120 -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",
@@ -6734,6 +6748,7 @@ dependencies = [
"tracing",
"tracing-appender",
"tracing-subscriber",
"webkit2gtk",
"webview2-com",
"windows",
"windows-sys 0.61.2",
@@ -7388,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",
@@ -7400,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",
@@ -9744,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",
@@ -11081,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",
@@ -11123,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",
@@ -11154,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",
@@ -11169,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",
@@ -11186,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",
@@ -11212,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",
@@ -11226,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",
@@ -11236,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",
@@ -11247,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",
@@ -11259,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",
@@ -11270,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",
@@ -11284,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",
@@ -11308,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,
+5 -1
Переглянути файл
@@ -203,7 +203,11 @@ async fn a_task_runs_on_a_v2_agent_and_resumes_its_session() {
let agent2 = Arc::new(FakeV2Agent::default());
let mgr2 = manager(tmp.path(), agent2.clone());
mgr2.prompt(&task.id, text("again"), false).await.unwrap();
tokio::time::sleep(Duration::from_millis(50)).await;
// The task is Ready until the resumed turn starts: wait for the turn's entries first.
let deadline = std::time::Instant::now() + Duration::from_secs(10);
while mgr2.entries(&task.id, None).unwrap().len() < 8 && std::time::Instant::now() < deadline {
tokio::time::sleep(Duration::from_millis(10)).await;
}
wait_for(&mgr2, &task.id, AgentStatus::Ready).await;
let entries = mgr2.entries(&task.id, None).unwrap();
assert_eq!(summary(&entries[6..]), ["user: again", "agent: second turn"]);
+89 -20
Переглянути файл
@@ -20,6 +20,7 @@ mod native;
mod provider;
pub mod registry;
pub mod security;
mod shell;
mod skills;
mod timeline;
mod worktree;
@@ -124,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,
@@ -147,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,
}
@@ -219,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);
@@ -400,6 +409,9 @@ struct TaskState {
/// the like), as it sent them: unlike a turn they outlive it, so an idle release
/// waits for the last one. A (re)started process runs nothing yet.
background_tasks: Vec<Value>,
/// Shell commands the user ran with `!` since the last prompt, as the text block that
/// goes ahead of the next one.
shell_context: Vec<String>,
}
impl TaskState {
@@ -512,6 +524,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);
@@ -646,6 +659,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.
@@ -793,7 +811,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
@@ -868,7 +887,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,
@@ -902,11 +921,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)
}
@@ -957,6 +978,26 @@ impl AgentManager {
Ok(())
}
/// Runs `command` (a composer line starting with `!`) in the task's folder with the user's
/// shell, without starting a turn: it shows as one entry with its output and exit code,
/// and goes to the agent with the next message.
pub async fn run_shell(&self, id: &str, command: &str, cancel: ide_core::CancellationToken) -> IdeResult<()> {
let task = self.task(id)?;
let command = command.trim();
if command.is_empty() {
return Err(IdeError::invalid("empty command"));
}
let cwd = {
let s = task.state.lock();
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
s.task.cwd.0.clone()
};
task.shell(command, &cwd, &cancel).await;
Ok(())
}
/// Drops a queued message.
pub fn unqueue(&self, id: &str, queued: &str) -> IdeResult<AgentQueued> {
let task = self.task(id)?;
@@ -1885,6 +1926,7 @@ impl Task {
title_renamed: file.title_renamed,
busy: false,
background_tasks: Vec::new(),
shell_context: Vec::new(),
}),
live: Mutex::new(None),
connecting: tokio::sync::Mutex::new(()),
@@ -2115,6 +2157,33 @@ impl Task {
}
}
/// Folds an update made here (not by the agent) into the main conversation.
fn apply_local(self: &Arc<Self>, update: &Value) {
let changed = self.state.lock().conversation.apply(None, update, now_ms());
self.mark_dirty(changed);
}
async fn shell(self: &Arc<Self>, command: &str, cwd: &Path, cancel: &ide_core::CancellationToken) {
let call = format!("shell-{}", uuid::Uuid::new_v4().simple());
self.apply_local(&json!({
"sessionUpdate": "tool_call",
"toolCallId": call,
"title": format!("! {command}"),
"kind": "execute",
"status": "in_progress",
}));
let ran = shell::run(command, cwd, cancel).await;
let status = if ran.code == Some(0) { "completed" } else { "failed" };
self.apply_local(&json!({
"sessionUpdate": "tool_call_update",
"toolCallId": call,
"status": status,
"content": [{ "type": "content", "content": { "type": "text", "text": ran.shown() } }],
}));
self.state.lock().shell_context.push(ran.context(command));
self.persist();
}
fn push_entry(self: &Arc<Self>, entry: AgentEntry) -> usize {
let i = self.state.lock().conversation.main.push(entry);
self.mark_dirty([(None, i)]);
@@ -2431,7 +2500,14 @@ impl Task {
if !prompt.images.is_empty() && !live.capabilities.images {
return Err(Failure::from("This agent can't read images.".to_owned()));
}
let mut content = self.content(&live, prompt).await;
let shell = std::mem::take(&mut self.state.lock().shell_context);
let with_shell = |mut content: Vec<Value>| {
if !shell.is_empty() {
content.insert(0, json!({ "type": "text", "text": shell.join("\n") }));
}
content
};
let mut content = with_shell(self.content(&live, prompt).await);
let mut result: Result<Value, RpcError> =
live.peer.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None).await;
if live.driver == provider::Driver::Copilot
@@ -2453,7 +2529,7 @@ impl Task {
if !prompt.images.is_empty() && !live.capabilities.images {
return Err(Failure::from("This agent can't read images.".to_owned()));
}
content = self.content(&live, prompt).await;
content = with_shell(self.content(&live, prompt).await);
result = live
.peer
.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None)
@@ -3709,21 +3785,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
+272 -15
Переглянути файл
@@ -24,7 +24,9 @@ use std::process::Command;
use std::time::Duration;
pub const REGISTRY_URL: &str = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
const COPILOT_RELEASE_BASE: &str = "https://github.com/github/copilot-cli/releases/download";
const MAX_REGISTRY_BYTES: u64 = 1024 * 1024;
const MAX_CHECKSUM_BYTES: u64 = 64 * 1024;
/// [`maintain`] refreshes a saved index older than this, so updates show without opening
/// the registry.
const REFRESH_AFTER: Duration = Duration::from_secs(24 * 60 * 60);
@@ -142,6 +144,9 @@ struct Binary {
env: BTreeMap<String, String>,
#[serde(default)]
sha256: Option<String>,
/// Checksum manifest (`SHA256SUMS.txt`) naming `archive`'s filename when `sha256` is not inline.
#[serde(skip)]
sha256_url: Option<String>,
}
#[derive(Clone, Debug, Deserialize)]
@@ -172,11 +177,48 @@ fn parse(text: &str) -> IdeResult<Vec<Entry>> {
if let Some(name) = provider::builtin_name(&e.id) {
e.name = name.to_owned();
}
if e.id == "copilot" {
add_copilot_release_binaries(&mut e, COPILOT_RELEASE_BASE);
}
e
})
.collect())
}
/// Upstream `github-copilot-cli` lists only an `npx` wrapper in the ACP Registry, while
/// `github/copilot-cli` publishes standalone archives and `SHA256SUMS.txt` on every GitHub
/// release. Supplying them installs Copilot without Node.js, npm, `~/.npmrc`, or mirror lag.
fn add_copilot_release_binaries(entry: &mut Entry, release_base: &str) {
let tag = format!("v{}", entry.version.trim_start_matches('v'));
let base = format!("{}/{}", release_base.trim_end_matches('/'), tag);
let sha256_url = format!("{base}/SHA256SUMS.txt");
let (args, env) = match &entry.distribution.npx {
Some(p) => (p.args.clone(), p.env.clone()),
None => (vec!["--acp".into()], BTreeMap::new()),
};
let linux = if cfg!(target_env = "musl") { "linuxmusl" } else { "linux" };
let linux_arm = format!("copilot-{linux}-arm64.tar.gz");
let linux_x64 = format!("copilot-{linux}-x64.tar.gz");
let targets = [
("darwin-aarch64", "copilot-darwin-arm64.tar.gz", "./copilot"),
("darwin-x86_64", "copilot-darwin-x64.tar.gz", "./copilot"),
("linux-aarch64", linux_arm.as_str(), "./copilot"),
("linux-x86_64", linux_x64.as_str(), "./copilot"),
("windows-aarch64", "copilot-win32-arm64.zip", "copilot.exe"),
("windows-x86_64", "copilot-win32-x64.zip", "copilot.exe"),
];
for (key, asset, cmd) in targets {
entry.distribution.binary.entry(key.to_owned()).or_insert_with(|| Binary {
archive: format!("{base}/{asset}"),
cmd: cmd.to_owned(),
args: args.clone(),
env: env.clone(),
sha256: None,
sha256_url: Some(sha256_url.clone()),
});
}
}
fn safe_segment(s: &str) -> bool {
!s.is_empty()
&& !s.starts_with('.')
@@ -316,7 +358,7 @@ fn visible(
None
};
let choice = choose(e, platform, on_path);
let no_checksum = matches!(choice, Some(Choice::Binary(b)) if b.sha256.is_none());
let no_checksum = matches!(choice, Some(Choice::Binary(b)) if b.sha256.is_none() && b.sha256_url.is_none());
let distribution = choice.map(|c| c.kind());
if distribution.is_none() && installed.is_none() {
return None;
@@ -423,6 +465,20 @@ fn install_entry(
on_path: &dyn Fn(&str) -> bool,
cancel: &CancellationToken,
emit: Emit,
) -> IdeResult<()> {
install_entry_with(paths, entry, platform, on_path, &install_npm, cancel, emit)
}
type NpmInstaller = dyn Fn(&Package, &Entry, &Path, Platform, &CancellationToken, Emit) -> IdeResult<PathBuf>;
fn install_entry_with(
paths: &RegistryPaths,
entry: &Entry,
platform: Platform,
on_path: &dyn Fn(&str) -> bool,
npm_installer: &NpmInstaller,
cancel: &CancellationToken,
emit: Emit,
) -> IdeResult<()> {
if is_builtin(&entry.id) {
return Err(IdeError::invalid(format!("{} is built in", entry.name)));
@@ -443,9 +499,32 @@ fn install_entry(
}
fs::create_dir_all(&dir)?;
let installed = match &choice {
Choice::Binary(b) => install_binary(b, &dir, cancel, emit).map(|exe| (exe, b.args.clone(), b.env.clone())),
Choice::Binary(b) => match install_binary(b, &dir, cancel, emit) {
Ok(exe) => Ok((exe, b.args.clone(), b.env.clone())),
Err(e)
if !cancel.is_cancelled()
&& e.kind != ErrorKind::Cancelled
&& !e.message.starts_with("checksum mismatch:")
&& entry.distribution.npx.is_some()
&& on_path("npm")
&& on_path("node") =>
{
let p = entry.distribution.npx.as_ref().expect("checked");
emit(InstallEvent::Line {
text: format!("Binary download failed ({}); falling back to npm…", e.message),
});
fs::remove_dir_all(&dir)?;
fs::create_dir_all(&dir)?;
npm_installer(p, entry, &dir, platform, cancel, emit)
.map(|exe| (exe, p.args.clone(), p.env.clone()))
.map_err(|npm_err| {
IdeError::new(npm_err.kind, format!("{}; npm fallback failed: {}", e.message, npm_err.message))
})
}
Err(e) => Err(e),
},
Choice::Npx(p) => {
install_npm(p, entry, &dir, platform, cancel, emit).map(|exe| (exe, p.args.clone(), p.env.clone()))
npm_installer(p, entry, &dir, platform, cancel, emit).map(|exe| (exe, p.args.clone(), p.env.clone()))
}
Choice::Uvx(p) => {
install_uv(p, entry, &dir, platform, cancel, emit).map(|exe| (exe, p.args.clone(), p.env.clone()))
@@ -508,13 +587,23 @@ fn install_binary(b: &Binary, dir: &Path, cancel: &CancellationToken, emit: Emit
fs::create_dir_all(&downloads)?;
let file = downloads.join(name);
emit(InstallEvent::Line { text: format!("Downloading {}", b.archive) });
http()?.download(&b.archive, &file, None, cancel, emit)?;
match &b.sha256 {
Some(expected) => {
let http = http()?;
http.download(&b.archive, &file, None, cancel, emit)?;
match (&b.sha256, &b.sha256_url) {
(Some(expected), _) => {
verify_sha256(&file, expected)?;
emit(InstallEvent::Line { text: "SHA-256 checksum verified".into() });
}
None => emit(InstallEvent::Line { text: "The registry gives no checksum for this download".into() }),
(None, Some(checksum_url)) => {
check_url(checksum_url)?;
let text = http.get_text_limited(checksum_url, Some(MAX_CHECKSUM_BYTES), cancel)?;
let expected = ide_tools::sources::parse_checksum(&text, name).ok_or_else(|| {
IdeError::new(ErrorKind::Protocol, format!("no SHA-256 checksum for {name} in {checksum_url}"))
})?;
verify_sha256(&file, &expected)?;
emit(InstallEvent::Line { text: "SHA-256 checksum verified".into() });
}
(None, None) => emit(InstallEvent::Line { text: "The registry gives no checksum for this download".into() }),
}
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
@@ -567,6 +656,20 @@ fn install_npm(
platform: Platform,
cancel: &CancellationToken,
emit: Emit,
) -> IdeResult<PathBuf> {
let (name, _) = split_npm_spec(&p.package);
let npm = which::which("npm").map_err(|_| IdeError::unavailable(format!("npm is required to install {name}")))?;
install_npm_with(&npm, p, entry, dir, platform, cancel, emit)
}
fn install_npm_with(
npm: &Path,
p: &Package,
entry: &Entry,
dir: &Path,
platform: Platform,
cancel: &CancellationToken,
emit: Emit,
) -> IdeResult<PathBuf> {
let (name, version) = split_npm_spec(&p.package);
let spec = match version {
@@ -574,10 +677,27 @@ fn install_npm(
_ => format!("{name}@{}", entry.version),
};
check_spec(&spec)?;
let npm = which::which("npm").map_err(|_| IdeError::unavailable(format!("npm is required to install {name}")))?;
let mut cmd = Command::new(npm);
cmd.arg("install").arg("--prefix").arg(dir).args(["--no-audit", "--no-fund"]).arg(&spec).current_dir(dir);
ide_tools::run_streamed(cmd, cancel, emit)?;
let specs = [spec.clone()];
ide_tools::run_npm_with_public_fallback(
|extra| {
if !extra.is_empty() {
let _ = fs::remove_dir_all(dir.join("node_modules"));
}
let mut cmd = Command::new(npm);
cmd.arg("install")
.arg("--prefix")
.arg(dir)
.args(["--no-audit", "--no-fund"])
.args(extra)
.arg(&spec)
.current_dir(dir);
cmd
},
&specs,
false,
cancel,
emit,
)?;
let modules = dir.join("node_modules");
let manifest: serde_json::Value = fs::read_to_string(modules.join(name).join("package.json"))
.ok()
@@ -872,6 +992,58 @@ mod tests {
assert!(check_url("ftp://x/a").is_err());
}
#[cfg(unix)]
#[test]
fn npm_registry_agent_retries_against_public_npmjs_on_mirror_miss() {
let dir = tempfile::tempdir().unwrap();
let install_dir = dir.path().join("acme/1.2.0");
fs::create_dir_all(&install_dir).unwrap();
let log = dir.path().join("npm-calls.log");
let npm = dir.path().join("npm");
fs::write(
&npm,
format!(
r#"#!/bin/sh
echo "$@" >> '{}'
case " $* " in
*" --registry=https://registry.npmjs.org/ --@acme:registry=https://registry.npmjs.org/ "*)
prefix=""; while [ $# -gt 0 ]; do [ "$1" = "--prefix" ] && prefix="$2"; shift; done
mkdir -p "$prefix/node_modules/.bin" "$prefix/node_modules/@acme/agent-acp"
printf '#!/bin/sh\necho 1.2.0\n' > "$prefix/node_modules/.bin/agent-acp"
chmod +x "$prefix/node_modules/.bin/agent-acp"
printf '{{"bin":"cli.js"}}\n' > "$prefix/node_modules/@acme/agent-acp/package.json"
exit 0
;;
*)
echo "npm error code ETARGET" >&2
echo "npm error notarget No matching version found for @acme/[email protected]." >&2
exit 1
;;
esac
"#,
log.display()
),
)
.unwrap();
archive::make_executable(&npm).unwrap();
let index = r#"{"agents":[
{"id":"acme","name":"Acme","version":"1.2.0",
"distribution":{"npx":{"package":"@acme/[email protected]","args":["--acp"]}}}
]}"#;
let entry = parse(index).unwrap().remove(0);
let pkg = entry.distribution.npx.as_ref().unwrap();
let exe =
install_npm_with(&npm, pkg, &entry, &install_dir, MAC_ARM, &CancellationToken::new(), &|_| {}).unwrap();
let calls: Vec<String> = fs::read_to_string(&log).unwrap().lines().map(str::to_owned).collect();
assert_eq!(calls.len(), 2, "{calls:?}");
assert!(!calls[0].contains("--registry="), "{calls:?}");
assert!(calls[1].contains("--registry=https://registry.npmjs.org/"), "{calls:?}");
assert!(calls[1].contains("--@acme:registry=https://registry.npmjs.org/"), "{calls:?}");
assert_eq!(exe, install_dir.join("node_modules/.bin/agent-acp"));
assert!(exe.is_file());
}
#[test]
fn checksums_are_verified() {
let dir = tempfile::tempdir().unwrap();
@@ -969,11 +1141,18 @@ mod tests {
assert_eq!(entries.len(), 1);
assert_eq!((entries[0].id.as_str(), entries[0].name.as_str()), ("copilot", "GitHub Copilot"));
let shown = visible(&p, &entries, MAC_ARM, &|c| c == "npm" || c == "node");
// Copilot installs as a verified GitHub Release binary even without Node.js or npm.
let shown = visible(&p, &entries, MAC_ARM, &|_| false);
assert_eq!(shown.len(), 1);
assert_eq!(
(shown[0].id.as_str(), shown[0].name.as_str(), shown[0].installed.as_deref()),
("copilot", "GitHub Copilot", None)
(
shown[0].id.as_str(),
shown[0].name.as_str(),
shown[0].installed.as_deref(),
shown[0].distribution,
shown[0].no_checksum,
),
("copilot", "GitHub Copilot", None, Some(RegistryDistribution::Binary), false)
);
CustomAgent {
@@ -987,7 +1166,7 @@ mod tests {
.write(&p.agent_file("copilot"))
.unwrap();
let shown = visible(&p, &entries, MAC_ARM, &|c| c == "npm" || c == "node");
let shown = visible(&p, &entries, MAC_ARM, &|_| false);
assert_eq!((shown[0].installed.as_deref(), shown[0].update), (Some("1.0.104"), true));
write_atomic(&p.cache_file, index.as_bytes()).unwrap();
@@ -1007,4 +1186,82 @@ mod tests {
let fallback = provider::load(Some(&p.agents_dir), None).into_iter().find(|s| s.id == "copilot").unwrap();
assert_eq!(fallback.source, AgentSource::Builtin);
}
#[cfg(unix)]
#[test]
fn installs_copilot_from_verified_release_archive_and_falls_back_to_npm_when_unavailable() {
let dir = tempfile::tempdir().unwrap();
let p = paths(dir.path());
let served = dir.path().join("releases/v1.0.114");
fs::create_dir_all(&served).unwrap();
let archive = served.join("copilot-darwin-arm64.tar.gz");
let stage = dir.path().join("archive-stage");
fs::create_dir_all(&stage).unwrap();
let staged_exe = stage.join("copilot");
fs::write(&staged_exe, "#!/bin/sh\necho 1.0.114\n").unwrap();
archive::make_executable(&staged_exe).unwrap();
assert!(
Command::new("tar")
.arg("-czf")
.arg(&archive)
.arg("-C")
.arg(&stage)
.arg("copilot")
.status()
.unwrap()
.success()
);
let sha = ide_tools::sources::sha256_file(&archive).unwrap();
let sums = served.join("SHA256SUMS.txt");
fs::write(&sums, format!("{sha} copilot-darwin-arm64.tar.gz\n")).unwrap();
let index = r#"{"agents":[
{"id":"github-copilot-cli","name":"Copilot","version":"1.0.114",
"distribution":{"npx":{"package":"@github/[email protected]","args":["--acp"]}}}
]}"#;
let mut entry = parse(index).unwrap().remove(0);
entry.distribution.binary.clear();
add_copilot_release_binaries(&mut entry, &format!("file://{}", dir.path().join("releases").display()));
let fake_npm = |_: &Package, _: &Entry, dest: &Path, _: Platform, _: &CancellationToken, _: Emit| {
let exe = dest.join("node_modules/.bin/copilot");
fs::create_dir_all(exe.parent().unwrap())?;
fs::write(&exe, "#!/bin/sh\necho npm-1.0.114\n")?;
archive::make_executable(&exe)?;
Ok(exe)
};
let node_on_path = |cmd: &str| matches!(cmd, "npm" | "node");
let cancel = CancellationToken::new();
let lines = std::sync::Mutex::new(Vec::new());
let emit = |e: InstallEvent| {
if let InstallEvent::Line { text } = e {
lines.lock().unwrap().push(text);
}
};
// 1. Verified GitHub Release archive installs directly without invoking npm.
install_entry_with(&p, &entry, MAC_ARM, &|_| false, &fake_npm, &cancel, &emit).unwrap();
assert!(lines.lock().unwrap().iter().any(|l| l == "SHA-256 checksum verified"));
let installed_bin = p.tools_dir.join("copilot/1.0.114/copilot");
assert!(installed_bin.is_file());
let saved = CustomAgent::read(&p.agent_file("copilot")).unwrap();
assert_eq!(saved.command, installed_bin.to_string_lossy());
assert_eq!(saved.args, ["--acp"]);
// 2. A tampered binary fails checksum verification and never falls back to npm.
fs::write(&sums, format!("{} copilot-darwin-arm64.tar.gz\n", "0".repeat(64))).unwrap();
let err = install_entry_with(&p, &entry, MAC_ARM, &node_on_path, &fake_npm, &cancel, &emit).unwrap_err();
assert!(err.message.contains("checksum mismatch"), "{err:?}");
assert!(!p.tools_dir.join("copilot/1.0.114").exists());
// 3. When the release download itself is unreachable, npm fallback installs it.
fs::remove_file(&archive).unwrap();
lines.lock().unwrap().clear();
install_entry_with(&p, &entry, MAC_ARM, &node_on_path, &fake_npm, &cancel, &emit).unwrap();
assert!(lines.lock().unwrap().iter().any(|l| l.contains("falling back to npm")));
let npm_bin = p.tools_dir.join("copilot/1.0.114/node_modules/.bin/copilot");
assert!(npm_bin.is_file());
assert_eq!(CustomAgent::read(&p.agent_file("copilot")).unwrap().command, npm_bin.to_string_lossy());
}
}
+160
Переглянути файл
@@ -0,0 +1,160 @@
//! `!` commands from the composer: run in the task's folder with the user's shell, outside
//! any turn, and handed to the agent with the next message as Claude Code's bash mode does.
use ide_core::CancellationToken;
use std::path::Path;
use std::process::Stdio;
use tokio::io::AsyncReadExt;
use tokio::process::Command;
/// Output kept from each stream; longer output keeps its tail.
const MAX_STREAM: usize = 32 * 1024;
#[derive(Debug, Default, PartialEq)]
pub(crate) struct Ran {
/// The exit code; `None` when it didn't start, was stopped or ended by a signal.
pub code: Option<i32>,
pub stdout: String,
pub stderr: String,
/// Why it didn't finish: it couldn't start, or it was stopped.
pub error: Option<String>,
}
impl Ran {
/// What the conversation shows: the output, then how it ended unless it succeeded.
pub fn shown(&self) -> String {
let mut text = [self.stdout.trim_end(), self.stderr.trim_end()]
.into_iter()
.filter(|t| !t.is_empty())
.collect::<Vec<_>>()
.join("\n");
let end = match (&self.error, self.code) {
(Some(error), _) => Some(error.clone()),
(None, Some(0)) => None,
(None, Some(code)) => Some(format!("Exit code {code}")),
(None, None) => Some("Terminated".into()),
};
if let Some(end) = end {
if !text.is_empty() {
text.push('\n');
}
text.push_str(&end);
}
text
}
/// The block that goes to the agent ahead of the next message.
pub fn context(&self, command: &str) -> String {
let mut stderr = self.stderr.trim_end().to_owned();
if let Some(error) = &self.error {
if !stderr.is_empty() {
stderr.push('\n');
}
stderr.push_str(error);
} else if let Some(code) = self.code.filter(|c| *c != 0) {
if !stderr.is_empty() {
stderr.push('\n');
}
stderr.push_str(&format!("Exit code {code}"));
}
format!(
"<bash-input>{command}</bash-input>\n<bash-stdout>{}</bash-stdout><bash-stderr>{stderr}</bash-stderr>",
self.stdout.trim_end()
)
}
}
/// Runs `command` with the user's shell in `cwd` until it ends or `cancel` stops it.
pub(crate) async fn run(command: &str, cwd: &Path, cancel: &CancellationToken) -> Ran {
let mut cmd = shell(command);
ide_core::process::prepare(cmd.as_std_mut());
cmd.current_dir(cwd).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped()).kill_on_drop(true);
let mut child = match cmd.spawn() {
Ok(child) => child,
Err(e) => return Ran { error: Some(format!("Cannot run it: {e}")), ..Ran::default() },
};
let (Some(mut out), Some(mut err)) = (child.stdout.take(), child.stderr.take()) else {
return Ran { error: Some("Cannot read its output".into()), ..Ran::default() };
};
let finished = async move {
let (mut stdout, mut stderr) = (Vec::new(), Vec::new());
let _ = tokio::join!(out.read_to_end(&mut stdout), err.read_to_end(&mut stderr));
let code = child.wait().await.ok().and_then(|s| s.code());
Ran { code, stdout: tail(&stdout), stderr: tail(&stderr), error: None }
};
tokio::select! {
ran = finished => ran,
// Dropping the child kills it.
() = cancel.cancelled() => Ran { error: Some("Stopped".into()), ..Ran::default() },
}
}
#[cfg(not(windows))]
fn shell(command: &str) -> Command {
let shell = std::env::var("SHELL").ok().filter(|s| !s.trim().is_empty()).unwrap_or_else(|| "/bin/sh".into());
let mut cmd = Command::new(shell);
cmd.arg("-c").arg(command);
cmd
}
#[cfg(windows)]
fn shell(command: &str) -> Command {
let mut cmd = Command::new(std::env::var("COMSPEC").unwrap_or_else(|_| "cmd.exe".into()));
// `/S /C "…"` runs the line as typed: cmd strips only the outer quotes.
cmd.raw_arg("/D /S /C \"").raw_arg(command).raw_arg("\"");
cmd
}
fn tail(bytes: &[u8]) -> String {
let text = String::from_utf8_lossy(bytes);
if text.len() <= MAX_STREAM {
return text.into_owned();
}
let mut cut = text.len() - MAX_STREAM;
while !text.is_char_boundary(cut) {
cut += 1;
}
format!("…{}", &text[cut..])
}
#[cfg(all(test, not(windows)))]
mod tests {
use super::*;
#[tokio::test]
async fn runs_in_the_folder_and_reports_output_and_exit_code() {
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join("marker.txt"), "").unwrap();
let ran = run("ls; echo oops >&2; exit 3", dir.path(), &CancellationToken::new()).await;
assert_eq!(ran.code, Some(3));
assert_eq!(ran.stdout.trim(), "marker.txt");
assert_eq!(ran.stderr.trim(), "oops");
assert_eq!(ran.shown(), "marker.txt\noops\nExit code 3");
assert_eq!(
ran.context("ls"),
"<bash-input>ls</bash-input>\n<bash-stdout>marker.txt</bash-stdout><bash-stderr>oops\nExit code 3</bash-stderr>"
);
}
#[tokio::test]
async fn a_stopped_command_is_killed() {
let dir = tempfile::tempdir().unwrap();
let cancel = CancellationToken::new();
let stop = cancel.clone();
tokio::spawn(async move {
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
stop.cancel();
});
let started = std::time::Instant::now();
let ran = run("sleep 30", dir.path(), &cancel).await;
assert!(started.elapsed() < std::time::Duration::from_secs(5));
assert_eq!(ran.shown(), "Stopped");
}
#[test]
fn long_output_keeps_its_tail() {
let long = "x".repeat(MAX_STREAM + 10) + "end";
let kept = tail(long.as_bytes());
assert!(kept.starts_with('…') && kept.ends_with("end"));
}
}
+89 -1
Переглянути файл
@@ -59,6 +59,8 @@ struct FakeAgent {
session_steering: bool,
/// Records the `mcpServers` array passed to `session/new`, `session/load`, and `session/fork`.
mcp_calls: Mutex<Vec<(String, Vec<String>)>>,
/// The content blocks of each `session/prompt`.
prompts: Mutex<Vec<Value>>,
}
impl FakeAgent {
@@ -247,7 +249,17 @@ impl Handler for FakeAgent {
Ok(json!({}))
}
"session/prompt" => {
let text = params.pointer("/prompt/0/text").and_then(Value::as_str).unwrap_or_default().to_owned();
self.prompts.lock().push(params.get("prompt").cloned().unwrap_or(Value::Null));
// `!` commands run since the last message come first; the message follows.
let first = match params.pointer("/prompt/0/text").and_then(Value::as_str) {
Some(t) if t.starts_with("<bash-input>") => 1,
_ => 0,
};
let text = params
.pointer(&format!("/prompt/{first}/text"))
.and_then(Value::as_str)
.unwrap_or_default()
.to_owned();
if text.starts_with("<send_user_message_question_reply>") {
self.say(&session, "answer received");
return Ok(json!({"stopReason": "end_turn"}));
@@ -1361,6 +1373,79 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
}
#[cfg(not(windows))]
#[tokio::test(flavor = "multi_thread")]
async fn shell_commands_show_in_the_conversation_and_go_with_the_next_message() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let turns = agent.prompts.lock().len();
mgr.run_shell(&task.id, " echo shell-out ", ide_core::CancellationToken::new()).await.unwrap();
assert_eq!(agent.prompts.lock().len(), turns, "a `!` command starts no turn");
let entries = mgr.entries(&task.id, None).unwrap();
let Some(AgentEntry::Tool { title, kind, status, output, .. }) = entries.last() else {
panic!("no entry for the command: {entries:?}")
};
assert_eq!((title.as_str(), kind.as_str(), *status), ("! echo shell-out", "execute", AgentToolStatus::Completed));
assert_eq!(output.as_deref(), Some("shell-out"));
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_eq!(
sent.pointer("/0/text").and_then(Value::as_str),
Some(
"<bash-input>echo shell-out</bash-input>\n<bash-stdout>shell-out</bash-stdout><bash-stderr></bash-stderr>"
)
);
assert_eq!(sent.pointer("/1/text").and_then(Value::as_str), Some("again"));
// Only once.
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_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();
@@ -4318,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();
@@ -4445,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();
@@ -4469,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();
+20 -3
Переглянути файл
@@ -182,7 +182,7 @@ fn collect(
}
/// Scans every input, storing project inputs relative to the project.
fn scan_all(
pub(super) fn scan_all(
root: &Path,
inputs: Vec<PathBuf>,
cancel: &CancellationToken,
@@ -210,7 +210,7 @@ pub fn launch_fingerprint(
if projects.is_empty() {
return Ok(None);
}
let plan = launch_plan(root, model, module, test, BuildKind::Build)?;
let plan = launch_plan(root, model, module, test, BuildKind::Build, cancel)?;
let Some(collected) = collect(root, &projects, &plan, local_repo)? else { return Ok(None) };
let Collected { inputs, environment, steps, inherited_hash } = collected;
let parameters = serde_json::to_string(&(root, module, test, steps, environment, inherited_hash, projects))
@@ -229,7 +229,7 @@ pub fn menu_fingerprint(
file: Option<&Path>,
cancel: &CancellationToken,
) -> IdeResult<Option<LaunchFingerprint>> {
let plan = plan(root, model, BuildKind::Build, file, None)?;
let plan = plan(root, model, BuildKind::Build, file, None, None, cancel)?;
if plan.system != BuildSystem::Maven {
return Ok(None);
}
@@ -264,6 +264,23 @@ pub fn menu_fingerprint(
Ok(Some(LaunchFingerprint { version: 2, parameters, files: scan_all(root, inputs, cancel)? }))
}
/// Input fingerprint of one Maven module's menu build (#4078): its POM chain,
/// source and resource trees plus the launcher settings that shape the build.
/// `None` disables the module-scoped reuse (unresolved custom roots).
/// All filesystem work belongs on the caller's blocking thread.
pub(super) fn module_fingerprint(
root: &Path,
project: &maven::MavenProject,
cancel: &CancellationToken,
) -> IdeResult<Option<LaunchFingerprint>> {
let projects = [project];
let Some(inputs) = maven::launch_inputs(root, &projects, None) else { return Ok(None) };
let parameters =
serde_json::to_string(&("module-build", &project.dir, &project.command, &project.options, &project.env))
.map_err(|e| IdeError::internal(e.to_string()))?;
Ok(Some(LaunchFingerprint { version: 2, parameters, files: scan_all(root, inputs, cancel)? }))
}
impl LaunchFingerprint {
/// Folders (relative to the project) of the Maven projects whose POM is an input.
pub(super) fn project_dirs(&self) -> impl Iterator<Item = &Path> {
+168 -40
Переглянути файл
@@ -5,6 +5,7 @@
mod fingerprint;
mod launch_resources;
mod modules;
mod parse;
mod single;
mod structure;
@@ -12,6 +13,7 @@ mod up_to_date;
pub use fingerprint::{LaunchFingerprint, launch_fingerprint, menu_fingerprint};
pub use launch_resources::process_launch_resources;
pub use modules::record_module_build;
pub use single::{
SingleFileTarget, compile_file_plan, find_javac, javac_step, module_classpath, single_file_classpath,
single_file_target,
@@ -220,12 +222,16 @@ fn ancestors_within<'a>(root: &'a Path, file: &'a Path) -> impl Iterator<Item =
/// The build of `root`, or of the module containing `file` (Build Module / Recompile).
/// `cmake`: the CMake profiles of the settings (the first one is built), if any.
/// `cache` enables the module-scoped Maven narrowing of `Build` project builds;
/// `None` plans every build exactly as before.
pub fn plan(
root: &Path,
model: &BuildModel,
kind: BuildKind,
file: Option<&Path>,
cmake: Option<&[CMakeProfile]>,
cache: Option<&Path>,
cancel: &CancellationToken,
) -> IdeResult<BuildPlan> {
let project_name = root.file_name().map_or_else(|| "project".to_owned(), |n| n.to_string_lossy().into_owned());
let module_dir = match file {
@@ -262,7 +268,7 @@ pub fn plan(
None => project_name,
};
let steps = match system {
BuildSystem::Maven => maven_steps(root, model, kind, module_dir.as_deref())?,
BuildSystem::Maven => maven_steps(root, model, kind, module_dir.as_deref(), cache, cancel)?,
BuildSystem::Gradle => gradle_steps(root, model, kind, module_dir.as_deref())?,
BuildSystem::Cargo => cargo_steps(&dir, kind),
// Go builds the file's package (a module holds many).
@@ -281,6 +287,8 @@ pub(super) fn maven_steps(
model: &BuildModel,
kind: BuildKind,
module: Option<&Path>,
cache: Option<&Path>,
cancel: &CancellationToken,
) -> IdeResult<Vec<BuildStep>> {
let fallback;
let m = match &model.maven {
@@ -320,7 +328,15 @@ pub(super) fn maven_steps(
s.env = p.env.clone();
s
};
let Some(module) = module else { return Ok(tops.iter().map(|p| step(p, &[])).collect()) };
let Some(module) = module else {
if kind == BuildKind::Build
&& let Some(cache) = cache
&& let Some(steps) = modules::narrowed_maven_steps(cache, root, m, &step, cancel)?
{
return Ok(steps);
}
return Ok(tops.iter().map(|p| step(p, &[])).collect());
};
// The reactor root containing the module builds it with what it depends on (`-pl … -am`).
let rel = rel_str(root, module);
if !m.projects.iter().any(|p| p.dir == rel) {
@@ -881,8 +897,15 @@ pub fn launch_has_non_java_sources(root: &Path, model: &BuildModel, module: &Pat
has_non_java_sources(module)
}
fn launch_plan(root: &Path, model: &BuildModel, module: &Path, test: bool, kind: BuildKind) -> IdeResult<BuildPlan> {
let mut plan = plan(root, model, kind, Some(module), None)?;
fn launch_plan(
root: &Path,
model: &BuildModel,
module: &Path,
test: bool,
kind: BuildKind,
cancel: &CancellationToken,
) -> IdeResult<BuildPlan> {
let mut plan = plan(root, model, kind, Some(module), None, None, cancel)?;
if plan.system == BuildSystem::Maven && !test {
for step in &mut plan.steps {
if let Some(goal) = step.args.last_mut() {
@@ -909,7 +932,7 @@ pub fn build_for_launch(
kind: BuildKind,
cancel: &CancellationToken,
) -> IdeResult<LaunchBuild> {
let plan = launch_plan(root, model, module, test, kind)?;
let plan = launch_plan(root, model, module, test, kind, cancel)?;
let result = run(root, &plan, cancel, &|_| {})?;
let failure = if !result.success {
let errors: Vec<String> = result
@@ -974,7 +997,9 @@ mod tests {
write(root, "../external/main.go", "package main\nimport \"example.com/lib\"\nfunc main(){_ = lib.Value()}\n");
// std canonicalization also exercises verbatim paths on Windows.
for root in [root.to_path_buf(), std::fs::canonicalize(root).unwrap()] {
let plan = plan(&root, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
let plan =
plan(&root, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new())
.unwrap();
for step in plan.steps {
let result = std::process::Command::new(&go)
.args(&step.args)
@@ -1000,7 +1025,7 @@ mod tests {
let canonical = std::fs::canonicalize(&root).unwrap();
for root in [&root, &canonical, &canonical.join("..").join("workspace")] {
for kind in [BuildKind::Build, BuildKind::Rebuild, BuildKind::Artifacts] {
let p = plan(root, &BuildModel::default(), kind, None, None).unwrap();
let p = plan(root, &BuildModel::default(), kind, None, None, None, &CancellationToken::new()).unwrap();
assert_eq!(p.system, BuildSystem::Go);
assert_eq!(p.steps.len(), 3);
for (step, module) in p.steps.iter().zip(["api", "lib with spaces", "../shared"]) {
@@ -1015,20 +1040,30 @@ mod tests {
}
}
}
let member =
plan(&root, &BuildModel::default(), BuildKind::Build, Some(&root.join("api/pkg/a.go")), None).unwrap();
let member = plan(
&root,
&BuildModel::default(),
BuildKind::Build,
Some(&root.join("api/pkg/a.go")),
None,
None,
&CancellationToken::new(),
)
.unwrap();
assert_eq!(member.steps.len(), 1);
assert_eq!(member.steps[0].cwd, root.join("api"));
assert_eq!(member.steps[0].args, ["build", "./pkg/..."]);
write(&root, "go.work", "use ./missing\n");
assert!(
plan(&root, &BuildModel::default(), BuildKind::Build, None, None)
plan(&root, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new())
.unwrap_err()
.to_string()
.contains("go.mod")
);
write(&root, "go.work", "go 1.22\n");
assert!(plan(&root, &BuildModel::default(), BuildKind::Build, None, None).is_err());
assert!(
plan(&root, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).is_err()
);
}
#[test]
@@ -1049,11 +1084,21 @@ mod tests {
let mut model = crate::load_linked(root, &root.join("cache"), None, &Default::default(), &settings);
model.gradle[0].env.insert("JAVA_HOME".into(), "/jdk-a".into());
model.gradle[1].env.insert("JAVA_HOME".into(), "/jdk-b".into());
let all = super::plan(root, &model, super::BuildKind::Build, None, None).unwrap();
let all =
super::plan(root, &model, super::BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
assert_eq!(all.steps.len(), 2);
assert_eq!(all.steps[0].cwd, root.join("a"));
assert_eq!(all.steps[1].cwd, root.join("b"));
let module = super::plan(root, &model, super::BuildKind::Rebuild, Some(&root.join("b/app")), None).unwrap();
let module = super::plan(
root,
&model,
super::BuildKind::Rebuild,
Some(&root.join("b/app")),
None,
None,
&CancellationToken::new(),
)
.unwrap();
assert_eq!(module.steps.len(), 1);
assert_eq!(module.steps[0].program, root.join("b").join(wrapper).to_string_lossy());
assert_eq!(module.steps[0].cwd, root.join("b"));
@@ -1066,11 +1111,31 @@ mod tests {
let mut nested = model.gradle[1].projects[1].clone();
nested.path = ":b:app".into();
model.gradle[0].projects.push(nested);
let nested = super::plan(root, &model, super::BuildKind::Build, Some(&root.join("b/app")), None).unwrap();
let nested = super::plan(
root,
&model,
super::BuildKind::Build,
Some(&root.join("b/app")),
None,
None,
&CancellationToken::new(),
)
.unwrap();
assert_eq!(nested.steps[0].program, root.join("b").join(wrapper).to_string_lossy());
assert_eq!(nested.steps[0].args, ["--console=plain", ":app:classes", ":app:testClasses"]);
model.gradle.clear();
assert!(super::plan(root, &model, super::BuildKind::Build, Some(&root.join("b/app")), None).is_err());
assert!(
super::plan(
root,
&model,
super::BuildKind::Build,
Some(&root.join("b/app")),
None,
None,
&CancellationToken::new()
)
.is_err()
);
}
#[test]
@@ -1092,18 +1157,24 @@ mod tests {
};
let mut model = crate::load_linked(&root, &base.join("cache"), None, &Default::default(), &settings);
model.gradle[0].env.insert("JAVA_HOME".into(), "/external-jdk".into());
let all = super::plan(&root, &model, super::BuildKind::Build, None, None).unwrap();
let all =
super::plan(&root, &model, super::BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
assert_eq!(all.steps[0].cwd, external);
// Linked roots are saved with forward slashes, so on Windows the program mixes separators.
assert_eq!(std::path::Path::new(&all.steps[0].program), external.join(wrapper));
let module = super::plan(&root, &model, super::BuildKind::Rebuild, Some(&source), None).unwrap();
let module =
super::plan(&root, &model, super::BuildKind::Rebuild, Some(&source), None, None, &CancellationToken::new())
.unwrap();
assert_eq!(module.steps[0].cwd, external);
assert_eq!(module.steps[0].env["JAVA_HOME"], "/external-jdk");
assert_eq!(module.steps[0].args, ["--console=plain", ":app:clean", ":app:classes", ":app:testClasses"]);
let other = base.join("unlinked");
std::fs::create_dir(&other).unwrap();
std::fs::write(other.join("build.gradle"), "").unwrap();
assert!(super::plan(&root, &model, super::BuildKind::Build, Some(&other), None).is_err());
assert!(
super::plan(&root, &model, super::BuildKind::Build, Some(&other), None, None, &CancellationToken::new())
.is_err()
);
}
use super::*;
@@ -1144,7 +1215,7 @@ mod tests {
write(&root, "pom.xml", "<project><artifactId>demo</artifactId></project>");
let model = crate::load(&root, &tmp.path().join("cache"), None);
for (kind, expected) in [(BuildKind::Build, true), (BuildKind::Rebuild, true), (BuildKind::Artifacts, false)] {
let plan = plan(&root, &model, kind, None, None).unwrap();
let plan = plan(&root, &model, kind, None, None, None, &CancellationToken::new()).unwrap();
assert_eq!(
plan.steps[0].args.iter().any(|arg| arg == "-Djacoco.skip=true"),
expected,
@@ -1165,7 +1236,7 @@ mod tests {
write(&root, "core/pom.xml", "<project><artifactId>core</artifactId></project>");
write(&root, "core/src/main/java/A.java", "class A {}");
let model = crate::load(&root, &tmp.path().join("cache"), None);
let p = plan(&root, &model, BuildKind::Build, None, None).unwrap();
let p = plan(&root, &model, BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
assert_eq!(p.system, BuildSystem::Maven);
assert_eq!(p.title, "demo");
assert_eq!(p.steps.len(), 1);
@@ -1173,7 +1244,16 @@ mod tests {
p.steps[0].args,
["-B", "-Dstyle.color=never", maven::LOCAL_REPO_TRACKING_ARG, "-Djacoco.skip=true", "test-compile"]
);
let p = plan(&root, &model, BuildKind::Rebuild, Some(&root.join("core/src/main/java/A.java")), None).unwrap();
let p = plan(
&root,
&model,
BuildKind::Rebuild,
Some(&root.join("core/src/main/java/A.java")),
None,
None,
&CancellationToken::new(),
)
.unwrap();
assert_eq!(
p.steps[0].args,
[
@@ -1195,24 +1275,36 @@ mod tests {
write(&g, "settings.gradle", "include 'app'");
write(&g, "app/build.gradle", "apply plugin: 'java'");
let model = crate::load(&g, &tmp.path().join("cache2"), None);
let p = plan(&g, &model, BuildKind::Build, Some(&g.join("app/src/A.java")), None).unwrap();
let p =
plan(&g, &model, BuildKind::Build, Some(&g.join("app/src/A.java")), None, None, &CancellationToken::new())
.unwrap();
assert_eq!(p.system, BuildSystem::Gradle);
assert_eq!(p.steps[0].args, ["--console=plain", ":app:classes", ":app:testClasses"]);
assert_eq!(
plan(&g, &model, BuildKind::Artifacts, None, None).unwrap().steps[0].args,
plan(&g, &model, BuildKind::Artifacts, None, None, None, &CancellationToken::new()).unwrap().steps[0].args,
["--console=plain", "assemble"]
);
let c = tmp.path().join("c");
write(&c, "Cargo.toml", "[package]\nname='c'");
let p = plan(&c, &BuildModel::default(), BuildKind::Rebuild, None, None).unwrap();
let p =
plan(&c, &BuildModel::default(), BuildKind::Rebuild, None, None, None, &CancellationToken::new()).unwrap();
assert_eq!(p.system, BuildSystem::Cargo);
assert_eq!(p.steps.len(), 2);
assert_eq!(p.steps[0].args[0], "clean");
let go = tmp.path().join("go");
write(&go, "go.mod", "module x");
let p = plan(&go, &BuildModel::default(), BuildKind::Build, Some(&go.join("pkg/a/a.go")), None).unwrap();
let p = plan(
&go,
&BuildModel::default(),
BuildKind::Build,
Some(&go.join("pkg/a/a.go")),
None,
None,
&CancellationToken::new(),
)
.unwrap();
assert_eq!(p.steps[0].args, ["build", "./pkg/a/..."]);
assert_eq!(p.steps[0].cwd, go);
@@ -1220,9 +1312,11 @@ mod tests {
write(&ts, "package.json", r#"{"scripts":{"build":"vite build"}}"#);
write(&ts, "tsconfig.json", "{}");
write(&ts, "pnpm-lock.yaml", "");
let p = plan(&ts, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
let p =
plan(&ts, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
assert_eq!(p.steps[0].args, ["--noEmit", "--pretty", "false", "-p", "."]);
let p = plan(&ts, &BuildModel::default(), BuildKind::Artifacts, None, None).unwrap();
let p = plan(&ts, &BuildModel::default(), BuildKind::Artifacts, None, None, None, &CancellationToken::new())
.unwrap();
assert_eq!(
(p.steps[0].program.as_str(), p.steps[0].args.as_slice()),
("pnpm", &["run".to_owned(), "build".to_owned()][..])
@@ -1235,21 +1329,32 @@ mod tests {
write(&net, "src/Api/Api.csproj", "<Project/>");
write(&net, "src/Api/package.json", "{}");
write(&net, "src/Api/Program.cs", "");
let p = plan(&net, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
let p =
plan(&net, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
assert_eq!(p.system, BuildSystem::Dotnet);
assert_eq!(p.steps[0].args, ["build", "App.sln", "-nologo", "-clp:NoSummary"]);
assert_eq!(p.steps[0].env["MSBUILDTERMINALLOGGER"], "off");
let p = plan(&net, &BuildModel::default(), BuildKind::Rebuild, Some(&net.join("src/Api/Program.cs")), None)
.unwrap();
let p = plan(
&net,
&BuildModel::default(),
BuildKind::Rebuild,
Some(&net.join("src/Api/Program.cs")),
None,
None,
&CancellationToken::new(),
)
.unwrap();
assert_eq!(p.steps[0].args, ["build", "Api.csproj", "-nologo", "-clp:NoSummary", "--no-incremental"]);
assert_eq!(p.steps[0].cwd, net.join("src/Api"));
let p = plan(&net, &BuildModel::default(), BuildKind::Artifacts, None, None).unwrap();
let p = plan(&net, &BuildModel::default(), BuildKind::Artifacts, None, None, None, &CancellationToken::new())
.unwrap();
assert_eq!(p.steps[0].args[0], "publish");
let cm = tmp.path().join("cm");
write(&cm, "CMakeLists.txt", "project(app)");
let args = |p: &BuildPlan| p.steps.iter().map(|s| s.args.join(" ")).collect::<Vec<_>>();
let p = plan(&cm, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
let p =
plan(&cm, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
assert_eq!(p.system, BuildSystem::CMake);
assert_eq!(
args(&p),
@@ -1260,7 +1365,8 @@ mod tests {
"an unconfigured project is configured first"
);
write(&cm, "cmake-build-release/CMakeCache.txt", "");
let p = plan(&cm, &BuildModel::default(), BuildKind::Rebuild, None, None).unwrap();
let p =
plan(&cm, &BuildModel::default(), BuildKind::Rebuild, None, None, None, &CancellationToken::new()).unwrap();
assert_eq!(
args(&p),
["--build cmake-build-release --config Debug --clean-first"],
@@ -1272,17 +1378,34 @@ mod tests {
build_args: vec!["-j".into(), "8".into()],
..CMakeProfile::default()
};
let p =
plan(&cm, &BuildModel::default(), BuildKind::Build, None, Some(std::slice::from_ref(&profile))).unwrap();
let p = plan(
&cm,
&BuildModel::default(),
BuildKind::Build,
None,
Some(std::slice::from_ref(&profile)),
None,
&CancellationToken::new(),
)
.unwrap();
assert_eq!(args(&p), ["--build cmake-build-release --config Release -j 8"]);
let p = plan(&cm, &BuildModel::default(), BuildKind::Build, None, Some(&[CMakeProfile::default()])).unwrap();
let p = plan(
&cm,
&BuildModel::default(),
BuildKind::Build,
None,
Some(&[CMakeProfile::default()]),
None,
&CancellationToken::new(),
)
.unwrap();
assert_eq!(p.steps[0].args[..4], ["-S", ".", "-B", "cmake-build-debug"]);
let siblings = tmp.path().join("siblings");
write(&siblings, "core/pom.xml", "<project><artifactId>core</artifactId></project>");
write(&siblings, "system/pom.xml", "<project><artifactId>system</artifactId></project>");
let model = crate::load(&siblings, &tmp.path().join("cache3"), None);
let p = plan(&siblings, &model, BuildKind::Build, None, None).unwrap();
let p = plan(&siblings, &model, BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
assert_eq!(p.system, BuildSystem::Maven);
assert_eq!(
p.steps.iter().map(|s| s.cwd.clone()).collect::<Vec<_>>(),
@@ -1291,7 +1414,9 @@ mod tests {
let none = tmp.path().join("none");
std::fs::create_dir_all(&none).unwrap();
assert!(plan(&none, &BuildModel::default(), BuildKind::Build, None, None).is_err());
assert!(
plan(&none, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).is_err()
);
}
#[test]
@@ -1490,7 +1615,8 @@ mod tests {
let model = reactor_model();
for (test, goal) in [(false, "compile"), (true, "test-compile")] {
// A normal launch is incremental: no `clean` (IDEA's Make, not Rebuild).
let plan = launch_plan(root, &model, &root.join("app"), test, BuildKind::Build).unwrap();
let plan = launch_plan(root, &model, &root.join("app"), test, BuildKind::Build, &CancellationToken::new())
.unwrap();
let step = &plan.steps[0];
assert_eq!(step.cwd, root);
assert_eq!(step.program, "mvnw");
@@ -1511,7 +1637,9 @@ mod tests {
]
);
// Rebuild cleans first, as IDEA's Rebuild does.
let plan = launch_plan(root, &model, &root.join("app"), test, BuildKind::Rebuild).unwrap();
let plan =
launch_plan(root, &model, &root.join("app"), test, BuildKind::Rebuild, &CancellationToken::new())
.unwrap();
assert_eq!(
plan.steps[0].args,
[
+408
Переглянути файл
@@ -0,0 +1,408 @@
//! Module-scoped Maven menu builds (`Build Project` on a multi-module reactor, #4078).
//!
//! A project build used to run every linked reactor from end to end; only the
//! all-or-nothing up-to-date check could skip it, so one edited file anywhere
//! paid a full reactor build. This module narrows the scope: per-module input
//! fingerprints recorded after the last successful build tell which modules'
//! sources, resources, POM chain or outputs changed, the module dependency graph
//! spreads that to the modules depending on them, and the reactor runs
//! `mvn -pl <modules> -am` over just that set. Maven still decides what
//! recompiles inside the selected modules; `-am` keeps the upstream modules a
//! changed module was built against. Reactors without a usable record, and any
//! analysis that cannot resolve its inputs, build everything as before.
use super::up_to_date::restamp;
use super::*;
use std::fs;
/// The per-module input fingerprints of one reactor's last successful build.
#[derive(serde::Serialize, serde::Deserialize)]
struct ReactorRecord {
/// Module directory (project-relative, `/`-separated) → its record.
modules: BTreeMap<String, ModuleRecord>,
}
#[derive(serde::Serialize, serde::Deserialize)]
struct ModuleRecord {
fingerprint: LaunchFingerprint,
/// Output folders of the module that existed after the build, relative to the
/// project. Deleting one outside the IDE (`mvn clean` in a terminal) leaves every
/// input unchanged, so the module is rebuilt only while they are gone.
outputs: Vec<PathBuf>,
}
fn record_path(cache: &Path, top_dir: &str) -> PathBuf {
let base = cache.join("menu-build").join("modules");
if top_dir.is_empty() { base.join("root.json") } else { base.join(format!("{top_dir}.json")) }
}
fn load_record(cache: &Path, top_dir: &str) -> Option<ReactorRecord> {
let bytes = fs::read(record_path(cache, top_dir)).ok()?;
serde_json::from_slice(&bytes).ok()
}
/// Projects of `reactor` that (transitively) depend on one of `changed`, through
/// dependencies whose version matches the provider. The reverse of the launch
/// upstream walk: a changed module's new classes force its consumers to recompile,
/// `test`-scoped ones included, since the project build compiles every module's tests.
fn affected_projects(reactor: &[&maven::MavenProject], changed: &HashSet<String>) -> HashSet<String> {
let mut affected = changed.clone();
let mut pending: Vec<&str> = changed.iter().map(String::as_str).collect();
while let Some(dir) = pending.pop() {
let Some(upstream) = reactor.iter().find(|p| p.dir == dir) else { continue };
for consumer in reactor {
if affected.contains(&consumer.dir) {
continue;
}
let depends = consumer.dependencies.iter().any(|d| {
d.resolved()
&& upstream.group_id == d.group_id
&& upstream.artifact_id == d.artifact_id
&& d.version.as_ref().is_none_or(|v| *v == upstream.version)
});
if depends {
affected.insert(consumer.dir.clone());
pending.push(consumer.dir.as_str());
}
}
}
affected
}
/// `-pl` entries of the affected modules, relative to the reactor root the step
/// runs in, sorted so the command line does not depend on the model's project
/// order (Maven reorders the selection into its own reactor order anyway).
fn selection(reactor: &[&maven::MavenProject], top_dir: &str, affected: &HashSet<String>) -> String {
let mut entries: Vec<String> = reactor
.iter()
.filter(|p| affected.contains(&p.dir))
.map(|p| {
Path::new(&p.dir).strip_prefix(top_dir).unwrap_or(Path::new(&p.dir)).to_string_lossy().replace('\\', "/")
})
.collect();
entries.sort();
entries.join(",")
}
/// Narrowed `Build Project` steps: per reactor, one full step when the reactor
/// or most of it is affected, one `-pl <modules> -am` step for the affected
/// subset, or no step at all when nothing changed since the last successful
/// build. `None` = some module's inputs cannot be fingerprinted, so the caller
/// falls back to the unscoped build. The `step` closure builds a reactor step
/// with the caller's goals and options.
pub(super) fn narrowed_maven_steps(
cache: &Path,
root: &Path,
m: &maven::MavenModel,
step: &impl Fn(&maven::MavenProject, &[String]) -> BuildStep,
cancel: &CancellationToken,
) -> IdeResult<Option<Vec<BuildStep>>> {
let mut steps = Vec::new();
for top in m.projects.iter().filter(|p| !p.aggregated) {
let Some(record) = load_record(cache, &top.dir) else {
steps.push(step(top, &[]));
continue;
};
let reactor = reactor_projects(m, top);
let mut changed = HashSet::new();
let mut lying: Vec<PathBuf> = Vec::new();
for project in &reactor {
let Some(current) = fingerprint::module_fingerprint(root, project, cancel)? else {
return Ok(None);
};
let Some(recorded) = record.modules.get(&project.dir) else {
changed.insert(project.dir.clone());
continue;
};
if recorded.fingerprint != current {
changed.insert(project.dir.clone());
lying.extend(recorded.fingerprint.mtime_preserved_edits(&current));
}
if !recorded.outputs.iter().all(|out| root.join(out).is_dir()) {
changed.insert(project.dir.clone());
}
}
if changed.is_empty() {
continue;
}
let affected = affected_projects(&reactor, &changed);
restamp(root, &lying);
if affected.len() >= reactor.len() || affected.contains(&top.dir) {
steps.push(step(top, &[]));
} else {
let pl = selection(&reactor, &top.dir, &affected);
steps.push(step(top, &["-pl".into(), pl, "-am".into()]));
}
}
Ok(Some(steps))
}
/// Records the per-module inputs of every linked reactor as the baseline of the
/// next narrowed build. Failures are swallowed: a missing record only costs one
/// unscoped Maven run. Called after a successful project build.
pub fn record_module_build(cache: &Path, root: &Path, model: &BuildModel, cancel: &CancellationToken) {
let Some(m) = &model.maven else { return };
for top in m.projects.iter().filter(|p| !p.aggregated) {
let mut modules = BTreeMap::new();
for project in reactor_projects(m, top) {
let Ok(Some(fingerprint)) = fingerprint::module_fingerprint(root, project, cancel) else { continue };
let outputs = ["target/classes", "target/test-classes"]
.iter()
.map(|out| Path::new(&project.dir).join(out))
.filter(|rel| root.join(rel).is_dir())
.collect();
modules.insert(project.dir.clone(), ModuleRecord { fingerprint, outputs });
}
let path = record_path(cache, &top.dir);
if path.parent().is_some_and(|p| fs::create_dir_all(p).is_err()) {
continue;
}
let Ok(bytes) = serde_json::to_vec(&ReactorRecord { modules }) else { continue };
let _ = fs::write(&path, bytes);
}
}
#[cfg(test)]
mod tests {
use super::*;
fn write(root: &Path, rel: &str, value: &str) {
let path = root.join(rel);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, value).unwrap();
}
/// `other` ← nothing, `app` ← `mid` ← `lib`, all under one reactor root.
fn fixture(root: &Path) -> BuildModel {
write(
root,
"pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><groupId>t</groupId><artifactId>root</artifactId><version>1</version><packaging>pom</packaging><modules><module>lib</module><module>mid</module><module>app</module><module>other</module></modules></project>"#,
);
for (dir, class, deps) in [
("lib", "L", ""),
(
"mid",
"M",
"<dependencies><dependency><groupId>t</groupId><artifactId>lib</artifactId><version>1</version></dependency></dependencies>",
),
(
"app",
"A",
"<dependencies><dependency><groupId>t</groupId><artifactId>mid</artifactId><version>1</version></dependency></dependencies>",
),
("other", "O", ""),
] {
write(
root,
&format!("{dir}/pom.xml"),
&format!(
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>{dir}</artifactId>{deps}</project>"#
),
);
write(
root,
&format!("{dir}/src/main/java/t/{class}.java"),
&format!("package t; public class {class} {{}}"),
);
}
BuildModel { maven: Some(maven::load(root)), ..Default::default() }
}
fn steps(cache: &Path, root: &Path, model: &BuildModel) -> Option<Vec<BuildStep>> {
narrowed_maven_steps(
cache,
root,
model.maven.as_ref().unwrap(),
&|p, extra| {
let mut s = BuildStep::new(&p.command, &["-B"], &subdir(root, &p.dir), Format::Maven);
s.args.extend(extra.iter().cloned());
s.args.push("test-compile".into());
s
},
&CancellationToken::new(),
)
.unwrap()
}
fn pl_arg(step: &BuildStep) -> String {
let i = step.args.iter().position(|a| a == "-pl").unwrap();
step.args[i + 1].clone()
}
#[test]
fn changed_module_selects_itself_and_transitive_dependents() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = fixture(root);
let cache = root.join("cache");
record_module_build(&cache, root, &model, &CancellationToken::new());
write(root, "lib/src/main/java/t/L.java", "package t; public class L { int x; }");
let steps = steps(&cache, root, &model).unwrap();
assert_eq!(steps.len(), 1);
assert_eq!(pl_arg(&steps[0]), "app,lib,mid");
assert!(steps[0].args.contains(&"-am".into()));
}
#[test]
fn unchanged_reactor_runs_nothing() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = fixture(root);
let cache = root.join("cache");
record_module_build(&cache, root, &model, &CancellationToken::new());
assert!(steps(&cache, root, &model).unwrap().is_empty());
}
#[test]
fn missing_or_corrupt_record_builds_everything() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = fixture(root);
let cache = root.join("cache");
assert_eq!(steps(&cache, root, &model).unwrap().len(), 1);
record_module_build(&cache, root, &model, &CancellationToken::new());
fs::create_dir_all(cache.join("menu-build").join("modules")).unwrap();
fs::write(cache.join("menu-build").join("modules").join("root.json"), b"{not json").unwrap();
assert_eq!(steps(&cache, root, &model).unwrap().len(), 1);
}
#[test]
fn deleted_output_rebuilds_the_module_without_spreading() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = fixture(root);
let cache = root.join("cache");
for out in ["mid/target/classes/t", "other/target/classes"] {
fs::create_dir_all(root.join(out)).unwrap();
}
record_module_build(&cache, root, &model, &CancellationToken::new());
fs::remove_dir_all(root.join("mid/target")).unwrap();
let steps = steps(&cache, root, &model).unwrap();
assert_eq!(pl_arg(&steps[0]), "app,mid");
}
#[test]
fn mtime_preserved_edit_is_restamped_before_the_build() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = fixture(root);
let cache = root.join("cache");
let rel = "lib/src/main/java/t/L.java";
write(root, rel, "package t; public class L { int x; }");
let mtime = fs::metadata(root.join(rel)).unwrap().modified().unwrap();
record_module_build(&cache, root, &model, &CancellationToken::new());
write(root, rel, "package t; public class L { int z; }");
fs::File::options().write(true).open(root.join(rel)).unwrap().set_modified(mtime).unwrap();
assert!(!steps(&cache, root, &model).unwrap().is_empty());
assert!(fs::metadata(root.join(rel)).unwrap().modified().unwrap() > mtime);
}
#[test]
fn test_scoped_consumers_are_rebuilt_and_version_mismatch_does_not_spread() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
write(
root,
"pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><groupId>t</groupId><artifactId>root</artifactId><version>1</version><packaging>pom</packaging><modules><module>lib</module><module>tester</module><module>v2</module></modules></project>"#,
);
write(
root,
"lib/pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>lib</artifactId></project>"#,
);
write(
root,
"tester/pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>tester</artifactId><dependencies><dependency><groupId>t</groupId><artifactId>lib</artifactId><version>1</version><scope>test</scope></dependency></dependencies></project>"#,
);
write(
root,
"v2/pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>v2</artifactId><dependencies><dependency><groupId>t</groupId><artifactId>lib</artifactId><version>2</version></dependency></dependencies></project>"#,
);
for module in ["lib", "tester", "v2"] {
write(root, &format!("{module}/src/main/java/t/{module}.java"), "package t;");
}
let model = BuildModel { maven: Some(maven::load(root)), ..Default::default() };
let cache = root.join("cache");
record_module_build(&cache, root, &model, &CancellationToken::new());
write(root, "lib/src/main/java/t/L.java", "package t; public class L {}");
let steps = steps(&cache, root, &model).unwrap();
// `tester`'s tests compile against `lib`.
assert_eq!(pl_arg(&steps[0]), "lib,tester");
}
#[test]
fn root_pom_change_selects_the_whole_reactor() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = fixture(root);
let cache = root.join("cache");
record_module_build(&cache, root, &model, &CancellationToken::new());
write(
root,
"pom.xml",
fs::read_to_string(root.join("pom.xml")).unwrap().replace("<modules>", "<!-- x --><modules>").as_str(),
);
let steps = steps(&cache, root, &model).unwrap();
assert_eq!(steps.len(), 1);
assert!(!steps[0].args.contains(&"-pl".into()));
}
/// A folder of two sibling reactors: `chain` (lib ← mid ← app) and `solo`.
fn two_reactors(root: &Path) -> BuildModel {
write(
root,
"chain/pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><groupId>t</groupId><artifactId>chain</artifactId><version>1</version><packaging>pom</packaging><modules><module>lib</module><module>mid</module><module>app</module></modules></project>"#,
);
for (dir, class, deps) in [
("lib", "L", ""),
(
"mid",
"M",
"<dependencies><dependency><groupId>t</groupId><artifactId>lib</artifactId><version>1</version></dependency></dependencies>",
),
(
"app",
"A",
"<dependencies><dependency><groupId>t</groupId><artifactId>mid</artifactId><version>1</version></dependency></dependencies>",
),
] {
write(
root,
&format!("chain/{dir}/pom.xml"),
&format!(
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>chain</artifactId><version>1</version></parent><artifactId>{dir}</artifactId>{deps}</project>"#
),
);
write(
root,
&format!("chain/{dir}/src/main/java/t/{class}.java"),
&format!("package t; public class {class} {{}}"),
);
}
write(
root,
"solo/pom.xml",
r#"<project><modelVersion>4.0.0</modelVersion><groupId>t</groupId><artifactId>solo</artifactId><version>1</version></project>"#,
);
write(root, "solo/src/main/java/t/S.java", "package t;");
BuildModel { maven: Some(maven::load(root)), ..Default::default() }
}
#[test]
fn unrelated_reactors_are_judged_separately() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = two_reactors(root);
let cache = root.join("cache");
record_module_build(&cache, root, &model, &CancellationToken::new());
write(root, "solo/src/main/java/t/S.java", "package t; public class S {}");
let steps = steps(&cache, root, &model).unwrap();
assert_eq!(steps.len(), 1);
assert_eq!(steps[0].cwd, subdir(root, "solo"));
}
}
+1 -1
Переглянути файл
@@ -41,7 +41,7 @@ fn record_path(cache: &Path, root: &Path, file: Option<&Path>) -> PathBuf {
/// Re-stamps files whose content changed without advancing mtime (git
/// checkout, external sync): timestamp-incremental Maven would otherwise skip
/// them as "unchanged" and the rebuild would compile nothing.
fn restamp(root: &Path, edits: &[PathBuf]) {
pub(super) fn restamp(root: &Path, edits: &[PathBuf]) {
let now = std::time::SystemTime::now();
for rel in edits {
let path = root.join(rel);
+5 -5
Переглянути файл
@@ -78,14 +78,14 @@ fn has_kotlin_sources(root: &Path) -> bool {
})
}
fn plan(root: &Path, model: &BuildModel) -> IdeResult<compile::BuildPlan> {
fn plan(root: &Path, model: &BuildModel, cancel: &CancellationToken) -> IdeResult<compile::BuildPlan> {
if model.maven.as_ref().is_none_or(|m| m.projects.is_empty()) {
return Err(IdeError::invalid("Kotlin bridge requires a Maven build root"));
}
Ok(compile::BuildPlan {
system: compile::BuildSystem::Maven,
title: root.file_name().unwrap_or_default().to_string_lossy().into_owned(),
steps: compile::maven_steps(root, model, BuildKind::Build, None)?,
steps: compile::maven_steps(root, model, BuildKind::Build, None, None, cancel)?,
})
}
@@ -99,7 +99,7 @@ pub fn build(
cancel: &CancellationToken,
) -> IdeResult<Outcome> {
std::fs::create_dir_all(generation)?;
let mut plan = plan(root, model)?;
let mut plan = plan(root, model, cancel)?;
let mut manifests = Vec::new();
for (index, step) in plan.steps.iter_mut().enumerate() {
step.args.push("--fail-at-end".into());
@@ -522,7 +522,7 @@ mod tests {
}
std::fs::write(root.join("kotlin/App.kt"), "class App").unwrap();
assert!(has_kotlin(root, &model), "{marker}");
let plan = plan(root, &model).unwrap();
let plan = plan(root, &model, &CancellationToken::new()).unwrap();
assert_eq!(plan.system, compile::BuildSystem::Maven);
assert_eq!(plan.steps.len(), 2);
for (step, name) in plan.steps.iter().zip(["java", "kotlin"]) {
@@ -562,7 +562,7 @@ mod tests {
..Default::default()
};
assert!(has_kotlin(workspace.path(), &model));
assert_eq!(plan(workspace.path(), &model).unwrap().steps[0].cwd, external.path());
assert_eq!(plan(workspace.path(), &model, &CancellationToken::new()).unwrap().steps[0].cwd, external.path());
}
#[test]
+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`,
+100 -4
Переглянути файл
@@ -16,18 +16,55 @@ pub const CREATE_NO_WINDOW: u32 = 0x0800_0000;
/// For a `tokio::process::Command`, pass `cmd.as_std_mut()`.
///
/// - Windows: release builds use the GUI subsystem, so without `CREATE_NO_WINDOW` every
/// console child flashes a `cmd` window.
/// console child flashes a `cmd` window. Batch files also need a PATH small enough for cmd.
/// - Linux AppImage, reloaded and project variables: see [`host_env`].
///
/// Variables the call site has already set are kept; call it before `env_clear` and after
/// `current_dir`, which picks the project environment.
/// Explicit variables take precedence over the host environment. Call after setting
/// `current_dir` and any explicit `PATH`, and before `env_clear`.
pub fn prepare(cmd: &mut Command) -> &mut Command {
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
cmd.creation_flags(CREATE_NO_WINDOW);
}
host_env(cmd)
host_env(cmd);
#[cfg(windows)]
compact_batch_path(cmd);
cmd
}
#[cfg(windows)]
fn compact_batch_path(cmd: &mut Command) {
use std::os::windows::ffi::OsStrExt;
use std::path::{Component, Prefix};
// Rust runs these files through cmd.exe, which drops inherited variables over this limit.
const CMD_ENV_LIMIT: usize = 8191;
let extension = Path::new(cmd.get_program()).extension();
if !extension.is_some_and(|ext| ext.eq_ignore_ascii_case("cmd") || ext.eq_ignore_ascii_case("bat")) {
return;
}
let path = match cmd.get_envs().find(|(key, _)| key.eq_ignore_ascii_case("PATH")) {
Some((_, path)) => path.map(OsStr::to_owned),
None => std::env::var_os("PATH"),
};
let Some(path) = path.filter(|p| p.encode_wide().count() > CMD_ENV_LIMIT) else { return };
// The IDE includes possible locations of as-yet uninstalled tools. Prune paths that are
// missing now, keeping search precedence and leaving UNC and relative paths alone.
let dirs = std::env::split_paths(&path).filter(|dir| {
let local = dir.is_absolute()
&& matches!(dir.components().next(), Some(Component::Prefix(p))
if matches!(p.kind(), Prefix::Disk(_) | Prefix::VerbatimDisk(_)));
!local
|| !std::fs::symlink_metadata(dir)
.is_err_and(|e| matches!(e.kind(), std::io::ErrorKind::NotFound | std::io::ErrorKind::NotADirectory))
});
if let Ok(compact) = std::env::join_paths(dirs)
&& compact.encode_wide().count() <= CMD_ENV_LIMIT
{
cmd.env("PATH", compact);
}
}
/// Starts the child as the leader of its own process group on Unix, so [`kill_tree`] and
@@ -770,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");
@@ -885,6 +943,44 @@ mod tests {
assert!(!process_alive(pid));
}
#[cfg(windows)]
#[test]
fn batch_launch_keeps_runtime_paths_when_cmd_would_drop_path() {
let root = tempfile::tempdir().unwrap();
let script = root.path().join("server.CMD");
std::fs::write(&script, "@echo off\r\nif not defined PATH exit /b 42\r\n").unwrap();
let selected = root.path().join("Selected Runtime");
let fallback = root.path().join("Fallback Runtime");
std::fs::create_dir(&selected).unwrap();
std::fs::create_dir(&fallback).unwrap();
let relative = Path::new("relative");
let unc = Path::new(r"\\openidea-test\share\bin");
let missing = root.path().join("uninstalled-".repeat(12));
let path = std::env::join_paths(
std::iter::once(selected.as_path()).chain(std::iter::repeat_n(missing.as_path(), 60)).chain([
unc,
relative,
fallback.as_path(),
]),
)
.unwrap();
let compact = std::env::join_paths([selected.as_path(), unc, relative, fallback.as_path()]).unwrap();
let path_in = |cmd: &Command| {
cmd.get_envs()
.find_map(|(key, value)| key.eq_ignore_ascii_case("PATH").then(|| value.map(OsStr::to_owned)))
.flatten()
};
let mut cmd = Command::new(&script);
cmd.current_dir(root.path()).env("PATH", &path);
prepare(&mut cmd);
assert_eq!(path_in(&cmd), Some(compact));
assert!(cmd.status().unwrap().success());
let mut native = Command::new(root.path().join("server.exe"));
assert_eq!(path_in(prepare(native.env("PATH", &path))), Some(path));
}
#[cfg(unix)]
#[test]
fn process_alive_rejects_ids_that_are_not_a_single_process() {
+40
Переглянути файл
@@ -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(),
@@ -752,6 +771,8 @@ pub struct AppearanceSettings {
pub compact_mode: bool,
/// IDEA "Use smaller indents in trees": tool window trees indent less per level.
pub small_tree_indents: bool,
/// Linux: WebKit animates each mouse wheel step
pub smooth_scrolling: bool,
pub full_path_in_title: bool,
pub project_colors_in_toolbar: bool,
pub dnd_with_alt_only: bool,
@@ -770,6 +791,8 @@ pub struct AppearanceSettings {
pub show_tool_window_names: bool,
pub show_tool_window_badges: bool,
pub widescreen_tool_windows: bool,
/// Each tool window keeps its own size; off, the windows of a side share one.
pub remember_tool_window_sizes: bool,
/// View › Appearance › Toolbar; hidden leaves IDEA's compact window header.
pub show_main_toolbar: bool,
pub show_status_bar: bool,
@@ -885,6 +908,7 @@ impl Default for AppearanceSettings {
different_tool_window_background: false,
compact_mode: false,
small_tree_indents: false,
smooth_scrolling: true,
full_path_in_title: false,
project_colors_in_toolbar: true,
dnd_with_alt_only: false,
@@ -898,6 +922,7 @@ impl Default for AppearanceSettings {
show_tool_window_names: false,
show_tool_window_badges: true,
widescreen_tool_windows: false,
remember_tool_window_sizes: false,
show_main_toolbar: true,
show_status_bar: true,
navigation_bar: NavigationBarPosition::StatusBar,
@@ -1378,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,
}
@@ -1508,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 {
@@ -1752,6 +1782,16 @@ mod tests {
assert_eq!(kept.appearance.theme, "solarized-dark");
}
#[test]
fn smooth_scrolling_defaults_on_and_round_trips() {
let old: Settings = serde_json::from_str(r#"{"appearance":{"zoom":110}}"#).unwrap();
assert!(old.appearance.smooth_scrolling);
let off: Settings = serde_json::from_str(r#"{"appearance":{"smoothScrolling":false}}"#).unwrap();
assert!(!off.appearance.smooth_scrolling);
let json = serde_json::to_value(&off).unwrap();
assert_eq!(json["appearance"]["smoothScrolling"], false);
}
#[test]
fn window_close_settings_default_off_and_round_trip() {
for old in [r#"{}"#, r#"{"general":{"confirmExit":false}}"#] {
+2
Переглянути файл
@@ -239,6 +239,8 @@ pub enum SymbolKind {
Event,
Operator,
Key,
/// A Flutter widget built in the code (Flutter outline only).
Widget,
Unknown,
}
+52
Переглянути файл
@@ -20,6 +20,34 @@ pub struct VcsSettings {
pub shelf: ShelfSettings,
/// Issue Navigation: commit-message patterns turned into links.
pub issue_navigation: Vec<IssueLink>,
/// Directory Mappings: repository roots added to or excluded from the detected ones.
pub mappings: VcsMappings,
}
/// Directory Mappings on top of repository detection. Paths are relative to the project
/// root (`.` for the root itself) or absolute outside it.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct VcsMappings {
/// Detected repositories the IDE leaves alone: no Git or Commit integration, files stay.
pub excluded: Vec<String>,
/// Repository roots detection does not reach (outside the project, or deeper).
pub added: Vec<String>,
}
impl VcsMappings {
pub fn is_empty(&self) -> bool {
self.excluded.is_empty() && self.added.is_empty()
}
/// `path` resolved against `project_root`.
pub fn resolve(project_root: &std::path::Path, path: &str) -> std::path::PathBuf {
match path {
"" | "." => project_root.to_path_buf(),
p if std::path::Path::new(p).is_absolute() => p.into(),
p => project_root.join(p),
}
}
}
impl Default for VcsSettings {
@@ -34,6 +62,7 @@ impl Default for VcsSettings {
confirmation: VcsConfirmationSettings::default(),
shelf: ShelfSettings::default(),
issue_navigation: Vec::new(),
mappings: VcsMappings::default(),
}
}
}
@@ -77,6 +106,9 @@ pub struct GitSettings {
/// The non-modal Commit tool window works on the index: Staged / Unstaged groups,
/// stage and unstage instead of inclusion checkboxes, and no change lists.
pub staging_area: bool,
/// Scan the working tree with `git status` (for file systems whose metadata only
/// the system git reads correctly) instead of in process.
pub cli_status: bool,
}
impl Default for GitSettings {
@@ -101,6 +133,7 @@ impl Default for GitSettings {
push_dialog_only_protected: false,
combine_stash_and_shelf: false,
staging_area: false,
cli_status: false,
}
}
}
@@ -137,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 {
@@ -159,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(),
}
}
}
@@ -334,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,
}
@@ -354,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(),
}
}
@@ -412,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,
@@ -427,6 +475,8 @@ pub struct TerminalSettings {
/// `block` | `underline` | `bar`.
pub cursor_shape: String,
pub cursor_blink: bool,
/// Cap PTY→xterm paint rate: `unlimited` | `60` | `30` | `15` | `10`.
pub max_fps: String,
pub use_editor_font: bool,
pub font_family: String,
pub font_size: f32,
@@ -445,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,
@@ -458,6 +509,7 @@ impl Default for TerminalSettings {
escape_to_editor: false,
cursor_shape: "block".into(),
cursor_blink: true,
max_fps: "unlimited".into(),
use_editor_font: true,
font_family: "JetBrains Mono".into(),
font_size: 13.0,
+17
Переглянути файл
@@ -22,6 +22,8 @@ use tokio::process::{Child, Command};
pub const PORT_PLACEHOLDER: &str = "${port}";
/// Replaced by the session's working directory (the project) in adapter arguments.
pub const ROOT_PLACEHOLDER: &str = "${root}";
/// java-analyzer's debug adapter (`java-analyzer dap`), a separate process over stdio.
pub const JAVA_ANALYZER: &str = "java-analyzer";
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Transport {
@@ -134,6 +136,14 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
"tcp",
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
),
// The Java language server's own debugger, for modules jdtls doesn't serve; the host
// runs the executable of the java-analyzer serving the module.
JAVA_ANALYZER => cfg(
"java-analyzer",
&["dap"],
"stdio",
"Configure java-analyzer as a Java language server (Settings › Languages & Frameworks › Language Servers)",
),
"bun-dap" => cfg(
"bun-dap",
&["${port}", "127.0.0.1"],
@@ -920,6 +930,13 @@ mod tests {
}
let delve = resolve(&builtin("delve").unwrap(), PathBuf::from("/"));
assert_eq!(delve.transport, Transport::Tcp);
// java-analyzer debugs over stdio with its `dap` subcommand.
let java_analyzer = resolve(&builtin(JAVA_ANALYZER).unwrap(), PathBuf::from("/"));
assert_eq!(
(java_analyzer.command.as_str(), java_analyzer.args.as_slice()),
("java-analyzer", &["dap".to_owned()][..])
);
assert_eq!(java_analyzer.transport, Transport::Stdio);
// GDB's own DAP interpreter over stdio, with the required version in its hint.
let gdb = builtin("gdb").unwrap();
assert_eq!(gdb.command, "gdb");
+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"] }
+17 -3
Переглянути файл
@@ -32,7 +32,7 @@ struct Session {
/// The response format: a names line, a types line, then one JSON array per row, so rows past
/// the grid's limit are skipped without being parsed.
const FORMAT: &str = "JSONCompactEachRowWithNamesAndTypes";
const SESSION_LOST: &str = "ClickHouse HTTP session not found on this node (code 372). Use one node or session affinity, or set use_http_session=false in Advanced for independent queries.";
const SESSION_LOST: &str = "ClickHouse HTTP session expired or is missing on this node (code 372). Reconnect to start a new session. Behind a load balancer, use one node or session affinity, or set use_http_session=false in Advanced for independent queries.";
pub(crate) fn transaction_error() -> IdeError {
IdeError::invalid("ClickHouse HTTP does not support SQL transactions; use auto-commit and run writes directly")
@@ -133,7 +133,7 @@ impl ClickhousePool {
endpoint,
user: if source.user.is_empty() { "default".into() } else { source.user.clone() },
password: password.unwrap_or_default().to_owned(),
database: if database.is_empty() { "default".into() } else { database.into() },
database: database.into(),
settings,
read_only: source.read_only,
session: Mutex::new(Session {
@@ -233,7 +233,7 @@ impl ClickhousePool {
request = request.query(&[("session_check", "1")]);
}
}
if session.id.is_none() || !session.initialized {
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
request = request.query(&[("database", &self.0.database)]);
}
if self.0.read_only && !session.strict_read_only {
@@ -808,6 +808,19 @@ mod tests {
assert!(pool.execute("SELECT 1", 1, &CancellationToken::new()).await.is_err());
}
#[tokio::test]
async fn an_unset_database_uses_the_accounts_default_in_both_modes() {
for mode in ["true", "false"] {
let (port, requests) = server(vec![("200 OK", "", ONE); 2]).await;
let source = DataSource { properties: vec![property("use_http_session", mode)], ..source(port) };
let pool = Pool::connect(&source, None, None).await.unwrap();
pool.execute("SELECT 1", 1, &CancellationToken::new()).await.unwrap();
for request in requests.await.unwrap() {
assert_eq!(query_value(&request_url(&request), "database"), None);
}
}
}
#[tokio::test]
async fn stateless_requests_keep_database_settings_readonly_and_limits() {
let (port, requests) = server(vec![("200 OK", "", ONE); 3]).await;
@@ -855,6 +868,7 @@ mod tests {
let error = pool.execute(sql, 0, &CancellationToken::new()).await.unwrap_err();
assert!(error.message.contains("372"));
assert!(error.message.contains("one node or session affinity"));
assert!(error.message.contains("Reconnect"));
assert!(error.message.contains("use_http_session=false"));
pool.execute("SELECT 1", 1, &CancellationToken::new()).await.unwrap();
+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(())
}
File diff suppressed because it is too large. Load diff
+26
Переглянути файл
@@ -5,6 +5,7 @@
//! Every function blocks; callers run them off the UI / command threads.
mod connection;
mod engine;
mod model;
mod process;
@@ -114,6 +115,11 @@ fn failure(args: &[&str], stderr: &str, stdout: &str) -> IdeError {
/// Whether docker can be used right now.
pub fn availability(ep: &DockerEndpoint) -> DockerAvailability {
if docker_executable().is_none()
&& let Some(available) = engine::availability(ep, Duration::from_secs(15))
{
return available;
}
let Ok(cmd) = command(ep, &["version", "--format", "{{json .}}"]) else {
return DockerAvailability::NotInstalled;
};
@@ -125,6 +131,11 @@ pub fn availability(ep: &DockerEndpoint) -> DockerAvailability {
/// Availability plus containers, images, volumes and networks (listed in parallel).
pub fn snapshot(ep: &DockerEndpoint) -> DockerSnapshot {
if docker_executable().is_none()
&& let Some(listed) = engine::snapshot(ep, QUICK)
{
return listed;
}
let availability = availability(ep);
let executable = docker_executable().map(|p| ide_core::ipc_path::to_ipc(&p));
let mut snap = DockerSnapshot {
@@ -202,6 +213,11 @@ pub fn container_op(ep: &DockerEndpoint, ids: &[String], op: ContainerOp) -> Ide
if ids.is_empty() {
return Ok(());
}
if docker_executable().is_none()
&& let Some(ran) = engine::container_op(ep, ids, op, LIFECYCLE)
{
return ran;
}
let mut args = vec!["container", op.verb()];
args.extend(ids.iter().map(String::as_str));
run(ep, &args, LIFECYCLE).map(drop)
@@ -232,6 +248,11 @@ pub fn remove(ep: &DockerEndpoint, object: DockerObject, ids: &[String], force:
if ids.is_empty() {
return Ok(());
}
if docker_executable().is_none()
&& let Some(ran) = engine::remove(ep, object, ids, force, LIFECYCLE)
{
return ran;
}
let mut args = vec![object.noun(), "rm"];
if force && matches!(object, DockerObject::Container | DockerObject::Image | DockerObject::Volume) {
args.push("--force");
@@ -242,6 +263,11 @@ pub fn remove(ep: &DockerEndpoint, object: DockerObject, ids: &[String], force:
/// `docker inspect` of one object, pretty-printed.
pub fn inspect(ep: &DockerEndpoint, object: DockerObject, id: &str) -> IdeResult<String> {
if docker_executable().is_none()
&& let Some(inspected) = engine::inspect(ep, object, id, QUICK)
{
return inspected;
}
let out = run(ep, &["inspect", "--type", object.noun(), id], QUICK)?;
match serde_json::from_str::<serde_json::Value>(&out) {
// A one-element array for a single id: show the object itself.
+5 -5
Переглянути файл
@@ -211,10 +211,10 @@ pub fn parse_labels(raw: &str) -> BTreeMap<String, String> {
out
}
const COMPOSE_PROJECT: &str = "com.docker.compose.project";
const COMPOSE_SERVICE: &str = "com.docker.compose.service";
const COMPOSE_DIR: &str = "com.docker.compose.project.working_dir";
const COMPOSE_FILES: &str = "com.docker.compose.project.config_files";
pub(crate) const COMPOSE_PROJECT: &str = "com.docker.compose.project";
pub(crate) const COMPOSE_SERVICE: &str = "com.docker.compose.service";
pub(crate) const COMPOSE_DIR: &str = "com.docker.compose.project.working_dir";
pub(crate) const COMPOSE_FILES: &str = "com.docker.compose.project.config_files";
fn lines<T: for<'de> Deserialize<'de>>(text: &str) -> impl Iterator<Item = T> + '_ {
text.lines().filter(|l| l.trim_start().starts_with('{')).filter_map(|l| match serde_json::from_str::<T>(l) {
@@ -253,7 +253,7 @@ struct RawContainer {
networks: String,
}
fn split_csv(raw: &str) -> Vec<String> {
pub(crate) fn split_csv(raw: &str) -> Vec<String> {
raw.split(',').map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned).collect()
}
+1 -1
Переглянути файл
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
pub const MANIFEST_FILE: &str = "plugin.toml";
/// The plugin API (engine) version this host implements.
pub const ENGINE_VERSION: &str = "1.11.0";
pub const ENGINE_VERSION: &str = "1.13.0";
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
pub const LEGACY_API: &str = "0.1";
/// Marketplace categories, in the order they are shown.
+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();
+1
Переглянути файл
@@ -869,6 +869,7 @@ async fn occurrences(
scope,
max_matches: 0,
context,
include_excluded: false,
};
let host = call.host();
let request = crate::mcp::tool::request_id();
+8 -8
Переглянути файл
@@ -1,5 +1,5 @@
use super::page::{OFFSET, Page};
use super::scope::{self, Scope};
use super::search::{PathScope, paths_param};
use super::tool::{Call, Output, Param, ParamType, Tool};
use ide_core::{Diagnostic, IdeResult, Severity};
use serde_json::{Map, Value, json};
@@ -16,7 +16,7 @@ pub fn tools() -> Vec<Tool> {
Use this tool to explore current open editors.",
open_editors,
)
.param(scope::param()),
.param(paths_param()),
Tool::new(
"get_current_file",
"Returns the focused editor's file and selection reported by the IDE.
@@ -45,20 +45,20 @@ Lines and UTF-16 columns are 1-based.",
project_problems,
)
.param(Param::optional("errorsOnly", ParamType::Boolean, "Only errors (default) or warnings too"))
.param(scope::param())
.param(paths_param())
.param(Param::optional("limit", ParamType::Integer, "Problems to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET)),
]
}
async fn open_editors(call: Call) -> IdeResult<Output> {
let dir = Scope::of(&call)?;
let paths = PathScope::of(&call)?;
let windows = call.host.mcp_windows(call.root());
let open = call.host.mcp_reports.editors(&windows);
let active = call.host.mcp_reports.focused(call.window()).filter(|e| dir.contains(&e.path.0));
let active = call.host.mcp_reports.focused(call.window()).filter(|e| paths.matches_path(&e.path.0));
Output::json(json!({
"activeFilePath": active.map(|e| call.display(&e.path.0)),
"openFiles": open.iter().filter(|p| dir.contains(p)).map(|p| call.display(p)).collect::<Vec<_>>(),
"openFiles": open.iter().filter(|p| paths.matches_path(p)).map(|p| call.display(p)).collect::<Vec<_>>(),
}))
}
@@ -103,11 +103,11 @@ async fn file_problems(call: Call) -> IdeResult<Output> {
async fn project_problems(call: Call) -> IdeResult<Output> {
let page = Page::of(&call, PROBLEMS_LIMIT)?;
let errors_only = call.flag("errorsOnly", true)?;
let dir = Scope::of(&call)?;
let paths = PathScope::of(&call)?;
let files = call.host.mcp_reports.problems(&call.host.mcp_windows(call.root()));
let problems: Vec<(String, Value)> = files
.into_iter()
.filter(|f| dir.contains(&f.path.0))
.filter(|f| paths.matches_path(&f.path.0))
.flat_map(|f| {
let path = call.display(&f.path.0);
let wanted = f.items.into_iter().filter(|d| !errors_only || d.severity == Severity::Error);
+124 -14
Переглянути файл
@@ -8,9 +8,10 @@ use crate::mcp::util::{
self, RELATIVE_PATH_IN_PROJECT_DESCRIPTION, TIMED_OUT_DESCRIPTION, TIMEOUT_MILLISECONDS_DESCRIPTION,
};
use ide_core::{CancellationToken, IdeError, IdeResult};
use ide_search::FileMask;
use serde::Serialize;
use serde_json::json;
use std::path::Path;
use std::path::{Path, PathBuf};
use std::time::{Duration, Instant};
const DEFAULT_READ_LIMIT: i64 = 2000;
@@ -166,7 +167,9 @@ fn list_directory_tree() -> Tool {
"Provides a tree representation of the specified directory in the pseudo graphic format like `tree` utility does.
Use this tool to explore the contents of a directory or the whole project.
You MUST prefer this tool over listing directories via command line utilities like `ls` or `dir`.
A page that starts inside a directory repeats the lines of the directories above it.",
A page that starts inside a directory repeats the lines of the directories above it.
What `.gitignore` ignores is marked [git-ignored] and what the project excludes [ide-excluded]; entries inside a
marked directory are not marked again.",
|call| async move {
let directory = call.str("directoryPath")?;
let max_depth = call.opt_i64("maxDepth")?.unwrap_or(DEFAULT_TREE_DEPTH);
@@ -181,6 +184,12 @@ A page that starts inside a directory repeats the lines of the directories above
}
let deadline = Instant::now() + Duration::from_millis(timeout.max(0) as u64);
let cancel = call.cancel.clone();
let marks = Marks {
root: call.root().to_path_buf(),
excludes: FileMask::new(&[], &call.project().search_excludes()).ok(),
};
// The directory itself, when it or one above it is left out.
let root_mark = marker(ide_index::walk_skips(call.root(), &dir), marks.ide_excluded(&dir, true));
let mut tree = TreeRender {
out: String::new(),
errors: Vec::new(),
@@ -190,11 +199,12 @@ A page that starts inside a directory repeats the lines of the directories above
page,
seen: 0,
above: Vec::new(),
marks,
};
let tree = call
.host()
.blocking(move || {
tree.render(&dir, "", true, max_depth, true);
tree.render(&dir, "", true, max_depth, true, root_mark, !root_mark.is_empty());
Ok(tree)
})
.await?;
@@ -234,7 +244,8 @@ A page that starts inside a directory repeats the lines of the directories above
/// The `tree`-like listing: the directory's absolute path, then every entry (hidden and
/// ignored ones too) by lower-cased name, directories marked with `/`; entries outside the
/// page are counted, not listed.
/// page are counted, not listed. An entry left out of the project is marked, the entries
/// inside it are not.
struct TreeRender {
out: String,
errors: Vec<String>,
@@ -246,10 +257,48 @@ struct TreeRender {
seen: usize,
/// The lines of the directories above the entry, and whether this page shows them yet.
above: Vec<(String, bool)>,
marks: Marks,
}
/// What the project leaves out, to mark in the listing.
struct Marks {
root: PathBuf,
/// The project's exclusions (excluded folders, "Exclude files" names), as Find in Files applies them.
excludes: Option<FileMask>,
}
impl Marks {
fn ide_excluded(&self, path: &Path, is_dir: bool) -> bool {
let (Some(mask), Ok(rel)) = (&self.excludes, path.strip_prefix(&self.root)) else { return false };
let rel = rel.to_string_lossy().replace('\\', "/");
// A directory is excluded with the files in it.
!rel.is_empty() && !mask.matches(&if is_dir { format!("{rel}/x") } else { rel })
}
}
/// Spelled out, so that the listing says what it means.
fn marker(git_ignored: bool, ide_excluded: bool) -> &'static str {
match (git_ignored, ide_excluded) {
(true, true) => " [git-ignored] [ide-excluded]",
(true, false) => " [git-ignored]",
(false, true) => " [ide-excluded]",
(false, false) => "",
}
}
impl TreeRender {
fn render(&mut self, path: &Path, indent: &str, is_last: bool, max_depth: i64, is_root: bool) {
/// `mark`: the entry's marker; `marked`: it or a directory above it is marked.
#[allow(clippy::too_many_arguments)]
fn render(
&mut self,
path: &Path,
indent: &str,
is_last: bool,
max_depth: i64,
is_root: bool,
mark: &str,
marked: bool,
) {
if max_depth <= 0 || self.timed_out || self.cancel.is_cancelled() {
return;
}
@@ -268,7 +317,7 @@ impl TreeRender {
path.file_name().unwrap_or_default().to_string_lossy().into_owned()
};
let is_dir = path.is_dir() && !path.is_symlink();
let line = format!("{indent}{prefix}{name}{}\n", if is_dir { "/" } else { "" });
let line = format!("{indent}{prefix}{name}{}{mark}\n", if is_dir { "/" } else { "" });
let shown = if is_root {
self.out.push_str(&line);
true
@@ -278,22 +327,38 @@ impl TreeRender {
if !is_dir {
return;
}
let mut children: Vec<_> = match std::fs::read_dir(path) {
Ok(entries) => entries.filter_map(|e| e.ok().map(|e| e.path())).collect(),
// Without exclusions, `ignored` is what `.gitignore` says.
let mut children: Vec<(PathBuf, bool)> = match ide_vfs::read_dir(path, &[]) {
Ok(entries) => entries.into_iter().map(|e| (e.path.0, e.ignored)).collect(),
Err(e) => {
self.errors.push(format!("Failed to read {}: {e}", path.display()));
self.errors.push(format!("Failed to read {}: {}", path.display(), e.message));
return;
}
};
let key = |p: &std::path::PathBuf| p.file_name().unwrap_or_default().to_string_lossy().into_owned();
children.sort_by_cached_key(|p| (key(p).to_lowercase(), key(p)));
let key = |p: &PathBuf| p.file_name().unwrap_or_default().to_string_lossy().into_owned();
children.sort_by_cached_key(|(p, _)| (key(p).to_lowercase(), key(p)));
let child_indent = format!("{indent}{}", if is_last { " " } else { "│ " });
let n = children.len();
if !is_root {
self.above.push((line, shown));
}
for (i, child) in children.iter().enumerate() {
self.render(child, &child_indent, i + 1 == n, max_depth - 1, false);
// Inside a marked directory nothing is marked again.
for (i, (child, git_ignored)) in children.iter().enumerate() {
let child_mark = if marked {
""
} else {
let child_dir = child.is_dir() && !child.is_symlink();
marker(*git_ignored, self.marks.ide_excluded(child, child_dir))
};
self.render(
child,
&child_indent,
i + 1 == n,
max_depth - 1,
false,
child_mark,
marked || !child_mark.is_empty(),
);
}
if !is_root {
self.above.pop();
@@ -383,8 +448,9 @@ mod tests {
page: Page { offset, limit },
seen: 0,
above: Vec::new(),
marks: Marks { root: tmp.path().to_path_buf(), excludes: None },
};
tree.render(tmp.path(), "", true, 5, true);
tree.render(tmp.path(), "", true, 5, true, "", false);
let root = format!("{}/\n", tmp.path().display());
(tree.out.strip_prefix(&root).unwrap().to_owned(), tree.seen)
};
@@ -396,4 +462,48 @@ mod tests {
);
assert_eq!(render(0, 100).0, " ├── a/\n │ ├── x.txt\n │ └── y.txt\n └── b.txt\n");
}
#[test]
fn what_the_project_leaves_out_is_marked_once() {
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap();
for file in ["ign/deep/a.txt", "out/b.txt", "both/c.txt", "src/d.txt", "src/e.log"] {
let path = root.join(file);
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
std::fs::write(path, "").unwrap();
}
std::fs::write(root.join(".gitignore"), "ign/\nboth/\n*.log\n").unwrap();
let excludes = ["out/**".to_owned(), "both/**".to_owned()];
let mut tree = TreeRender {
out: String::new(),
errors: Vec::new(),
timed_out: false,
deadline: Instant::now() + Duration::from_secs(10),
cancel: CancellationToken::new(),
page: Page { offset: 0, limit: 100 },
seen: 0,
above: Vec::new(),
marks: Marks { root: root.clone(), excludes: FileMask::new(&[], &excludes).ok() },
};
tree.render(&root, "", true, 5, true, "", false);
let listing = tree.out.strip_prefix(&format!("{}/\n", root.display())).unwrap().to_owned();
assert_eq!(
listing,
[
" ├── .gitignore",
" ├── both/ [git-ignored] [ide-excluded]",
" │ └── c.txt",
" ├── ign/ [git-ignored]",
" │ └── deep/",
" │ └── a.txt",
" ├── out/ [ide-excluded]",
" │ └── b.txt",
" └── src/",
" ├── d.txt",
" └── e.log [git-ignored]",
"",
]
.join("\n")
);
}
}
+3 -2
Переглянути файл
@@ -10,8 +10,8 @@ mod files;
mod http;
mod page;
pub mod reports;
mod scope;
mod search;
pub mod service;
mod symbols;
mod tool;
mod util;
@@ -23,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;
@@ -56,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);
+3 -3
Переглянути файл
@@ -305,7 +305,7 @@ pub fn list_runs() -> Tool {
start of the command, exit code and times. `get_run_status` gives a tab's whole status.",
|call| async move {
let page = Page::of(&call, LIST_LIMIT)?;
let dir = crate::mcp::scope::Scope::of(&call)?;
let paths = crate::mcp::search::PathScope::of(&call)?;
let wanted = call.opt_str("state")?.filter(|s| s != "all");
let states = match wanted.as_deref() {
None => None,
@@ -327,7 +327,7 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
.rev()
.map(|r| r.status())
// A tab belongs where its command runs.
.filter(|s| dir.contains_shown(call.root(), s["workingDirectory"].as_str().unwrap_or_default()))
.filter(|s| paths.matches_dir(&call.root().join(s["workingDirectory"].as_str().unwrap_or_default())))
.filter(|s| {
states.as_ref().is_none_or(|states| s["state"].as_str().is_some_and(|v| states.contains(&v)))
})
@@ -344,7 +344,7 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
ParamType::String,
"all (default), running, idle (not running), error (failed, crashed, startFailed), or one state",
))
.param(crate::mcp::scope::param())
.param(crate::mcp::search::paths_param())
.param(Param::optional("limit", ParamType::Integer, "Tabs to return at most (default 10)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
+5 -3
Переглянути файл
@@ -139,12 +139,14 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
}
let page = Page::of(&call, CONFIGURATIONS_LIMIT)?;
let query = call.opt_str("query")?.map(|q| q.to_lowercase());
let dir = crate::mcp::scope::Scope::of(&call)?;
let paths = crate::mcp::search::PathScope::of(&call)?;
let list: Vec<Value> = configs
.iter()
// A configuration belongs where it runs.
.filter(|c| {
dir.contains(&c.cwd.as_deref().map_or_else(|| call.root().to_path_buf(), |d| call.root().join(d)))
paths.matches_dir(
&c.cwd.as_deref().map_or_else(|| call.root().to_path_buf(), |d| call.root().join(d)),
)
})
.filter(|c| {
query.as_ref().is_none_or(|q| {
@@ -169,7 +171,7 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
in the file instead of project-wide run configurations.",
))
.param(Param::optional("query", ParamType::String, "Only configurations whose name, type or command contains it"))
.param(crate::mcp::scope::param())
.param(crate::mcp::search::paths_param())
.param(Param::optional("limit", ParamType::Integer, "Configurations to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
-56
Переглянути файл
@@ -1,56 +0,0 @@
//! The `scope` argument of the query tools: the directory their results are limited to, a
//! folder of the project or a project attached to it.
use crate::mcp::tool::{Call, Param, ParamType};
use ide_core::{IdeError, IdeResult};
use std::path::{Path, PathBuf};
pub fn param() -> Param {
Param::optional(
"scope",
ParamType::String,
"Directory to limit results to: relative to the project root, or absolute",
)
}
/// No `scope`: everything.
pub struct Scope(Option<PathBuf>);
impl Scope {
pub fn of(call: &Call) -> IdeResult<Self> {
let Some(raw) = call.opt_str("scope")?.filter(|s| !s.trim().is_empty()) else { return Ok(Self(None)) };
let given = Path::new(raw.trim());
let path = crate::mcp::tool::normalize(&if given.is_absolute() {
given.to_path_buf()
} else {
call.root().join(given)
});
let roots: Vec<PathBuf> =
std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots()).collect();
// Before touching the file system: on Windows, resolving `\\host\share` signs in to that host.
if !ide_vfs::content_path_allowed(&path, &roots) {
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
}
let path = dunce::canonicalize(&path).unwrap_or(path);
if !path.is_dir() {
return Err(IdeError::not_found(format!("scope {raw} is not a directory")));
}
if !roots.iter().any(|root| path.starts_with(root)) {
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
}
Ok(Self(Some(path)))
}
pub fn dir(&self) -> Option<&Path> {
self.0.as_deref()
}
pub fn contains(&self, path: &Path) -> bool {
self.0.as_ref().is_none_or(|dir| path.starts_with(dir))
}
/// For a path the tools return: project-relative with `/`, or absolute.
pub fn contains_shown(&self, root: &Path, path: &str) -> bool {
self.0.is_none() || self.contains(&root.join(path))
}
}
+173 -65
Переглянути файл
@@ -6,7 +6,6 @@
//! the editor (one per character except emoji and other astral characters).
use crate::mcp::page::{OFFSET, Page};
use crate::mcp::scope::{self, Scope};
use crate::mcp::tool::{Call, Output, Param, ParamType, Tool};
use crate::mcp::util::{INDEXING_PARTIAL_RESULT_REASON, MEDIUM_TIMEOUT};
use crate::ops::search::SearchEvent;
@@ -37,8 +36,10 @@ const MIN_UNMASKED_MATCHES: usize = 10_000;
/// outside the window of a longer line are left out.
const LINE_WINDOW: usize = 500;
const PATHS_DESCRIPTION: &str = "Optional list of project-relative glob patterns to filter results. Supports '!' \
excludes. Trailing '/' expands to '**'. Patterns without '/' are treated as '**/pattern'. Empty strings are ignored.";
const INCLUDE_EXCLUDED_DESCRIPTION: &str = "Whether to include excluded/ignored files in results";
const PATHS_DESCRIPTION: &str = "Optional list of project-relative glob patterns to filter results (absolute ones for a \
project attached outside it). Supports '!' excludes. Trailing '/' expands to '**'. Patterns without '/' are treated as \
'**/pattern'. Empty strings are ignored.";
const LIMIT_DESCRIPTION: &str = "Results to return at most (default 100)";
const SYMBOL_LIMIT_DESCRIPTION: &str = "Results to return at most (default 50)";
const CONTEXT_DESCRIPTION: &str = "Lines around each match to return besides the matched line (`lineText`): \"+N\" the \
@@ -68,8 +69,8 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|call| async move { text_search(call, false).await },
)
.param(Param::required("q", ParamType::String, "Text to search for"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(paths_param())
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
.param(Param::optional("context", ParamType::String, CONTEXT_DESCRIPTION))
@@ -91,8 +92,8 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|call| async move { text_search(call, true).await },
)
.param(Param::required("q", ParamType::String, "Regex pattern to search for"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(paths_param())
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
.param(Param::optional("context", ParamType::String, CONTEXT_DESCRIPTION))
@@ -113,8 +114,7 @@ If you don't find a suitable result, try again with include_external=true to sea
|call| async move { symbol_search(call).await },
)
.param(Param::required("q", ParamType::String, "Symbol query text"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(paths_param())
.param(Param::optional(
"include_external",
ParamType::Boolean,
@@ -140,13 +140,8 @@ Paths are optional additional glob filters relative to the project root.",
|call| async move { file_search(call).await },
)
.param(Param::required("q", ParamType::String, "Glob pattern to search for"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(Param::optional(
"includeExcluded",
ParamType::Boolean,
"Whether to include excluded/ignored files in results",
))
.param(paths_param())
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
.output(result_schema())
@@ -336,22 +331,39 @@ async fn fill_lines(
// --- path globs ----------------------------------------------------------------
/// The `paths` argument: project-relative globs, `!` excludes.
struct PathScope {
/// The `paths` argument every query tool takes.
pub(crate) fn paths_param() -> Param {
Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION)
}
/// The `paths` argument: project-relative globs (absolute ones in a project attached outside
/// the project), `!` excludes. It only narrows: what the project leaves out stays out.
#[derive(Clone)]
pub(crate) struct PathScope {
root: PathBuf,
/// `None` when only excludes were given (everything is included).
include: Option<GlobSet>,
exclude: GlobSet,
/// The globs as `FileMask` masks for Find in Files (`{a,b}` expanded, as masks
/// split on commas), `None` when they cannot be expressed.
masks: Option<(Vec<String>, Vec<String>)>,
/// The folders the included globs lie in, `None` when one may match anywhere (`**/a.rs`).
roots: Option<Vec<PathBuf>>,
}
impl PathScope {
fn new(root: &Path, patterns: &[String]) -> IdeResult<Self> {
pub(crate) fn of(call: &Call) -> IdeResult<Self> {
Self::new(call.root(), &call.project().content_roots(), &call.str_list("paths")?)
}
/// `attached`: the content roots, whose files outside `root` the globs name by absolute path.
fn new(root: &Path, attached: &[PathBuf], patterns: &[String]) -> IdeResult<Self> {
let (mut include, mut exclude) = (GlobSetBuilder::new(), GlobSetBuilder::new());
let (mut include_masks, mut exclude_masks) = (Vec::new(), Vec::new());
let mut roots = Vec::new();
let mut has_include = false;
let mut maskable = true;
let mut anywhere = false;
for raw in patterns {
let raw = raw.trim();
if raw.is_empty() {
@@ -362,12 +374,18 @@ impl PathScope {
Some(rest) => (true, rest.trim()),
None => (false, raw),
};
let mut glob = normalize_glob(pattern, root)?;
let mut glob = normalize_glob(pattern, root, attached)?;
// A path naming an existing directory covers the files below it.
if index_of_glob_char(&glob).is_none() && root.join(&glob).is_dir() {
glob.push_str("/**");
}
let alternatives = expand_braces(&glob);
if !negated {
match glob_folder(&glob, root) {
Some(folder) => roots.push(folder),
None => anywhere = true,
}
}
let alternatives = expand_braces(&engine_mask(&glob, attached));
maskable &= alternatives.is_some();
let (set, masks) =
if negated { (&mut exclude, &mut exclude_masks) } else { (&mut include, &mut include_masks) };
@@ -376,27 +394,83 @@ impl PathScope {
has_include |= !negated;
}
let build = |b: GlobSetBuilder| b.build().map_err(|e| IdeError::invalid(format!("Invalid glob pattern: {e}")));
// A folder inside another one is walked with it.
roots.sort();
roots.dedup_by(|inner, outer| inner.starts_with(outer));
Ok(Self {
root: root.to_path_buf(),
include: if has_include { Some(build(include)?) } else { None },
exclude: build(exclude)?,
masks: maskable.then_some((include_masks, exclude_masks)),
roots: (has_include && !anywhere).then_some(roots),
})
}
fn is_all(&self) -> bool {
pub(crate) fn is_all(&self) -> bool {
self.include.is_none() && self.exclude.is_empty()
}
/// `path` is project-relative with `/` (absolute outside the project).
fn matches(&self, path: &str) -> bool {
pub(crate) fn matches(&self, path: &str) -> bool {
self.include.as_ref().is_none_or(|s| s.is_match(path)) && !self.exclude.is_match(path)
}
pub(crate) fn matches_path(&self, path: &Path) -> bool {
self.is_all() || self.matches(&shown(&self.root, path))
}
/// Whether `dir` or a file in it is in: a directory something runs in.
pub(crate) fn matches_dir(&self, dir: &Path) -> bool {
if self.is_all() {
return true;
}
let dir = shown(&self.root, dir);
self.matches(&dir) || self.matches(&if dir.is_empty() { "x".into() } else { format!("{dir}/x") })
}
/// The folders to walk instead of the whole project, `None` when a glob may match anywhere.
pub(crate) fn roots(&self) -> Option<&[PathBuf]> {
self.roots.as_deref()
}
}
/// `path` as the tools give it: relative to `root` with `/`, absolute (with `/`) outside it.
fn shown(root: &Path, path: &Path) -> String {
path.strip_prefix(root).unwrap_or(path).to_string_lossy().replace('\\', "/")
}
/// The folder a normalized glob lies in (the whole segments before its first glob character),
/// `None` for one that may match anywhere.
fn glob_folder(glob: &str, root: &Path) -> Option<PathBuf> {
let end = index_of_glob_char(glob).map_or(glob.len(), |i| glob[..i].rfind('/').unwrap_or(0));
let prefix = glob[..end].trim_end_matches('/');
if prefix.is_empty() {
return None;
}
let path = root.join(prefix);
// A file named by its path lies in its folder.
Some(if index_of_glob_char(glob).is_none() && !path.is_dir() { path.parent()?.to_path_buf() } else { path })
}
/// `glob` as Find in Files matches it: a project attached outside the project goes by its
/// folder name there (as `search_project` shows its files), not by its absolute path.
fn engine_mask(glob: &str, attached: &[PathBuf]) -> String {
if is_absolute_pattern(glob) {
for root in attached {
let shown = root.to_string_lossy().replace('\\', "/");
if let Some(rest) = glob.strip_prefix(&shown).filter(|r| r.is_empty() || r.starts_with('/')) {
return format!("{}{rest}", root.file_name().unwrap_or_default().to_string_lossy());
}
}
}
glob.to_owned()
}
/// A glob as a project-relative pattern: `\` → `/`, leading `./` dropped, `dir/` → `dir/**`,
/// `name` → `**/name`, and its leading directories (`..`, absolute paths) resolved against
/// `root`. Errors when that points outside the project.
fn normalize_glob(raw: &str, root: &Path) -> IdeResult<String> {
/// `root`; absolute in a project of `attached` outside it. Errors when that points outside the
/// project.
fn normalize_glob(raw: &str, root: &Path, attached: &[PathBuf]) -> IdeResult<String> {
let mut value = raw.trim().replace('\\', "/");
if value.is_empty() {
return Err(IdeError::invalid("Glob pattern is empty"));
@@ -411,7 +485,7 @@ fn normalize_glob(raw: &str, root: &Path) -> IdeResult<String> {
if !value.contains('/') {
value = format!("**/{value}");
}
let value = normalize_path_pattern(&value, root)?;
let value = normalize_path_pattern(&value, root, attached)?;
if value.is_empty() {
return Err(IdeError::invalid(format!("Invalid glob pattern: {raw}")));
}
@@ -421,7 +495,7 @@ fn normalize_glob(raw: &str, root: &Path) -> IdeResult<String> {
/// Resolves the whole directory segments before the first glob character against `root`.
/// (JetBrains resolves up to the glob character itself, turning `src/Foo*.java` into
/// `src/Foo/*.java`; only whole segments are resolved here.)
fn normalize_path_pattern(pattern: &str, root: &Path) -> IdeResult<String> {
fn normalize_path_pattern(pattern: &str, root: &Path, attached: &[PathBuf]) -> IdeResult<String> {
let outside = || {
IdeError::invalid(format!("Specified path '{pattern}' points to the location outside of the project directory"))
};
@@ -442,8 +516,16 @@ fn normalize_path_pattern(pattern: &str, root: &Path) -> IdeResult<String> {
} else {
root.join(prefix_path)
});
let relative = relative_to_root(root, &absolute).ok_or_else(outside)?;
let suffix = pattern[prefix_len..].trim_start_matches('/');
let Some(relative) = relative_to_root(root, &absolute) else {
// A project attached outside the project goes by its absolute path, as its files do.
let absolute = dunce::canonicalize(&absolute).unwrap_or(absolute);
if !attached.iter().any(|r| absolute.starts_with(r)) {
return Err(outside());
}
let absolute = absolute.to_string_lossy().replace('\\', "/");
return Ok(if suffix.is_empty() { absolute } else { format!("{absolute}/{suffix}") });
};
Ok(match (relative.is_empty(), suffix.is_empty()) {
(true, _) => suffix.to_owned(),
(false, true) => relative,
@@ -544,8 +626,7 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
let pattern = query(&call, if is_regex { "Regex pattern is empty" } else { "Search text is empty" })?;
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
let around = context(&call)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
let scope = PathScope::of(&call)?;
// Globs Find in Files cannot take are applied afterwards, so the engine must not
// stop at `limit` matches the filter may drop.
let (masks, max_matches) = match scope.masks.clone() {
@@ -565,22 +646,18 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
whole_word: false,
include,
exclude,
// Only `scope` is walked.
scope: dir.dir().map_or(SearchScope::Project, |d| SearchScope::Directory { path: d.to_path_buf().into() }),
scope: SearchScope::Project,
max_matches,
context: Default::default(),
include_excluded: call.flag("includeExcluded", false)?,
};
if is_regex && let Err(e) = ide_search::match_ranges("", &query) {
return Err(IdeError::invalid(format!("Invalid regex pattern: {pattern} ({})", e.message)));
}
let (files, summary, timed_out) = run_search(&call, query.clone()).await?;
// Content roots outside the project are reported by absolute path.
let mut files: Vec<(String, FileMatches)> = files
.into_iter()
.filter(|f| dir.contains(&f.path.0))
.map(|f| (call.display(&f.path.0), f))
.filter(|(path, _)| scope.matches(path))
.collect();
let mut files: Vec<(String, FileMatches)> =
files.into_iter().map(|f| (call.display(&f.path.0), f)).filter(|(path, _)| scope.matches(path)).collect();
files.sort_by(|a, b| a.0.cmp(&b.0));
// Only these can match a line break.
let may_span = is_regex || pattern.contains('\n');
@@ -750,27 +827,35 @@ async fn run_search(call: &Call, query: SearchQuery) -> IdeResult<(Vec<FileMatch
async fn file_search(call: Call) -> IdeResult<Output> {
let q = query(&call, "Glob pattern is empty")?;
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
let scope = PathScope::of(&call)?;
let include_excluded = call.flag("includeExcluded", false)?;
let glob = GlobSetBuilder::new()
.add(build_glob(&normalize_glob(&q, call.root())?)?)
.add(build_glob(&normalize_glob(&q, call.root(), &[])?)?)
.build()
.map_err(|_| IdeError::invalid(format!("Invalid glob pattern: {q}")))?;
// Ignored names and "Exclude files" patterns, which `read_dir` does not flag.
let excludes = if include_excluded { None } else { Some(FileMask::new(&[], &call.project().search_excludes())?) };
let root = call.root().to_path_buf();
// `scope`, or the project folder and the content roots its walk does not cover: those
// outside it and those inside it that it skips as ignored.
let roots: Vec<PathBuf> = match dir.dir() {
Some(dir) => vec![dir.to_path_buf()],
let content = call.project().content_roots();
// Where a folder's exclusions are matched from: the content root holding it, or the project.
let base_of =
|dir: &Path| content.iter().filter(|r| dir.starts_with(r)).max_by_key(|r| r.components().count()).cloned();
// The folders of `paths`, or the project folder and the content roots its walk does not
// cover: those outside it and those inside it that it skips as ignored.
let roots: Vec<(PathBuf, PathBuf)> = match scope.roots() {
Some(dirs) => dirs
.iter()
.filter(|d| d.is_dir())
.map(|d| (d.clone(), base_of(d).unwrap_or_else(|| root.clone())))
.collect(),
None => std::iter::once(root.clone())
.chain(
call.project()
.content_roots()
.into_iter()
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r)),
content
.iter()
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r))
.cloned(),
)
.map(|r| (r.clone(), r))
.collect(),
};
let host = call.host();
@@ -790,7 +875,7 @@ async fn file_search(call: Call) -> IdeResult<Output> {
let (paths, more, timed_out) = host
.blocking(move || {
let mut found = Vec::new();
let more = roots.iter().any(|base| walk.dir(base, base, &mut found));
let more = roots.iter().any(|(dir, base)| walk.dir(dir, base, &mut found));
if walk.cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
@@ -877,23 +962,23 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
let q = query(&call, "Search query is empty")?;
let (page, limit) = page(&call, SYMBOL_SEARCH_DEFAULT_LIMIT)?;
let around = context(&call)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
let scope = PathScope::of(&call)?;
let external = call.flag("include_external", false)?;
let host = call.host();
let project = call.project().clone();
let indexing_before = project.index.status().indexing;
let pool = if scope.is_all() { limit + 1 } else { ((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL) };
let found = {
let (project, q, dir) = (project.clone(), q.clone(), dir.dir().map(Path::to_path_buf));
let (project, q, within) = (project.clone(), q.clone(), scope.clone());
host.blocking(move || {
Ok(match dir {
Ok(if within.is_all() {
project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool)
} else {
// Filtered in the index: a pool cut before the filter could miss every match.
Some(dir) => project
project
.index
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| p.starts_with(&dir), &|| false)
.unwrap_or_default(),
None => project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool),
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| within.matches_path(p), &|| false)
.unwrap_or_default()
})
})
.await?
@@ -902,7 +987,6 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
.into_iter()
// By the path the other tools give: the index shows a root outside the project by its
// folder name, which is no path to read.
.filter(|s| dir.contains(&s.path.0))
.map(|s| (call.display(&s.path.0), s))
.filter(|(path, _)| scope.matches(path))
.map(|(path, s)| SearchItem {
@@ -920,11 +1004,11 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
roots.extend(crate::mcp::tool::attached_projects(call.root()));
for (name, container, location) in symbols {
let path = location.uri.clone().unwrap_or_else(|| call.display(&location.path));
// Project files (attached projects' too) obey `scope` and `paths`; library symbols
// are what was asked for.
// Project files (attached projects' too) obey `paths`; library symbols are what was
// asked for.
let inside = location.uri.is_none()
&& (!Path::new(&path).is_absolute() || roots.iter().any(|r| location.path.starts_with(r)));
if inside && !(dir.contains_shown(call.root(), &path) && scope.matches(&path)) {
if inside && !scope.matches(&path) {
continue;
}
let item = SearchItem {
@@ -999,13 +1083,13 @@ mod tests {
}
fn scope(root: &Path, p: &[&str]) -> PathScope {
PathScope::new(root, &p.iter().map(|s| s.to_string()).collect::<Vec<_>>()).unwrap()
PathScope::new(root, &[], &p.iter().map(|s| s.to_string()).collect::<Vec<_>>()).unwrap()
}
#[test]
fn normalizes_globs() {
let (_dir, root) = root();
let n = |p: &str| normalize_glob(p, &root);
let n = |p: &str| normalize_glob(p, &root, &[]);
assert_eq!(n("*.rs").unwrap(), "**/*.rs");
assert_eq!(n("./foo/bar.txt").unwrap(), "foo/bar.txt");
assert_eq!(n("foo/").unwrap(), "foo/**");
@@ -1082,9 +1166,33 @@ mod tests {
assert!(s.matches("a.rs") && !s.matches("docs/a.md"));
assert!(scope(root, &["*.{rs,ts}"]).masks.is_some());
assert!(scope(root, &["*.{rs,{ts,js}}"]).masks.is_none());
let err = |p: &str| PathScope::new(root, &[p.to_owned()]).err().unwrap().message;
let err = |p: &str| PathScope::new(root, &[], &[p.to_owned()]).err().unwrap().message;
assert!(err("a[").contains("Invalid glob pattern"));
assert!(err("!").contains("Exclude pattern is empty"));
assert!(err("../x/**").contains("outside of the project directory"));
}
#[test]
fn paths_name_the_folders_to_walk_and_projects_attached_outside() {
let (dir, root) = root();
let roots = |p: &[&str]| scope(&root, p).roots().map(<[PathBuf]>::to_vec);
// Only the folders the globs lie in, a folder inside another one walked with it.
assert_eq!(roots(&["subdir1/**", "subdir1/nested/*.rs", "!**/gen/**"]), Some(vec![root.join("subdir1")]));
assert_eq!(roots(&["subdir1/nested/x.rs"]), Some(vec![root.join("subdir1/nested")]));
// A glob matching anywhere, or none included, means the whole project.
assert_eq!(roots(&["subdir1/**", "**/*.rs"]), None);
assert_eq!(roots(&["!**/*.md"]), None);
let attached = dunce::canonicalize(dir.path()).unwrap().join("attached");
std::fs::create_dir_all(attached.join("src")).unwrap();
let shown = attached.to_string_lossy().replace('\\', "/");
let s = PathScope::new(&root, std::slice::from_ref(&attached), &[format!("{shown}/src/**")]).unwrap();
assert!(s.matches(&format!("{shown}/src/a.rs")) && !s.matches("src/a.rs"));
assert!(s.matches_path(&attached.join("src/a.rs")));
assert_eq!(s.roots(), Some(&[attached.join("src")][..]));
// Find in Files shows such a project's files under its folder name.
assert_eq!(s.masks.unwrap().0, ["attached/src/**"]);
let unattached = PathScope::new(&root, &[], &[format!("{shown}/src/**")]);
assert!(unattached.err().unwrap().message.contains("outside of the project directory"));
}
}
+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,
);
+8 -8
Переглянути файл
@@ -214,7 +214,7 @@ pub fn find_references() -> Tool {
Tool::new("find_references", "Find references using the language service and the IDE's project index. Positions are 1-based UTF-16. Reports incomplete results when analysis is still running.", |call| async move {
let path = call.resolve_readable(&call.str("filePath")?).await?;
let page = super::page::Page::of(&call, REFERENCES_LIMIT)?;
let dir = super::scope::Scope::of(&call)?;
let paths = super::search::PathScope::of(&call)?;
let opened = open_at(&call, path).await?;
let request = super::tool::request_id();
let work = crate::ops::lsp::lsp_references(&call.host, &call.window, request, opened.doc, opened.pos, call.flag("includeDeclaration", true)?, true, false, crate::ops::Channel::new(|_| {}));
@@ -237,8 +237,8 @@ pub fn find_references() -> Tool {
if let serde_json::Value::Object(map) = &mut value {
let mut list = |key: &str| match map.remove(key) { Some(serde_json::Value::Array(items)) => items, _ => Vec::new() };
let (mut locations, mut classified) = (list("locations"), list("classified"));
if dir.dir().is_some() {
let inside = |l: &serde_json::Value| l["path"].as_str().is_some_and(|p| dir.contains(std::path::Path::new(p)));
if !paths.is_all() {
let inside = |l: &serde_json::Value| l["path"].as_str().is_some_and(|p| paths.matches_path(std::path::Path::new(p)));
locations.retain(inside);
classified.retain(|c| inside(&c["location"]));
}
@@ -253,7 +253,7 @@ pub fn find_references() -> Tool {
.param(Param::required("line", ParamType::Integer, "1-based line"))
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
.param(Param::optional("includeDeclaration", ParamType::Boolean, "Include declarations (default true)"))
.param(super::scope::param())
.param(super::search::paths_param())
.param(Param::optional("limit", ParamType::Integer, "References to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
}
@@ -336,7 +336,7 @@ pub fn get_call_hierarchy() -> Tool {
.param(Param::required("line", ParamType::Integer, "1-based line"))
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
.param(Param::optional("direction", ParamType::String, "incoming (callers, default) or outgoing (callees)"))
.param(super::scope::param())
.param(super::search::paths_param())
.param(Param::optional("limit", ParamType::Integer, "Items to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
}
@@ -354,7 +354,7 @@ async fn call_hierarchy(call: Call) -> IdeResult<Output> {
Some(_) => return Err(IdeError::invalid("direction must be incoming or outgoing")),
};
let page = super::page::Page::of(&call, CALLS_LIMIT)?;
let scope = super::scope::Scope::of(&call)?;
let paths = super::search::PathScope::of(&call)?;
let path = call.resolve_readable(&call.str("filePath")?).await?;
let opened = open_at(&call, path).await?;
let hierarchy_at = |pos| {
@@ -378,8 +378,8 @@ async fn call_hierarchy(call: Call) -> IdeResult<Output> {
}
result => result?,
};
if scope.dir().is_some() {
found.items.retain(|i| i.uri.is_none() && scope.contains(&i.path.0));
if !paths.is_all() {
found.items.retain(|i| i.uri.is_none() && paths.matches_path(&i.path.0));
}
let incomplete = found.incomplete;
let (mut root, items) = call_items(found, |p| call.display(p));
+20 -14
Переглянути файл
@@ -266,33 +266,39 @@ By default all Git repositories are returned.",
.map(|r| (r.root.into_path_buf(), r.head))
.collect();
let wanted = call.opt_str("repositoryPathRelativeToProject")?;
let scope = super::scope::Scope::of(&call)?;
let paths = super::search::PathScope::of(&call)?;
let git = git_executable(&call);
// A repository asked for, or the one holding `scope`.
let target = match &wanted {
Some(wanted) => Some(call.resolve_inside(wanted)?),
None => scope.dir().map(Path::to_path_buf),
// The repository asked for, or those holding the folders of `paths`.
let targets: Vec<PathBuf> = match &wanted {
Some(wanted) => vec![call.resolve_inside(wanted)?],
None => paths.roots().map(<[PathBuf]>::to_vec).unwrap_or_default(),
};
let mut roots: Vec<(PathBuf, Option<String>)> = match target {
None => repos,
Some(path) => {
let mut roots: Vec<(PathBuf, Option<String>)> = if targets.is_empty() {
repos
} else {
let mut picked: Vec<(PathBuf, Option<String>)> = Vec::new();
for path in targets {
// The innermost repository containing the path.
match innermost_repo(repos, &path) {
Some(repo) => vec![repo],
let repo = match innermost_repo(repos.clone(), &path) {
Some(repo) => repo,
None => match find_git_root(call.root(), &path) {
Some(root) => {
// JetBrains reads the branch of any repository it reports.
let (git, dir) = (git.clone(), root.clone());
let branch = host.blocking(move || Ok(read_branch(&git, &dir))).await?;
vec![(root, branch)]
(root, branch)
}
None => {
let shown = wanted.unwrap_or_else(|| call.display(&path));
let shown = wanted.clone().unwrap_or_else(|| call.display(&path));
return Err(IdeError::not_found(format!("No git repository found for path: {shown}")));
}
},
};
if !picked.iter().any(|p| p.0 == repo.0) {
picked.push(repo);
}
}
picked
};
roots.sort_by_key(|r| relative_to_project(&call, &r.0));
let mut repositories = Vec::new();
@@ -305,7 +311,7 @@ By default all Git repositories are returned.",
.map_err(|e| {
IdeError::internal(format!("Failed to get git status for repository '{rel}': {}", e.message))
})?;
entries.retain(|e| scope.contains(&root.join(e.path.trim_end_matches('/'))));
entries.retain(|e| paths.matches_path(&root.join(e.path.trim_end_matches('/'))));
let count = |f: fn(&StatusEntry) -> bool| entries.iter().filter(|e| f(e)).count();
let listed: Vec<Value> = entries
.iter()
@@ -352,7 +358,7 @@ By default all Git repositories are returned.",
))
.param(Param::optional("includeUntracked", ParamType::Boolean, "Whether to include untracked files"))
.param(Param::optional("includeIgnored", ParamType::Boolean, "Whether to include ignored files"))
.param(super::scope::param())
.param(super::search::paths_param())
.param(Param::optional("limit", ParamType::Integer, "Entries to return per repository at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
+19
Переглянути файл
@@ -268,6 +268,24 @@ pub async fn agent_prompt(host: &Host, window: &str, task: String, prompt: Agent
host.project(window)?.agents.prompt(&task, prompt, now).await
}
/// Runs a `!` line of the composer in the task's folder with the user's shell, without
/// starting a turn; its output goes to the agent with the next message.
#[command(trust = trusted)]
pub async fn agent_shell(
host: &Host,
window: &str,
task: String,
command: String,
request: RequestId,
) -> IdeResult<()> {
host.require_trust(window)?;
let agents = host.project(window)?.agents.clone();
let cancel = host.begin_request(request);
let result = agents.run_shell(&task, &command, cancel).await;
host.end_request(request);
result
}
/// Answers a non-blocking question, without cancelling the current turn.
#[command(trust = trusted)]
pub async fn agent_answer_question(
@@ -1080,6 +1098,7 @@ ide_command::domain!(
agent_rollback_changes,
agent_send_queued_now,
agent_set_command,
agent_shell,
agent_set_config,
agent_set_env,
agent_set_mcp_overrides,
+57 -10
Переглянути файл
@@ -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();
@@ -815,7 +820,15 @@ pub async fn build_run(
if compile::menu_up_to_date(&cache, &root, &model, file.as_deref(), &token) {
let started = std::time::Instant::now();
let plan = prepare_plan(
compile::plan(&root, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref())?,
compile::plan(
&root,
&model,
kind,
file.as_deref(),
settings.cmake.profiles.as_deref(),
None,
&token,
)?,
&root,
&settings,
);
@@ -853,7 +866,15 @@ pub async fn build_run(
if member == &root { cache.clone() } else { cache.join(crate::project::project_key(member)) };
let model = with_profiles(load(member, &member_cache, &settings), &member_cache);
let plan = prepare_plan(
compile::plan(member, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref())?,
compile::plan(
member,
&model,
kind,
file.as_deref(),
settings.cmake.profiles.as_deref(),
None,
&token,
)?,
member,
&settings,
);
@@ -867,7 +888,15 @@ pub async fn build_run(
plan
} else {
let model = with_profiles(load(&root, &cache, &settings), &cache);
match compile::plan(&root, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref()) {
match compile::plan(
&root,
&model,
kind,
file.as_deref(),
settings.cmake.profiles.as_deref(),
Some(&cache),
&token,
) {
Ok(plan) => prepare_plan(plan, &root, &settings),
// No build tool: a Java project builds from its Project Structure.
Err(e) if e.kind == ide_core::error::ErrorKind::NotFound => {
@@ -882,6 +911,11 @@ pub async fn build_run(
if result.success && single && kind == BuildKind::Build {
let model = with_profiles(load(&root, &cache, &settings), &cache);
compile::record_menu_build(&cache, &root, &model, file.as_deref(), &token);
// Only a project build covers every changed module; after Build Module the
// others may still be stale.
if file.is_none() {
compile::record_module_build(&cache, &root, &model, &token);
}
}
for (path, items) in compile::diagnostics(&result.messages) {
sink.emit(IdeEvent::Diagnostics { path: path.into(), source: compile::DIAGNOSTICS_SOURCE.into(), items });
@@ -1015,7 +1049,16 @@ mod build_tool_settings_tests {
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join(marker), source).unwrap();
let plan = prepare_plan(
compile::plan(&dir, &Default::default(), BuildKind::Artifacts, None, None).unwrap(),
compile::plan(
&dir,
&Default::default(),
BuildKind::Artifacts,
None,
None,
None,
&ide_core::CancellationToken::new(),
)
.unwrap(),
root,
&settings,
);
@@ -1089,7 +1132,9 @@ mod build_tool_settings_tests {
let expected = root.join(if runner.is_empty() { "project-jdk" } else { runner });
let model = load(&root, &root.join("cache"), &settings);
assert_eq!(model.maven.as_ref().unwrap().projects[0].env["JAVA_HOME"], expected.to_string_lossy());
let plan = compile::plan(&root, &model, BuildKind::Build, None, None).unwrap();
let plan =
compile::plan(&root, &model, BuildKind::Build, None, None, None, &ide_core::CancellationToken::new())
.unwrap();
assert!(!plan.steps.is_empty());
for step in plan.steps {
assert_eq!(step.env["JAVA_HOME"], expected.to_string_lossy());
@@ -1121,7 +1166,9 @@ mod build_tool_settings_tests {
let expected = root.join(name);
let model = load(&root, &root.join("cache"), &settings);
assert_eq!(model.maven.as_ref().unwrap().projects[0].env["JAVA_HOME"], expected.to_string_lossy());
let plan = compile::plan(&root, &model, BuildKind::Build, None, None).unwrap();
let plan =
compile::plan(&root, &model, BuildKind::Build, None, None, None, &ide_core::CancellationToken::new())
.unwrap();
assert!(!plan.steps.is_empty());
for step in plan.steps {
assert_eq!(step.env["JAVA_HOME"], expected.to_string_lossy());
+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,
+38 -6
Переглянути файл
@@ -113,7 +113,11 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
})
.await?;
}
let java_analyzer = java_analyzer_command(host, window, &config)?;
let custom = |command: &str| {
if let Some(binary) = java_analyzer {
return Some(binary.to_string_lossy().into_owned());
}
let path = ide_sdk::apply::tool_command(&root, &settings, command)
.or_else(|| ruby_tools.into_iter().find(|(name, _)| *name == command).map(|(_, path)| path))?;
Some(path.to_string_lossy().into_owned())
@@ -142,6 +146,28 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
result
}
/// For java-analyzer's debugger, the executable of the java-analyzer serving the module
/// (`projectRoot`, else the working directory), so the session debugs with the server that
/// analyzes the code.
fn java_analyzer_command(host: &Host, window: &str, config: &LaunchConfig) -> IdeResult<Option<PathBuf>> {
if config.adapter != ide_dap::adapter::JAVA_ANALYZER {
return Ok(None);
}
let project = host.project(window)?;
let extra: serde_json::Value =
config.extra_json.as_deref().and_then(|e| serde_json::from_str(e).ok()).unwrap_or_default();
let module = extra["projectRoot"]
.as_str()
.map(PathBuf::from)
.or_else(|| config.cwd.clone().map(PathBuf::from))
.unwrap_or_else(|| project.root.clone());
project.lsp.java_analyzer_binary(&module).map(Some).ok_or_else(|| {
ide_core::IdeError::unavailable(
"No java-analyzer serves this module: configure it as a Java language server to debug without jdtls",
)
})
}
fn require_unity_editor(pid: u32) -> IdeResult<()> {
if !ide_core::process::process_alive(pid) {
return Err(ide_core::IdeError::unavailable(format!(
@@ -178,13 +204,16 @@ fn attach_jvm_inspector(host: &Host, window: &str, session: DebugSessionId, port
}
/// A JVM the debugger starts itself: an Application or Spring Boot configuration, launched by
/// java-debug or the Kotlin debugger (JAR Application debugs through a run with a JDWP agent).
/// java-debug, java-analyzer or the Kotlin debugger (JAR Application debugs through a run with a
/// JDWP agent).
fn is_jvm_launch(config: &LaunchConfig) -> bool {
config.request == "launch" && matches!(config.adapter.as_str(), "java-debug" | ide_dap::kotlin::ADAPTER)
config.request == "launch"
&& matches!(config.adapter.as_str(), "java-debug" | ide_dap::kotlin::ADAPTER | ide_dap::adapter::JAVA_ANALYZER)
}
/// Plugins' Java agents ([`ide_run::java_agent`]) after the configuration's VM options:
/// java-debug's `vmArgs` (one line, or a list) or the Kotlin debugger's `vmArguments` (a list).
/// java-debug's and java-analyzer's `vmArgs` (one line, or a list) or the Kotlin debugger's
/// `vmArguments` (a list).
fn add_java_agents(mut config: LaunchConfig, options: &[String]) -> LaunchConfig {
if options.is_empty() || !is_jvm_launch(&config) {
return config;
@@ -194,7 +223,7 @@ fn add_java_agents(mut config: LaunchConfig, options: &[String]) -> LaunchConfig
else {
return config;
};
let key = if config.adapter == "java-debug" { "vmArgs" } else { "vmArguments" };
let key = if config.adapter == ide_dap::kotlin::ADAPTER { "vmArguments" } else { "vmArgs" };
let value = match extra.get(key) {
None | Some(serde_json::Value::Null) if key == "vmArgs" => {
ide_run::java_agent::add_to_vm_args_text("", options).into()
@@ -328,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<()> {
@@ -735,6 +764,9 @@ mod tests {
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!(["-Xmx1g", agent]));
let kotlin = launch(ide_dap::kotlin::ADAPTER, "launch", serde_json::json!({}));
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!([agent]));
let java_analyzer =
launch(ide_dap::adapter::JAVA_ANALYZER, "launch", serde_json::json!({"vmArgs": ["-Xmx1g"]}));
assert_eq!(vm_args(&add_java_agents(java_analyzer, options)), serde_json::json!(["-Xmx1g", agent]));
// Attaching (remote debug included), other adapters, and no granted agent: unchanged.
for config in [
launch("java-debug", "attach", serde_json::json!({"vmArgs": "-Xmx1g"})),
+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);
+29 -7
Переглянути файл
@@ -3,6 +3,7 @@ use crate::Host;
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId};
use ide_vfs::FileEntry;
use ide_workspace::DeletionUndo;
use std::path::{Path, PathBuf};
#[command(trust = always)]
@@ -163,14 +164,27 @@ pub fn fs_set_writable(host: &Host, window: &str, path: PathBuf, writable: bool)
/// Moving to the trash can take a while (large trees): kept off the main thread.
#[command(trust = always)]
pub async fn fs_delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
// Local History keeps the contents so deleted files can be restored.
let project = host.project(window).ok();
let history = project.as_ref().map(|p| p.history.clone());
delete_with_history(host, window, path, false).await.map(|_| ())
}
/// Moves an item to the Trash and returns the snapshot for Project View Undo.
#[command(trust = always)]
pub async fn fs_delete_with_undo(host: &Host, window: &str, path: PathBuf) -> IdeResult<DeletionUndo> {
delete_with_history(host, window, path, true).await
}
async fn delete_with_history(host: &Host, window: &str, path: PathBuf, undoable: bool) -> IdeResult<DeletionUndo> {
let project = if undoable { Some(host.project(window)?) } else { host.project(window).ok() };
host.blocking(move || {
let paths = ide_workspace::file_ops::deletion_paths(&path)?;
if let Some(h) = history {
for p in &paths {
h.record_deletion(p, DELETE_SNAPSHOT_LIMIT);
let mut undo = DeletionUndo::default();
if let Some(p) = &project {
if undoable {
undo = p.history.capture_deletion_undo(&paths, DELETE_SNAPSHOT_LIMIT);
} else {
for pth in &paths {
p.history.record_deletion(pth, DELETE_SNAPSHOT_LIMIT);
}
}
}
ide_workspace::file_ops::delete(&path)?;
@@ -178,11 +192,17 @@ pub async fn fs_delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()
if let Some(p) = project {
let _ = p.with_backend_of(&path, |r| r.files_deleted(&paths));
}
Ok(())
Ok(undo)
})
.await
}
#[command(trust = always)]
pub async fn fs_undo_delete(host: &Host, window: &str, undo: DeletionUndo) -> IdeResult<Vec<ide_core::IpcPath>> {
let project = host.project(window)?;
host.blocking(move || Ok(project.history.restore_deletion_undo(undo))).await
}
#[command(trust = always)]
pub async fn fs_copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
let project = host.project(window).ok();
@@ -280,9 +300,11 @@ ide_command::domain!(
fs_create_file,
fs_create_file_bytes,
fs_delete,
fs_delete_with_undo,
fs_entry_kind,
fs_read_dir,
fs_read_text,
fs_rename,
fs_set_writable,
fs_undo_delete,
);
+168 -31
Переглянути файл
@@ -5,12 +5,14 @@ use crate::Host;
use ide_command::command;
use super::build::load;
use ide_build::BuildModel;
use ide_build::compile;
use ide_core::error::ErrorKind;
use ide_core::settings::Settings;
use ide_core::{CancellationToken, IdeError, IdeResult, RequestId};
use ide_lsp::jdtls::{JavaBuildStatus, JavaLaunchInfo};
use ide_run::BuildPolicy;
use std::path::PathBuf;
use std::path::{Path, PathBuf};
/// Cancellable with `cancel_request(request)`.
/// Builds according to `policy`, then resolves the runtime (or test)
@@ -45,6 +47,9 @@ pub(crate) async fn resolve_launch(
let started = std::time::Instant::now();
let project = host.project(window)?;
let module = project.root.join(module);
if !project.lsp.java_served_by_jdtls(&module) {
return resolve_launch_without_jdtls(host, &project, module, test, policy, cancel).await;
}
let settings = project.settings.effective();
// A launch builds incrementally unless the configuration asks for Rebuild or NoBuild.
let build = policy != BuildPolicy::NoBuild;
@@ -161,35 +166,7 @@ pub(crate) async fn resolve_launch(
}
}
let compile_ms = started.elapsed().as_millis() - lsp_ms;
// The module/project JDK, else the JDK jdtls compiles the module against, else one matching its Java version.
let project_jdk = ide_sdk::apply::module_jdk(&project.root, &module, &settings);
let from_jdtls = info.java_home.as_deref().map(ide_sdk::java::java_executable).filter(|p| p.is_file());
let java = project_jdk.map(|j| ide_sdk::java::java_executable(&j.home)).or(from_jdtls).or_else(|| {
// The build model's level includes what the module inherits from its parent POMs.
let release = model
.maven
.as_ref()
.and_then(|m| m.projects.iter().find(|p| project.root.join(&p.dir) == module))
.and_then(|p| p.java_version)
.or_else(|| ide_sdk::java::project_java_version(&module));
let jdks = ide_sdk::java::installed_jdks();
info.hints.extend(ide_sdk::java::missing_jdk_message(&jdks, release));
ide_sdk::java::pick_jdk(&jdks, release).map(|j| ide_sdk::java::java_executable(&j.home))
});
info.java_exec = Some(java.map(|p| p.to_string_lossy().into_owned()).unwrap_or_else(|| "java".to_owned()));
let exec = PathBuf::from(info.java_exec.as_deref().unwrap_or("java"));
let shorten =
ide_run::java_cmdline::shortening_for(&exec, &info.class_paths, &info.module_paths, cfg!(windows));
info.shorten_command_line = Some(shorten.as_str().to_owned());
if info.error_count > 0 {
let own = ide_sdk::lombok::agent_in_args(settings.languages.java.jdtls_vm_args.split_whitespace());
let managed = ide_tools::managed_bundle(&data_dir, "lombok");
let repo = ide_sdk::apply::maven_local_repository(&project.root, &settings);
let root = project.root.clone();
// Detection may read the project's sources.
let lombok = ide_sdk::lombok::lombok_agent(&root, own, managed, repo);
info.hints.extend(lombok.problem());
}
finish_launch(&mut info, &project.root, &module, &settings, &model, &data_dir);
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
@@ -206,6 +183,151 @@ pub(crate) async fn resolve_launch(
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// A launch of a module jdtls doesn't serve (another Java language server, or none): the
/// build tool compiles it, and the classpath comes from that server, else from Maven.
async fn resolve_launch_without_jdtls(
host: &Host,
project: &std::sync::Arc<crate::Project>,
module: PathBuf,
test: bool,
policy: BuildPolicy,
cancel: &CancellationToken,
) -> IdeResult<JavaLaunchInfo> {
let started = std::time::Instant::now();
let settings = project.settings.effective();
let kind = if policy == BuildPolicy::Rebuild { compile::BuildKind::Rebuild } else { compile::BuildKind::Build };
let (model, built) = {
let (root, cache, settings, module, cancel) =
(project.root.clone(), project.build_cache_dir(), settings.clone(), module.clone(), cancel.clone());
tokio::task::spawn_blocking(move || {
let model = load(&root, &cache, &settings);
let built = if policy == BuildPolicy::NoBuild {
None
} else {
Some(compile::build_for_launch(&root, &model, &module, test, kind, &cancel))
};
(model, built)
})
.await
.map_err(|e| IdeError::internal(e.to_string()))?
};
let mut info =
JavaLaunchInfo { path_list_separator: if cfg!(windows) { ";" } else { ":" }.into(), ..Default::default() };
let mut class_paths = Vec::new();
match built {
None => {}
Some(Err(e)) if e.kind == ErrorKind::Cancelled => return Err(e),
Some(Err(e)) => {
return Err(IdeError::unavailable(format!(
"Cannot build the module without jdtls: {}. Running needs a Maven or Gradle build, or jdtls",
e.message
)));
}
Some(Ok(built)) => {
info.build = Some(match built.failure {
None => JavaBuildStatus::Succeeded,
Some(failure) if policy == BuildPolicy::MakeAndContinueOnErrors => {
info.hints.push(failure);
JavaBuildStatus::Failed
}
Some(failure) => return Err(IdeError::internal(failure)),
});
class_paths.extend(built.class_dirs.iter().map(|p| p.to_string_lossy().into_owned()));
}
}
let build_ms = started.elapsed().as_millis();
let from_server = project.lsp.java_server_classpath(&module, test, cancel).await?;
let data_dir = host.local_data_dir.clone();
let project = project.clone();
let cancel = cancel.clone();
tokio::task::spawn_blocking(move || {
match from_server {
Some(server) => {
info.project_root = server.classpath.project_root;
info.module_paths = server.classpath.module_paths;
info.java_home = server.jdk_home.map(Into::into);
append_unique_class_paths(&mut class_paths, server.classpath.class_paths);
}
None => {
let is_maven = model
.maven
.as_ref()
.is_some_and(|m| m.projects.iter().any(|p| project.root.join(&p.dir) == module));
if !is_maven {
return Err(IdeError::unavailable(
"Cannot resolve the classpath: the Java language server does not report it \
(java-analyzer/projectClasspath), and the module is not a Maven project",
));
}
let local_repo = ide_sdk::apply::maven_local_repository(&project.root, &settings);
let classpath = compile::module_classpath(
&project.root,
&model,
&module,
test,
local_repo,
&project.build_cache_dir(),
&cancel,
)?;
append_unique_class_paths(
&mut class_paths,
std::env::split_paths(&classpath).map(|p| p.to_string_lossy().into_owned()),
);
}
}
info.class_paths = class_paths;
apply_library_classpath(&mut info, &project.root, &settings.project_structure.libraries, test);
finish_launch(&mut info, &project.root, &module, &settings, &model, &data_dir);
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
tracing::info!(build_ms, total_ms = started.elapsed().as_millis(), "Java launch resolved without jdtls");
Ok(info)
})
.await
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// Picks the `java` launcher and how to shorten its command line, and explains likely
/// causes of compile errors.
fn finish_launch(
info: &mut JavaLaunchInfo,
root: &Path,
module: &Path,
settings: &Settings,
model: &BuildModel,
data_dir: &Path,
) {
// The module/project JDK, else the JDK the Java language server builds the module with, else one
// matching its Java version.
let project_jdk = ide_sdk::apply::module_jdk(root, module, settings);
let from_server = info.java_home.as_deref().map(ide_sdk::java::java_executable).filter(|p| p.is_file());
let java = project_jdk.map(|j| ide_sdk::java::java_executable(&j.home)).or(from_server).or_else(|| {
// The build model's level includes what the module inherits from its parent POMs.
let release = model
.maven
.as_ref()
.and_then(|m| m.projects.iter().find(|p| root.join(&p.dir) == module))
.and_then(|p| p.java_version)
.or_else(|| ide_sdk::java::project_java_version(module));
let jdks = ide_sdk::java::installed_jdks();
info.hints.extend(ide_sdk::java::missing_jdk_message(&jdks, release));
ide_sdk::java::pick_jdk(&jdks, release).map(|j| ide_sdk::java::java_executable(&j.home))
});
info.java_exec = Some(java.map(|p| p.to_string_lossy().into_owned()).unwrap_or_else(|| "java".to_owned()));
let exec = PathBuf::from(info.java_exec.as_deref().unwrap_or("java"));
let shorten = ide_run::java_cmdline::shortening_for(&exec, &info.class_paths, &info.module_paths, cfg!(windows));
info.shorten_command_line = Some(shorten.as_str().to_owned());
if info.error_count > 0 {
let own = ide_sdk::lombok::agent_in_args(settings.languages.java.jdtls_vm_args.split_whitespace());
let managed = ide_tools::managed_bundle(data_dir, "lombok");
let repo = ide_sdk::apply::maven_local_repository(root, settings);
// Detection may read the project's sources.
let lombok = ide_sdk::lombok::lombok_agent(root, own, managed, repo);
info.hints.extend(lombok.problem());
}
}
/// With Settings › Maven › Delegate IDE build/run actions to Maven, javac's verdict replaces
/// JDT's. Classes JDT wrote for sources with errors look up to date to Maven's incremental
/// compiler, so a launch JDT reports errors for recompiles everything.
@@ -374,6 +496,21 @@ fn use_snapshot_on(
copies
}
/// The debug adapter for the JVMs of `module`: `java-debug` inside jdtls, or `java-analyzer`
/// (`java-analyzer dap`) when jdtls doesn't serve the module and java-analyzer does.
#[command(trust = trusted)]
pub fn java_debug_adapter(host: &Host, window: &str, module: PathBuf) -> IdeResult<String> {
let project = host.project(window)?;
let module = project.root.join(module);
let lsp = &project.lsp;
Ok(if !lsp.java_served_by_jdtls(&module) && lsp.java_analyzer_binary(&module).is_some() {
ide_dap::adapter::JAVA_ANALYZER
} else {
"java-debug"
}
.to_owned())
}
/// Port of java-debug's DAP server inside the jdtls serving `module` (started on demand).
#[command(trust = trusted)]
pub async fn java_debug_server(host: &Host, window: &str, module: PathBuf) -> IdeResult<u16> {
@@ -671,4 +808,4 @@ mod tests {
}
}
ide_command::domain!(java: java_build_workspace, java_debug_server, java_resolve_launch);
ide_command::domain!(java: java_build_workspace, java_debug_adapter, java_debug_server, java_resolve_launch);
+4
Переглянути файл
@@ -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,
@@ -98,6 +101,7 @@ ide_command::domains!(
plugins_commit: crate::plugins::commit,
plugins_index_ops: crate::plugins::index_ops,
plugins_run_targets: crate::plugins::run_targets,
plugins_search: crate::plugins::search,
plugins_views: crate::plugins::views,
project: crate::ops::project,
refactor: crate::ops::refactor,
+26
Переглянути файл
@@ -68,6 +68,31 @@ pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeRes
blocking(move || Ok(project.index.files_named(&name).into_iter().map(Into::into).collect())).await
}
/// The files of a custom scope (`file:src//*.ts`), for the Project view's scope panes.
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct ScopeFiles {
pub paths: Vec<IpcPath>,
/// More files than `limit` matched; `paths` holds the first ones.
pub truncated: bool,
}
#[command(trust = always)]
pub async fn scope_files(host: &Host, window: &str, pattern: String, limit: u32) -> IdeResult<ScopeFiles> {
let project = host.project(window)?;
blocking(move || {
let mask = ide_search::FileMask::new(&[], &project.search_excludes())?;
let scope = ide_search::SearchScope::Pattern { pattern };
let mut files =
ide_search::scope_files(&project.root, &scope, &mask, None, &ide_core::CancellationToken::new())?;
files.sort_by(|a, b| a.rel_path.cmp(&b.rel_path));
let truncated = files.len() > limit as usize;
files.truncate(limit as usize);
Ok(ScopeFiles { paths: files.into_iter().map(|f| f.path.into()).collect(), truncated })
})
.await
}
/// Folders holding indexed files, for `@` references.
#[command(trust = always)]
pub async fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
@@ -375,6 +400,7 @@ ide_command::domain!(
path_completions,
recent_files,
remove_recent,
scope_files,
web_goto,
web_unresolved_references,
);
+21 -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 {
@@ -302,6 +312,15 @@ pub fn set_settings(
}
});
}
// Directory Mappings change which repositories the project has.
if key == "vcs" || key == "vcs.mappings" || key.starts_with("vcs.mappings.") {
let affected = affected();
host.runtime.spawn_blocking(move || {
for project in affected {
project.refresh_repositories();
}
});
}
if key == "ssh" || key.starts_with("ssh.") {
host.ssh.set_configs(host.global_settings.effective().ssh.configs);
}
@@ -377,6 +396,7 @@ ide_command::domain!(
project_trust_set,
project_trust_status,
settings_get,
settings_get_global,
settings_removed_theme,
settings_set,
);
+12 -5
Переглянути файл
@@ -34,8 +34,10 @@ pub async fn search_start(
) -> IdeResult<()> {
let project = host.project(window)?;
// Excluded roots (Project Structure marks and detected `target`, `node_modules`, …) and
// ignored names are never searched.
query.exclude.extend(project.search_excludes());
// ignored names are not searched, unless the query asks for them.
if !query.include_excluded {
query.exclude.extend(project.search_excludes());
}
let cancel = host.begin_request(request);
let events = on_event.clone();
let syntax = host.syntax();
@@ -80,10 +82,15 @@ pub(crate) fn search_project(
query.scope,
ide_search::SearchScope::Directory { .. } | ide_search::SearchScope::Files { .. }
));
let content_roots = match query.scope {
let content_roots: Vec<std::path::PathBuf> = match query.scope {
ide_search::SearchScope::Project
| ide_search::SearchScope::FileSet { .. }
| ide_search::SearchScope::Pattern { .. } => project.content_roots(),
| ide_search::SearchScope::Pattern { .. } => project
.content_roots()
.into_iter()
// Kept out of the root's walk only by its ignore rules, which this search does not apply.
.filter(|r| !(query.include_excluded && include_root && r.starts_with(root)))
.collect(),
_ => within.into_iter().collect(),
};
let filter = |rel: &str| match set {
@@ -144,7 +151,7 @@ pub(crate) fn search_project(
/// Project-relative `masks` (each a comma-separated list) for a search from the content root
/// shown as `prefix`: paths below it lose the prefix, other paths can match nothing there and
/// are dropped, names and `**/` patterns (`*.rs`, `**/build/**`) stay as they are.
fn rebase_masks(masks: &[String], prefix: &str) -> Vec<String> {
pub(crate) fn rebase_masks(masks: &[String], prefix: &str) -> Vec<String> {
let prefix = format!("{}/", prefix.trim_end_matches('/'));
masks
.iter()
+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())
+2
Переглянути файл
@@ -18,6 +18,7 @@ pub async fn vcs_status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>>
}
for r in repos.all() {
r.set_ignored_names(settings.ignored_names());
r.set_cli_status(settings.vcs.git.cli_status);
}
repos.status()
})
@@ -40,6 +41,7 @@ pub async fn vcs_status_paths(host: &Host, window: &str, paths: Vec<std::path::P
}
for r in repos.all() {
r.set_ignored_names(settings.ignored_names());
r.set_cli_status(settings.vcs.git.cli_status);
}
repos.status_paths(&paths)
})
+52 -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,
@@ -338,6 +334,13 @@ fn keep_private(root: &Path) {
}
}
/// Directory Mappings: the repository roots detection finds, before any are excluded or added.
#[command(trust = always)]
pub async fn vcs_detected_roots(host: &Host, window: &str) -> IdeResult<Vec<PathBuf>> {
let project = host.project(window)?;
blocking(move || project.detected_repository_roots()).await
}
/// The project's repositories, the primary one first.
#[command(trust = always)]
pub fn vcs_roots(host: &Host, window: &str) -> IdeResult<Vec<VcsRoot>> {
@@ -940,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 } => {
@@ -954,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> {
@@ -1061,6 +1089,22 @@ pub async fn vcs_config_get(
blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.config_get(&key))).await
}
/// Git User Name Is Not Defined: sets `user.name` / `user.email` for commits in the
/// repository, or globally.
#[command(trust = trusted)]
pub async fn vcs_set_user_identity(
host: &Host,
window: &str,
repo: Option<PathBuf>,
name: String,
email: String,
global: bool,
) -> IdeResult<()> {
host.require_trust(window)?;
let project = host.project(window)?;
blocking(move || project.with_repo_at(repo.as_deref(), |r| r.set_user_identity(&name, &email, global))).await
}
/// Local history operation that may take a while (hooks, large checkouts); git's
/// output streams through `on_output`. Cancellable.
#[command(trust = trusted)]
@@ -1569,6 +1613,7 @@ ide_command::domain!(
vcs_compare_paths,
vcs_compare_scope,
vcs_config_get,
vcs_set_user_identity,
vcs_conflict_versions,
vcs_create_branch,
vcs_create_patch,
@@ -1606,6 +1651,7 @@ ide_command::domain!(
vcs_rebase,
vcs_rebase_with,
vcs_remote,
vcs_update_branches,
vcs_remotes,
vcs_remove_worktree,
vcs_rename_branch,
@@ -1616,6 +1662,7 @@ ide_command::domain!(
vcs_revision_files,
vcs_reword,
vcs_roots,
vcs_detected_roots,
vcs_shelf_delete,
vcs_shelf_diff,
vcs_shelf_import,
+50
Переглянути файл
@@ -568,6 +568,8 @@ pub(super) struct Shared {
/// (plugin, item id) → item, for windows opened later.
output: Mutex<BTreeMap<(String, String), String>>,
decorations: Mutex<BTreeMap<String, Vec<super::DecorationSet>>>,
/// plugin → its console highlight rules, in order.
console_rules: Mutex<BTreeMap<String, Vec<ide_plugin::ConsoleRule>>>,
status: Mutex<BTreeMap<(String, String), StatusItem>>,
setting_snapshots: Mutex<SettingSnapshots>,
window_status: Mutex<BTreeMap<(String, String, String), StatusItem>>,
@@ -648,6 +650,7 @@ impl Shared {
status: Mutex::default(),
output: Mutex::default(),
decorations: Mutex::default(),
console_rules: Mutex::default(),
window_status: Mutex::default(),
setting_snapshots: Mutex::default(),
contexts: Mutex::default(),
@@ -874,6 +877,9 @@ impl Shared {
if self.decorations.lock().remove(plugin).is_some() {
self.sink.emit(None, PluginEvent::DecorationsChanged { plugin_id: plugin.into(), sets: Vec::new() });
}
if self.console_rules.lock().remove(plugin).is_some() {
self.sink.emit(None, PluginEvent::ConsoleRulesChanged { plugin_id: plugin.into(), rules: Vec::new() });
}
self.withdraw_prompts(plugin);
self.net_prompts.lock().remove(plugin);
self.session_net_hosts.lock().remove(plugin);
@@ -1706,6 +1712,18 @@ impl HostApi for PluginApi {
fn file_icon_decorations(&self, set: &str, items: Vec<(PathBuf, String)>) -> Result<(), HostError> {
self.set_file_icon_decorations(set, items)
}
fn console_rules(&self, rules: Vec<ide_plugin::ConsoleRule>) -> Result<(), HostError> {
let rules = super::console_rules::normalize(rules).map_err(HostError::Invalid)?;
let mut all = self.shared.console_rules.lock();
if rules.is_empty() {
all.remove(self.id());
} else {
all.insert(self.id().into(), rules.clone());
}
// Emitted under the lock so replacements cannot arrive out of order.
self.shared.sink.emit(None, PluginEvent::ConsoleRulesChanged { plugin_id: self.id().into(), rules });
Ok(())
}
fn vcs_log(
&self,
root: &Path,
@@ -3276,6 +3294,7 @@ impl PluginWorkspace for HostWorkspace {
scope: ide_search::SearchScope::Project,
max_matches: limit.min(10_000).saturating_add(1),
context: Default::default(),
include_excluded: false,
};
query.exclude.extend(project.search_excludes());
let files = Mutex::new(Vec::new());
@@ -4441,6 +4460,9 @@ impl Shared {
pub(super) fn decoration_sets(&self) -> BTreeMap<String, Vec<super::DecorationSet>> {
self.decorations.lock().clone()
}
pub(super) fn console_rules(&self) -> BTreeMap<String, Vec<ide_plugin::ConsoleRule>> {
self.console_rules.lock().clone()
}
}
#[cfg(test)]
@@ -4612,6 +4634,34 @@ mod workbench_tests {
assert!(api.shared.decoration_sets().is_empty());
}
#[test]
fn console_rules_replace_keep_the_last_valid_list_and_go_with_the_plugin() {
let dir = tempfile::tempdir().unwrap();
let api = api(dir.path(), false, None);
let rule = |pattern: &str| ide_plugin::ConsoleRule {
pattern: pattern.into(),
ignore_case: false,
foreground: Some("bright-yellow".into()),
background: Some("navy".into()),
styles: vec!["bold".into()],
whole_line: true,
enabled: true,
};
// No capability, and no trusted project, is needed: the rules read nothing.
api.console_rules(vec![rule(r"\[AUDIT\]"), rule(r"JOB-\d+")]).unwrap();
let rules = &api.shared.console_rules()["test"];
assert_eq!(rules.len(), 2);
assert_eq!((rules[0].foreground.as_deref(), rules[0].background.as_deref()), (Some("bright-yellow"), None));
assert!(matches!(api.console_rules(vec![rule("(a+)+b")]), Err(HostError::Invalid(_))));
assert_eq!(api.shared.console_rules()["test"].len(), 2);
api.console_rules(vec![rule("x")]).unwrap();
assert_eq!(api.shared.console_rules()["test"].len(), 1);
api.console_rules(Vec::new()).unwrap();
assert!(api.shared.console_rules().is_empty());
api.console_rules(vec![rule("x")]).unwrap();
api.shared.clear_plugin("test", true);
assert!(api.shared.console_rules().is_empty());
}
#[test]
fn decoration_styles_keep_the_severity_palette_the_editor_renders() {
// Inspection Lens colours typos and weak warnings with their own styles; the
// host must keep them, not silently drop them the way an unknown style is dropped.
+7
Переглянути файл
@@ -184,6 +184,12 @@ pub fn plugin_decoration_sets(plugins: &Arc<PluginHost>) -> BTreeMap<String, Vec
plugins.decoration_sets()
}
/// Every plugin's console highlight rules (later changes arrive as `consoleRulesChanged`).
#[command(trust = trusted)]
pub fn plugin_console_rules(plugins: &Arc<PluginHost>) -> BTreeMap<String, Vec<ide_plugin::ConsoleRule>> {
plugins.console_rules()
}
/// Reports exactly one completion from the operation's launching window.
#[command(trust = trusted)]
pub fn plugin_finish_operation(
@@ -296,6 +302,7 @@ ide_command::domain!(
plugin_answer_prompt,
plugin_cancel_task,
plugin_choose_program,
plugin_console_rules,
plugin_content_tab_action,
plugin_context_keys,
plugin_debug_attach_target,
+325
Переглянути файл
@@ -0,0 +1,325 @@
//! Console highlight rules (API 1.12, `ui.set-console-rules`): validated here,
//! matched by the windows with JavaScript's backtracking `RegExp`. A rule is
//! refused unless its worst case on a line of [`LINE_LEN`] characters stays
//! within [`MAX_STEPS`] backtracking steps, estimated from its structure.
use ide_plugin::ConsoleRule;
use regex_syntax::hir::{Class, ClassUnicode, ClassUnicodeRange, Hir, HirKind, Look};
pub(crate) const MAX_RULES: usize = 100;
/// The characters of a line the windows match rules against (`src/ui/consoleRules.ts`).
const LINE_LEN: u64 = 2000;
/// About 4 · 2000², a few milliseconds of `RegExp` work for one line.
const MAX_STEPS: u64 = 4 * LINE_LEN * LINE_LEN;
const COLORS: &[&str] = &["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"];
const STYLES: &[&str] = &["bold", "italic", "underline", "strikethrough", "dim"];
/// Validates every rule and drops colours and styles this host doesn't know.
pub(crate) fn normalize(rules: Vec<ConsoleRule>) -> Result<Vec<ConsoleRule>, String> {
if rules.len() > MAX_RULES {
return Err(format!("at most {MAX_RULES} console rules"));
}
rules
.into_iter()
.enumerate()
.map(|(i, rule)| {
validate_pattern(&rule.pattern, rule.ignore_case).map_err(|e| format!("console rule {i}: {e}"))?;
let mut styles: Vec<String> = Vec::new();
for style in rule.styles {
if STYLES.contains(&style.as_str()) && !styles.contains(&style) {
styles.push(style);
}
}
Ok(ConsoleRule {
foreground: rule.foreground.filter(|c| known_color(c)),
background: rule.background.filter(|c| known_color(c)),
styles,
..rule
})
})
.collect()
}
fn known_color(name: &str) -> bool {
COLORS.contains(&name.strip_prefix("bright-").unwrap_or(name))
}
fn validate_pattern(pattern: &str, ignore_case: bool) -> Result<(), String> {
if pattern.is_empty() {
return Err("empty pattern".into());
}
if pattern.len() > super::icon_patterns::MAX_PATTERN_LEN {
return Err(format!("pattern {pattern:?} is too long (max {})", super::icon_patterns::MAX_PATTERN_LEN));
}
if let Some(construct) = super::icon_patterns::unsupported_construct(pattern) {
return Err(format!("pattern {pattern:?}: {construct} is not supported"));
}
let parse = |p: &str| {
regex_syntax::ParserBuilder::new()
.case_insensitive(ignore_case)
.build()
.parse(p)
.map_err(|e| format!("invalid pattern {pattern:?}: {e}"))
};
parse(pattern)?;
let hir = parse(&javascript_classes(pattern))?;
let anchored = starts_anchored(&hir);
let cost = cost(&hir, &ClassUnicode::empty(), true)
.map_err(|why| format!("pattern {pattern:?}: {why} is not supported"))?;
let starts = if anchored { 1 } else { LINE_LEN };
if cost.work.saturating_mul(starts) > MAX_STEPS {
return Err(format!(
"pattern {pattern:?} could take too long on a long line: avoid two repetitions that can match the same text (`.*a.*b`, `\\w+\\w+`); a class such as `[^)]*` often helps"
));
}
Ok(())
}
fn starts_anchored(hir: &Hir) -> bool {
match hir.kind() {
HirKind::Look(Look::Start) => true,
HirKind::Capture(c) => starts_anchored(&c.sub),
HirKind::Concat(items) => items.first().is_some_and(starts_anchored),
HirKind::Alternation(items) => items.iter().all(starts_anchored),
_ => false,
}
}
/// From one start: `ways` the expression can end (each a backtracking point for
/// what follows) and the `work` of trying them all when what follows fails.
/// `scan`: the work is one pass over a run of characters.
#[derive(Clone, Copy)]
struct Cost {
ways: u64,
work: u64,
scan: bool,
}
const ONE: Cost = Cost { ways: 1, work: 1, scan: false };
/// `follow`: the characters what comes after `hir` can start with (empty when
/// only assertions follow). `last`: nothing follows, so the first way to end is the match.
fn cost(hir: &Hir, follow: &ClassUnicode, last: bool) -> Result<Cost, &'static str> {
match hir.kind() {
HirKind::Empty | HirKind::Literal(_) | HirKind::Class(_) | HirKind::Look(_) => Ok(ONE),
HirKind::Capture(c) => cost(&c.sub, follow, last),
HirKind::Concat(items) => {
let mut total = Cost { ways: 1, work: 0, scan: false };
let mut fixed = false;
let mut scanned = None;
for (i, item) in items.iter().enumerate() {
let rest = &items[i + 1..];
// Nothing after this can fail: the first way to end is the match.
if last && rest.is_empty() && nullable(item) {
total.work = total.work.saturating_add(total.ways);
break;
}
let next = first_of_seq(rest, follow);
let c = cost(item, &next, last && rest.is_empty())?;
// In a run of single characters (`[Ee][Rr]…`) only the first one is tried each way,
// and runs of one way cover different parts of the line: one pass in all.
let single = c.ways == 1 && c.work == 1;
let rescan = c.scan && scanned == Some(total.ways);
if !(single && fixed) && !rescan {
total.work = total.work.saturating_add(total.ways.saturating_mul(c.work));
}
fixed = single;
if c.scan {
scanned = Some(total.ways);
}
total.ways = total.ways.saturating_mul(c.ways);
}
Ok(Cost { ways: total.ways, work: total.work.max(1), scan: false })
}
HirKind::Alternation(items) => items.iter().try_fold(Cost { ways: 0, work: 0, scan: false }, |acc, h| {
let c = cost(h, follow, last)?;
Ok(Cost { ways: acc.ways.saturating_add(c.ways), work: acc.work.saturating_add(c.work), scan: false })
}),
HirKind::Repetition(r) => match r.max {
None if matches!(r.sub.kind(), HirKind::Literal(_) | HirKind::Class(_)) => {
// A run that what follows can't start inside ends in one place.
let ways = if overlaps(&first(&r.sub), follow) { LINE_LEN } else { 1 };
Ok(Cost { ways, work: LINE_LEN, scan: true })
}
None => Err("a repeated group (`(…)*`, `(…)+`)"),
Some(max) => {
// Each copy may end in `c.ways` places, and the count itself may vary.
let c = cost(&r.sub, &union(&first(&r.sub), follow), false)?;
let ways = c.ways.saturating_pow(max).saturating_mul(u64::from(max - r.min) + 1);
Ok(Cost { ways, work: ways.saturating_mul(c.work).saturating_add(u64::from(max)), scan: false })
}
},
}
}
fn overlaps(a: &ClassUnicode, b: &ClassUnicode) -> bool {
let mut both = a.clone();
both.intersect(b);
!both.ranges().is_empty()
}
/// `pattern` with JavaScript's ASCII-only `\w` and `\d` (Rust's are Unicode), so that
/// `\W` and `\D` include letters such as `é` as they do where the rules run.
fn javascript_classes(pattern: &str) -> String {
let mut out = String::with_capacity(pattern.len());
let mut chars = pattern.chars();
while let Some(c) = chars.next() {
if c != '\\' {
out.push(c);
continue;
}
match chars.next() {
Some('w') => out.push_str("[0-9A-Za-z_]"),
Some('W') => out.push_str("[^0-9A-Za-z_]"),
Some('d') => out.push_str("[0-9]"),
Some('D') => out.push_str("[^0-9]"),
Some(next) => {
out.push('\\');
out.push(next);
}
None => out.push('\\'),
}
}
out
}
fn nullable(hir: &Hir) -> bool {
hir.properties().minimum_len() == Some(0)
}
/// The characters `hir` can start with (everything, for a byte class).
fn first(hir: &Hir) -> ClassUnicode {
match hir.kind() {
HirKind::Empty | HirKind::Look(_) => ClassUnicode::empty(),
HirKind::Literal(lit) => match std::str::from_utf8(&lit.0).ok().and_then(|s| s.chars().next()) {
Some(c) => ClassUnicode::new([ClassUnicodeRange::new(c, c)]),
None => any(),
},
HirKind::Class(Class::Unicode(class)) => class.clone(),
HirKind::Class(Class::Bytes(_)) => any(),
HirKind::Capture(c) => first(&c.sub),
HirKind::Repetition(r) => first(&r.sub),
HirKind::Concat(items) => first_of_seq(items, &ClassUnicode::empty()),
HirKind::Alternation(items) => items.iter().fold(ClassUnicode::empty(), |acc, h| union(&acc, &first(h))),
}
}
/// The characters a sequence can start with, then `follow` if it may match nothing.
fn first_of_seq(items: &[Hir], follow: &ClassUnicode) -> ClassUnicode {
let mut set = ClassUnicode::empty();
for item in items {
set = union(&set, &first(item));
if !nullable(item) {
return set;
}
}
union(&set, follow)
}
fn union(a: &ClassUnicode, b: &ClassUnicode) -> ClassUnicode {
let mut out = a.clone();
out.union(b);
out
}
fn any() -> ClassUnicode {
ClassUnicode::new([ClassUnicodeRange::new('\0', char::MAX)])
}
#[cfg(test)]
mod tests {
use super::*;
fn rule(pattern: &str) -> ConsoleRule {
ConsoleRule {
pattern: pattern.into(),
ignore_case: false,
foreground: Some("red".into()),
background: None,
styles: Vec::new(),
whole_line: false,
enabled: true,
}
}
fn err(pattern: &str) -> String {
validate_pattern(pattern, false).unwrap_err()
}
#[test]
fn accepts_typical_log_rules() {
for pattern in [
r"\[AUDIT\]",
r"\[(AUDIT|METRIC|TASK-FAIL)\]",
r"JOB-\d+",
r"Exception in thread .*",
r".*ERROR.*",
r"took \d+(\.\d+)?ms",
r"\d+\.\d+\.\d+\.\d+",
r"\w+@\w+\.com",
r"user=\S+\s+id=\d+",
r#"^\s*at [^(]*\([^)]*\)$"#,
r"^\[service-a\].*",
r"SELECT .* FROM",
r"\b(GET|POST|PUT|DELETE) /\S*",
r"\d+(\.\d+){0,3}",
r"\w+(-\w+){0,4}",
r"(ERROR|WARN)\b.*$",
] {
assert!(validate_pattern(pattern, false).is_ok(), "{pattern}: {:?}", validate_pattern(pattern, false));
assert!(validate_pattern(pattern, true).is_ok(), "{pattern} (ignore case)");
}
}
#[test]
fn rejects_patterns_that_backtrack_for_too_long() {
// Each takes seconds or more on a 2000-character line in V8.
assert!(err(r"(a+)+$").contains("repeated group"));
assert!(err(r"^(a|aa)+b$").contains("repeated group"));
assert!(err(r"a*a*a*b").contains("too long"));
assert!(err(r".*a.*b").contains("too long"));
assert!(err(r"\w+\w+!").contains("too long"));
assert!(err(r"^(a?){30}a{30}$").contains("too long"));
// A group before `$` or `\b` is not the end of the pattern: those can still fail.
assert!(err(r"(x(a+)*)$").contains("repeated group"));
assert!(err(r"(?:foo|x(a+)*)\b").contains("repeated group"));
assert!(err(r"^(x\w*\w*\w*)$").contains("too long"));
// JavaScript's `\W` matches `é` and `\D` matches `٣`, Rust's don't.
assert!(err(r"\W+é+!").contains("too long"));
assert!(err(r"[\D]+[٣]+!").contains("too long"));
assert!(validate_pattern(r"\\w+\\w+!", false).is_ok(), "an escaped backslash, then `w`");
assert!(validate_pattern(r"[0-9a-f]{32}", false).is_ok());
// Anchored, the same shape tries one start instead of every position.
assert!(validate_pattern(r"^\w+\w+!", false).is_ok());
assert!(err(r"^.*a.*b.*c").contains("too long"));
}
#[test]
fn rejects_constructs_javascript_reads_differently() {
for pattern in [r"(?i)error", r"(?P<n>a)", r"(?=a)", r"\Aerror", r"error\z", r"\p{L}", r"[[:alpha:]]"] {
assert!(err(pattern).contains("not supported"), "{pattern}");
}
assert!(err("(").contains("invalid pattern"));
assert!(err("").contains("empty"));
assert!(err(&"a".repeat(513)).contains("too long"));
}
#[test]
fn normalizing_keeps_known_colours_and_styles_and_bounds_the_list() {
let mut r = rule("x");
r.foreground = Some("bright-cyan".into());
r.background = Some("#ff0000".into());
r.styles = vec!["bold".into(), "blink".into(), "bold".into(), "dim".into()];
let out = normalize(vec![r, ConsoleRule { foreground: Some("teal".into()), ..rule("y") }]).unwrap();
assert_eq!(out[0].foreground.as_deref(), Some("bright-cyan"));
assert_eq!(out[0].background, None);
assert_eq!(out[0].styles, ["bold", "dim"]);
assert_eq!(out[1].foreground, None);
let e = normalize(vec![rule("ok"), rule(".*a.*b")]).unwrap_err();
assert!(e.starts_with("console rule 1:"), "{e}");
assert!(normalize(vec![rule("x"); MAX_RULES]).is_ok());
assert!(normalize(vec![rule("x"); MAX_RULES + 1]).unwrap_err().contains("at most 100"));
}
}
+1 -1
Переглянути файл
@@ -30,7 +30,7 @@ pub(crate) fn validate_pattern(pattern: &str) -> Result<(), String> {
}
}
fn unsupported_construct(pattern: &str) -> Option<&'static str> {
pub(crate) fn unsupported_construct(pattern: &str) -> Option<&'static str> {
if pattern.match_indices("(?").any(|(at, _)| !pattern[at + 2..].starts_with(':')) {
return Some("an inline flag, lookaround or named group");
}
+7
Переглянути файл
@@ -20,6 +20,7 @@ mod auth;
mod build_graph;
pub mod commands;
pub mod commit;
mod console_rules;
mod database;
mod dependencies;
pub(crate) mod diagnostics;
@@ -50,6 +51,7 @@ pub mod remote;
pub mod remote_host;
mod run_detectors;
pub mod run_targets;
pub mod search;
mod semantic_tokens;
mod snippets;
mod theme;
@@ -438,6 +440,11 @@ impl PluginHost {
self.shared.decoration_sets()
}
/// Every plugin's console highlight rules, for windows opening after they were set.
pub fn console_rules(&self) -> std::collections::BTreeMap<String, Vec<ide_plugin::ConsoleRule>> {
self.shared.console_rules()
}
/// Creates the host; call [`load_all`](Self::load_all) to load installed plugins.
pub fn new(plugins_dir: PathBuf, sink: Arc<dyn PluginEventSink>, limits: Limits) -> IdeResult<Self> {
std::fs::create_dir_all(&plugins_dir)?;
+1
Переглянути файл
@@ -76,6 +76,7 @@ pub fn register_builtin_points(
registry.register(Arc::new(super::navigation::IndexersPoint))?;
registry.register(Arc::new(super::providers::ProvidersPoint::new(providers.clone())))?;
registry.register(Arc::new(UiPoint::new(super::providers::SECRETS_POINT, ui.clone(), super::providers::secret)))?;
registry.register(Arc::new(UiPoint::new(super::search::POINT, ui.clone(), super::search::declaration)))?;
registry.register(Arc::new(UiPoint::new(super::endpoints::POINT, ui.clone(), super::endpoints::declaration)))?;
registry.register(Arc::new(UiPoint::new(
"runConfigurations",
+1
Переглянути файл
@@ -144,6 +144,7 @@ pub fn forwarded(event: &PluginEvent) -> bool {
| PluginEvent::ContentTabReply { .. }
| PluginEvent::OpenDiff { .. }
| PluginEvent::DecorationsChanged { .. }
| PluginEvent::ConsoleRulesChanged { .. }
| PluginEvent::EditorOpen { .. }
| PluginEvent::EditorRanges { .. }
| PluginEvent::Notification { .. }
+298
Переглянути файл
@@ -0,0 +1,298 @@
//! Cancellable, non-interactive Search Everywhere providers.
use super::PluginHost;
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId, ipc_path::to_ipc};
use ide_extension::{Capability, Package, UiDecl, decode, validate_item_id};
use ide_plugin::{
Invocation,
search::{SearchPage, SearchTarget},
};
use serde::{Deserialize, Serialize};
use std::{
collections::{BTreeMap, BTreeSet},
path::Path,
sync::Arc,
time::Duration,
};
pub(super) const POINT: &str = "searchCategories";
pub const MAX_RESULTS: u32 = 200;
#[derive(Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
struct Decl {
id: String,
title: String,
}
pub(super) fn declaration(pkg: &Package, value: toml::Value) -> Result<UiDecl, String> {
let d: Decl = decode(POINT, value)?;
pkg.manifest.needs_api("contributes.searchCategories", 13)?;
validate_item_id(&d.id, "search category id")?;
if pkg.manifest.wasm.is_none()
|| d.title.trim().is_empty()
|| d.title.len() > 256
|| d.title.chars().any(char::is_control)
{
return Err("search categories need code and a title of 1–256 bytes".into());
}
Ok(UiDecl::new(d.id.clone(), d.title.clone(), serde_json::to_value(d).map_err(|e| e.to_string())?))
}
#[derive(Clone, Debug, Serialize, specta::Type)]
#[serde(tag = "kind", content = "value", rename_all = "camelCase")]
pub enum PluginSearchTarget {
Location(ide_core::Location),
Command { id: String, arg: Option<String> },
}
#[derive(Clone, Debug, Serialize, specta::Type)]
pub struct PluginSearchItem {
pub id: String,
pub title: String,
pub description: Option<String>,
pub target: PluginSearchTarget,
}
#[derive(Clone, Debug, Default, Serialize, specta::Type)]
#[serde(rename_all = "camelCase")]
pub struct PluginSearchPage {
pub items: Vec<PluginSearchItem>,
pub has_more: bool,
}
/// One page of `plugin_id`'s results for its search `category`. Cancellable with
/// `cancel_request(request)`.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn plugin_search(
host: &crate::Host,
plugins: &Arc<PluginHost>,
window: &str,
plugin_id: String,
category: String,
query: String,
limit: u32,
request: RequestId,
) -> IdeResult<PluginSearchPage> {
if query.len() > 1024 || !(1..=MAX_RESULTS).contains(&limit) {
return Err(IdeError::invalid("search query exceeds 1024 bytes or limit is outside 1–200"));
}
let root = host.project(window).ok().map(|p| p.root.clone());
let invocation = Invocation { workspace_root: root, client: Some(window.to_owned()), ..Default::default() };
let cancel = host.begin_project_request(window, request);
let worker_cancel = cancel.clone();
let plugins = plugins.clone();
// Startup and file reads can outlive a provider call. The request still returns
// promptly; the worker checks this token before doing or publishing more work.
let result = tokio::select! {
_ = cancel.cancelled() => Err(IdeError::cancelled()),
result = tokio::time::timeout(Duration::from_secs(2), host.blocking(move || {
plugins.search_category(&plugin_id, &category, query, limit, invocation, &worker_cancel)
})) => match result {
Ok(result) => result,
Err(_) => Err(IdeError::new(ide_core::error::ErrorKind::TimedOut, "plugin search timed out")),
},
};
cancel.cancel();
host.end_request(request);
result
}
impl PluginHost {
fn search_category(
&self,
plugin: &str,
category: &str,
query: String,
limit: u32,
invocation: Invocation,
cancel: &ide_core::CancellationToken,
) -> IdeResult<PluginSearchPage> {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let loaded = self.get(plugin)?;
let workspace = self.shared.workspace();
let eligible = || {
loaded.status().is_live()
&& loaded.meta.lock().pending.is_empty()
&& self.ui.items(POINT, Some(plugin)).iter().any(|d| d.key == category)
&& loaded.dev_root.as_deref().is_none_or(|r| invocation.workspace_root.as_deref() == Some(r))
&& invocation
.workspace_root
.as_ref()
.is_none_or(|r| workspace.as_ref().is_some_and(|w| w.projects().contains(r) && w.trusted(r)))
};
if !eligible() {
return Err(IdeError::unavailable("search category is no longer available"));
}
let id = category.to_owned();
let page = self.code_call_with_budget(
plugin,
invocation.clone(),
"searching",
Some(cancel),
Some(Duration::from_secs(2)),
move |rt, ctx| rt.search(&id, &query, limit, ctx),
)?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
if !eligible() || !self.plugins.read().get(plugin).is_some_and(|p| Arc::ptr_eq(p, &loaded)) {
return Err(IdeError::cancelled());
}
let commands = self.ui.items(super::points::COMMANDS, Some(plugin)).into_iter().map(|d| d.key).collect();
let can_read = loaded.meta.lock().granted.contains(&Capability::ProjectRead);
let check = || {
if cancel.is_cancelled()
|| !eligible()
|| !self.plugins.read().get(plugin).is_some_and(|p| Arc::ptr_eq(p, &loaded))
{
Err(IdeError::cancelled())
} else {
Ok(())
}
};
let page = validate(page, limit, &commands, |location| {
check()?;
if !can_read {
return Err(IdeError::invalid("search locations require project.read"));
}
let root = invocation
.workspace_root
.as_deref()
.ok_or_else(|| IdeError::invalid("search locations need a project"))?;
let path =
ide_plugin::resolve_in_root(root, &location.path.to_string_lossy()).map_err(IdeError::invalid)?;
let w = workspace.as_ref().ok_or_else(|| IdeError::unavailable("project closed"))?;
let text = w
.buffer_text_in(invocation.client.as_deref(), &path)
.map(Ok)
.unwrap_or_else(|| ide_plugin::read_text(&path).map_err(IdeError::invalid))?;
check()?;
Ok((path, text))
})?;
check()?;
Ok(page)
}
}
fn validate(
page: SearchPage,
limit: u32,
commands: &BTreeSet<String>,
mut document: impl FnMut(&ide_plugin::Location) -> IdeResult<(std::path::PathBuf, String)>,
) -> IdeResult<PluginSearchPage> {
if page.items.len() > limit as usize {
return Err(IdeError::invalid("search provider exceeded its result limit"));
}
let mut ids = BTreeSet::new();
let mut bytes = 0;
let mut document_bytes = 0;
let mut texts = BTreeMap::new();
let mut items = Vec::with_capacity(page.items.len());
for item in page.items {
bytes += item.id.len() + item.title.len() + item.description.as_ref().map_or(0, String::len);
if item.id.is_empty()
|| item.id.len() > 256
|| !ids.insert(item.id.clone())
|| item.title.trim().is_empty()
|| item.title.len() > 1024
|| item.title.chars().any(char::is_control)
|| item.description.as_ref().is_some_and(|s| s.len() > 4096 || s.chars().any(char::is_control))
{
return Err(IdeError::invalid("invalid or duplicate search result"));
}
let target = match item.target {
SearchTarget::Command { id, arg } => {
bytes += id.len() + arg.as_ref().map_or(0, String::len);
if !commands.contains(&id) || arg.as_ref().is_some_and(|s| s.len() > 16 << 10) {
return Err(IdeError::invalid(
"search results may only run their plugin's declared commands, with at most 16 KiB of arguments",
));
}
PluginSearchTarget::Command { id, arg }
}
SearchTarget::Location(location) => {
bytes += location.path.as_os_str().len();
if !texts.contains_key(&location.path) {
let (path, text) = document(&location)?;
document_bytes += text.len();
if document_bytes > 16 << 20 {
return Err(IdeError::invalid("search documents exceed 16 MiB"));
}
let lines: Vec<usize> =
text.split('\n').map(|s| s.trim_end_matches('\r').encode_utf16().count()).collect();
texts.insert(location.path.clone(), (path, lines));
}
let (path, lines) = &texts[&location.path];
let range = location.range;
if range.start > range.end
|| [range.start, range.end]
.iter()
.any(|p| lines.get(p.line as usize).is_none_or(|len| p.col as usize > *len))
{
return Err(IdeError::invalid("search location is outside its UTF-16 document range"));
}
PluginSearchTarget::Location(ide_core::Location {
path: to_ipc(Path::new(path)).into(),
range,
uri: None,
})
}
};
if bytes > 1 << 20 {
return Err(IdeError::invalid("search results exceed 1 MiB"));
}
items.push(PluginSearchItem { id: item.id, title: item.title, description: item.description, target });
}
Ok(PluginSearchPage { items, has_more: page.has_more && limit < MAX_RESULTS })
}
ide_command::domain!(plugins_search: plugin_search);
#[cfg(test)]
mod tests {
use super::*;
use ide_plugin::search::SearchItem;
fn command(id: &str) -> SearchItem {
SearchItem {
id: "one".into(),
title: "Open route".into(),
description: None,
target: SearchTarget::Command { id: id.into(), arg: Some("/users/:id".into()) },
}
}
#[test]
fn bounded_results_and_only_own_declared_commands() {
let declared = BTreeSet::from(["open".into()]);
let check = |items, limit| validate(SearchPage { items, has_more: true }, limit, &declared, |_| unreachable!());
assert!(check(vec![command("open")], 1).unwrap().has_more);
assert!(!check(vec![command("open")], MAX_RESULTS).unwrap().has_more);
assert!(check(vec![command("other.plugin.command")], 1).is_err());
assert!(check(vec![command("open"), command("open")], 2).is_err());
assert!(check(vec![command("open")], 0).is_err());
let mut bad = command("open");
bad.title = "bad\nresult".into();
assert!(check(vec![bad], 1).is_err());
}
#[test]
fn source_locations_use_utf16_and_validate_whole_page() {
let item = |end| SearchItem {
id: "source".into(),
title: "Handler".into(),
description: None,
target: SearchTarget::Location(ide_plugin::Location {
path: "routes.txt".into(),
range: ide_core::Range::new(ide_core::Pos::new(0, 2), ide_core::Pos::new(0, end)),
}),
};
let check = |end| {
validate(SearchPage { items: vec![item(end)], has_more: false }, 50, &BTreeSet::new(), |_| {
Ok(("/project/routes.txt".into(), "😀x\n".into()))
})
};
assert!(check(3).is_ok());
assert!(check(4).is_err());
assert!(check(1).is_err());
}
}
+3
Переглянути файл
@@ -241,6 +241,9 @@ pub enum PluginEvent {
/// Complete replacement of one plugin's project-scoped decorations.
#[serde(rename_all = "camelCase")]
DecorationsChanged { plugin_id: String, sets: Vec<DecorationSet> },
/// Complete replacement of one plugin's console highlight rules (empty: none).
#[serde(rename_all = "camelCase")]
ConsoleRulesChanged { plugin_id: String, rules: Vec<ide_plugin::ConsoleRule> },
/// Open a file in the invoking window.
EditorOpen { path: ide_core::IpcPath, selection: Option<ide_core::Range> },
/// Change selection or scrolling only in this window's already open editor.
+41 -3
Переглянути файл
@@ -2,6 +2,7 @@
//! watchers and the per-project services, opened by [`crate::Host::open_project`].
use crate::Host;
use ide_core::workflow_settings::VcsMappings;
use ide_core::{CancellationToken, IdeError, IdeEvent, IdeResult, LanguageId, SharedSink};
use ide_index::ProjectIndex;
use ide_language::{FileTypes, LanguageRegistry, SyntaxCache};
@@ -60,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>,
@@ -199,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" {
@@ -600,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,
@@ -730,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)
}
}
@@ -808,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,
@@ -955,10 +969,27 @@ fn scan_repositories(
}
}
/// The repository containing `root` and those nested below it or below a content root.
/// The repository containing `root` and those nested below it or below a content root,
/// with the project's Directory Mappings applied.
/// The project-open scan and the watcher's rescan share these skip rules.
fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Path, trusted: bool) -> IdeResult<Repos> {
let ignored = settings.effective().ignored_names();
let settings = settings.effective();
let found = detect_repositories(root, &settings, build_cache, trusted)?;
let mappings = &settings.vcs.mappings;
if mappings.is_empty() {
return Ok(found);
}
let resolve = |list: &[String]| -> Vec<PathBuf> { list.iter().map(|p| VcsMappings::resolve(root, p)).collect() };
Ok(found.mapped(&resolve(&mappings.excluded), &resolve(&mappings.added), root))
}
fn detect_repositories(
root: &Path,
settings: &ide_core::settings::Settings,
build_cache: &Path,
trusted: bool,
) -> IdeResult<Repos> {
let ignored = settings.ignored_names();
let skip = |p: &Path| {
p.file_name().is_some_and(|n| {
let name = n.to_string_lossy();
@@ -968,11 +999,17 @@ fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Pa
})
};
let mut roots = vec![root.to_path_buf()];
roots.extend(content_roots(&settings.effective(), root, build_cache, trusted));
roots.extend(content_roots(settings, root, build_cache, trusted));
Repos::discover_roots(&roots, &skip)
}
impl Project {
/// The repository roots detection finds, before Directory Mappings exclude or add any.
pub fn detected_repository_roots(&self) -> IdeResult<Vec<PathBuf>> {
let settings = self.settings.effective();
Ok(detect_repositories(&self.root, &settings, &self.build_cache_dir(), self.is_trusted())?.roots())
}
pub fn refresh_repositories(&self) {
scan_repositories(
&self.root,
@@ -1076,6 +1113,7 @@ impl Project {
apply_git_executable(&settings);
}
repo.set_ignored_names(settings.ignored_names());
repo.set_cli_status(settings.vcs.git.cli_status);
f(repo)
}
+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
+95 -17
Переглянути файл
@@ -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")));
}
@@ -284,6 +287,18 @@ async fn files_of_a_project_attached_outside_go_by_their_absolute_path_everywher
.map(|r| r["repositoryPathRelativeToProject"].as_str().unwrap())
.collect();
assert!(repos.contains(&shown("").trim_end_matches('/')), "{repos:?}");
// `paths` names such a project by its absolute path, in every tool.
let only = json!([format!("{}/src/**", shown(""))]);
let files = h.json("search_file", json!({"q":"*.rs","paths":only})).await;
assert_eq!(files["items"], json!([{ "filePath": shown("src/lib.rs") }]));
let text = h.json("search_text", json!({"q":"attached_marker","paths":only})).await;
assert_eq!(text["items"][0]["filePath"], shown("src/lib.rs"), "{text}");
let symbols = h.json("search_symbol", json!({"q":"attached_marker","paths":only})).await;
assert_eq!(symbols["items"][0]["filePath"], shown("src/lib.rs"), "{symbols}");
let status = h.json("git_status", json!({"paths":only})).await;
assert_eq!(status["repositories"].as_array().unwrap().len(), 1, "{status}");
assert_eq!(status["repositories"][0]["repositoryPathRelativeToProject"], shown("").trim_end_matches('/'));
}
#[tokio::test(flavor = "multi_thread")]
@@ -442,7 +457,7 @@ async fn git_status_and_diff_on_a_temporary_repository() {
}
#[tokio::test(flavor = "multi_thread")]
async fn scope_limits_the_query_tools_to_a_directory() {
async fn paths_limit_the_query_tools_to_folders() {
let h = Harness::new();
std::fs::create_dir_all(h.root.join("lib")).unwrap();
std::fs::write(h.root.join("lib/c.txt"), "needle\n").unwrap();
@@ -452,17 +467,20 @@ async fn scope_limits_the_query_tools_to_a_directory() {
out.dedup();
out
};
assert_eq!(paths(&h.json("search_text", json!({"q":"needle","scope":"lib"})).await), ["lib/c.txt"]);
assert_eq!(paths(&h.json("search_regex", json!({"q":"need.e","scope":"lib/"})).await), ["lib/c.txt"]);
assert_eq!(paths(&h.json("search_text", json!({"q":"needle","paths":["lib/"]})).await), ["lib/c.txt"]);
assert_eq!(paths(&h.json("search_regex", json!({"q":"need.e","paths":["lib/**"]})).await), ["lib/c.txt"]);
let absolute = h.root.join("src").to_string_lossy().into_owned();
assert_eq!(paths(&h.json("search_file", json!({"q":"*.txt","scope":absolute})).await), ["src/a.txt", "src/b.txt"]);
// Within the scope, `paths` narrows further.
assert_eq!(
paths(&h.json("search_text", json!({"q":"needle","scope":"src","paths":["**/b.txt"]})).await),
["src/b.txt"]
paths(&h.json("search_file", json!({"q":"*.txt","paths":[absolute]})).await),
["src/a.txt", "src/b.txt"]
);
assert!(h.error("search_text", json!({"q":"needle","scope":"missing"})).await.contains("is not a directory"));
assert!(h.error("search_text", json!({"q":"needle","scope":".."})).await.contains("outside the project"));
// Several folders at once, and exclusions.
assert_eq!(
paths(&h.json("search_text", json!({"q":"needle","paths":["src/**","lib/**","!**/a.txt"]})).await),
["lib/c.txt", "src/b.txt"]
);
let outside = h.error("search_text", json!({"q":"needle","paths":["../**"]})).await;
assert!(outside.contains("outside of the project directory"), "{outside}");
let git = |args: &[&str]| {
let output = std::process::Command::new("git").current_dir(&h.root).args(args).output().unwrap();
@@ -473,7 +491,7 @@ async fn scope_limits_the_query_tools_to_a_directory() {
git(&["-c", "user.name=Test", "-c", "[email protected]", "commit", "-m", "Initial"]);
std::fs::write(h.root.join("src/a.txt"), "changed\n").unwrap();
std::fs::write(h.root.join("lib/c.txt"), "changed\n").unwrap();
let status = h.json("git_status", json!({"scope":"lib"})).await;
let status = h.json("git_status", json!({"paths":["lib/"]})).await;
assert_eq!(status["repositories"].as_array().unwrap().len(), 1);
assert_eq!(
status["repositories"][0]["entries"],
@@ -482,7 +500,63 @@ async fn scope_limits_the_query_tools_to_a_directory() {
}
#[tokio::test(flavor = "multi_thread")]
async fn a_scoped_symbol_search_finds_matches_past_the_unscoped_ones() {
async fn excluded_and_ignored_folders_are_searched_when_asked_for() {
let h = Harness::new();
// `ignored/` is ignored by the project's `.gitignore`; `excluded/` is excluded in its settings.
std::fs::create_dir_all(h.root.join("excluded")).unwrap();
std::fs::write(h.root.join("excluded/e.txt"), "needle\n").unwrap();
std::fs::create_dir_all(h.root.join("src/ignored")).unwrap();
std::fs::write(h.root.join("src/ignored/x.txt"), "needle\n").unwrap();
ide_host::ops::project::set_settings(
&h.host,
"main",
ide_workspace::settings::SettingsScope::Project,
"projectStructure.excluded",
"[\"excluded\"]",
)
.unwrap();
let found = |args: Value| {
let h = &h;
async move {
let v = h.json(args["tool"].as_str().unwrap(), args["args"].clone()).await;
let mut out: Vec<String> = v["items"]
.as_array()
.cloned()
.unwrap_or_default()
.iter()
.map(|i| i["filePath"].as_str().unwrap().to_owned())
.collect();
out.sort();
out.dedup();
out
}
};
let text = |args: Value| json!({ "tool": "search_text", "args": args });
assert_eq!(found(text(json!({"q":"needle"}))).await, ["src/a.txt", "src/b.txt"]);
let every = ["excluded/e.txt", "ignored/a.txt", "src/a.txt", "src/b.txt", "src/ignored/x.txt"];
assert_eq!(found(text(json!({"q":"needle","includeExcluded":true}))).await, every);
assert_eq!(found(json!({"tool":"search_regex","args":{"q":"need.e","includeExcluded":true}})).await, every);
// `paths` only narrows: a folder the project leaves out stays out when named ...
let nothing: Vec<String> = Vec::new();
assert_eq!(found(text(json!({"q":"needle","paths":["ignored/"]}))).await, nothing);
assert_eq!(found(text(json!({"q":"needle","paths":["excluded/"]}))).await, nothing);
// ... and is searched, alone, when asked for.
assert_eq!(
found(text(json!({"q":"needle","paths":["ignored/","excluded/"],"includeExcluded":true}))).await,
["excluded/e.txt", "ignored/a.txt"]
);
let file = |dir: &str| json!({"tool":"search_file","args":{"q":"*.txt","paths":[dir],"includeExcluded":true}});
assert_eq!(found(file("excluded/")).await, ["excluded/e.txt"]);
assert_eq!(found(file("ignored/")).await, ["ignored/a.txt"]);
assert_eq!(found(text(json!({"q":"needle","paths":["src/"]}))).await, ["src/a.txt", "src/b.txt"]);
assert_eq!(
found(text(json!({"q":"needle","paths":["src/"],"includeExcluded":true}))).await,
["src/a.txt", "src/b.txt", "src/ignored/x.txt"]
);
}
#[tokio::test(flavor = "multi_thread")]
async fn a_symbol_search_with_paths_finds_matches_past_the_others() {
let h = Harness::new();
std::fs::create_dir_all(h.root.join("many")).unwrap();
for i in 0..60 {
@@ -498,12 +572,12 @@ async fn a_scoped_symbol_search_finds_matches_past_the_unscoped_ones() {
assert!(std::time::Instant::now() < deadline, "the files were never indexed");
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
}
let found = h.json("search_symbol", json!({"q":"pool_marker","scope":"zz","limit":1})).await;
let found = h.json("search_symbol", json!({"q":"pool_marker","paths":["zz/"],"limit":1})).await;
assert_eq!(found["items"][0]["filePath"], "zz/last.rs", "{found}");
}
#[tokio::test(flavor = "multi_thread")]
async fn scope_reaches_an_attached_worktree_the_repository_ignores() {
async fn paths_reach_an_attached_worktree_the_repository_ignores() {
let h = Harness::new();
h.trust().await;
let git = |dir: &Path, args: &[&str]| {
@@ -545,10 +619,14 @@ async fn scope_reaches_an_attached_worktree_the_repository_ignores() {
let everywhere = found(json!({"q":"needle"})).await;
assert!(everywhere.contains(&".wt/feature/src/b.txt".to_owned()), "{everywhere:?}");
assert_eq!(
found(json!({"q":"needle","scope":".wt/feature/src"})).await,
found(json!({"q":"needle","paths":[".wt/feature/src/"]})).await,
[".wt/feature/src/a.txt", ".wt/feature/src/b.txt"]
);
assert_eq!(found(json!({"q":"needle","paths":[".wt/feature/src/b.txt"]})).await, [".wt/feature/src/b.txt"]);
// With `includeExcluded` the root's walk enters the ignored worktree: its files still come once.
let all = h.json("search_text", json!({"q":"needle","includeExcluded":true})).await;
let items = all["items"].as_array().unwrap();
assert_eq!(items.iter().filter(|i| i["filePath"] == ".wt/feature/src/b.txt").count(), 1, "{all}");
}
#[cfg(unix)]
@@ -1217,8 +1295,8 @@ async fn call_hierarchy_pages_are_sorted_and_scoped() {
assert_eq!((&first["more"], &first["nextOffset"]), (&json!(true), &json!(2)));
let next = h.json("get_call_hierarchy", at(json!({"limit":2,"offset":2}))).await;
assert_eq!(names(&next), ["main"]);
let scoped = h.json("get_call_hierarchy", at(json!({"scope":"src"}))).await;
let scoped = h.json("get_call_hierarchy", at(json!({"paths":["src/"]}))).await;
assert_eq!(names(&scoped), ["main"]);
assert_eq!(scoped["total"], 1);
assert_eq!(scoped["root"]["name"], "price", "the root is shown whatever the scope");
assert_eq!(scoped["root"]["name"], "price", "the root is shown whatever the paths");
}
+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()
+49 -1
Переглянути файл
@@ -121,6 +121,7 @@ impl PluginWorkspace for TestWorkspace {
scope: ide_search::SearchScope::Project,
max_matches: limit,
context: Default::default(),
include_excluded: false,
};
let files = Mutex::new(Vec::new());
let summary = ide_search::search(root, &query, &|_| None, cancel, &|file| files.lock().push(file))
@@ -1559,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);
@@ -4860,6 +4865,49 @@ fn plugins_set_their_own_context_keys() {
assert!(f.host.context_keys(Some("main")).is_empty(), "cleared when the plugin stops");
}
/// `ui.set-console-rules` (API 1.12) replaces the plugin's rules for every window without a
/// capability; unknown colours are dropped, an invalid rule keeps the previous list.
#[test]
fn plugins_replace_their_console_rules_and_lose_them_when_they_stop() {
let f = fixture(Limits::default());
f.install(&sample("jobs"));
f.take_events();
f.run("jobs", "console-rules", None).unwrap();
let changed: Vec<_> = f
.take_events()
.into_iter()
.filter_map(|(client, e)| match e {
PluginEvent::ConsoleRulesChanged { plugin_id, rules } => Some((client, plugin_id, rules)),
_ => None,
})
.collect();
assert_eq!(changed.len(), 1);
let (client, plugin_id, rules) = &changed[0];
assert_eq!((client.as_deref(), plugin_id.as_str()), (None, "jobs"));
assert_eq!(rules.iter().map(|r| r.pattern.as_str()).collect::<Vec<_>>(), [r"\[AUDIT\]", r"job-\d+"]);
assert!(
rules[0].whole_line && rules[0].styles == ["bold"] && rules[0].foreground.as_deref() == Some("bright-yellow")
);
assert!(rules[1].ignore_case && rules[1].foreground.as_deref() == Some("cyan") && rules[1].background.is_none());
assert_eq!(f.host.console_rules()["jobs"], *rules);
let err = f.run("jobs", "console-rules", Some("(a+)+b")).unwrap_err();
assert!(err.contains("invalid") && err.contains("repeated group"), "{err}");
assert!(f.run("jobs", "console-rules", Some(".*a.*b")).unwrap_err().contains("too long"));
assert_eq!(f.host.console_rules()["jobs"].len(), 2, "an invalid list keeps the previous one");
f.run("jobs", "console-rules", Some("")).unwrap();
assert!(f.host.console_rules().is_empty());
f.run("jobs", "console-rules", None).unwrap();
f.take_events();
f.host.set_enabled("jobs", false).unwrap();
assert!(f.host.console_rules().is_empty(), "cleared when the plugin stops");
assert!(f.take_events().iter().any(
|(_, e)| matches!(e, PluginEvent::ConsoleRulesChanged { plugin_id, rules } if plugin_id == "jobs" && rules.is_empty())
));
}
#[test]
fn context_keys_are_capped_and_windows_overlay_global_ones() {
let f = fixture(Limits::default());
+2
Переглянути файл
@@ -47,6 +47,7 @@ async fn find(host: &Host, paths: Vec<PathBuf>, pattern: &str) -> Vec<ide_search
scope: SearchScope::Files { paths: paths.into_iter().map(Into::into).collect() },
max_matches: 0,
context: Default::default(),
include_excluded: false,
},
ide_host::ops::Channel::new(move |event| {
if let search::SearchEvent::File { file } = event {
@@ -165,6 +166,7 @@ async fn properties_search_git_and_document_coordinates_agree() {
scope: SearchScope::Files { paths: vec![closed_path.clone().into()] },
max_matches: 0,
context: Default::default(),
include_excluded: false,
};
search::replace_in_files(
&host,
+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
Переглянути файл
@@ -174,6 +174,7 @@ async fn restricted_vcs_commands_run_no_program_of_the_repository() {
call!("vcs_status", "", ops::vcs::vcs_status(host, w)),
call!("vcs_status_paths", "", ops::vcs::vcs_status_paths(host, w, vec![file.clone()])),
sync!("vcs_roots", "", vcs::vcs_roots(host, w)),
call!("vcs_detected_roots", "", vcs::vcs_detected_roots(host, w)),
call!("vcs_branch_info", "", vcs::vcs_branch_info(host, w, root())),
call!("vcs_line_hunks", "", vcs::vcs_line_hunks(host, w, file.clone())),
call!("vcs_file_at", "", vcs::vcs_file_at(host, w, file.clone(), None)),
+128 -139
Переглянути файл
@@ -2,15 +2,12 @@
//! `ignore` crate) plus the user's `files.exclude` globs, below the project root
//! and the extra content roots (Project Structure).
//!
//! Like IDEA, ignored directories are left out entirely, while ignored files in
//! the remaining directories (`.env`) are listed by name only, so Go to File finds
//! them but their symbols stay out of the index.
//! Git-ignored files and folders are listed by name only: Go to File finds them
//! without reading their contents or indexing their symbols. Excluded folders
//! (including project-model outputs and dependencies) are not walked at all.
use globset::{GlobBuilder, GlobSet, GlobSetBuilder};
use ignore::gitignore::{Gitignore, GitignoreBuilder};
use ignore::{WalkBuilder, WalkState};
use std::collections::HashMap;
use std::collections::hash_map::Entry;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc;
@@ -25,9 +22,6 @@ pub(crate) struct PathFilter {
/// Content roots outside `root`, indexed as `<folder name>/<path>`.
extra: Vec<ExtraRoot>,
excludes: GlobSet,
/// Root-level ignore files, for paths reported by the watcher (the walker
/// applies nested ignore files itself).
gitignore: Gitignore,
/// What the filter was built from: `(extra roots, exclude globs)`.
config: (crate::IndexRoots, Vec<String>),
}
@@ -36,25 +30,11 @@ struct ExtraRoot {
path: PathBuf,
/// Shown before the paths inside it (`shared-lib/src/x.rs`).
name: String,
gitignore: Gitignore,
}
fn root_ignores(root: &Path) -> Gitignore {
let mut gi = GitignoreBuilder::new(root);
for f in [".gitignore", ".ignore", ".git/info/exclude"] {
let path = root.join(f);
if path.is_file()
&& let Some(e) = gi.add(&path)
{
tracing::debug!("{}: {e}", path.display());
}
}
gi.build().unwrap_or_else(|_| Gitignore::empty())
}
/// Whether walking `root` leaves out `dir`, a folder below it: `dir` or a folder between
/// them is ignored (`.gitignore`, `.ignore`, `info/exclude`, the global excludes). Such a
/// folder can be a root of its own, with its own rules, without its files being walked twice.
/// Whether an ignore-aware content walk of `root` leaves out `dir` or an ancestor.
/// An ignored folder can be an explicit content root with its own ignore rules,
/// promoting its files from filename-only entries to indexable content.
pub fn walk_skips(root: &Path, dir: &Path) -> bool {
if dir == root || !dir.starts_with(root) || !dir.is_dir() {
return false;
@@ -150,14 +130,13 @@ impl PathFilter {
Ok(rel) if extra_roots.include_root => rel_string(rel),
_ => path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),
};
extra.push(ExtraRoot { gitignore: root_ignores(&path), name, path });
extra.push(ExtraRoot { name, path });
}
Self {
root: root.to_owned(),
include_root: extra_roots.include_root,
extra,
excludes,
gitignore: root_ignores(root),
config: (extra_roots.clone(), exclude_globs.to_vec()),
}
}
@@ -170,7 +149,7 @@ impl PathFilter {
/// Stable fingerprint of the persisted-scope configuration; a start-up
/// snapshot is only trusted when this still matches.
pub(crate) fn stamp(&self) -> String {
let mut stamp = format!("include_root={}\n", self.config.0.include_root);
let mut stamp = format!("ignored_folders=names\ninclude_root={}\n", self.config.0.include_root);
for folder in &self.config.0.folders {
stamp.push_str(&folder.to_string_lossy());
stamp.push('\n');
@@ -203,13 +182,13 @@ impl PathFilter {
.chain(self.extra.iter().map(|e| e.path.as_path()))
}
/// The root containing `path`, its display prefix (`None` for the project root) and ignore rules.
fn base_of(&self, path: &Path) -> Option<(&Path, Option<&str>, &Gitignore)> {
/// The root containing `path` and its display prefix (`None` for the project root).
fn base_of(&self, path: &Path) -> Option<(&Path, Option<&str>)> {
// An extra root inside the project root wins: its own rules apply below it.
if let Some(e) = self.extra.iter().find(|e| path.starts_with(&e.path)) {
return Some((e.path.as_path(), Some(e.name.as_str()), &e.gitignore));
return Some((e.path.as_path(), Some(e.name.as_str())));
}
(self.include_root && path.starts_with(&self.root)).then_some((self.root.as_path(), None, &self.gitignore))
(self.include_root && path.starts_with(&self.root)).then_some((self.root.as_path(), None))
}
/// Whether `path` is (at or) below one of the roots.
@@ -220,7 +199,7 @@ impl PathFilter {
/// `/`-separated path relative to its root, as displayed; paths in extra
/// content roots start with the root's folder name.
pub(crate) fn rel(&self, path: &Path) -> Option<String> {
let (base, prefix, _) = self.base_of(path)?;
let (base, prefix) = self.base_of(path)?;
let rel = rel_string(path.strip_prefix(base).ok()?);
if rel.is_empty() {
return None;
@@ -258,11 +237,10 @@ impl PathFilter {
ALWAYS_SKIP.contains(&name)
}
/// Whether a path reported by the watcher should be left out (outside the
/// root, excluded, or an ignored directory or inside one). Ignored files
/// elsewhere stay in, listed by name only.
pub(crate) fn is_excluded(&self, path: &Path, is_dir: bool) -> bool {
let Some((base, _, gitignore)) = self.base_of(path) else { return true };
/// Whether a path is outside the roots, VCS metadata, or explicitly excluded.
/// Git-ignore rules classify files as filename-only, not excluded.
pub(crate) fn is_excluded(&self, path: &Path) -> bool {
let Some((base, _)) = self.base_of(path) else { return true };
let rel = path.strip_prefix(base).map(rel_string).unwrap_or_default();
if rel.is_empty() {
return true;
@@ -280,32 +258,32 @@ impl PathFilter {
return true;
}
}
let dir = if is_dir { Some(path) } else { path.parent().filter(|p| *p != base) };
dir.is_some_and(|d| gitignore.matched_path_or_any_parents(d, true).is_ignore())
false
}
/// A filename walk: only explicit exclusions prune directories. Extra roots
/// inside another root are walked separately, with their own ignore rules.
fn walker(&self, dir: &Path) -> Option<WalkBuilder> {
let (root, _) = self.base_of(dir)?;
if dir != root && self.is_excluded(dir) {
return None;
}
let root = root.to_path_buf();
let excludes = self.excludes.clone();
let extra: Vec<PathBuf> = self.extra.iter().filter(|e| e.path != dir).map(|e| e.path.clone()).collect();
let mut builder = WalkBuilder::new(dir);
builder.standard_filters(false).follow_links(false).filter_entry(move |e| {
!Self::skip_name(&e.file_name().to_string_lossy())
&& !glob_excluded(&excludes, &root, e.path())
&& !extra.iter().any(|r| e.path() == r)
});
Some(builder)
}
/// All directories at or below `dir` that the index would walk, in walk order.
pub(crate) fn dirs(&self, dir: &Path) -> Vec<PathBuf> {
let Some((root, _, _)) = self.base_of(dir) else { return Vec::new() };
let root = root.to_path_buf();
let excludes = self.excludes.clone();
let walk_root = root.clone();
let walk_excludes = excludes.clone();
let walker = WalkBuilder::new(dir)
.hidden(false)
.parents(true)
.ignore(true)
.git_ignore(true)
.git_global(true)
.git_exclude(true)
.require_git(ide_core::ignored::inside_git_repo(dir))
.follow_links(false)
.filter_entry(move |e| {
let name = e.file_name().to_string_lossy();
!Self::skip_name(&name) && !glob_excluded(&walk_excludes, &walk_root, e.path())
})
.build();
walker.flatten().filter(|e| e.file_type().is_some_and(|t| t.is_dir())).map(|e| e.into_path()).collect()
let Some(builder) = self.walker(dir) else { return Vec::new() };
builder.build().flatten().filter(|e| e.file_type().is_some_and(|t| t.is_dir())).map(|e| e.into_path()).collect()
}
/// All indexable files at or below `dir`, walked in parallel.
@@ -320,57 +298,35 @@ impl PathFilter {
}
fn walk_to(&self, dir: &Path, max_depth: Option<usize>, cancel: &AtomicBool) -> Vec<Found> {
let (tx, rx) = mpsc::channel::<Vec<Found>>();
let Some((root, _, _)) = self.base_of(dir) else { return Vec::new() };
let root = root.to_path_buf();
let excludes = self.excludes.clone();
let (walk_root, walk_excludes) = (root.clone(), excludes.clone());
let walker = WalkBuilder::new(dir)
let Some(mut builder) = self.walker(dir) else { return Vec::new() };
let Some((root, _)) = self.base_of(dir) else { return Vec::new() };
// Keep the matcher's root at the content root, even for a watcher scan
// starting inside an ignored folder, so ancestor rules still apply.
let matcher = WalkBuilder::new(root)
.hidden(false)
.parents(true)
.ignore(true)
.git_ignore(true)
.git_global(true)
.git_exclude(true)
.require_git(ide_core::ignored::inside_git_repo(dir))
.follow_links(false)
.max_depth(max_depth)
.filter_entry(move |e| {
let name = e.file_name().to_string_lossy();
!Self::skip_name(&name) && !glob_excluded(&walk_excludes, &walk_root, e.path())
})
.build_parallel();
walker.run(|| {
let (root, excludes) = (&root, &excludes);
.require_git(ide_core::ignored::inside_git_repo(root))
.build_matchers()
.pop()
.expect("one content root");
let (tx, rx) = mpsc::channel::<Vec<Found>>();
builder.max_depth(max_depth).build_parallel().run(|| {
let mut matcher = matcher.clone();
let mut batch = Batch { tx: tx.clone(), items: Vec::with_capacity(256) };
Box::new(move |entry| {
if cancel.load(Ordering::Relaxed) {
return WalkState::Quit;
}
let Ok(entry) = entry else { return WalkState::Continue };
let Some(file_type) = entry.file_type() else { return WalkState::Continue };
if file_type.is_dir() && max_depth.is_none_or(|max| entry.depth() < max) {
// The walker drops ignored files unseen: list every file of a
// walked directory; those the walker doesn't report are ignored.
let Ok(children) = std::fs::read_dir(entry.path()) else { return WalkState::Continue };
for child in children.flatten() {
let path = child.path();
if child.file_type().is_ok_and(|t| t.is_file())
&& !Self::skip_name(&child.file_name().to_string_lossy())
&& !glob_excluded(excludes, root, &path)
&& let Ok(meta) = child.metadata()
{
batch.items.push(Found { path, mtime: mtime_of(&meta), size: meta.len(), ignored: true });
}
}
} else if file_type.is_file()
if entry.file_type().is_some_and(|t| t.is_file())
&& let Ok(meta) = entry.metadata()
&& let Ok(rel) = entry.path().strip_prefix(root)
{
let ignored = matcher.matched(rel, false).is_ignore();
batch.items.push(Found {
path: entry.into_path(),
mtime: mtime_of(&meta),
size: meta.len(),
ignored: false,
ignored,
});
}
if batch.items.len() >= 256 && batch.tx.send(std::mem::take(&mut batch.items)).is_err() {
@@ -380,17 +336,7 @@ impl PathFilter {
})
});
drop(tx);
// Each file comes once from its directory listing and, unless ignored, once from the walker.
let mut by_path: HashMap<PathBuf, Found> = HashMap::new();
for f in rx.into_iter().flatten() {
match by_path.entry(f.path.clone()) {
Entry::Occupied(mut e) => e.get_mut().ignored &= f.ignored,
Entry::Vacant(e) => {
e.insert(f);
}
}
}
by_path.into_values().collect()
rx.into_iter().flatten().collect()
}
}
@@ -435,23 +381,26 @@ mod tests {
touch(&root, f);
}
std::fs::write(root.join(".gitignore"), "build/\n").unwrap();
let filter =
PathFilter::new(&root, &vec![].into(), &["**/node_modules".into(), "target".into(), "docs/**".into()]);
let filter = PathFilter::new(
&root,
&vec![].into(),
&["**/node_modules".into(), "target".into(), "/build".into(), "docs/**".into()],
);
let mut found: Vec<String> =
filter.walk(&root, &AtomicBool::new(false)).iter().filter_map(|f| filter.rel(&f.path)).collect();
found.sort();
assert_eq!(found, vec![".github/workflows/ci.yml", ".gitignore", "src/a.rs", "src/deep/b.rs"]);
assert!(filter.is_excluded(&root.join("node_modules/y.js"), false));
assert!(filter.is_excluded(&root.join("a/target/z.rs"), false));
assert!(filter.is_excluded(&root.join("build/new.rs"), false));
assert!(filter.is_excluded(&root.join(".git/HEAD"), false));
assert!(filter.is_excluded(Path::new("/elsewhere/x.rs"), false));
assert!(!filter.is_excluded(&root.join("src/new.rs"), false));
assert!(filter.is_excluded(&root.join("node_modules/y.js")));
assert!(filter.is_excluded(&root.join("a/target/z.rs")));
assert!(filter.is_excluded(&root.join("build/new.rs")));
assert!(filter.is_excluded(&root.join(".git/HEAD")));
assert!(filter.is_excluded(Path::new("/elsewhere/x.rs")));
assert!(!filter.is_excluded(&root.join("src/new.rs")));
}
#[test]
fn ignored_files_are_listed_but_ignored_directories_are_not() {
fn ignored_files_and_directories_are_listed_by_name_only() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
for f in [
@@ -497,11 +446,15 @@ src/local/
let expected = [
(".env", true),
(".gitignore", false),
("build/nested/deep.rs", true),
("build/out.rs", true),
("logs/app.log", true),
("pkg/.gitignore", false),
("pkg/gen.rs", true),
("pkg/keep.rs", false),
("src/a.rs", false),
("src/debug.log", true),
("src/local/secrets.json", true),
];
assert_eq!(found, expected.map(|(p, i)| (p.to_owned(), i)));
@@ -514,18 +467,15 @@ src/local/
let top: Vec<String> = filter.list_dir(&root).iter().filter_map(|f| filter.rel(&f.path)).collect();
assert!(top.iter().all(|p| !p.contains('/')), "{top:?}");
for (rel, excluded) in [
(".env", false),
("src/new.log", false),
("src/new.rs", false),
("build/x.rs", true),
("logs/app.log", true),
("src/local/x.json", true),
] {
assert_eq!(filter.is_excluded(&root.join(rel), false), excluded, "{rel}");
for rel in
[".env", "src/new.log", "src/new.rs", "build/x.rs", "logs/app.log", "src/local/x.json", "build", "src"]
{
assert!(!filter.is_excluded(&root.join(rel)), "{rel}");
}
assert!(filter.is_excluded(&root.join("build"), true));
assert!(!filter.is_excluded(&root.join("src"), true));
let listed = filter.list_dir(&root.join("src/local"));
assert_eq!(listed.len(), 1);
assert_eq!(listed[0].path, root.join("src/local/secrets.json"));
assert!(listed[0].ignored);
}
#[test]
@@ -544,7 +494,7 @@ src/local/
let mut found: Vec<String> =
filter.walk(&root, &AtomicBool::new(false)).iter().filter_map(|f| filter.rel(&f.path)).collect();
found.sort();
assert_eq!(found, [".gitignore", "src/a.rs"]);
assert_eq!(found, [".gitignore", "out/x.rs", "src/a.rs"]);
}
#[test]
@@ -564,12 +514,12 @@ src/local/
.filter_map(|f| filter.rel(&f.path))
.collect();
found.sort();
assert_eq!(found, ["shared-lib/.gitignore", "shared-lib/src/b.rs", "src/a.rs"]);
assert_eq!(found, ["shared-lib/.gitignore", "shared-lib/out/x.rs", "shared-lib/src/b.rs", "src/a.rs"]);
assert_eq!(filter.store_key(&shared.join("src/b.rs")), None, "extra roots are not persisted");
assert_eq!(filter.store_key(&root.join("src/a.rs")).as_deref(), Some("src/a.rs"));
assert!(!filter.is_excluded(&shared.join("src/new.rs"), false));
assert!(filter.is_excluded(&shared.join("target/y.rs"), false));
assert!(filter.is_excluded(&shared.join("out/y.rs"), false));
assert!(!filter.is_excluded(&shared.join("src/new.rs")));
assert!(filter.is_excluded(&shared.join("target/y.rs")));
assert!(!filter.is_excluded(&shared.join("out/y.rs")));
assert!(filter.same_config(&vec![shared.clone(), root.join("src")].into(), &["target".into()]));
assert!(!filter.same_config(&vec![shared].into(), &["target".into()]));
}
@@ -598,10 +548,49 @@ src/local/
.filter_map(|f| filter.rel(&f.path))
.collect();
found.sort();
assert_eq!(found, [".wt/feature/.gitignore", ".wt/feature/src/b.rs", "lib/d.rs", "src/a.rs"]);
assert_eq!(
found,
[".wt/feature/.gitignore", ".wt/feature/out/c.rs", ".wt/feature/src/b.rs", "lib/d.rs", "src/a.rs"]
);
assert_eq!(filter.store_key(&nested.join("src/b.rs")), None, "extra roots are not persisted");
assert!(!filter.is_excluded(&nested.join("src/new.rs"), false));
assert!(filter.is_excluded(&nested.join("out/new.rs"), false));
assert!(filter.is_excluded(&root.join(".wt/other/x.rs"), false));
assert!(!filter.is_excluded(&nested.join("src/new.rs")));
assert!(!filter.is_excluded(&nested.join("out/new.rs")));
assert!(!filter.is_excluded(&root.join(".wt/other/x.rs")));
let own_files = filter.walk(&nested, &AtomicBool::new(false));
assert!(!own_files.iter().find(|f| f.path == nested.join("src/b.rs")).unwrap().ignored);
assert!(own_files.iter().find(|f| f.path == nested.join("out/c.rs")).unwrap().ignored);
}
#[test]
fn explicit_exclusions_prune_filename_walks_and_watcher_subtrees() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
// The caller supplies files.exclude and the project model's anchored
// output/dependency/environment roots; ignored business folders stay in.
let excluded = ["node_modules", "jvm/build", "rust/target", ".venv", "python/__pycache__", "private"];
for folder in excluded {
touch(&root, &format!("{folder}/nested/hidden.ts"));
}
touch(&root, "notes/nested/todo.ts");
touch(&root, "internal/build/source.ts");
std::fs::write(root.join(".gitignore"), "notes/\ninternal/\n").unwrap();
let globs: Vec<String> = excluded.iter().map(|p| format!("/{p}")).collect();
let filter = PathFilter::new(&root, &vec![].into(), &globs);
let mut found = filter.walk(&root, &AtomicBool::new(false));
found.sort_by(|a, b| a.path.cmp(&b.path));
assert_eq!(
found.iter().map(|f| filter.rel(&f.path).unwrap()).collect::<Vec<_>>(),
[".gitignore", "internal/build/source.ts", "notes/nested/todo.ts"]
);
assert!(found[1..].iter().all(|f| f.ignored));
let dirs = filter.dirs(&root);
assert!(dirs.contains(&root.join("notes/nested")));
for folder in excluded {
let subtree = root.join(folder).join("nested");
assert!(filter.is_excluded(&subtree));
assert!(filter.walk(&subtree, &AtomicBool::new(false)).is_empty());
assert!(filter.list_dir(&subtree).is_empty());
assert!(!dirs.iter().any(|d| d.starts_with(root.join(folder))));
}
}
}
+139 -16
Переглянути файл
@@ -57,6 +57,15 @@ fn files(idx: &ProjectIndex, q: &str) -> Vec<String> {
idx.find_files(q, 20).into_iter().map(|m| m.rel_path).collect()
}
fn assert_filename_only(idx: &ProjectIndex, path: &str) {
assert!(files(idx, path).iter().any(|found| found == path), "{path} must be findable");
let data = idx.shared.data.read();
let entry = data.files.iter().flatten().find(|entry| entry.rel.as_ref() == path).unwrap();
assert!(entry.ignored, "{path} must remain classified as ignored");
assert_eq!(entry.hash, [0; 32], "{path} must not be content-hashed");
assert_eq!(entry.sym_len, 0, "{path} must not have symbols");
}
#[test]
fn exact_file_names_keep_all_source_candidates() {
let f = Fixture::new(&[
@@ -368,7 +377,7 @@ fn go_to_file_finds_ignored_files_but_not_their_symbols() {
let idx = fx.open();
assert_eq!(files(&idx, ".env"), vec![".env"], "the reported case: a git-ignored root file");
assert_eq!(files(&idx, "config.local"), vec!["src/config.local.ts"]);
assert!(files(&idx, "bundle").is_empty(), "ignored directories stay out");
assert_eq!(files(&idx, "bundle"), ["dist/bundle.js"]);
assert!(symbols(&idx, "localOnly", SymbolFilter::All).is_empty(), "ignored files are listed by name only");
assert_eq!(symbols(&idx, "app", SymbolFilter::All), vec!["app"]);
@@ -379,7 +388,8 @@ fn go_to_file_finds_ignored_files_but_not_their_symbols() {
assert!(idx.wait_idle(WAIT));
assert_eq!(files(&idx, "fresh.local"), vec!["src/fresh.local.ts"]);
assert!(symbols(&idx, "freshLocal", SymbolFilter::All).is_empty());
assert!(files(&idx, "more.js").is_empty());
assert_eq!(files(&idx, "more.js"), ["dist/more.js"]);
assert!(symbols(&idx, "more", SymbolFilter::All).is_empty());
// Nested ignore files apply to watcher updates as they do to the scan.
fx.write("pkg/.gitignore", "gen.ts\n");
@@ -406,6 +416,93 @@ fn go_to_file_finds_ignored_files_but_not_their_symbols() {
assert_eq!(files(&idx, "bundle"), vec!["dist/bundle.js"]);
}
#[test]
fn go_to_file_finds_files_in_ignored_folders() {
let fx = Fixture::new(&[
(".git/info/exclude", "/notes/\n"),
(".gitignore", "/local/\n"),
(".ignore", "/scratch/\n"),
("pkg/.gitignore", "private/\n"),
("notes/todo.ts", "export class IgnoredNote {}\n"),
("notes/deep/other.ts", "export class IgnoredOther {}\n"),
("local/config.ts", "export class IgnoredConfig {}\n"),
("scratch/draft.ts", "export class IgnoredDraft {}\n"),
("pkg/private/data.ts", "export class IgnoredData {}\n"),
("pkg/public.ts", "export class PublicThing {}\n"),
("node_modules/dep.ts", "export class Dependency {}\n"),
("target/gen.ts", "export class Generated {}\n"),
]);
std::fs::create_dir(fx.root.join("notes/empty")).unwrap();
let idx = fx.open();
for path in ["notes/todo.ts", "notes/deep/other.ts", "local/config.ts", "scratch/draft.ts", "pkg/private/data.ts"] {
assert_filename_only(&idx, path);
}
assert!(symbols(&idx, "Ignored", SymbolFilter::All).is_empty());
assert_eq!(symbols(&idx, "PublicThing", SymbolFilter::Types), ["PublicThing"]);
assert!(files(&idx, "node_modules/dep.ts").is_empty());
assert!(files(&idx, "target/gen.ts").is_empty());
let fresh = fx.write("pkg/private/new.ts", "export class IgnoredFresh {}\n");
fx.write("notes/new/deep.ts", "export class IgnoredDeep {}\n");
let dependency = fx.write("node_modules/new.ts", "export class DependencyFresh {}\n");
idx.update(&[fresh.clone(), fx.root.join("notes/new"), dependency], &[]);
assert!(idx.wait_idle(WAIT));
assert_filename_only(&idx, "pkg/private/new.ts");
assert_filename_only(&idx, "notes/new/deep.ts");
assert!(files(&idx, "node_modules/new.ts").is_empty());
assert!(symbols(&idx, "Ignored", SymbolFilter::All).is_empty());
std::fs::remove_file(&fresh).unwrap();
std::fs::remove_dir_all(fx.root.join("notes/deep")).unwrap();
idx.update(&[], &[fresh, fx.root.join("notes/deep")]);
assert!(idx.wait_idle(WAIT));
assert!(files(&idx, "pkg/private/new.ts").is_empty());
assert!(files(&idx, "notes/deep/other.ts").is_empty());
drop(idx);
// New files in populated and previously empty ignored directories invalidate the manifest.
let idx = fx.open();
assert_eq!(files(&idx, "notes/todo.ts"), ["notes/todo.ts"]);
drop(idx);
fx.write("notes/offline.ts", "export class IgnoredOffline {}\n");
fx.write("notes/empty/offline.ts", "export class IgnoredEmptyOffline {}\n");
let idx = fx.open();
assert_filename_only(&idx, "notes/offline.ts");
assert_filename_only(&idx, "notes/empty/offline.ts");
assert!(symbols(&idx, "Ignored", SymbolFilter::All).is_empty());
}
#[test]
fn explicit_content_roots_keep_their_own_ignored_files_filename_only() {
let fx = Fixture::new(&[("src/app.ts", "export class App {}\n")]);
let shared = fx._dir.path().join("shared");
std::fs::create_dir_all(shared.join("private")).unwrap();
std::fs::create_dir_all(shared.join("node_modules")).unwrap();
std::fs::write(shared.join(".ignore"), "private/\n").unwrap();
std::fs::write(shared.join("private/local.ts"), "export class SharedIgnored {}\n").unwrap();
std::fs::write(shared.join("public.ts"), "export class SharedPublic {}\n").unwrap();
std::fs::write(shared.join("node_modules/dep.ts"), "export class SharedDependency {}\n").unwrap();
let idx = fx.open();
idx.set_scope(vec![shared.clone()], vec!["**/node_modules".into(), "**/target".into()]);
assert!(idx.wait_idle(WAIT));
assert_filename_only(&idx, "shared/private/local.ts");
assert_eq!(symbols(&idx, "SharedPublic", SymbolFilter::Types), ["SharedPublic"]);
assert!(symbols(&idx, "SharedIgnored", SymbolFilter::All).is_empty());
assert!(files(&idx, "shared/node_modules/dep.ts").is_empty());
std::fs::create_dir(shared.join("private/new")).unwrap();
std::fs::write(shared.join("private/new/fresh.ts"), "export class SharedFresh {}\n").unwrap();
idx.update(&[shared.join("private/new")], &[]);
assert!(idx.wait_idle(WAIT));
assert_filename_only(&idx, "shared/private/new/fresh.ts");
assert!(symbols(&idx, "SharedFresh", SymbolFilter::All).is_empty());
std::fs::remove_dir_all(shared.join("private/new")).unwrap();
idx.update(&[], &[shared.join("private/new")]);
assert!(idx.wait_idle(WAIT));
assert!(files(&idx, "shared/private/new/fresh.ts").is_empty());
assert_filename_only(&idx, "shared/private/local.ts");
}
#[test]
fn second_window_on_same_project_works_in_memory() {
let fx = sample();
@@ -854,13 +951,19 @@ fn warm_start_detects_changed_ignore_rules() {
let f = Fixture::new(&[("sub/generated/a.rs", "fn a() {}\n"), (".git/HEAD", "ref: refs/heads/main\n")]);
f.write("sub/.gitignore", "");
let idx = f.open();
assert_eq!(idx.status().files, 2, "generated/a.rs plus .gitignore itself");
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"]);
drop(idx);
std::thread::sleep(Duration::from_millis(20));
f.write("sub/.gitignore", "generated/\n");
let idx = f.open();
assert_eq!(idx.status().files, 1, "an updated ignore rule invalidates the warm snapshot");
assert_filename_only(&idx, "sub/generated/a.rs");
assert!(symbols(&idx, "a", SymbolFilter::All).is_empty(), "changed rules invalidate cached symbols");
drop(idx);
f.write("sub/.gitignore", "");
let idx = f.open();
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"], "unchanged contents are parsed after unignoring");
}
#[test]
@@ -871,20 +974,24 @@ fn warm_start_detects_changed_ignore_rules_above_the_project() {
std::fs::create_dir_all(repo.join(".git/info")).unwrap();
std::fs::write(repo.join(".git/HEAD"), "ref: refs/heads/main\n").unwrap();
let idx = f.open();
assert_eq!(idx.status().files, 2);
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"]);
assert_eq!(symbols(&idx, "b", SymbolFilter::All), ["b"]);
drop(idx);
std::fs::write(repo.join(".gitignore"), "proj/generated/\n").unwrap();
let idx = f.open();
assert_eq!(idx.status().files, 1, "a new ignore file above the project invalidates the warm snapshot");
assert_filename_only(&idx, "generated/a.rs");
assert!(symbols(&idx, "a", SymbolFilter::All).is_empty(), "new ancestor rules invalidate cached symbols");
assert_eq!(symbols(&idx, "b", SymbolFilter::All), ["b"]);
drop(idx);
std::thread::sleep(Duration::from_millis(20));
std::fs::write(repo.join(".gitignore"), "").unwrap();
std::fs::write(repo.join(".git/info/exclude"), "proj/src/\n").unwrap();
let idx = f.open();
assert_eq!(idx.status().files, 1, "so do the enclosing repository's changed rules");
assert!(!symbols(&idx, "a", SymbolFilter::All).is_empty());
assert_filename_only(&idx, "src/b.rs");
assert!(symbols(&idx, "b", SymbolFilter::All).is_empty());
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"], "unignored contents are re-parsed unchanged");
}
#[test]
@@ -901,12 +1008,20 @@ fn warm_start_detects_a_changed_exclude_file_of_a_linked_worktree() {
std::fs::write(worktree.join("commondir"), "../..\n").unwrap();
std::fs::write(f.root.join(".git"), format!("gitdir: {}\n", worktree.display())).unwrap();
let idx = f.open();
assert_eq!(idx.status().files, 2);
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"]);
assert_eq!(symbols(&idx, "b", SymbolFilter::All), ["b"]);
drop(idx);
std::fs::write(main.join("info/exclude"), "generated/\n").unwrap();
let idx = f.open();
assert_eq!(idx.status().files, 1, "the shared exclude file invalidates the warm snapshot");
assert_filename_only(&idx, "generated/a.rs");
assert!(symbols(&idx, "a", SymbolFilter::All).is_empty(), "shared exclude rules invalidate cached symbols");
assert_eq!(symbols(&idx, "b", SymbolFilter::All), ["b"]);
drop(idx);
std::fs::write(main.join("info/exclude"), "").unwrap();
let idx = f.open();
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"], "unignored contents are re-parsed unchanged");
}
#[test]
@@ -939,19 +1054,24 @@ fn rule_changes_refresh_only_the_affected_index_subtree() {
fx.write(rule, "");
let idx = fx.open();
assert_eq!(files(&idx, "file.ts"), ["sub/generated/file.ts"]);
assert_eq!(symbols(&idx, "generated", SymbolFilter::All), ["generated"]);
assert_eq!(symbols(&idx, "localOnly", SymbolFilter::All), ["localOnly"]);
fx.write(rule, "generated/\nlocal.ts\n");
let dirs = [fx.root.join(subtree)];
idx.ignore_rules_changed(&dirs);
assert!(idx.wait_idle(WAIT));
assert!(files(&idx, "file.ts").is_empty(), "{rule}: ignored directory remained indexed");
assert_eq!(files(&idx, "local.ts"), ["sub/local.ts"]);
assert_filename_only(&idx, "sub/generated/file.ts");
assert!(symbols(&idx, "generated", SymbolFilter::All).is_empty(), "{rule}: ignored symbols remained indexed");
assert_filename_only(&idx, "sub/local.ts");
assert!(symbols(&idx, "localOnly", SymbolFilter::All).is_empty());
assert_eq!(files(&idx, "keep.ts"), ["other/keep.ts"]);
assert_eq!(symbols(&idx, "keep", SymbolFilter::All), ["keep"]);
fx.write(rule, "");
idx.ignore_rules_changed(&dirs);
assert!(idx.wait_idle(WAIT));
assert_eq!(files(&idx, "file.ts"), ["sub/generated/file.ts"]);
assert_eq!(symbols(&idx, "generated", SymbolFilter::All), ["generated"]);
assert_eq!(symbols(&idx, "localOnly", SymbolFilter::All), ["localOnly"]);
// The cached root matcher must also follow the rules for later watcher updates.
let fresh = fx.write("sub/generated/new.ts", "export function fresh() {}\n");
@@ -966,7 +1086,7 @@ fn repository_rule_changes_refresh_members_of_an_unindexed_container() {
let fx = Fixture::new(&[
(".git/HEAD", "ref: refs/heads/main\n"),
(".git/info/exclude", ""),
("member/generated/item.txt", "x"),
("member/generated/item.rs", "fn member_item() {}\n"),
]);
let idx = ProjectIndex::open(
&fx.root,
@@ -979,15 +1099,18 @@ fn repository_rule_changes_refresh_members_of_an_unindexed_container() {
)
.unwrap();
assert!(idx.wait_idle(WAIT));
assert_eq!(files(&idx, "item.txt"), ["member/generated/item.txt"]);
assert_eq!(files(&idx, "item.rs"), ["member/generated/item.rs"]);
assert_eq!(symbols(&idx, "member_item", SymbolFilter::All), ["member_item"]);
fx.write(".git/info/exclude", "generated/\n");
idx.ignore_rules_changed(std::slice::from_ref(&fx.root));
assert!(idx.wait_idle(WAIT));
assert!(files(&idx, "item.txt").is_empty());
assert_filename_only(&idx, "member/generated/item.rs");
assert!(symbols(&idx, "member_item", SymbolFilter::All).is_empty());
fx.write(".git/info/exclude", "");
idx.ignore_rules_changed(std::slice::from_ref(&fx.root));
assert!(idx.wait_idle(WAIT));
assert_eq!(files(&idx, "item.txt"), ["member/generated/item.txt"]);
assert_eq!(files(&idx, "item.rs"), ["member/generated/item.rs"]);
assert_eq!(symbols(&idx, "member_item", SymbolFilter::All), ["member_item"]);
}
#[test]
+1 -1
Переглянути файл
@@ -926,7 +926,7 @@ impl Shared {
continue;
}
let Ok(meta) = std::fs::symlink_metadata(&path) else { continue };
if filter.is_excluded(&path, meta.is_dir()) {
if filter.is_excluded(&path) {
continue;
}
if meta.is_dir() {
+4 -8
Переглянути файл
@@ -407,18 +407,14 @@ impl Peer {
let resolved = resolve_spawn_program(command, env);
let mut cmd = tokio::process::Command::new(&resolved);
// The working directory first: it picks the project's environment.
cmd.current_dir(cwd);
cmd.current_dir(cwd)
.envs(ide_core::process::shell_env_in(cwd))
.envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())));
ide_core::process::prepare(cmd.as_std_mut());
// Wrappers (`npx`, `codex.cmd`, launcher scripts) start the real server as a child:
// stopping the connection stops the whole tree.
ide_core::process::own_group(cmd.as_std_mut());
cmd.args(args)
.envs(ide_core::process::shell_env_in(cwd))
.envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())))
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
cmd.args(args).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).kill_on_drop(true);
let mut child = cmd.spawn()?;
let stdin = child.stdin.take().ok_or_else(|| std::io::Error::other("child stdin unavailable"))?;
let stdout = child.stdout.take().ok_or_else(|| std::io::Error::other("child stdout unavailable"))?;
+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)));
}
}
Loaded 100 of 798 files, more files were not shown because too many files have changed in this diff. Show more