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

...
Автор SHA1 Повідомлення Дата
l0ng-ai 60882d647f Merge remote-tracking branch 'origin/main' into fix/debugger-evaluation-layout 2026-11-20 04:36:10 +08:00
l0ng-ai 1ad8b06a1a fix(markdown): keep the Project view clickable in Preview only (#4604)
In Preview only the editor panel stays mounted but hidden, with no separator. react-resizable-panels adds an implicit resize region between two enabled panels without a separator; with the hidden panel's rect at zero it spanned everything left of the preview, showing a resize cursor and swallowing clicks in the Project view. The hidden editor panel is now disabled, leaving the group a single resizable panel.

Fixes #4589
2026-11-20 04:35:55 +08:00
l0ng-ai 2ca0e195e5 fix(editor): keep inline find controls inside narrow panes (#4588)
The inline find/replace bar used a fixed grid with a 220px minimum field, so in narrow editor panes the counter, option buttons and Close spilled outside the pane. The bar is now a container-query layout: fields shrink, the action groups wrap, and below 500px (and again below 224px) the actions and replace field move to their own rows while Show Replace and Close stay reachable.
2026-11-20 04:33:34 +08:00
Mr0Bread 750d35dd6e fix(vcs): discard stale status after project switch (#4598)
The VCS store reset on project switch, but replies to refreshes started for the previous project still wrote to it, restoring its branch, changed files and decorations and firing conflict notifications. A project generation, bumped on every switch (also when reopening the same folder), now gates full and incremental refresh results, errors and discovered roots; queued paths are dropped on switch, and the refresh queue still drains for the active project.

Closes #4596

Co-authored-by: Mr0Bread <[email protected]>
2026-11-20 04:10:23 +08:00
l0ng-ai f0273690b9 fix(run): keep test results readable in narrow panes (#4586)
The test tree's header held the counts, duration and every toolbar action in one 28px row, so narrow Run panes clipped the counts and buttons. As in IDEA's new layout, the status (icon, counts, total duration) now sits above the console, Expand All, Collapse All and Export Test Results move into a More Actions menu, and the tree and console stack vertically below 560px with their own remembered split.
2026-11-20 04:07:52 +08:00
l0ng-ai 04611c0388 fix(database): show a running SQL statement in the editor and results (#4601)
The console tracked the running request only for Run and Cancel; statement marks and result tabs arrived after it ended, and the Results view said "No results" meanwhile. While a request runs, the submitted statements are highlighted with a gutter spinner and a ticking elapsed time, and the Results view opens with an executing bar above the previous result. Edits during the run move the marks and the outcomes land on their statements; cancel or an error clears the indication and keeps the previous result.

Fixes #4565
2026-11-20 04:06:41 +08:00
l0ng-ai 1cfc71ae58 fix(editor): make symbol rename and its preview readable in narrow windows (#4583)
The symbol rename prompt was a caret-anchored popup that could be clipped in narrow windows, and its preview truncated long names. When in-place rename isn't available, Rename now opens a dialog with the symbol context, a New name field in the editor font, and an optional note; the refactoring preview keeps the context, wraps occurrence snippets in the editor font and theme, and truncates long file names with the full path in the tooltip.
2026-11-20 03:56:29 +08:00
l0ng-ai 8daaef38d9 fix(run): keep Run Anything controls visible on short windows (#4581)
Run Anything had a fixed 620px popup with a 360px list cap and a footer that could fall off short windows. The popup now fits the viewport as a column whose list shrinks, uses the shared search field with combobox semantics, shows the completion of the selected entry in the field, pages by the visible row count (compact-aware), and keeps a wrapping footer with the navigation hints.
2026-11-20 03:39:37 +08:00
Chris Schofield efd4e454ee feat(appearance): make Compact Mode match IntelliJ's compact density (#4593)
Compact Mode only lowered the title bar and narrowed the stripes: row heights, toolbar widgets and icons were fixed in code, and nothing in JS (where virtualised list row heights are set) could tell whether the mode was on. A small density store now mirrors the setting for JS, and Compact Mode uses IntelliJ's *.compact theme values: tree/list rows 22 (VCS log 24), toolbar widgets 26, toolbar and stripe icons 16, status bar 24, island gap 4, and chrome text 1px smaller.

Co-authored-by: ChildishForces <[email protected]>
2026-11-20 03:26:32 +08:00
l0ng-ai 0379c37a49 fix(usages): keep results and previews readable in narrow windows (#4580)
The Show Usages popup and the Find usages view used fixed header heights, a flexible spacer and a fixed preview height, so in narrow windows the title, file names and line numbers were clipped and the preview pushed results off screen. Headers now wrap their actions, rows use a file / line / text grid with truncation, and the preview shrinks with the viewport.
2026-11-20 03:21:33 +08:00
l0ng-ai 98da80b2b3 fix(editor): keep the current breadcrumb visible (#4579)
Long breadcrumb trails hid the current file or symbol when the editor or status bar ran out of room. Both trails now scroll to the current location (with edge fades) and keep earlier entries reachable by wheel, trackpad or keyboard. The status bar reserves a minimum width for the path and moves lower-priority widgets into its overflow menu. Code breadcrumbs use the editor font and highlight the symbol at the caret.
2026-11-20 03:05:31 +08:00
l0ng-ai 5c2e7ff92a fix(editor): fit intention previews beside or below the list (#4578)
The intention preview had a fixed 420px width beside the list, which pushed the action list away from the caret or got clipped in narrow windows. The preview now opens to the right when there is room, to the left when that keeps the list by the caret, and below the list in narrow windows. Preview code follows the editor's font settings and theme and wraps long lines.
2026-11-20 02:54:44 +08:00
l0ng-ai e86a853048 fix(run): keep configuration names visible in narrow sidebars (#4573)
A long run target could take the whole row in the Run/Debug Configurations sidebar, leaving the configuration name at zero width and forcing horizontal scrolling. Target labels now truncate in wide panes, narrow panes (container query) hide the muted target and scope, and the row tooltip carries the full name, target, scope and command. Type headings are semibold.
2026-11-20 02:53:44 +08:00
l0ng-ai fd8f0eb99c fix(editor): make quick documentation fit narrow windows (#4568)
Quick Documentation used a fixed 600px cap and kept its caret anchor after the window shrank, so short documents looked cramped and the actions could end up off screen. The popup now sizes to a 300-500px content width, keeps its actions together in the lower-right corner while the document scrolls, and clamps the anchor to the current viewport.
2026-11-20 02:52:46 +08:00
l0ng-ai 121e1fa535 fix(completion): fit the lookup to the editor and its font (#4566)
The lookup reserved a fixed 420px row, so long names pushed the signature and type past the editor edge, and the body-level tooltip ignored temporary editor zoom. It now sizes to its content within the editor's tooltip bounds, truncates each field, applies the label alignment through CodeMirror's own offset so the viewport clamp accounts for it, and follows the editor's current font size.
2026-11-20 02:51:47 +08:00
lleviathe 5859cf9f5b feat(mcp): show background projects in the status bar (#4590)
A Background Projects status bar item shows how many projects the MCP server holds open without a window, only while there are any (and never in a remote window). Its popup lists each project with its badge, state and path, opens one in its own window or unloads it, and offers Unload All and MCP Server Settings. The Settings page's Open now list uses the same rows.

Co-authored-by: lleviathe <[email protected]>
2026-11-20 02:49:08 +08:00
l0ng-ai 21b187f2d5 test: fix main's spacing-scale and model-refresh failures (#4591)
pnpm test failed on main twice: the HTTP Client's redirect list from #4519 used gap: 2px instead of --space-0-5, and the agent model-refresh test's IPC mock lacked vcsRemotes, which the session's origin lookup reads since #4554.
2026-11-20 02:47:51 +08:00
Aditya Aggarwalтаaditya-786 121d7edc15 feat(spring): find Feign clients for a controller endpoint (#4584)
A Spring controller endpoint gets Find Feign Clients (gutter menu, editor context menu, Find Action; Java and Kotlin): it matches the HTTP method and literal route across the trusted workspace and uses the controller module's spring.application.name to leave out clients of other services. One known match opens directly; otherwise a chooser lists the interface methods, with unresolved service names and explicit URLs marked Possible match.

Co-authored-by: aditya-786 <[email protected]>
2026-11-20 02:44:16 +08:00
l0ng-ai 9c0dcb94cf fix(debugger): keep evaluation results readable in short dialogs 2026-11-20 02:43:21 +08:00
Gabriel Gondim b9256a7260 fix(deployment): use Commit selection for upload shortcuts (#4585)
Deployment actions run by shortcut, Find Action or the Tools menu used the Project view's selection (else the editor's file) even in the Commit tool window, where only the context menu passed the selected changes. The changes tree now provides its selection while Commit or Git > Local Changes is focused, without deleted files, and Deployment takes it after a menu's paths.

Co-authored-by: GGVidal <[email protected]>
2026-11-20 02:28:50 +08:00
Mansur Akhmadiтаmansur-akhmadi 47b4cb55ba feat(run): Sort Alphabetically / Sort by Duration in the test results toolbar (#4576)
The test results toolbar gets Sorting Options with Sort Alphabetically (by name at every level, ignoring case, numbers by value) and Sort by Duration (slowest first at every level, a suite by its total, untimed last; disabled and not applied while the run is in progress). The two replace each other, run after the filters and are kept with Show Passed / Show Ignored.

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-20 01:31:29 +08:00
Vadim LazukтаInf1mum da1bcd67cd fix(http-client): keep the request method across redirects and show the hops (#4519)
reqwest's automatic redirects turned a POST into a plain GET on a 301 or 302, such as the http to https redirect in #4486, and hid the redirect. Redirects are now followed by hand, as IntelliJ's HTTP Client does: 301, 302, 303, 307 and 308, at most 50 times. A 303 continues as GET without the body; the other statuses keep the method and body. Authorization and cookie headers are not re-sent to another host. The followed hops are listed in the response view.

Co-authored-by: Inf1mum <[email protected]>
2026-11-20 01:30:22 +08:00
Mr0Bread 67a4797cf4 fix(editor): preserve dirty state across concurrent saves (#4571)
Typing while a save was pending could leave the editor clean although the newest edit was not written: the save reply cleared the dirty flag even after a dirty event for a newer version, and a delayed clean event for the earlier write could clear it too. DocDirty now carries the document version from under the backend lock; the editor applies a clean transition only when that version is the synced one and no edits are pending, and a save reply only confirms the version it sent.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-20 01:28:48 +08:00
l0ng-ai 39523bc419 fix(terminal): float search over the output area (#4560)
Find in Terminal took a full-width row and shrank the grid. Wide, tall panes now show a compact search bar over the output's upper-right corner, keeping the full grid; it moves to the lower right when it would cover the active match. Short panes use an inline bar and narrow panes put the controls in two rows.
2026-11-20 01:23:38 +08:00
Mr0Bread 639c76d54c test(documents): protect dirty state on failed saves (#4567)
Tests that a failed save keeps the edited buffer dirty and emits no clean-state event: text the encoding can't represent, permission denial (Unix, with a retry after restoring permissions) and a file replaced by a directory. Disk bytes and the replacement directory stay untouched.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-20 01:21:12 +08:00
l0ng-ai d5f29ea256 fix(build-tools): keep toolbar actions reachable in narrow panes (#4558)
The Maven and Gradle toolbars used one fixed row, which clipped actions in narrow panes. Narrow panes keep reload or cancel, run and execute visible and group the rest in More Actions; widening the pane restores the full toolbar, keeping the offline and skip-tests toggle states.
2026-11-20 01:06:13 +08:00
l0ng-ai f9455549a7 fix(vcs): keep branch rows readable in narrow popups (#4551)
Git Branches uses the interface font for branch names, tracked branches and refs, tapers indentation at deeper levels and limits the width of secondary refs, so deeply nested branches keep room for the name, commit counts and submenu arrow. The full branch and tracked ref show on hover.
2026-11-20 00:45:28 +08:00
l0ng-ai dd14e8b040 fix(run): keep classpath and target probes from opening console windows on Windows (#4562)
On Windows the GUI-subsystem app gave console children their own window unless they were spawned with CREATE_NO_WINDOW. Three probes used a bare std Command: the Maven classpath probe behind delegated Run/Debug, the .NET target-path probe and go list for file-scoped Go tests. The first two now go through ide_core::process::prepare; the Go probe, whose environment is already built, gets the flag. The other backend spawn sites already prepare.
2026-11-20 00:42:56 +08:00
Paweł SzymańskiтаPawelSzymanski89 efce16d45d feat(agents): add Hermes Agent with a profile picker and richer tool-call view (#4542)
Adds Hermes Agent as a built-in ACP agent, with a Hermes profile picker. The tool-call view also gets richer: kind icons, duration, status, exit codes, a terminal block for commands, and links to the files a tool touched (omitted when the title already names the file).

Co-authored-by: PawelSzymanski89 <[email protected]>
2026-11-20 00:32:51 +08:00
l0ng-ai 977ce62bf0 fix(search): improve recent file and location layouts (#4548)
Recent Files keeps directories beside file names and gives the list and filter more room in narrow windows. Recent Locations snippets follow the editor font and line spacing, and long file names leave room for the change label and timestamp.
2026-11-20 00:22:22 +08:00
l0ng-ai 479123dcf3 fix(plugins): give a child's status only with the last of its output (#4572)
poll and wait returned the exit status as soon as the process ended. Reader threads could still be copying its pipes, or more output could be buffered than one chunk holds, so a caller stopping at the first status parsed a truncated result. The status now comes only with the chunk that drains the output once both pipes reached the end. WIT, SDK and guide docs say so, and point to run_command for a command's whole output.
2026-11-20 00:18:30 +08:00
l0ng-ai 09301ca12d test(bench): skip browser tests where Playwright's Chromium isn't installed (#4570)
Since #4489 and #4491, harness tests under pnpm test launched Chromium, but CI's Frontend job installs no Playwright browsers, so Frontend failed on every pull request. Those tests now skip when the build they launch (headless shell, or the full browser for the chromium channel) is missing. The legacy artifact-date test compares whole seconds, which every file system keeps.
2026-11-20 00:03:28 +08:00
l0ng-ai 485c1ac40b fix(search): fit Search Everywhere within a compact popup (#4546)
Search Everywhere opens at 700 px wide and up to 600 px tall, query and footer included. Long lists and the code preview fit inside that height, so more of the editor stays visible.
2026-11-20 00:02:05 +08:00
l0ng-ai 6d756ec472 fix(editor): keep diagnostics in place through edits when another source updates (#4563)
Whenever any diagnostic source published, the editor converted every source's stored line/column ranges against the current text again. So lists published earlier, notably checks of the saved file (build, PHPStan, Kotlin bridge), jumped to the wrong code after typing. Each source's list is now anchored to the text it arrived for, and placed through the edits made since then. The editor-side counterpart of #4482.
2026-11-19 23:40:34 +08:00
Mr0Bread 8b427bcedd test(editor): cover stale formatter responses (#4559)
Regression tests for formatter responses that arrive after the document changed: format on save stays silent, explicit formatting shows the stale-response hint, a same-length edit is still detected, and an unchanged buffer formats as before.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Closes #4466

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

Closes #4474

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

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

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

Co-authored-by: 0xC3B6 <[email protected]>
2026-11-19 19:16:43 +08:00
l0ng-ai 58585e1064 feat(vcs): choose the agent, model and effort for Generate Commit Message (#4504)
Settings › Version Control › Commit › Commit Message Generation gets Agent, Model and Effort dropdowns (vcs.commit.agent / agentModel / agentEffort). Automatic keeps the agent of the latest task on its model; a chosen agent runs on the chosen model and thinking level when it offers them, independent of the chat's model. The lists come from the agent's model catalog.
2026-11-19 19:15:53 +08:00
l0ng-ai 0f355c286d fix(format): keep the caret when a language server replaces the whole file (#4497)
Vue's language server answers Reformat Code with one edit replacing the whole document, which moved the caret and the view to the top of the file. Multi-line LSP formatting edits are now reduced to one edit per changed region via Document::diff, which covers every server that formats this way.
2026-11-19 19:05:18 +08:00
l0ng-ai a0a51a63cb feat(vcs): open a push dialog file's diff in its own window (#4490)
Double-click or Enter on a file in the push dialog opens its diff in a separate diff window (Show Diff in New Window), as IDEA's push dialog does; closing it returns to the dialog. Before, the diff was only shown in a split inside the small modal dialog. Selecting a file still shows the diff in the dialog.
2026-11-19 18:28:32 +08:00
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
l0ng-ai f3e80ba020 feat(http-client): navigate from a request URL to its endpoint handler (#4341)
⌘-click / Go to Declaration on a request URL in a .http file opens the handler of the endpoint it reaches, matched by method and path ({var}/*/** in the mapping, {{var}} in the request, an optional context path).
2026-11-18 22:42:02 +08:00
l0ng-ai f767bd2e7c fix(http-client): resolve Spring mapping constants declared in other classes (#4340)
Mapping paths were evaluated with the controller file's own constants only, so paths built from another class's constants dropped out of Endpoints search and showed partial URLs in the gutter. A shared constant pool finds the referenced classes by name in the index (imported package first), reads them and resolves their constants, following static imports and superclasses up to three hops.
2026-11-18 22:39:20 +08:00
l0ng-ai 51174842cc fix(database): keep Save password ticked in the connect prompt (#4338)
The connect-time password prompt stored the password but left the data source's savePassword off, and saved passwords are only read when it is on, so every connection asked again. The prompt's checkbox now updates the data source setting; the SSH secret prompt does the same for a source's own SSH settings.
2026-11-18 22:32:53 +08:00
l0ng-ai e4ece2bd8d fix(search): list scratch files in Recent Files (#4337)
Recent Files only recorded paths inside the project, so scratch files never appeared in ⌘E. Files outside the project are now recorded and persisted by absolute path; the popup and Switcher show files under the Scratches root as Scratches/<path>.
2026-11-18 22:30:54 +08:00
l0ng-ai a5093c0cd1 fix(workbench): space project tabs from the island below by the island gap (#4336)
The tab bar's bottom padding was --space-0-5 (2px), so the selected project tab island sat 2px above the islands below while islands are --island-gap (6px) apart.
2026-11-18 22:23:47 +08:00
l0ng-ai 9a0256c7d4 fix(ui): show a resize cursor on splitters under WebKit on macOS 26.2 (#4334)
WebKit on macOS 26.2 renders ew-resize/ns-resize as the default arrow, so dividers gave no hover feedback. Dividers (tool window gaps and splits, editor splits, side tabs, diff gutter, column resizers, review handles) and the drag-time cursor lock now use col-resize/row-resize. Window and popup edge handles are unchanged.
2026-11-18 22:21:24 +08:00
l0ng-ai 78b478ee38 fix(plugins): say which project a document-changed path is relative to (#4332)
document-changed gave plugins the path relative to the file's own project but not which project, so with two open projects holding the same relative path a plugin couldn't tell which document changed. The event now carries project (the root the path is relative to); the SDK's DocumentChanged exposes it as Option<String>. The payload is JSON through other, so WIT is unchanged; plugin components are rebuilt for the SDK change.
2026-11-18 22:13:03 +08:00
Akbar Husain 926a5424d1 perf(build): bound retained compile output, keep head and tail (#4025)
A compile step kept every line of its child's output in memory for the error summary, though each line is already streamed to the Build tool window. Compile steps now run through process::run_bounded, which keeps the head and tail of the output (and splits over-long lines) and marks the text as truncated; the error summary says when lines may be missing. Callers that parse a successful run's output (Gradle model and tasks, Gradle dependencies, Maven dependency trees and sources) keep using process::run with full retention.

Co-authored-by: akbar1214 <[email protected]>
2026-11-18 21:53:57 +08:00
MyRRR f1aa47e762 feat(editor): structured Julia syntax highlighting (#4161)
Julia used CodeMirror's legacy StreamLanguage mode, which has no tags for function calls, type names or macros. It now uses Pluto's MIT-licensed Lezer grammar (@plutojl/lang-julia), with call targets tagged as function names, and Julia joins the language-scoped Color Scheme settings with a preview sample.

Co-authored-by: Royshare <[email protected]>
2026-11-18 21:50:17 +08:00
l0ng-ai 305dbdc316 fix(gradle): show resolvable configurations for the selected project (#4281)
Dependency Analyzer offered a fixed list of configurations, so a custom resolvable configuration couldn't be selected. It now lists the configurations Gradle reports as resolvable for the selected project, custom ones included, and syncs projects whose configuration data is missing or stale when it opens. Configurations used only to declare dependencies are excluded.
2026-11-18 21:46:45 +08:00
Mamaev Igor 0a4f2fc1df fix(vim): move between notebook cells with j and k (#4317)
In a notebook with Vim enabled, Normal-mode j on a cell's last line and k on its first line now continue into the next or previous cell that shows an editor (code, or Markdown being edited), at the same column; Markdown previews and raw cells are skipped. Counts, operators and registers (3j, dj) stay inside the cell. Notebooks provide the neighbouring editor through a new adjacentEditor facet.

Co-authored-by: pxc1984 <[email protected]>
2026-11-18 21:45:04 +08:00
Mr0Bread 93210c8c04 fix(agents): refresh models in existing chats (#4062)
An existing chat only offered the models its session reported. Its composer now uses the same searchable model picker and Refresh models control as New Agent Task. A model that only the fresh catalog lists is tried on the live session first; if the agent rejects it and the session is idle and resumable, the choice is kept as pending, the live process is recycled, and the next message reloads the same session and applies it through the existing wanted-settings path. If the reload can't apply it, the previous model is restored and the error reported without sending.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-18 21:43:50 +08:00
Vladislav Kuzmin c52067f815 fix(database): support ClickHouse HTTP endpoints without session affinity (#4316)
Behind an endpoint that alternates replicas, the named HTTP session opened by Test Connection was missing on the next node (code 372), so the data source could not connect. Setting use_http_session=false in a data source's Advanced properties sends each request without a session, carrying its own database, settings and limits; startup scripts are rejected in that mode. Named sessions stay the default and now run USE for the configured database, since the HTTP database parameter applies only to the request carrying it. A lost session reports how to fix it and never replays the user's SQL.

Co-authored-by: principalwater <[email protected]>
2026-11-18 21:39:34 +08:00
Moler1995 fce37c5627 fix(vim): sync registers with the system clipboard and route paste/copy per mode (#4136)
The "+ and "* registers read and write the system clipboard (CRLF normalised, linewise when the text ends with a line break), Insert-mode Ctrl+V / Shift+Insert paste and Visual-mode Ctrl+C copy. A new clipboard option (default ideaput,autoselect) controls the unnamed register: set clipboard+=unnamed or clipboard=unnamedplus in .ideavimrc mirrors yanks, deletes and changes to the system clipboard; by default they stay in Vim's registers. "+ is read through the native clipboard where the backend provides it.

Co-authored-by: Moler1995 <[email protected]>
2026-11-18 21:38:01 +08:00
liziing 90df4ba48e fix(vcs): show declaration icons in the Compare tool window (#4300)
The Compare tool window chose every icon from the file name alone. When a revision is compared with the working tree, files that still exist now take their icon from the shared file presentation cache, as the Project tree does: Java and Kotlin classes, interfaces and tests, and Spring config files. Deleted files and comparisons between two revisions keep their file-type icons.

Co-authored-by: liziing <[email protected]>
2026-11-18 21:33:45 +08:00
l0ng-ai c3034b25e8 Stage TODO and Vim preferences until Settings applies them (#4283) 2026-11-18 21:32:25 +08:00
l0ng-ai b5c2a84d5d Keep file type association edits on the visible selection (#4282) 2026-11-18 21:32:17 +08:00
lleviathe 723666891d feat(settings): indent dependent options under their checkbox and disable them while unchecked (#4308)
A checkbox option on a declarative settings page can have children, rendered indented under it and disabled while it is unchecked, like the editor pages already do. IDE MCP Server's Port is the first one, under Use a fixed port; both search indexes still list it.

Co-authored-by: lleviathe <[email protected]>
2026-11-18 21:30:35 +08:00
lleviathe 268f12349f fix(settings): space hints from their control and start checkbox hints at the checkbox text (#4306)
Hints now sit 4px below their control, and checkbox hints start at the checkbox text (box plus label gap) on both declarative and editor settings pages.

Co-authored-by: lleviathe <[email protected]>
2026-11-18 21:30:31 +08:00
lleviathe 4dfdbd35fd fix(settings): keep wrapped hints from overlapping the next row in WebKit (#4305)
WebKit sizes an auto grid row from its item's height at an earlier width, so after the Settings window narrowed, a hint that wrapped to one more line lay over the row below. The form group and row grids now use grid-auto-rows: min-content.

Co-authored-by: lleviathe <[email protected]>
2026-11-18 21:30:26 +08:00
l0ng-ai 281b093774 fix(todo): include live matches from all files in Open Files scope (#4279) 2026-11-18 21:29:54 +08:00
l0ng-ai a55394782a Apply Vim mappings when reloading from Settings (#4278) 2026-11-18 21:29:47 +08:00
l0ng-ai ede72f0941 fix(startup): don't time out while the Trust Project prompt waits for an answer (#4321)
A window opened for an untrusted project asks Trust Project over the splash. The 60-second startup watchdog in boot.js kept counting while the prompt was up, so answering after a minute replaced it with the startup failure page. askOverSplash now signals when a question starts and ends, and the watchdog pauses for that time, as it already does while the window is hidden.
2026-11-18 21:25:58 +08:00
l0ng-ai 3ed4fa6836 fix(vcs): keep worktree operation errors through refresh (#4271) 2026-11-18 21:20:10 +08:00
l0ng-ai 4990a90bbf Keep build selections when reloading the .NET workspace (#4267) 2026-11-18 21:14:17 +08:00
l0ng-ai 762b509b66 fix(coverage): keep asynchronous results with their project (#4260) 2026-11-18 21:05:39 +08:00
l0ng-ai 2964b2ffc5 Ignore Logcat callbacks from superseded streams (#4259) 2026-11-18 21:05:16 +08:00
l0ng-ai 704952a6ae fix(build): ignore completions from superseded requests (#4258) 2026-11-18 21:05:07 +08:00
l0ng-ai 65007093e7 Confirm before replacing a saved macro recording (#4256) 2026-11-18 21:03:14 +08:00
l0ng-ai 696ab0c3ba fix(http-client): pin the starting environment for request batches (#4255) 2026-11-18 21:01:37 +08:00
l0ng-ai e282546697 Isolate GitHub review drafts by pull request context (#4252) 2026-11-18 20:55:46 +08:00
l0ng-ai 93fb7b6a85 fix(search): keep an empty Directory scope inactive (#4250) 2026-11-18 20:53:07 +08:00
Mr0Bread e691aa9fb3 fix(ui): remeasure popup height before choosing a side (#4296)
The shared Popup decided where it fit using the max-height cap from its previous placement, so a popup clipped below its anchor still looked as if it fit there: the agent Composer's @ list stayed clipped after erasing the filter or when file results arrived after it opened. A middleware now clears the old cap before flip, and the size step only caps a popup that is taller than the space available.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-18 20:35:10 +08:00
acaoтаamphetamlne 44a12abbd7 perf(vfs): compact adjacent duplicate modification events (#3276)
Adjacent, exactly identical single-path Modify(Any/Data/Metadata) notifications (same path spelling, event and process id) are merged before they accumulate in the debounce queue; create/remove/rename, multi-path and flagged events are kept, and the first/last arrival times are kept so the 100 ms debounce and 1 s maximum delay don't move. A debug-level "file watcher batch" line reports received/queued counts and queue, processing and callback times.

Co-authored-by: amphetamlne <[email protected]>
2026-11-18 20:33:50 +08:00
GuoYuтаguoyucode 497b25bf4a fix(mcp): say projectPath defaults to the connection's project (#4262)
Every MCP tool described projectPath as optional only when one project is open, so agents with several projects open passed it on every call. The description now matches resolve_project: the call's projectPath, then the connection's project (?project= / X-OpenIDEA-Project), then the only open project.

Co-authored-by: guoyucode <[email protected]>
2026-11-18 20:31:47 +08:00
l0ng-ai 4ecfb98c94 fix(local-history): keep a file's content from before its first edit (#4302)
A file with no Local History entries had nothing to revert to at a label put before its first save. The first edit of an open document now records the file's content on disk as an "Original" snapshot when the file has no history yet, dated by its modification time (but not before the oldest entry kept, so retention and working days are unaffected). A label put before the edit finds it; a file written after the label is dated after it.
2026-11-18 20:29:55 +08:00
l0ng-ai f1d6b0dc1b fix(nav): drop a useless conversion clippy rejects (#4301) 2026-11-18 20:27:21 +08:00
Bert Verhelstтаbertyhell f2cfe38931 feat(agents): view and roll back the last turn's changes (#4042)
The agent session's Changes pane gets a Whole Task / Last Turn switch. Each turn records a baseline the way a task records its start (HEAD, the stamped list of changed files and copies of them in the task store, reusing copies of files unchanged since the previous turn); Last Turn lists only what the last turn changed, diffs against the file as that turn started, and Rollback restores only that turn's changes. Accept still brings over the whole task. Host-side behind agent_changes / agent_base_text / agent_rollback_changes (lastTurn view), so remote development works the same way.

Closes #3689

Co-authored-by: bertyhell <[email protected]>
2026-11-18 20:22:19 +08:00
l0ng-ai d18ac58b56 feat(lsp): configure a language server from the status bar popup (#4298)
Each server in the Language Servers popup gets a Configure button that opens Settings › Language Servers on that server's language with the server selected, where the interchangeable servers are chosen and additional ones turned off. tools.languageServers takes the server name and opens the page as languages.servers#<name>; the page selects that tool and scrolls its language into view.
2026-11-18 20:08:31 +08:00
Vladislav Kuzmin 0021a764c3 fix(database): connect to ClickHouse accounts with strict read-only settings (#4292)
A ClickHouse account with server-enforced readonly = 1 rejected the HTTP driver's own per-query settings (Code 164) on the connection probe. When the probe fails on one of those settings, the driver checks getSetting('readonly') in the same session and, only when it is 1, sends further requests without its own settings (the server then provides write protection; the client still caps the grid rows). A writable session that reports the error keeps failing as before.

Closes #4275

Co-authored-by: principalwater <[email protected]>
2026-11-18 20:01:45 +08:00
Mollo-i a30103d410 feat(nav): @property@ in YAML and properties resources jumps to its pom properties entry (#4243)
Go to Declaration on a Maven resource-filtering placeholder (`@profileActive@` in `application.yml` or `application.properties`) jumps to the `<properties>` entry that defines it: the nearest `pom.xml` above the resource, up through the project root, is searched along its parent chain with the lookup the pom's own `${property}` navigation uses (now exposed as `ide_build::maven::property_declaration`). Plugin definition providers still run, with the pom result first.

Closes #4241

Co-authored-by: Greenker <[email protected]>
2026-11-18 20:00:25 +08:00
Mollo-i 89798baa3c fix(lsp): a Maven resource-filtering placeholder no longer fails YAML parsing (#4242)
yaml-language-server reports "Plain value cannot start with reserved character @" for unquoted Maven placeholders such as `spring.profiles.active: @profileActive@`, which Maven replaces before the file is read as YAML. The diagnostic is dropped when its scalar is exactly an `@token@` placeholder; other parser errors (an unpaired `@`, a different message, a stale range) still show.

Co-authored-by: Greenker <[email protected]>
2026-11-18 20:00:10 +08:00
l0ng-ai c09c9b8aaf docs: describe the Linux DMA-BUF workaround for unresponsive windows (#4295)
The troubleshooting entry still said NVIDIA on Wayland gets WEBKIT_DISABLE_DMABUF_RENDERER=1; since #2179 the app turns the driver's explicit sync off instead. The entry now covers windows that stop reacting to input, notes the slower CPU drawing, and shows how to keep the variable for menu launches.
2026-11-18 19:50:24 +08:00
l0ng-ai 995a9563f7 feat(profiler): navigate and zoom the flame graph with the keyboard (#4294)
The flame graph had no keyboard focus target. It is now focusable with a current frame (outlined, announced via aria-activedescendant): Up/Down go to callee/caller, Left/Right to neighbours, Enter zooms, Escape resets, F4 opens the source. Fixes #4209.
2026-11-18 19:45:37 +08:00
l0ng-ai 893d9af6e6 fix(inspections): Rerun Inspection repeats the file its results are for (#4291)
A Current file inspection stored its unresolved scope, so Rerun resolved it to whichever file was active. The run now records the file it inspected and Rerun inspects that file again. Fixes #4234.
2026-11-18 19:42:27 +08:00
l0ng-ai 73496669e7 fix(web): the built-in preview reloads only for the page and web resources (#4290)
The HTML preview reloaded on any project file change or document save, so editing notes.txt cleared the page's inputs and scroll position. It now reloads when the page itself or a web resource changes. Fixes #4231.
2026-11-18 19:41:01 +08:00
l0ng-ai add914f7fb fix(markdown): a word double-clicked in the preview leaves out the space after it (#4288)
On Windows a double-click selects the word plus the following space, so the preview's selection highlights and Find used "Order ". A word selection's trailing whitespace is now dropped from the text and, when it ends in a text node, from the selection itself. Fixes #4230.
2026-11-18 19:37:24 +08:00
l0ng-ai 0fd0f08865 fix(search): Replace All saves open documents that had no unsaved changes (#4286)
Replace All saved only files it opened itself, so a file the search preview held open got the replacement in memory but not on disk. Documents without unsaved changes are now saved after the replacement; buffers the user is editing are left unsaved. Fixes #4202.
2026-11-18 19:35:26 +08:00
l0ng-ai 054d2ba517 fix(toolwindows): show Hide All Tool Windows as Restore Tool Windows when it restores (#4277)
With every window hidden, Hide All restores them but kept its Hide label. The actions registry gets retitleAction for titles that follow state; the action and its menu label read Restore Tool Windows while a hidden set can be restored. Fixes #4162.
2026-11-18 19:27:54 +08:00
l0ng-ai 738dc12ef7 fix(libraries): clear the previous project's External Libraries on switching (#4276)
The External Libraries node and last complete result were kept across a project switch until the new discovery answered, so the new project showed and filled in the old project's libraries. Refreshing for another project now clears them first. Fixes #4194.
2026-11-18 19:26:48 +08:00
l0ng-ai 6135a5326d fix(local-history): reverting to a label leaves files deleted before it absent (#4274)
A file whose last revision before a label is its Deleted snapshot was absent at the label, but Revert restored it and counted it. Folder reverts now skip such files; a file's own revert says it did not exist then. Part of #4199.
2026-11-18 19:22:37 +08:00
l0ng-ai 403bb28ca4 fix(local-history): keep snapshots as document text (no BOM, LF) (#4272)
Saves record the document's text but the watcher snapshotted the file with its BOM and CRLF, adding an External change revision per save; reverting that revision doubled the BOM. Disk snapshots and snapshot content are now normalized to document text. Fixes #4195.
2026-11-18 19:21:04 +08:00
l0ng-ai 3249d4ee90 fix(lsp): count a Rust error once when rust-analyzer and rustc both report it (#4270)
rust-analyzer publishes its own analysis next to cargo check's, so one type mismatch arrived as rust-analyzer(E0308) and rustc(E0308) and counted twice. Its own entry is dropped when rustc reports the same code and severity over an overlapping range. Fixes #4193.
2026-11-18 19:18:46 +08:00
l0ng-ai 79e41c85ff fix(build): resolve Build Module's Cargo diagnostics from the workspace root (#4269)
rustc names workspace members' files from the workspace root; Build Module runs cargo in the member, so its diagnostics doubled the member folder. Resolution now tries the manifest directory, then its ancestors, taking the first existing file. Fixes #4189.
2026-11-18 19:17:01 +08:00
l0ng-ai f0a7cca1b1 fix(project-view): say which view option hides a file Select Opened File can't reach (#4268)
With Show Excluded Files or Show Hidden Files off, Select Opened File silently selected the nearest shown ancestor. It now notifies which option hides the file, with an action that turns it on and selects the file. Fixes #4181.
2026-11-18 19:15:14 +08:00
l0ng-ai 21f1e2bbb4 fix(editor): don't carry untitled tabs to the Welcome screen (#4264)
Untitled tabs were carried when Close Project returned to Welcome, after the leave guard had asked about them, so a draft discarded with Don't Save reopened as an empty focused tab. Closing to Welcome now drops them; in-place switches still carry them. Fixes #4173.
2026-11-18 19:11:22 +08:00
l0ng-ai ffdb5d74f2 fix(navigation): Navigate to Test uses the top-level class at the caret (#4263)
Navigate to Test derived test names from the file name, so with the caret in a second top-level class it offered the file's test instead. For Java, Kotlin, Scala, Groovy and C# it now takes the outermost type around the caret from the document outline, falling back to the file name. Fixes #4171.
2026-11-18 19:08:21 +08:00
l0ng-ai d4d9e7d191 fix(editor): tab limit keeps VCS-changed tabs with Close non-modified files first (#4261)
The tab limit's closing policy only counted unsaved changes as modified, so a saved file with a Git change closed before clean tabs. It now shares Close Unmodified Tabs' check: unsaved changes or a VCS status. Fixes #4166.
2026-11-18 19:05:43 +08:00
l0ng-ai 6a41509fd2 fix(project-trust): list restricted projects in Project Trust settings (#4257)
A project with a restricted decision stays restricted inside a trusted location, but the settings page didn't list those decisions. The page now lists restricted projects with a Trust button, and the location hint says restricted projects are excluded. Fixes #4156.
2026-11-18 19:03:39 +08:00
l0ng-ai 6efece99a4 fix(project): ask about trust before leaving the current project (#4253)
Opening a folder in this window confirmed leaving the current project (which stops its running processes) before the trust prompt, so Don't Open left the original project without its processes. Trust is now asked first; the fallback open path follows the same order. Fixes #4160.
2026-11-18 19:00:24 +08:00
l0ng-ai 0fab45689f fix(vcs): expire the conflict notice once the merge or rebase is over (#4251)
"All conflicts resolved" kept its Commit… and Abort Merge actions after the
merge was committed, and Abort Merge then reported no merge in progress. The
conflict notices (key vcs.conflicts) now expire when the repository leaves
the merge, rebase, cherry-pick, revert or am they refer to, however it ended.

Fixes #4154
2026-11-18 18:53:43 +08:00
l0ng-ai 71090202b6 fix(debugger): Breakpoints dialog selects on click and keeps typed conditions (#4249)
A single click on a breakpoint jumped to its source and closed the dialog,
and a condition typed and confirmed with Enter (Done) was lost, as only
leaving the field saved it. A click now selects the breakpoint (double-click
or Enter goes to the source), and the shown breakpoint's typed fields are
saved when the dialog closes or another breakpoint is shown, for method and
field breakpoints too; unchanged fields are not written again.

Fixes #4150
2026-11-18 18:52:04 +08:00
l0ng-ai 8ed08510ed fix: Delete in a popup's search field edits the text before it removes the selection (#4248)
Open Recent removed the selected project on Delete wherever the caret was in
the search field, and the run configuration chooser deleted the selected
configuration without asking. Delete now acts on the selection only when it
has no text to delete (the caret at the end of the query, nothing selected;
⌘⌫ only with an empty query), and the chooser asks before deleting a
configuration, from Delete or its menu, as IDEA's popup does.

Fixes #4159
Fixes #4203
2026-11-18 18:48:03 +08:00
l0ng-ai 500df4ffc4 fix(vcs): Show Diff of a staged or unstaged row shows that side of the index (#4247)
The changes tree's Show Diff passed only the file's path to the action, which
opened HEAD against the working copy, so a partially staged file showed its
unstaged edit from the Staged group too. The menu item now opens the row's own
diff, as double-click does: HEAD ↔ Index under Staged, Index ↔ working copy under
Unstaged. Show Diff from the keyboard builds the tree the Commit window shows
(staging groups, no change lists, with the staging area) so the selected row is
found, and uses it with the non-modal interface too.

Fixes #4152
2026-11-18 18:45:05 +08:00
l0ng-ai 81aa9418aa fix(vcs): no Commit File… in the changes tree with the staging area (#4246)
With the staging area the commit takes the whole index, so Commit File… on a
staged file only focused the message and committed every staged file. The
item is left out of the changes tree's menu while the staging area is on, as
the staging tree has no per-file commit.

Fixes #4153
2026-11-18 18:39:57 +08:00
acaoтаamphetamlne 706ce87cb7 test(plugins): exercise fuel renewal with explicit CPU work (#3438)
Keeps main's 40,000 foreground fuel budget and patient CPU workload, and adds a quiet mode that runs the same workload without task reports and must exhaust the scaled budget, so beginning a task alone is shown not to renew it. The Git capability setup now fails the test instead of returning early. Production limits are unchanged.

Co-authored-by: amphetamlne <[email protected]>
2026-11-18 18:38:14 +08:00
胡翀таzzxzz12345 4e5dbc8e0c feat(markdown): render LaTeX math with KaTeX (#4138)
Markdown views (file preview, agent chat, notebook Markdown cells, LSP/GitHub/plugin Markdown) now typeset $...$, $$...$$, \(...\), \[...\] and ```math blocks with KaTeX. The marked extension emits [data-math] placeholders that survive DOMPurify and are typeset after sanitizing (trust: false); inline $ follows Pandoc's rules, so currency like $5 and $10 stays text. The Markdown preview keeps the placeholders in its rendered HTML and typesets them after each render, like Mermaid diagrams, so its per-block sanitize cache is unaffected.

New dependency: katex 0.19.1 (MIT).

Co-authored-by: zzxzz12345 <[email protected]>
2026-11-18 18:36:43 +08:00
Deng Liuтаdengliu 79accd1311 perf(settings): split Settings and auxiliary window boot out of the Workbench module (#4044)
Native auxiliary windows (settings, comparison, diff, deployment) all booted src/main.tsx, which statically imported the Workbench and every workbench feature (CodeMirror, xterm, editor extensions) even when the Settings window rendered none of them. main.tsx is now a small window-kind router with one boot module per window kind, and the settings pages, core plugin points and plugin theme runtime are registered from editor-free modules, so the Settings window loads no Workbench, @codemirror, @xterm or @/editor modules (about 57% less JS and a third less heap per Settings window). A static test keeps the Settings boot isolated.

Part of #3942

Co-authored-by: dengliu <[email protected]>
2026-11-18 18:32:14 +08:00
Deng Liuтаdengliu 85d02e03f9 feat(agents): discover MCP servers from installed Copilot CLI plugins (#4029)
MCP servers bundled in installed GitHub Copilot CLI plugins (installedPlugins in ~/.copilot/config.json) were started by Copilot CLI in sessions but never listed in Session MCP Servers or Agent Configs, so they could not be seen, disabled per session or imported. External discovery and import now also read each enabled plugin's .mcp.json / plugin.json mcpServers inside its cache_path (paths kept within the plugin root), expand ${COPILOT_PLUGIN_ROOT} / ${CLAUDE_PLUGIN_ROOT} / ${PLUGIN_ROOT}, and honour disabledMcpServers and enabledPlugins in ~/.copilot/settings.json.

Co-authored-by: dengliu <[email protected]>
2026-11-18 18:18:21 +08:00
Ernstjan FreriksтаEjaYF e689c95e93 feat(database): create and drop databases and schemas from the tree (#4201)
The Database tree gets New > Database... and New > Schema..., and Drop... on database nodes (PostgreSQL, MySQL/MariaDB schemas, SQL Server), each with a preview of the statement it runs.

Creating closes the IDE's own connections to the database the server copies (the template on PostgreSQL, model on SQL Server), which both refuse to copy while it has sessions. Dropping closes the IDE's pools and sessions of that database first and runs DROP DATABASE on the data source's default database; "Close the sessions of other clients" adds WITH (FORCE) on PostgreSQL 13+ and single-user mode on SQL Server. Drop is refused for the data source's own database and read-only data sources. Both go through withConnection, so a password the data source does not save is asked for first.

Closes #3189

Co-authored-by: EjaYF <[email protected]>
2026-11-18 18:17:18 +08:00
faithererer bb243909bf feat(vcs): suggest branch name prefixes in the New Branch dialog (#4219)
Typing a name in Create New Branch now suggests the folders of existing local branch names (typing `fe` offers `feat/`, `feat/2610/`, `feat/2610/08/`), shallowest first. Arrow keys pick one, Enter or Tab fills it in and keeps typing; Enter without a pick creates the branch as typed. Remote branches are left out of the suggestions.

Closes #4208

Co-authored-by: faithererer <[email protected]>
2026-11-18 18:00:55 +08:00
HL-SLCтаHL-slc 64544a4edd fix(database): don't read data sources after the project is closed (#4226)
Closing the project resets the database state to not loaded while an open SQL file's console bar is still mounted; its effect called loadSources() with no project open and showed "Cannot read data sources: no project is open in this window". loadSources() now returns early without a project; the next project loads its sources as before.

Co-authored-by: HL-slc <[email protected]>
2026-11-18 17:58:16 +08:00
l0ng-ai 4fd1e4356e fix(java): keep jdtls temporary files in its workspace and clear them at start (#4238)
JDT APT copies a project's annotation processor jars into a new jdt-apt-*
folder in the system temp directory for each processor class loader, and
deletes them only when the JVM exits normally. jdtls stopped by the IDE never
does, and on Windows the jars are still open at exit, so every start left
another copy behind (tens of GB in %TEMP% after a while).

jdtls now gets -Djava.io.tmpdir=<workspace>/.tmp for the workspaces the IDE
creates, and that folder is emptied before each start. A temp directory set in
the user's JVM arguments, and a -data workspace of the user's own, are left
alone.

Fixes #4192
2026-11-18 17:56:21 +08:00
l0ng-ai 1794cd4fbb fix(database): table tabs keep their filter, sort and page when switching tabs (#4236)
Table editor tabs unmounted when another tab was shown, so their WHERE / ORDER BY
text, paging and unsubmitted edits were lost and the rows were queried again.
Table tabs are now kept alive like other editors, and the view state (filter,
sort, page) is remembered per table so a tab that is closed and reopened, or
dropped from the kept set, starts from the same view.

Fixes #4158
2026-11-18 17:47:32 +08:00
Bert Verhelstтаbertyhell 10d39e14ca feat(php): align key-value pairs and consecutive assignments when formatting (#4045)
Settings › Editor › Code Style › PHP gets an Alignment section with Align key-value pairs (=> in multi-line arrays) and Align consecutive assignments (= in assignment statements on consecutive lines), both off by default. The backend applies them after whichever formatter ran (language server, PHP-CS-Fixer or a plugin formatter), for Reformat Code, format on save and the Reformat dialog; a selection changes only its lines. Alignment walks the PHP tree-sitter tree per array and statement list, so operators inside strings, comments, heredocs, foreach, arrow functions, match and default parameters are never touched.

Closes #3889

Co-authored-by: bertyhell <[email protected]>
2026-11-18 17:42:39 +08:00
l0ng-ai 101890ab4c fix(mcp): execute_run_configuration resolves a Java application's classpath (#4215)
MCP runs started a JVM application configuration as written, so ${classpath} reached java literally and the main class was not found. Application and Spring Boot configurations now go through the Run tool window's launch preparation (ops::java::resolve_launch): build per the configuration's policy (including the delegated Maven build), resolve ${classpath} / ${testClasspath}, the module path and the module's JDK, find a missing module from the main class, and stop on compile errors unless the policy continues on errors. Before-launch runs of such configurations are resolved the same way.

Fixes #4127
2026-11-18 17:20:47 +08:00
usong 86778d259f fix(editor): locate Lombok accessors and Java fields in library sources (#4190)
Go to Definition into a dependency's Lombok entity landed on the class header or the @Getter/@Setter annotation: library source lookup recognized Java methods but not fields, and never mapped a generated get/set/is accessor back to its field. Java field declarations (with or without an initializer) are now located, accessors map to their field when no method of that name is declared, and a jdt: library class uses the source declaration only when jdtls' range does not name the member, so overloads keep jdtls' exact range.

Closes #4186

Co-authored-by: usongon <[email protected]>
2026-11-18 17:12:47 +08:00
Bin 59c39a7e77 fix(editor): collapse multiline imports after the import keyword (#4170)
An import group whose first statement spans several lines folded from the end of its header line, leaving the first specifier visible. The fold now starts after the import keyword, so the editor shows `import …`, and the gutter finds an imports fold that starts inside its header line. Go and Rust delimiter handling is unchanged.

Co-authored-by: ffgenius <[email protected]>
2026-11-18 17:08:22 +08:00
Muuтаmuutot 4d45ddc5a5 fix(editor): a fold click can miss folds that arrived asynchronously (#4165)
CodeMirror's fold gutter rebuilds its chevrons only on document, viewport or language changes, but backend folding ranges arrive through setBackendFolds, so a chevron could sit at a stale line and a click did nothing. The placeholder chip resolved its fold through the clicked line block, which can miss a fold starting at a line boundary (a Python docstring, an Allman header). The gutter now rebuilds whenever the backend fold field changes, and the chip resolves the fold at its own position, falling back to CodeMirror's handler.

Closes #4082

Co-authored-by: muutot <[email protected]>
2026-11-18 17:06:47 +08:00
Bert Verhelstтаbertyhell bfd6f01471 perf(markdown): sanitize only the changed blocks when the preview re-renders (#4041)
The Markdown preview re-sanitized the whole document with DOMPurify on every settled edit. It now caches each block's sanitized HTML and sanitizes only the blocks an edit changed; a block whose markup carries into the following blocks (unclosed tags, comments, form state) falls back to sanitizing the whole document, so the output is the same.

Part of #3940

Co-authored-by: bertyhell <[email protected]>
2026-11-18 17:04:44 +08:00
Bert Verhelstтаbertyhell 895d042dd7 perf(problems): rebuild only the changed file's Problems entries per diagnostics update (#4040)
A diagnostics event for one file made the Problems view merge, filter and sort every file's diagnostics again, and the tab header and tool window badge recounted every error in the workspace. Each file's merged list and Problems node are now cached by its sources map (replaced only when that file changes), and the store keeps project severity counts up to date per event, recomputing them on a profile change. Output is unchanged.

Part of #3937

Co-authored-by: bertyhell <[email protected]>
2026-11-18 17:04:39 +08:00
Bert Verhelstтаbertyhell eb37d9e96a perf(search): claim the match budget while a file is searched, not after it (#4043)
Each file claimed its matches from the shared budget only after it was fully searched, so a broad Find in Files query over dense files could build up to the whole budget once per walker thread and throw most of it away. Files now claim matches in batches of 64 as they find them; a binary file gives its claim back, and a non-UTF-8 file searched again as decoded text fills its byte search's claim. When the limit is hit, exactly the budget is returned. Adds a dense-files bench with a budget.

Part of #3939

Co-authored-by: bertyhell <[email protected]>
2026-11-18 16:58:56 +08:00
Bert Verhelstтаbertyhell dc8ae96206 perf(text): diff a document without copying its whole rope (#4039)
Document::diff copied the whole rope into a String and counted UTF-16 units across the unchanged prefix before trimming the common ends. The common ends are now found by walking the rope's chunks against the new text, only the changed middle is copied, and the prefix's UTF-16 offset comes from the rope's metadata. The trimmed (prefix, suffix) is unchanged, so the change sets are too. Adds a 5 MB one-edit diff bench with a budget.

Part of #3938

Co-authored-by: bertyhell <[email protected]>
2026-11-18 16:57:29 +08:00
l0ng-ai e70bca39ee fix(editor): autosave leaves a file changed on disk after an edit (#4197)
After an external change to a file whose buffer had unsaved edits, the next autosave wrote the buffer over the disk change despite the conflict warning. The document store now remembers the conflict and the new doc_autosave command declines to write such a buffer; an explicit save still overwrites and a reload clears the conflict.

Fixes #4115
2026-11-18 16:55:49 +08:00
l0ng-ai 2fe09e73f5 fix(editor): a document closed with changes no longer counts as unsaved (#4196)
Closing a modified document with Don't Save left the backend dirty flag set, so the exit guard asked about it again on Exit. The document store now reports a buffer clean when it is closed.

Fixes #4118
2026-11-18 16:54:23 +08:00
l0ng-ai b921de184b fix(editor): keep a modified file open when its last tab closes without autosave (#4191)
With autosave off, closing the only tab of a modified file disposed its document and lost the edits. As in IDEA, DocumentManager.release keeps a dirty (non-untitled) document open without a tab: reopening shows the edits, Save All and the exit check still cover them; also when autosave on close fails.

Fixes #4116
2026-11-18 16:43:51 +08:00
l0ng-ai 23739c90c7 fix(run): Run starts another instance of a configuration that allows multiple instances (#4187)
run.run reran the selected configuration's running session even with Allow multiple instances, stopping the process. As in IDEA (Rerun/Stop only for configurations that don't run in parallel), such a configuration keeps Run/Debug in the toolbar and Run starts another instance; a tab's Rerun still restarts its session.

Fixes #4148
2026-11-18 16:39:53 +08:00
LU XIANGRUIтаwildcatDownstairs 923325aeae feat(color-scheme): foreground for Identifier under caret (#4135)
Identifier under caret and Identifier under caret (write) can now set a Foreground, as in IDEA; imported .icls schemes carry it too. The highlight mark wraps the syntax and semantic token spans, so the colour is applied with the inherited -webkit-text-fill-color: unset, the declaration drops and tokens keep their syntax colours; find matches, selection, links, inlay hints and fold placeholders keep their own colours. Multi-line highlights colour only the highlighted text, not the indent.

Closes #4109

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 16:37:49 +08:00
LU XIANGRUIтаwildcatDownstairs d7351dca1d feat(run): Python run configuration type (#4126)
Adds PyCharm's Python configuration: a script or a -m module with arguments, command (interpreter or uv/poetry) and runner arguments; a plain python/python3 runs on the project interpreter as before. Existing python configurations (detected, imported, run from the context menu) open in this form when their command line maps to a script or module. projectPython prefers a detected python configuration over one made by hand.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 16:36:56 +08:00
l0ng-ai 8959f7aa5d fix(debugger): answer the debuggee terminal's cursor position query (#4185)
Python debugging on Windows timed out waiting for debugpy's launcher: since #3374 it runs through runInTerminal on a ConPTY, which asks the terminal for the cursor position (ESC[6n) and starts the program only after the answer; the debug console never answered. The runInTerminal output forwarder now answers cursor position queries and drops them from the output. A runInTerminal test now runs on Windows too.

Fixes #4123
Fixes #4141
2026-11-18 16:34:54 +08:00
l0ng-ai 5e4f187107 fix(settings): detect SDKs and install tools from Settings without a project (#4184)
SDK combos in Settings opened from the Welcome screen loaded forever: sdk_detect and the interpreter/tool commands were Trusted and called require_trust, which refuse a window without a project, and useDetected kept loading after a failed detection. They are now OutsideRestricted with Host::require_trust_if_project (still refused in Restricted Mode; commands that take a project path keep the strict check), and a failed detection ends loading.

Closes #4110
2026-11-18 16:34:49 +08:00
l0ng-ai aebd26bd7d feat(maven): setting to download dependency sources on import (#4182)
Settings › Build Tools › Maven › Automatically download sources maps to jdtls java.maven.downloadSources (previously always on in languages/java.toml). Off by default, as in IDEA's Maven › Importing: library classes open decompiled and the Download Sources banner fetches one library's sources on demand.

Closes #4097
2026-11-18 16:34:44 +08:00
l0ng-aiтаClaude c43a6169be ci: run only the jobs and smoke languages a pull request can affect (#4172)
CI's Changes job now decides each job on its own: Plugins on the plugin
workspaces, Cargo deny on manifests, the remote server build skips
desktop-, SDK- and test-only changes, Frontend skips backend-only changes
(a new Text catalog job runs the one test that reads Rust sources), and
E2E runs on the browser app's own sources.

Language smoke picks its matrix from the changed files: a language's
fixture, definition or JDT LS bundle runs that language, crates the
smoke doesn't exercise and crate tests run none. java/ now triggers it.

Co-authored-by: Claude <[email protected]>
2026-11-18 16:23:00 +08:00
LU XIANGRUIтаwildcatDownstairs c4836f6cd8 fix(viewers): Markdown preview follows File Types associations (#4139)
The Editor / Editor and Preview / Preview layouts were gated on a fixed extension list, while highlighting and LSP follow the language the backend detects from Settings › File Types. A file associated with Markdown (e.g. *.mmd) or overridden to Markdown now gets the preview, a file moved away from Markdown loses it, and open tabs update when File Types change. The check reuses hasFileType from #4144; the live-text contribution keys on the document's language.

Refs #4099

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 16:14:32 +08:00
l0ng-ai 02235cae04 test(heap): wait for the background cleanup in the stuck-capture shutdown test (#4169)
shutdown_within waits only briefly for the snapshot-directory cleanup and lets it finish in the background; on a busy CI runner the stuck-capture test asserted before it was done. The test now waits up to 10 s for the directory to go.
2026-11-18 16:14:09 +08:00
LU XIANGRUIтаwildcatDownstairs fcef18048a fix(web): HTML preview follows File Types associations (#4144)
The browser bar, Built-in Preview and Open in Browser were gated on a fixed extension list, and the built-in server chose Content-Type by extension, so a file associated with HTML in Settings › File Types (or via Override File Type) had no preview, and one moved away from HTML kept it. The frontend now decides with hasFileType (override, user patterns, then built-in extensions not removed — the order of LanguageRegistry::detect), open tabs update when File Types change, and web_url serves a file the backend detects as HTML as text/html (also fixes .shtml being served as application/octet-stream).

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 16:12:54 +08:00
Bin d72363b6ba fix(lsp): include workspace folder in ESLint configuration (#4145)
vscode-eslint resolves workingDirectory {mode: auto} from settings.workspaceFolder; without it the server falls back to the linted file's directory, so resolvers configured relative to the project (eslint-import-resolver-alias './src') looked under src/src and reported import/no-unresolved. The full workspace/configuration answer for eslint now carries the server root as workspaceFolder, as VS Code's client does. Other servers' answers are unchanged.

Closes #4143

Co-authored-by: ffgenius <[email protected]>
2026-11-18 16:11:18 +08:00
l0ng-ai 4ab4e0b44f fix(ci): use a Windows-absolute devshell path in the project environment test (#4149)
The project environment test's PATH entry /nix/store/x-devshell/bin has no drive letter on Windows, so the tool search path, which keeps absolute entries only, dropped it and the test failed there. The test uses C:\nix\store\x-devshell\bin on Windows.
2026-11-18 15:11:25 +08:00
l0ng-ai 43f7b6db25 chore: v0.1.48 2026-11-18 14:22:05 +08:00
l0ng-ai 92fd29707d fix(plugins): space marketplace detail notices from the header above 2026-11-18 14:15:40 +08:00
l0ng-ai 7482b27518 fix(run): a separate build linked inside another build's folder gets its own run configurations (#4134)
A Maven project or Gradle build linked explicitly got no run configurations when it sat inside the folder of another detected build without being one of its projects (a POM loaded with Load Maven Project below a root pom.xml that doesn't list it as a module, or a second linked Gradle build inside the root build's folder), so its main() fell back to Java Single File. A linked build is now left to the build around it only when that build's Maven reactor reaches it through <module>s (active profiles included) or its Gradle settings include it as a subproject. ide_build::maven::reactor_member_dirs lists a reactor's project folders from the memoized reactor walk.
2026-11-18 14:00:47 +08:00
l0ng-ai a949a93454 fix(ci): drop an undefined Compare Directories class and a Unix-only test variable on Windows (#4132)
main's Frontend job failed in cssModules.test.ts because DirectoryCompare.tsx read styles.name, a class its CSS module never defined; the name cell now uses styles.cell only. The Windows clippy job failed on the unused temp folder in the mock_server path-spelling test; it only holds the Unix symlink, so it is created under cfg(unix) as well.
2026-11-18 13:35:11 +08:00
Mariano Dupont 16cfb63bda fix(windows): offer recovery after WebView2 browser crashes (#4055) 2026-11-18 12:03:13 +08:00
Mariano Dupontтаmarianomd 6b1d5aca50 fix(ci): resolve Windows and plugin frame failures (#4121)
Four failures of the full CI run: the JDT LS workspace marker's modification time is set explicitly (an empty write can keep the old time on Windows); the JS debugger waits for CDP to acknowledge Fetch.disable before closing the socket, so the connection isn't reset with unread replies; the Maven generated-source test compares paths as PathBuf so Windows separators compare equal; the plugin iframe test finds the document message by type and also covers a theme message arriving first.

Co-authored-by: marianomd <[email protected]>
2026-11-18 11:58:37 +08:00
Mr0Bread b5bdab0a63 fix(agents): release closed and deleted tasks' conversations (#4037)
The agents store never released a task's conversation: deleting, archiving, closing its tab or switching the docked task kept its entries, subagent conversations and changes in memory for the whole session, and the Web Content process kept growing in long sessions. A deleted task, or an archived one that isn't shown, is now dropped at once; closed or un-docked tasks stay in a cache of the 5 most recent and fetch their conversation and changes again when reopened. Change fetches that finish after a task's cache was dropped are discarded. The symbol lookup, file-existence and GitHub item caches are bounded, and a large symbol lookup answers every name of the request.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-18 11:55:57 +08:00
acaoтаamphetamlne c3e19c93d3 fix(lsp): preserve configured environment for Go module checks (#3287)
The go.mod deprecation query ran 'go list -m -u -e -json' without the language server's configured env, so GOPRIVATE, GOPROXY, GOTOOLCHAIN and GOWORK set for gopls were lost. The command now gets the server's env, with PATH still the server's search path.

Co-authored-by: amphetamlne <[email protected]>
2026-11-18 11:55:04 +08:00
l0ng-ai b33762b4c8 fix(vcs): Compare Directories copies nothing before the overwrite answer, filters nested folders, keeps name columns readable (#4120)
copy_merge without overwrite now finds the first conflict before writing anything, so declining the overwrite prompt leaves the destination untouched. A filter match below nested one-sided folders is attributed to the outermost one, the only row shown for that subtree. Name columns keep at least 96px; size and date shrink first and end in an ellipsis.

Fixes #4084
Fixes #4085
Fixes #4086
2026-11-18 11:54:13 +08:00
Muuтаmuutot 41087d074b fix(editor): fold Python & Elixir docstrings by default (#4072)
Fold by default > Documentation comments ignored docstrings written as string literals: the folding backend only emitted Comment folds for comment nodes. It now marks a multi-line Python docstring (the first statement of a module, class or function body) and an Elixir @doc / @moduledoc / @typedoc string or sigil as Comment folds. The frontend treats a comment fold as the file header only when it sits at the top of the file and starts with a comment token, so a module docstring follows the documentation toggle.

Co-authored-by: muutot <[email protected]>
2026-11-18 11:53:39 +08:00
Bert Verhelstтаbertyhell fa8dd2465a fix(vcs): the unified diff viewer shows whole added and deleted blocks as blocks (#4036)
A chunk without inner (word) fragments stored its whole block as changes, so @codemirror/merge's unified view marked every line of an added or deleted block as changed text and the block looked broken into per-line bars. Such chunks, and the coarse fallback chunks used when the comparison gives up on repetitive files, now carry no changes. Whole deleted blocks take the full deleted colour; only the old lines of a word-compared chunk keep the lighter one.

Closes #3913

Co-authored-by: bertyhell <[email protected]>
2026-11-18 11:51:41 +08:00
l0ng-ai ea965c7e2d fix(search): Windows module scopes and file URLs, and search again after a multi-line replace (#4119)
A Windows workspace module scope joined the module path with '/', so Find in Files searched nothing; it now resolves the directory like the other scopes (same fix for Markdown relative links and version catalog paths). A file:///C:/ URL typed as a query kept its leading slash and percent-escapes; it is now decoded to the drive path. After Replace with a multi-line replacement, a pattern that can match a line break, a cancelled run or fewer replacements than usages, the result list was stale; Find in Files now searches again.

Fixes #4069
Fixes #4079
Fixes #4082
2026-11-18 11:48:42 +08:00
l0ng-ai db790adf2f fix(agents): reference files of every workspace project from the composer (#4113)
In a multi-project window the composer only resolved paths against the agent task's folder and its project, so drops from another workspace project were ignored and @ completion named them wrongly. referenceOf() now resolves against the task root first, then names a file of another workspace project as <project folder>/<path> with its absolute path; paths outside the window's projects are reported instead of silently dropped. Folder references keep their trailing slash.

Fixes #4074
2026-11-18 11:34:39 +08:00
LU XIANGRUIтаwildcatDownstairs d5caebc2bb fix(run): find openideaRun on Gradle 7.0 and older when jvmargs are set (#4108)
With org.gradle.jvmargs set (project or ~/.gradle), Gradle 7.0 and older pass the command line's -D values to a build JVM only after settings load, so gradleRun.gradle read openidea.run.project as null at the top of the init script and skipped registering openideaRun ("Task 'openideaRun' not found"). The property is now read inside the allprojects action, which runs after settings. gradleBoot.gradle and gradleTests.gradle already read theirs in projectsEvaluated.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 11:09:34 +08:00
Bin 9f39cf2963 fix(editor): fold imports inside Vue script blocks (#4098)
Syntax folding for HTML-based containers (Vue, HTML, Svelte, JSP) parsed only the HTML tree, so embedded <script> blocks produced no TypeScript/JavaScript folds and their imports never folded (nor folded by default). The folds of each script region are now computed with its own language and shifted to document lines, for both the cached and uncached paths; non-JavaScript script types are left alone.

Co-authored-by: ffgenius <[email protected]>
2026-11-18 11:08:45 +08:00
LU XIANGRUIтаwildcatDownstairs e8abf8a800 fix(search): Replace All past the result limit replaces every match in scope (#4106)
Replace All sent only the listed (limit-capped) usages to the backend, and in a single file it skipped the confirmation that mentioned the limit, so matches past the 2,000 (popup) / 10,000 (Find window) limit were silently left. Once the search hit its limit, Replace All now always confirms and asks replace_in_files for all_in_scope: the backend searches the scope again without the limit on a blocking thread (project excludes applied, cancellable) and replaces every match, keeping excluded or already-replaced usages through the new ReplaceTarget.skip. Below the limit nothing changes; Replace Selected still replaces only the selection.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 11:05:54 +08:00
LU XIANGRUIтаwildcatDownstairs cd63696998 fix(search): Search Everywhere text search uses the query as typed (#4104)
SeController parsed every section's query with parseLocationQuery, so a trailing :digits (a port in http://localhost:8080, 10:30, a:1) was taken as a line and dropped from text searches; the Find in Files handoff used the parsed text too. Location parsing now applies only to sections whose results open at a line (files, classes, symbols); text, actions and endpoints, and the handoff to Find in Files, use the trimmed query.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 10:58:31 +08:00
LU XIANGRUIтаwildcatDownstairs cb52ba066d fix(search): keep Find in Files header controls inside a narrow popup (#4102)
At the minimum window size the Find/Replace in Files header was a single non-wrapping flex row with a fixed-width mask input, so the title and count wrapped and Search Context / Pin Window were clipped by the popup. Below the popup's own minimum width (a container query) the mask and buttons move to a second row; the title and count stay on one line and end in an ellipsis. An e2e test checks every search popup's header controls at 400 × 500.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 10:58:26 +08:00
LU XIANGRUIтаwildcatDownstairs 7a3f004235 fix(notifications): take down a failure balloon once a reload or server start succeeds (#4101)
A failed Maven/Gradle reload left its error balloon on screen after a later reload succeeded: syncTool notified on failure under build-sync-<tool> but never expired that key on success. A clean sync now expires it (the Notifications tool window keeps the entry). The same holds for the language-server prompts (not installed, JDK required, outdated build): a server turning ready expires them, for when the fix came from a settings page rather than the prompt's button. expireNotification leaves the state untouched when no balloon is shown.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 10:54:51 +08:00
acaoтаamphetamlne 4952a94064 chore(lsp): correlate server lifecycle and diagnostic logs (#3249)
Language-server startup, initialize and window/logMessage entries carry the server id and generation, and the initialize log reports startup_to_initialize_ms (settings, queueing, launch and initialize) even without serverInfo. Routing to a server for a file outside the project logs its root at DEBUG only. Tests characterize how an external Go file reuses the first module's server and reopens after a restart.

Co-authored-by: amphetamlne <[email protected]>
2026-11-18 10:43:35 +08:00
acaoтаamphetamlne [email protected] 49b11e59ec test(sdk): verify portable Python commands preserve fallback settings (#3433)
Saving and reloading a Python run configuration, and moving a saved bare member onto another primary project's auto-detected venv, must round-trip the whole resolved configuration (interpreter, env, PATH, module), not only the command.

Co-authored-by: amphetamlne [email protected]
2026-11-18 10:42:38 +08:00
Deng Liuтаdengliu c4674a65f3 fix(editor): treat an unset softWrap like the default (enabled) (#4090)
softWrapActive coerced an unset softWrap to false, while DEFAULT_SETTINGS.editor.softWrap and the backend EditorSettings default it to true (scoped by softWrapFiles). Editors opened before settings load, or with the field unset, skipped wrapping on *.md / *.txt / *.rst / *.adoc. An unset value now behaves like the default; an explicit false still disables wrapping.

Co-authored-by: dengliu <[email protected]>
2026-11-18 10:29:54 +08:00
Muuтаmuutot e7c2032fd1 fix(python): resolve imports from attached dependency projects (#4091)
Projects added in Project Structure > Dependencies (or picked as a workspace member's dependencies) only reached the IDE's index and navigation, so basedpyright/Pyright reported imports into them as unresolved. Their roots, plus a src folder when the dependency has a src layout, are now appended to the server's analysis.extraPaths, keeping and de-duplicating paths already configured. Container Python targets keep their own site-packages extraPaths. A malformed settings section is replaced instead of panicking.

Closes #4076

Co-authored-by: muutot <[email protected]>
2026-11-18 10:28:41 +08:00
Deng Liuтаdengliu bb827d02f9 feat(markdown): make the editor and preview split resizable (#4060)
The Markdown editor and preview split is now a SplitGroup with a draggable handle (10-90%), one persisted ratio for all Markdown files, and double-click on the handle resets to 50/50. Double-click reset lives in SplitHandle, so every split gets it. The editor re-measures CodeMirror and the preview stays anchored to the editor's top line while the divider moves; wide preview tables scroll horizontally instead of overflowing.

Co-authored-by: dengliu <[email protected]>
2026-11-18 10:21:46 +08:00
Deng Liuтаdengliu 0e29c78616 perf(settings): open Settings directly from the native menu (#4053)
Settings… and Settings for New Projects… from the native menu went through the focused project window's frontend (menu event → executeAction → window_open_settings), so a busy JS thread in that window delayed the Settings window. With Settings in a separate window, the menu handler now opens or focuses settings-<parent> in Rust. Auxiliary windows route to their project window as before; a pending cold launch or the in-window dialog mode still goes through the frontend. Auxiliary windows opened without a frame colour now get the parent's theme frame colour computed natively.

Co-authored-by: dengliu <[email protected]>
2026-11-18 10:19:06 +08:00
LU XIANGRUIтаwildcatDownstairs 7edc35e515 fix(lsp): serve files spelt differently from the project root with its framework servers (#4075)
The project root is canonicalized when a project opens (real letter case on macOS, symlinks resolved), but document paths are not. Choosing language servers and framework UI modes checked path.starts_with(project_root), so a file opened under another spelling (other letter case, a symlinked folder) looked outside the project: servers that require a root marker (Angular, ESLint/oxlint, Ruff, laravel-lsp, arduino) skipped it, and Angular templates fell back to plain HTML. ide_language::project_spelling now retries with the canonical path when a path looks outside the project; LspManager::servers_for, serves_path and LanguageRegistry::framework_ui_mode use it. URIs sent to servers keep the document's own spelling.

Closes #4061

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 10:12:06 +08:00
LU XIANGRUIтаwildcatDownstairs 7780c3fe64 fix(workbench): move status items that don't fit into an overflow popup (#4087)
At narrow window widths the right status items were clipped off the bar (the bar is overflow: hidden and right items don't shrink), so the Python interpreter picker, caret, encoding and others became unreachable. Right items that don't fit now move into a trailing "..." popup, lowest priority first, and come back when the window widens. Each item renders into a stable host element that moves between the bar and the popup, so widgets keep their state and their own popups.

Closes #4071

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 10:10:58 +08:00
l0ng-ai d98592ea7f feat(maven): add an unlinked pom.xml as a Maven project (#4088)
The Project view offers Add as Maven Project on a pom.xml that Maven doesn't load (neither linked nor a module of a linked project), and the editor shows a banner above such a file with Load Maven Project and Skip. Skip, and unlinking a project, stop the banner for that pom.xml and the folders under it. Files under build output, sources or dependency folders get no banner.
2026-11-18 10:08:39 +08:00
LU XIANGRUIтаwildcatDownstairs c69c5935f3 fix(run): detect run configurations for Maven/Gradle builds linked deeper than the folder scan (#4073)
After Add Maven Projects linked a module four levels deep, the run gutter on its main() still fell back to Java Single File. Run configuration detection only scanned build files three levels deep and ignored the builds the user linked, so the module had no maven/gradle configuration and the run producers treated the file as outside any build. detected_and_saved now passes the linked Maven POM folders and linked Gradle build folders that detection did not reach to the new ide_run::detect_builds, which reuses the existing Maven/Gradle detection (including Spring Boot applications). Folders inside a detected build stay with its reactor, and POMs linked from outside the project folder are handled too. Unlinked deep modules are unchanged.

Closes #4066

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 10:00:01 +08:00
Mr0Bread a67b094e2c refactor(agents): split the session editor into per-component modules (#3760)
SessionEditor.tsx (about 3,500 lines) is split into modules under src/features/agents/session/: the status line, composer, stream, messages, tool entries, question form, changes pane, find bar, folds, process and working rows. The declarations move unchanged apart from their exports; SessionEditor.tsx keeps the task session shell. Changes main made to the session editor after the split was prepared (#3961, #4013, #4015) are carried into the modules that now hold that code.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-18 09:54:52 +08:00
l0ng-ai 688d5f1b30 feat(vcs): open Compare Directories as an editor tab with columns per side (#4077)
Compare Directories opens as a restorable editor tab instead of a modal dialog. The table shows name, size and date for each side with a status marker between them, colours rows by status, groups files under their folder (a folder present on both sides heads its group and can be copied whole; a one-sided folder is one row), and previews the selected file's diff below; Enter or double-click opens it in its own tab. Toolbar toggles filter by status. The backend comparison now returns each side's file size and modification time.

Part of #3925
2026-11-18 09:44:01 +08:00
Bert Verhelstтаbertyhell 6ad6559f4a feat(env): load the project's direnv environment (#4049)
A trusted project with an .envrc in its root now gets its direnv environment, locally and over remote development. The IDE runs `direnv export json` in the background (cancellable, 10-minute timeout); terminals, run configurations, language servers, build tools and debuggers started in the project get what it exports, and language servers wait until it has loaded.

The environment layer was process-wide, but one desktop process holds several projects: ide_core::project_env keeps one environment per project root, and the shared spawn helpers pick it from the child's working directory (host_env / prepare from current_dir, plus the *_in variants for PTYs and PATH lookups). Restricted Mode never runs direnv, and revoking trust drops the environment.

A missing direnv gives a one-time hint, a blocked .envrc a warning to run direnv allow (the IDE never runs it), failures and timeouts an error with the end of direnv's output. Changes to .envrc, flake.nix or flake.lock offer Reload Environment, which loads direnv again too. The changed-file notice's title is now translated.

Closes #3555

Co-authored-by: bertyhell <[email protected]>
2026-11-18 09:29:59 +08:00
Bert Verhelstтаbertyhell 69d839e123 feat(plugins): read the clipboard from user-invoked commands (API 1.11) (#4047)
Plugins could write the clipboard but not read it. ui.read-clipboard() (SDK host::read_clipboard()) returns the text and a PNG image of the user's clipboard, behind a new clipboard.read capability. Only calls the user started can read: plugin commands and view actions run by the user, not event handlers, web view messages or commands chained through command-runner. The host never reads the clipboard itself: it asks the invoking window (ClipboardRequested / plugin_answer_clipboard), so remote development reads the client's clipboard, and a remote window asks the user first. Plugin API 1.11.0; components rebuilt.

Closes #3524

Co-authored-by: bertyhell <[email protected]>
2026-11-18 09:20:09 +08:00
Deng Liuтаdengliu 606a66b5dd perf(settings): batch store registrations and defer font enumeration (#4058)
Settings pages, parent action proxies and template actions registered one by one, cloning the store map and notifying subscribers per item (~1,650 action and ~172 page updates per Settings open). registerActions now disposes in one update too, and the new registerSettingsPages batches page registration and disposal; both keep later per-id overrides. Disabled font pickers no longer enumerate system fonts; enabled ones defer it to idle and load at once on interaction, and the icon-font probe waits past startup.

Co-authored-by: dengliu <[email protected]>
2026-11-18 09:10:40 +08:00
Akbar Husain 0e169cc653 feat(editor): render Zig doc comments without a grammar (#4052)
Doc comments were found by walking the CodeMirror syntax tree, so languages without a grammar (Zig) never had their /// and //! docs rendered. docComments() now scans the lines when the tree is empty, with the tree walk's markers and rules, limited to languages whose comment tokens are // (line docs) or /* (block docs) so plain text and logs stay untouched.

Co-authored-by: akbar1214 <[email protected]>
2026-11-18 09:06:55 +08:00
Mr0Bread 21314846cf fix(agents): stop the conversation leaking graphics memory into the app process (#4057)
WebKit leaves the surfaces of a scrolling view in the app process when the view's height keeps crossing 2048 CSS px, which the agent conversation does while turns fold and replies stream (~1 GB per 40 crossings). Each conversation row now paints into its own layer (will-change: transform), so the stream's scrolled contents allocate no such surfaces.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-18 09:02:24 +08:00
l0ng-ai 4fd04b93d4 fix(editor): draw rainbow indent guides at half strength (#4068)
Rainbow indent guides used text palettes (semantic highlighting, rainbow brackets) at full strength, which read as heavy lines. Guides now mix each colour 55% with transparent, keeping the hues distinct and matched to their brackets.

Fixes #4022
2026-11-18 08:59:39 +08:00
l0ng-ai 79d2b1e5c0 feat(editor): underline editor tabs of files with errors (#4067)
Editor tabs show the Project view's wavy error underline for files the problems provider marks with errors. The label gets block padding so the ellipsis clip doesn't cut the wave off.

Fixes #4027
2026-11-18 08:54:51 +08:00
l0ng-ai 5657dbd3e3 fix(color-scheme): an unticked Foreground keeps the text visible (#4065)
Unticking Foreground wrote the cleared colour, transparent, into the
attribute's colour variable, so its tokens became invisible. A cleared
foreground now falls back to the default text colour; cleared backgrounds
and effects stay transparent.

Refs #4059
2026-11-18 08:45:40 +08:00
l0ng-ai 2678698bf9 fix(agents): report a session that fails to load instead of replacing it (#4064)
When session/load failed for a task's saved session, the task silently
started a new session and stored its id over the old one, so the agent lost
the conversation without a word in the chat (OMP fails to load a session
saved with a model it cannot restore). The failure now shows in the chat and
keeps the saved session; sending again starts a new session. An
authentication failure during the load shows the sign-in error instead.

Fixes #4035
2026-11-18 08:43:12 +08:00
l0ng-ai e8d91b4615 docs: drop the memory indicator from the landing page screenshot (#4063) 2026-11-18 08:41:44 +08:00
Ray Liangтаcubelitblade c1f3debbb9 fix(terminal): use fish's hostname variable for OSC 7 (#4050)
The fish prompt hook ran the external hostname command to build the OSC 7
working-directory URL, so fish printed an error at every prompt where that
command is unavailable. It now uses fish's built-in \$hostname variable.

Closes #4046

Co-authored-by: cubelitblade <[email protected]>
2026-11-18 08:37:55 +08:00
l0ng-ai c1782f01eb docs: add a landing page and a plugin marketplace to the documentation site (#4033)
/en and /zh open a landing page: the product in the dark theme, startup and
memory numbers, the main features, featured plugins and the default keymap.
The introduction pages move to /en/introduction and /zh/introduction.

/plugins and /zh/plugins list the marketplace's plugins with search,
category filters, sorting and a details dialog. The list is a snapshot of
plugins-index.json written by `pnpm gen:plugin-catalog`.
2026-11-18 02:03:42 +08:00
Ernstjan FreriksтаEjaYF 9cfe667b6a fix(clipboard): build on Windows again after the command refactor (#4030)
#3598 moved blocking from src-tauri's commands::doc to ide_host::ops::doc,
but the Windows-only import in commands/clipboard.rs still named the old
path, so src-tauri no longer compiled on Windows. It now imports
ide_host::ops::doc::blocking like commands/db.rs and commands/perf.rs.

Co-authored-by: EjaYF <[email protected]>
2026-11-17 23:40:40 +08:00
Ernstjan FreriksтаEjaYF 318f4a2d82 feat(database): export with mysqldump and restore with mysql (#4001)
MySQL and MariaDB data sources, schemas and tables get Import/Export >
Export with 'mysqldump' and Restore with 'mysql'. ide-db builds the arguments
from typed options and runs the tool connected like the data source (TCP,
the driver's SSL flags, the SSH tunnel); the password goes in a user-only
temporary option file passed as --defaults-extra-file and removed after the
run. Restore pipes the dump into mysql's standard input.

Restore dialogs (MySQL and PostgreSQL) now check the target first: the
Database field lists the source's databases and disables Run for a missing
one, and db_dump_info (formerly db_dump_kind) reports whether an SQL dump
creates its database itself. pg_restore gains --create.

Part of #3188

Co-authored-by: EjaYF <[email protected]>
2026-11-17 23:39:50 +08:00
LU XIANGRUIтаwildcatDownstairs 31466f2834 feat(lsp): make type names in other languages' documentation signatures clickable (#4010)
Go signatures already linked their type names (#3959). For other languages
the name is looked up near the documented symbol's declaration and the
language server's definition there is the target; parameters, the symbol's
own name, inferred types and names with several definitions don't link.
Names resolve on hover, so only those that lead somewhere look like links,
and only the signature code blocks are considered (leading blocks, or the
one after the last rule for clangd). Plain names a grammar leaves untagged
get a tok-name span so they can be followed.

Refs #3874

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-17 23:29:20 +08:00
lleviathe 9f9beaa27c feat(mcp): show the callers and callees of a function with get_call_hierarchy (#4019)
The built-in MCP server had no call hierarchy, so agents fell back to text
search for callers. get_call_hierarchy returns one level of callers (default)
or callees of the function at a position through lsp_call_hierarchy, with
call sites and their line text, paging and scope like find_references; a
position inside a body means the enclosing function. ide-lsp reports the
hierarchy's root and the file of an outgoing call's sites. find_references
now shares the document guard and the cancel/timeout race with it.

Co-authored-by: lleviathe <[email protected]>
2026-11-17 23:27:25 +08:00
xiaowu0203 182285647e fix(editor): make rectangular mouse selection configurable (#4020)
The rectangular drag gestures were hard-coded, and a middle-button press
navigated immediately, which cut off a middle drag. A new keymap action,
Create Rectangular Selection on Mouse Drag (Alt+Left and Middle by default),
now decides the gesture; middle-click navigation fires on release when the
mouse did not move. Linux keeps middle-button paste unless the user binds the
middle button explicitly, and the mouse shortcut recorder accepts modified
middle clicks.

Closes #3713

Co-authored-by: xiaowu0203 <[email protected]>
2026-11-17 23:22:56 +08:00
Yann ba4bf0ce1d fix(agents): show Codex asynchronous questions (#4013)
Codex attaches non-blocking questions to completed agent messages, but the
question metadata was discarded and only the message text was shown. The
Codex shim now emits them as user_question updates (live and from history),
the timeline keeps them as Question entries that survive the turn's end and
restarts, and the existing question card answers them with Codex's stable
question ids: a running turn is steered, an idle task starts a normal turn.
Skipping does not cancel the agent; blocking permission questions keep
priority over asynchronous ones.

Co-authored-by: YannABC <[email protected]>
2026-11-17 23:19:50 +08:00
l0ng-ai 76c75b0f7f fix(plugins): deliver document-changed events to plugins (#4028)
The event queue relativized path events at enqueue time, so the delivery
filter looked up a project-relative document path, found no project and
dropped every document-changed event. Document paths now stay absolute
through filtering and are relativized to the file's own project at hand-off.
The path-events fixture subscribes document-changed to cover the flow.

Fixes #4008
2026-11-17 23:13:54 +08:00
l0ng-ai c8a91e5b0f feat(appearance): Presentation Assistant (#4026)
While on, each action the user runs shows its name and shortcut in a popup, for screencasts and demos. Toggled from View › Appearance › Presentation Assistant; Settings › Appearance › Presentation Assistant sets the popup size, duration, position and whether to also show the other platform's shortcut (macOS ⇄ Windows/Linux). Hidden actions are not shown.

Closes #3949
2026-11-17 23:01:12 +08:00
l0ng-ai a430d4ace7 fix(tools): fail and retry a stalled tool download instead of hanging (#4024)
Tool downloads used curl with only a connect timeout, so a connection that stopped delivering (a stalled proxy or mirror) left Install waiting indefinitely. Requests now fail after 30 s without data (--speed-limit 1 --speed-time 30), which curl's --retry treats as transient and retries.
2026-11-17 22:47:14 +08:00
l0ng-ai 7e5277eaa6 feat(languages): Typst with the tinymist language server (#4023)
Typst (.typ) files get syntax colouring for markup, embedded code and math, a file icon, and the tinymist language server (installable from its GitHub releases) for completion, diagnostics, navigation and the outline.

Closes #3924
2026-11-17 22:44:13 +08:00
l0ng-ai 2278cf6e8f fix(editor): don't indent C++ namespace and extern "C" contents on Enter (#4018)
Enter inside namespace x { … } or extern "C" { … } indented the new line one level, like any brace body. clang-format's built-in styles (LLVM, Google, Chromium, Mozilla, Microsoft, GNU) keep those contents at the level of the braces' line (NamespaceIndentation: None), so the editor now does too; other brace bodies keep their indentation.

Fixes #3993
2026-11-17 22:10:13 +08:00
l0ng-ai d4f6114be1 feat(settings): context menu for the deployment server list (#4017)
Right-clicking a server or server group in Settings › Build, Execution, Deployment › Deployment selects it and offers Add (Server / Server Group), Duplicate and Use as Default for a server, and Remove; the empty part of the list offers Add.

Closes #3910
2026-11-17 22:03:35 +08:00
l0ng-ai ad93e491c9 feat(settings): choose PHP include paths with a folder chooser (#4016)
+ under Settings › Languages & Frameworks › PHP › Include paths opens a folder chooser and adds the picked folder; Edit and double-click still take a typed path, and outside the desktop app + keeps adding a row to type into. Additional stubs are stub names, so that list stays typed.

Closes #3912
2026-11-17 22:00:43 +08:00
l0ng-ai 098e80dbef fix(agents): name the task's agent in the session status line (#4015)
The session status line under the composer lost the agent's icon and name when it was reduced to one quiet line; with several tasks open side by side there was no way to tell which agent answered without opening the picker. It starts with the agent's icon and name again, before the branch.

Fixes #3917
2026-11-17 21:58:00 +08:00
l0ng-ai 6ab7627fc4 feat(vcs): project conventions for Generate Commit Message with Agent (#4014)
Settings › Version Control › Commit gets a Commit Message Generation section with a multi-line field (vcs.commit.agentInstructions, global or per project). Its text is added to the agent's prompt as the conventions to follow, ahead of the style taken from recent commit subjects.

Closes #3934
2026-11-17 21:53:38 +08:00
l0ng-ai 55e778897f feat(vcs): show a stash's changed files and their diff in the Stash tab (#4012)
Stashes in the Commit tool window's Stash tab expand to the files they changed against the commit they were made on; selecting a file previews its diff (with Show Diff Preview on) and double-clicking opens it. Double-clicking a stash expands it instead of applying it; Apply / Pop / Unstash stay on the toolbar and context menu. Stash (IPC) now carries the stash commit and its base.

Closes #3968
2026-11-17 21:45:50 +08:00
l0ng-ai cc6ed6b5fd feat(editor): copy a multi-line selection's path as path:first-last (#4011)
Copy Path with Line Number (and its entry in Copy Path/Reference…) copies path:12-18 when the selection spans several lines, leaving out a last line the selection only reaches the start of; a caret or single-line selection still copies path:12.

Closes #3962
2026-11-17 21:39:11 +08:00
Vadim LazukтаInf1mum 5efd58d3af fix(workbench): move any project tab to a new window from its own arrow (#3991)
The Move Tab to New Window arrow was one bar-level button drawn inside the last tab, above its centre line, and always moved the selected tab. Every project tab now has its own arrow on its right edge, centred and revealed on hover like the close button, and the tab context menu's Move Tab to New Window works on any tab. window_group_detach takes the tab's label and selects it before detaching; without an argument (Find Action) the action still moves the selected tab.

Fixes #3954

Co-authored-by: Inf1mum <[email protected]>
2026-11-17 21:37:59 +08:00
acaoтаamphetamlne d250b351bb fix(index): report accurate scan work counts (#3229)
Index scans log what they actually did as structured fields: files discovered, metadata reused, candidates scheduled, and mutually exclusive extraction outcomes (symbols extracted, hash reused, ignored, oversized, binary, unsupported, read failed, not processed), instead of calling every metadata-stale candidate parsed. Warm-snapshot startup and fallback scans log their phases separately; cancelled scans log no completion summary. Indexing behaviour is unchanged.

Co-authored-by: amphetamlne <[email protected]>
2026-11-17 21:34:47 +08:00
Aditya Aggarwalтаaditya-786 033f049caf feat(spring): navigate from Feign client methods to controller endpoints (#3997)
Feign client methods in Java and Kotlin get a Go to Feign Endpoint gutter arrow and action, and Go to Declaration on a literal mapping path opens the matching controller methods. Matching reuses the Spring route index (HTTP method + literal path, whole {variable} segments); a literal Feign name narrows candidates to the module whose spring.application.name matches, while dynamic or missing identities and explicit url clients keep every method/path candidate in the declaration chooser.

Refs #3882

Co-authored-by: aditya-786 <[email protected]>
2026-11-17 21:30:26 +08:00
lleviathe 74157ffe54 fix(editor): highlight toml keys, dates and booleans like IntelliJ (#3981)
Adds a TOML stream parser so keys are coloured as keys wherever they stand (table headers, dotted keys, inline tables), with numbers, booleans/dates, strings and valid/invalid escapes told apart, in files, lock files and fenced code blocks.

Co-authored-by: lleviathe <[email protected]>
2026-11-17 21:27:09 +08:00
lleviathe 732e92f756 fix(editor): colour .env and properties keys like other key-value files (#3979)
Adds a properties/.env stream language wrapper so keys use the keyword colour, the first separator the operator colour and values the string colour.

Co-authored-by: lleviathe <[email protected]>
2026-11-17 21:23:53 +08:00
QтаNeverKnowsTomorrow a83bad107c fix(plugins): ask before loading a changed Java agent (#4003)
When a plugin's Java agent jar changed, the host already refused to load it until java.agent was granted again, but Settings still showed the permission as granted, so the agent silently disappeared from Run/Debug. PluginInfo now carries the agent's file name, arguments and whether its jar still matches the approved hash; Settings › Plugins warns about a changed jar and offers Approve new jar, which grants the permission again.

Co-authored-by: NeverKnowsTomorrow <[email protected]>
2026-11-17 21:20:40 +08:00
Akbar Husain 39f709def5 fix(run): debug Zig build steps via the executable config (#4002)
Debug on a detected 'zig build run' configuration said it had no debug adapter: build-step configs only run 'zig build <step>'. Steps that run an executable (addRunArtifact in build.zig) now link to that executable's config, and Debug delegates to it — running its before-launch build and keeping the clicked step as the session's origin.

Refs #3260

Co-authored-by: akbar1214 <[email protected]>
2026-11-17 21:17:05 +08:00
pravdomil ea6638b05e fix(editor): keep scroll inertia out of ⌘/Ctrl+wheel font zoom (#3985)
WebViews don't expose macOS momentum phases, so a trackpad scroll still coasting when ⌘ was pressed zoomed the text, and the inertia after a ⌘ swipe kept zooming. Wheel events less than 150 ms apart now count as one gesture: only a gesture that started with ⌘/Ctrl zooms, and once its deltas shrink four events in a row the rest is inertia. All ⌘/Ctrl+wheel font-zoom surfaces use it (editor, terminal, agent chat, Markdown preview, plugin and services log editors).

Co-authored-by: pravdomil <[email protected]>
2026-11-17 21:15:20 +08:00
TarasтаTarasMK a91421c6e0 fix(docker): list containers without asking the daemon for their sizes (#3976)
Containers were listed with --format '{{json .}}', which includes Size, so the daemon computed every container's writable layer and a busy daemon exceeded the 20 s listing timeout ('docker did not respond in time', no Compose groups). The listing now uses a template with only the fields the parser reads.

Fixes #3975

Co-authored-by: TarasMK <[email protected]>
2026-11-17 21:13:09 +08:00
l0ng-ai 973f0a18a8 fix(vue): don't indent code in top-level <script> and <style> blocks (#4009)
The HTML base indented every element's children, so Enter in <script setup> indented the new line. Like WebStorm's Vue code style, only the top-level <template>'s children are indented; code in top-level <script> and <style> blocks starts at the margin.

Fixes #3982
2026-11-17 21:11:13 +08:00
Vadim LazukтаInf1mum fb64f0cd26 fix(vcs): say whether blocked checkout would remove or overwrite the untracked files (#4005)
When git refused a checkout because of untracked files, the notification always said they would be overwritten; git's own reason (removed vs overwritten) is now carried on CheckoutOutcome::UntrackedFiles and the notification uses git's wording for each case.

Fixes #3980

Co-authored-by: Inf1mum <[email protected]>
2026-11-17 21:07:39 +08:00
l0ng-ai 34f2e18ff1 fix(macos): keep full screen when Escape goes unhandled (#4006)
Escape the page leaves unhandled goes back from WebKit as the web view's doCommandBySelector:(cancelOperation:), run through NSView's own implementation, which leaves full screen directly; the window-level cancelOperation: hook from #3134 was never reached and is removed. In macOS full screen the workbench now marks Escape handled after every key handler has seen it (also when one stops it); Ctrl+Cmd+F leaves full screen.

Refs #3970, #3104
2026-11-17 20:58:44 +08:00
l0ng-ai 83a949ffe9 fix(debugger): keep an expanded value hint open (#4004)
Expanding an object in the debugger's value hint grew it into a variables tree that no longer fit above the line, so the tooltip moved below it, away from the mouse, and the hover tooltip closed as soon as the mouse moved towards it. An expanded hover hint is now shown pinned at the expression until Escape, a click in the editor, an edit or the next step; hints shown with a timeout (selection, quick evaluate, inline values) are kept once clicked or focused.

Refs #3970
2026-11-17 20:39:19 +08:00
l0ng-ai af8bd1afcd fix(debugger): debug Python with a Windows venv interpreter given by its path (#3999)
debugpyLaunch split the run configuration's command only at '/', so a Windows venv interpreter path (C:\...\.venv\Scripts\python.exe) fell back to a bare python from PATH and was passed as the module to run; when that python could not start, debugpy's launcher never connected ("Timed out waiting for launcher to connect"). Command names now split at both separators, and a venv tool given by a backslash path debugs with the python.exe next to it.

Fixes #3907
2026-11-17 20:29:12 +08:00
l0ng-ai ce12f68613 fix(hierarchy): load library types' levels from their language server (#3998)
The type hierarchy's withDocument opened every node from disk, so library types (jdt:// URIs) failed with os error 2: look-ahead loads failed silently, leaving expand arrows on every JDK type, and expanding one showed "failed to load". Library URIs now open as virtual documents.

Fixes #3409
2026-11-17 20:24:37 +08:00
l0ng-ai 77996f17e7 fix(terminal): open file:// links in the editor (#3996)
Compiler output such as Kotlin's "file:///develop/app/src/A.kt:15:56 Unresolved
reference" was linked as a URL and handed to the system opener: in a remote
window it failed with "Not allowed to open url", and locally it opened the file
in another app. A file:// URL is now a file location with its line and column,
opened in the editor on the machine the terminal runs on, as the Run console
already does.

Refs #3447
2026-11-17 20:12:33 +08:00
l0ng-ai bacdd3e5c3 fix(run): detect Spring Boot apps that inherit the plugin or use a meta-annotation (#3995)
Project detection only treated a module as Spring Boot when its own build file
applied the plugin, so microservice modules that inherit spring-boot-maven-plugin
from the parent POM's <build><plugins> (or Gradle's subprojects block) were missing
from Run configurations and Services until their main class was run once. And only
the literal @SpringBootApplication marked an application class, not
@SpringCloudApplication or a project annotation carrying @SpringBootApplication, so
the gutter's Run created a plain Application configuration.

A module now applies Spring Boot through its own build or a build above it
(pluginManagement alone doesn't apply it). Application classes are recognised by
@SpringBootApplication, @SpringCloudApplication, or a project annotation declared
with either (resolved through imports and the modules' main source roots). The
gutter reuses the Spring Boot kind of the detected configuration with the same id.

Fixes #3916
2026-11-17 20:10:43 +08:00
tomgorтаtomgor cb7bddec14 fix(java): show Maven-generated sources in Problems (#3944)
jdtls/m2e only import source folders declared in the POM. Generators such as protobuf/gRPC, jOOQ, Avro, OpenAPI and QueryDSL add theirs with addCompileSourceRoot while the build runs, so Problems stayed red after a successful Maven compile. After a Maven project update, and after Build, Rebuild and Compile File, the IDE now scans target/generated-sources and generated-test-sources and puts those folders on the jdtls classpath through openidea.java.generatedSources (java-usages bundle 1.16.0), marked so a later scan can drop them; annotation-processor output, which jdtls compiles itself, is left out. A Maven build never starts jdtls by itself.

Co-authored-by: tomgor <[email protected]>
2026-11-17 20:06:44 +08:00
Mr0Bread 407561e59a feat(agents): jump to the chat input with ⌘L from anywhere that doesn't claim it (#3961)
Focus Agent Input (⌘L / Ctrl+L) only worked while focus was already in a task view. It now also focuses the message input of the task shown in an editor tab or the Agents tool window (the one used last when several are shown) from anywhere that doesn't own the key: in a code editor ⌘L stays Go to Line, the terminal keeps Ctrl+L, and popups and dialogs keep focus. Inside a task view it still wins over the editor.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-17 20:02:09 +08:00
LU XIANGRUIтаwildcatDownstairs e34e925b8f feat(lsp): follow doc.rust-lang.org and docs.rs links inside the documentation popup (#3960)
rust-analyzer renders intra-doc links as rustdoc URLs (doc.rust-lang.org for the standard library, docs.rs for other crates, the project's own included). Such a link now resolves by crate, module path, name and member (#method.x, #variant.X) through workspace/symbol and opens as the next history step when exactly one declaration fits (re-exports don't count); otherwise it opens in the browser. Web link rules live per language in src/editor/lsp/docLinks/. typescript-language-server's #L20%2C3 source links keep their column.

Refs #3874

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-17 20:00:01 +08:00
LU XIANGRUIтаwildcatDownstairs 04ab9e8999 feat(lsp): follow pkg.go.dev links and Go signature types inside the documentation popup (#3959)
A pkg.go.dev link in gopls documentation (#Name, #Type.Method, @version paths) opens its declaration's documentation as the next history step when workspace/symbol finds exactly one; otherwise it opens in the browser as before (⌘-click always does). Type names in a Go signature are clickable: a qualified pkg.Name resolves through the imports (aliases included) of the hovered file and the declaring file, an unqualified name in the declaring package, and builtins in $GOROOT/src/builtin/builtin.go. Only a unique exact match navigates.

Refs #3874

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-17 19:57:34 +08:00
LU XIANGRUIтаwildcatDownstairs 4a9927c256 feat(lsp): resizable documentation popup; hover documentation shares the F1 view (#3958)
The Quick Documentation popup can be resized from its right and bottom edges and corner; the size is remembered. Hover documentation now uses the same DocView as the F1 popup and the Documentation tool window, so links open inside the popup with back/forward history, F4 / Edit Source goes to the source, and it can be moved to the tool window. The popup's 600px / 420px caps, which floating-ui's inline sizes overrode, now apply to the content.

Refs #3874

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-17 19:46:15 +08:00
Muuтаmuutot 084be4fb51 fix(vcs): Git Log column dividers, resize direction and Hide Column (#3879)
Dragging a Git Log column divider moved the wrong way and could shift unrelated columns, and the resize target was hard to find. The divider now sits on a column's left edge, follows the pointer, and resizes only its two neighbours; the flexible Commit column gets a header divider that resizes the column to its left. Visible dividers are an opt-in View Options › Columns › Column Dividers (off by default; the hit strip and resize cursor always work), and the column header menu can hide any column except Commit.

Co-authored-by: muutot <[email protected]>
2026-11-17 19:43:43 +08:00
l0ng-ai 5c0ff2a918 fix(search): show tool window names in the UI language in Recent Files (#3990)
The tool-window column of Recent Files / Switcher listed every window by its
English title in a localized UI; the window's own header translates it. Recent
Files, the Run configuration's Activate tool window task and its menu now use the
same translated title (plugin windows keep theirs), and the English name still
finds a translated window when typed.

Fixes #3931
2026-11-17 19:41:31 +08:00
l0ng-ai c65acc902e chore(release): drop nightly builds (#3988)
Stable releases ship often enough that a separate nightly channel isn't needed.
Removes the nightly workflow and its prepare script, the nightly branches in the
release build's updater manifest, the nightly-only update endpoint, and the
once-a-day prompt throttle for nightly versions.
2026-11-17 19:41:20 +08:00
l0ng-ai ec0a681b72 fix(terminal): clear terminalFocus when the focused terminal pane is closed (#3989)
Removing the focused pane (the shell exiting with Close session when it ends on,
or closing the focused tab) fires no blur, so terminalFocus stayed set and the
terminal's keyWhen bindings kept winning: with the IntelliJ macOS keymap ⌘T opened
a new terminal tab from the editor instead of Update Project. Disposing a session
whose pane holds the caret now clears it; a pane that takes the caret sets it again.

Fixes #3923
2026-11-17 19:40:44 +08:00
l0ng-ai 5895022904 fix(agents): declare an image's type from its bytes when sending it to an agent (#3987)
A pasted image kept the type the clipboard declared, which for an image copied from
a web page can be image/png over JPEG or WebP bytes. Agents that validate image
blocks (DeepSeek Harness over ACP, Claude's API) rejected the whole prompt with
"Declared image type does not match its bytes". Image blocks now declare the type
read from the PNG, JPEG, GIF or WebP signature, and the declared one otherwise.

Fixes #3911
2026-11-17 19:37:05 +08:00
Muuтаmuutot 215023e85c fix(plugins): wake problems-changed plugins on UI-side diagnostics (#3957)
problems-changed was only forwarded for backend diagnostics events. Spelling and the other UI-side inspections publish through localDiagnostics, so a plugin drawing problems (Inspection Lens) kept showing a Typo after Add to Dictionary cleared it. Local diagnostic changes now post the same event.

Co-authored-by: muutot <[email protected]>
2026-11-17 19:32:33 +08:00
Bin aab53f89b3 fix(editor): hide the final import when folding import runs (#3945)
Folding a run of imports left the closing `} from '…'` line of a final multiline import visible beside the first import. An imports fold now keeps its last line visible only when that line is a bare closing delimiter (Go's `)`, Rust's `};`); otherwise it hides the whole final statement. Syntax regions keep their closing delimiter as before.

Co-authored-by: ffgenius <[email protected]>
2026-11-17 19:31:59 +08:00
Aditya Aggarwalтаaditya-786 519f1d43f4 fix(java): exclude undeclared reactor test outputs from Maven classpaths (#3965)
Maven launches prepended every reactor module's target/test-classes before Maven's scope-filtered classpath, so test-only Spring beans leaked into application runs. Reactor modules now contribute only target/classes; the current module's tests stay on test launches and single-file test compilation, and test artifacts Maven resolves are kept. Cached classpath records carry a format version, so records written before this are rebuilt.

Closes #3932

Co-authored-by: aditya-786 <[email protected]>
2026-11-17 19:28:05 +08:00
Akbar Husain 88368033be fix(lsp): answer server message requests with the chosen action (#3928)
window/showMessageRequest was shown as a plain notification and always answered null, so Dart cancelled renames that carry a warning ("Renamed field will be invisible in …"). The question now opens a dialog with the server's own buttons and the chosen MessageActionItem is returned; an action the server did not offer is answered null. The answer command (lsp_message_request_answer, declared with #[command]) runs where the language server runs, so remote projects work too. Questions time out below the rename's timeout and at most eight wait at once.

Closes #2197

Co-authored-by: akbar1214 <[email protected]>
2026-11-17 19:26:15 +08:00
l0ng-ai d952827557 fix(agents): shorten the import link in the empty task list (#3984)
The empty Agents list now reads "Import Sessions…" instead of the full
"Import Sessions from Other Apps…", which wrapped awkwardly in a narrow
tool window. The command title and dialog title keep the full wording.
2026-11-17 19:23:15 +08:00
Yann bb3fd570a6 fix(agents): open Windows file links in replies (#3947)
Drive-letter links in agent replies looked clickable but did nothing: DOMPurify dropped their href as an unknown scheme, and the click handler treated the drive letter as a URL scheme. Validated drive-letter paths (also /E:/…, backslashes and percent-encoded forms) now keep their href and open the file at the linked line and column; other schemes and network shares stay blocked. Each link shows its full target on hover.

Co-authored-by: YannABC <[email protected]>
2026-11-17 19:16:20 +08:00
Vadim LazukтаInf1mum 92119e2040 fix(agents): show ACP model names instead of raw model ids (#3973)
The ACP model picker derived each label from the model id and used the agent-reported name only as a fallback, so OpenCode's opencode/beam-free showed as beam-free. The label now prefers the reported name, without the provider prefix the agent repeats; the id stays in the detail line, and agents that echo the id keep the id tail.

Fixes #3919

Co-authored-by: Inf1mum <[email protected]>
2026-11-17 19:15:14 +08:00
l0ng-ai 93d7f76b20 fix(docker): connect through any SSH configuration, not only OpenSSH-config ones (#3898)
A Docker connection over SSH could only use an SSH configuration with OpenSSH config
authentication, because docker ran the system ssh; a configuration with a password or
key left OK disabled until an Engine API URL was typed. Such a configuration is now
saved as its own endpoint kind. The host opens the configuration's SSH session with
its saved credentials and a local listener whose connections each run
`docker system dial-stdio` on the host, as the Docker CLI's ssh:// does, and points
docker at that listener. A dropped SSH connection is reopened on the next command.

Fixes #3850
2026-11-17 19:14:29 +08:00
l0ng-ai f53a7ec42c feat(tools): show which language servers are interchangeable and which run together (#3963)
Interchangeable servers on Settings › Language Servers are now one radio group (Automatic, each server, None) with the server that will run tagged In use; servers that run alongside them are listed under Additional servers, each with its on/off box in the list. Missing tools named in the banner jump to their row, a server found on PATH offers Install IDE Copy, languages are listed by popularity, and a search lists languages matched by name before those matched only by a tool.
2026-11-17 19:14:22 +08:00
Mr0Bread be384e460a refactor(ipc): declare each command once, on its implementation (#3598)
A command is now declared once, on the fn that implements it. A project-host command is an
ide-host fn with #[command(trust = …)] listed in its module's domain!; its Tauri adapter,
bindings entry, JSON-RPC handler, trust class and remote routing are derived from that
declaration. Desktop-only commands keep their Tauri fn and add #[desktop_command(trust = …)].

This removes the hand-written pass-through adapters, collect_commands!, the per-domain register
fns and the trust tables in trust.rs. The invoke handler looks up each command's declared trust
class; a name nothing declares is denied. A remote window routes the project-host commands of
the desktop's own build. Duplicate names are a compile error. CI runs ide-command's
compile_fail doctests.

Part of #3344.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-17 19:10:13 +08:00
huanglininnтаmoyining f86c5e3460 fix(vcs): keep a diff pane's horizontal scrollbar at its bottom edge (#3933)
In the aligned side-by-side diff the panes scroll together in the outer
MergeView, so each pane's scroller is as tall as its content and its
horizontal scrollbar renders at the bottom of the content: with wrapping
off and lines wider than the pane, the bar floats mid-screen for short
diffs and sits below the viewport for long ones, reachable only after
scrolling the diff to its end.

Every split diff but a fitted block now scrolls its panes themselves (as
the unaligned mode already does), so both scrollbars stay at the pane's
edges. The padded panes lay their lines out identically, so a small sync
copies one pane's scrollTop to the other; the overview lane is per pane
as in the unaligned mode, and the outer-scroller lane support goes away.
A fitted block keeps one stripe, on the right pane (IDEA's shared
scrollbar), not one per pane.

How it was verified:
- new e2e/diffScrollbar.spec.ts asserts in all three modes (unaligned,
  aligned, unified) that the right pane's scroller spans the host
  viewport while its content is ~24k px wider than it;
- e2e diff suite (27 cases: small diffs, a 44,000-character line, 10,000-
  line files padded / sync / unified / collapsed, soft-wrap toggles) and
  the overview-lane and diff-navigation specs pass;
- unit tests: new PaddedPanes sync cases (follow, sync off, animated
  scroll source) and the updated per-pane lane assertions pass; the full
  suite shows only the two pre-existing Windows-checkout failures
  (scripts/check-webkit path separators, generated theme docs);
- pnpm typecheck, lint, knip and build pass; touched files are oxfmt-clean.

Co-authored-by: moyining <[email protected]>
2026-11-17 16:34:33 +08:00
l0ng-ai 0fb574e815 fix(spell): accept -ize verbs the dictionary lists only as -ization/-ized (#3951)
parallelize, modularize, virtualize and similar verbs were flagged as typos
while parallelization/parallelized passed. Add the missing base forms (US and
UK spelling) to the extra dictionary.
2026-11-17 16:22:24 +08:00
l0ng-ai 43f9ec99f6 feat(plugins): Marketplace / Installed tabs and a roomier page layout (#3950)
Settings › Plugins gets Marketplace and Installed tabs again, centred in the
page header with the gear menu; the Installed tab shows how many updates are
available. Search (and the category filter on Marketplace) sits at the top of
the list column, and the list and details fill the page under the header.

Rows show a bold name, a 40px icon, and version, vendor (marketplace rows:
downloads first) on the second line; the description moves to the details.
Install / Update and the enable checkbox line up with the name, and an
installed plugin's update is an Update button beside its checkbox.

The details header lists tags, then the name, vendor, and the actions with
the version, without the large icon.

Settings pages can put controls beside their title through
useSettingsHeaderSlot and fill the page edge to edge with `bleed`.

Also adds the missing comma after "Add to Message" in en.json and zh.json,
which kept the text catalog from parsing.
2026-11-17 16:19:26 +08:00
Deng Liu e86e2e8e5c test(agents): fix FakeCopilotServer initializer and restore background-shell test (#3935)
When main (#3908) was merged into #3846 right before landing, the conflict resolution at the end of crates/ide-agent/src/native/copilot/tests.rs left shim_forwards_disabled_mcp_servers_on_create_and_resume without background_shell: false and dropped stop_ends_a_turn_left_running_only_by_background_shells (leaving std::time::Duration unused).

Add background_shell: false to the #3908 initializer and restore stop_ends_a_turn_left_running_only_by_background_shells.
2026-11-17 16:00:59 +08:00
l0ng-ai 811b98dd4b fix(plugins): keep version and Update badge intact in plugin rows (#3946)
Only the vendor name shrinks and ellipsizes in a row's meta line, so a long
author list no longer clips the version or tags. The Update badge moves out
of the meta line to a fixed slot before the checkbox, so it lines up across
installed rows.
2026-11-17 15:59:51 +08:00
l0ng-ai 76377b6eec fix(project-view): keep the tree still when a file is dragged out of it (#3930)
Dragging a file from the Project view to the terminal kept scrolling the tree: WebKit autoscrolls the pressed scroll container toward the pointer once it leaves. During a drag the tree now keeps its position while the pointer is outside it and scrolls itself only within 24 px of its top or bottom edge, as IDEA's tree and our tree reorder drag do. Fixes #3902
2026-11-17 15:10:58 +08:00
l0ng-ai 61ba70394f fix(vcs): don't open an empty blame column for a file Git has no commit of (#3927)
Annotate with Git Blame on an unversioned, ignored, or added-but-not-committed file opened a wide, empty annotation column: the backend blames every line of a file missing from HEAD as not committed. The action is now disabled for files the status lists as untracked, ignored or added, as in IDEA, and a blame without a single committed line leaves the column closed with a notification that the file has no committed history. Fixes #3900
2026-11-17 15:05:41 +08:00
defiaтаdefia bbc5412605 feat(editor): expose Find Usages above Go To (#3918)
The editor context menu shows Find Usages at the top level, immediately above the Go To submenu, as IDEA's editor popup does; the rest of Go To, the action, its shortcut and availability are unchanged.

Co-authored-by: defia <[email protected]>
2026-11-17 14:57:12 +08:00
Deng Liuтаarookieofc 3032bf108f feat(agents): surface session pull requests, issues, references, and artifacts above composer (#3819)
Co-authored-by: arookieofc <[email protected]>
2026-11-17 14:55:43 +08:00
Deng Liu bde17e4f47 fix(macos): keep auxiliary windows at full logical size across mixed-DPI displays (#3631)
* fix(macos): keep auxiliary windows at full logical size across mixed-DPI displays

* fix(macos): don't wait forever for the main thread to fit an auxiliary window
2026-11-17 14:55:28 +08:00
l0ng-ai af55109b27 fix(kotlin): open jdtls' class when the Kotlin server names its jar by another path (#3922)
Going to a library class from Kotlin swaps the Kotlin server's signature stub for jdtls' decompiled class, matched by package, name and the jar's path. When the servers know the jar by different paths (a system-scope jar, as reported), nothing matched and the stub stayed. The redirect now takes jdtls' only class of that name and logs why when it still finds none; java_class_file keeps the exact-archive match for debugger line mapping. Refs #3447
2026-11-17 14:55:12 +08:00
Deng Liuтаarookieofc 3663556a2e fix(agents): make Send now and Stop work while Copilot background shells run (#3846)
A Copilot turn only ended on `session.idle`, which Copilot defers until
every attached background shell (e.g. `gh pr checks --watch`) exits. The
main loop had long gone idle, so the turn showed "Writing…" for hours,
messages queued behind it, and Send now on a queued message only
cancelled a turn that `session.abort` could not end.

- Send now on a queued message steers it into the running turn when the
  agent supports steering, and falls back to interrupting the turn.
- The Copilot shim tracks whether its main loop is busy: Stop on a turn
  kept open only by background work ends it at once and leaves that work
  running, and steering then starts a new run instead of joining one.
- The Copilot shim reports background shells and agents
  (`session.tasks.list`) and stops them (`session.tasks.cancel`), so they
  show as background tasks that can be stopped one by one.

Co-authored-by: arookieofc <[email protected]>
2026-11-17 14:53:10 +08:00
l0ng-ai 217bd29860 fix(editor): colour Kotlin soft keywords only where they act as keywords (#3921)
The Kotlin stream mode coloured every soft keyword as a keyword, so a package segment (import top.ttb.data.Model), a member (result.data) or a name (val data = ...) looked like one. A word after . or ?. is now always a name, and a soft keyword is a keyword only before a declaration or another modifier (data class, open fun, by lazy) or, for catch / finally / init / constructor / get / set, before ( or {. Refs #3447
2026-11-17 14:50:25 +08:00
l0ng-ai 25d6e8ac7c fix(remote): browse the remote host when a setting asks for a path (#3920)
In a remote window, choosePath (Project Structure libraries, SDK homes, interpreters and the other settings that pick a file or folder) opened the desktop's own dialog, so it listed this machine's files while the path is used on the remote host. It now opens an in-app chooser that lists the host's folders through fs_read_dir: click selects, double click or Enter opens a folder or chooses the file, the arrow goes to the parent folder, and the path can be typed. Local windows keep the desktop dialog. Refs #3447
2026-11-17 14:48:50 +08:00
misswellтаmisswell 280760a5d4 fix(agents): keep the Agent sessions task list scrollable (#3909)
The imported-sessions section of the Agent sessions popup was flex: none, so many imported sessions (17 took 385 of 420 px) left the task list 0 px tall and the wheel had nothing to scroll. The section now shrinks within a 40% cap and scrolls on its own; the task list keeps its own scroll area.

Co-authored-by: misswell <[email protected]>
2026-11-17 14:26:57 +08:00
Deng Liuтаdengliu b3008be32b fix(agents): disable CLI-configured MCP servers when turned off in Copilot and Codex (#3908)
A server turned off in OpenIDEA (globally, per project, by agent filter, or in the session MCP picker) was only left out of mcpServers; Copilot and Codex still loaded it from their own configuration (~/.copilot/mcp-config.json, ~/.codex/config.toml). The session's _meta.openidea.mcpServersOff now reaches Copilot as disabledMcpServers on session.create/resume (--disable-mcp-server on the --acp fallback) and Codex as mcp_servers.<name>.enabled = false for names its own config defines. servers_off also counts agent-filtered and unapproved workspace entries. Changing Global, Project or built-in IDE MCP settings recycles idle resumable sessions (or reloads after the running turn), and the session picker gets per-session toggles for Agent Config entries.

Co-authored-by: dengliu <[email protected]>
2026-11-17 14:15:40 +08:00
LU XIANGRUIтаwildcatDownstairs 577193d387 feat(plugins): the editor's tab size in editor panels (#3906)
openidea.editor.get() includes tabSize, the editor state's tab size (Code Style, .editorconfig, indent detection or the status bar's indent picker), and onTarget fires again with the new get() value when it changes for the same file, at most once a frame. Documented under API 1.10; the minimap fixture expands tabs to that size.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-17 13:31:19 +08:00
LU XIANGRUIтаwildcatDownstairs 449db6baa7 feat(plugins): the change-marker lane's VCS changes in editor panels (#3905)
An editor panel's page can read the added, modified and deleted lines the change-marker lane shows with openidea.editor.changes() ([{ line, lastLine, kind }] in file order, [] outside version control) and hear them through onChanges, at most once a frame. The values are the lane's own hunks: hunkField provides a new lineChanges facet in src/editor/api.ts, so the panel reads them without importing the VCS feature. Frames get the lane's colours as --openidea-change-added / -modified / -deleted. Documented under API 1.10; the minimap fixture marks changes at its left edge.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-17 13:30:29 +08:00
LU XIANGRUIтаwildcatDownstairs ea1f1e54d0 feat(plugins): the caret and selections in editor panels (#3904)
An editor panel's page can read the caret and every selection of its group's editor with openidea.editor.selections() (main selection first, then the others in file order; 0-based lines, UTF-16 columns) and hear them through onSelections, at most once a frame, also after an edit or a file switch. Documented under API 1.10; the editor-panel minimap fixture tints the selected lines and the caret's line.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-17 13:29:00 +08:00
l0ng-ai 4201aad9f9 feat(vcs): join each merge change to the result with a curved band (#3903)
The merge editor's panes sat edge to edge, so it was hard to see where a side's change lands in the result. A divider between each side and the result now draws a curved band per open change of that side (conflicts in the conflict colour), as IDEA's merge viewer does; a side's band goes once that side is accepted or ignored.

Closes #3876
2026-11-17 13:13:27 +08:00
l0ng-ai 678407f4c0 fix(clipboard): mark copied files as a copy for Windows paste targets (#3901)
Explorer writes "Preferred DropEffect" (DROPEFFECT_COPY) with every file list it copies, and paste targets that transfer files between machines, such as Remote Desktop's clipboard redirection, read it. Files copied in the Project view now carry it too.

Refs #3863
2026-11-17 13:06:31 +08:00
1790 змінених файлів з 103975 додано та 28350 видалено

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}`);
+89 -18
Переглянути файл
@@ -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
@@ -32,7 +34,12 @@ jobs:
pull-requests: read
outputs:
rust: ${{ steps.classify.outputs.rust }}
server: ${{ steps.classify.outputs.server }}
plugins: ${{ steps.classify.outputs.plugins }}
deny: ${{ steps.classify.outputs.deny }}
frontend: ${{ steps.classify.outputs.frontend }}
e2e: ${{ steps.classify.outputs.e2e }}
catalog: ${{ steps.classify.outputs.catalog }}
steps:
- id: classify
env:
@@ -40,26 +47,55 @@ jobs:
PR: ${{ github.event.pull_request.number }}
run: |
set -euo pipefail
jobs="rust server plugins deny frontend e2e catalog"
if [ "$GITHUB_EVENT_NAME" != pull_request ]; then
echo "rust=true" >> "$GITHUB_OUTPUT"
echo "frontend=true" >> "$GITHUB_OUTPUT"
for job in $jobs; do echo "$job=true" >> "$GITHUB_OUTPUT"; done
exit 0
fi
gh api --paginate "repos/$GITHUB_REPOSITORY/pulls/$PR/files" \
--jq '.[] | .filename, (.previous_filename // empty)' > files.txt
cat files.txt
# A change to CI itself runs everything.
ci='^\.github/(workflows/ci\.yml|actions/)'
docs='^(docs/|\.agents/|\.claude/|\.idea/|\.github/ISSUE_TEMPLATE/|\.github/pull_request_template\.md$|[^/]+\.md$|LICENSE$|NOTICE$)'
# Frontend-only paths. The Rust code embeds a few files under src/; those stay out.
web='^(src/|e2e/|perf/|public/|scripts/|smoke/|index\.html$|vite\.config\.ts$|tsconfig[^/]*\.json$|knip\.ts$|playwright\.config\.ts$|\.oxlintrc\.json$|\.oxfmtrc\.json$)'
web='^(src/|e2e/|perf/|public/|scripts/|smoke/|evals/|index\.html$|vite\.config\.ts$|tsconfig[^/]*\.json$|knip\.ts$|playwright\.config\.ts$|\.oxlintrc\.json$|\.oxfmtrc\.json$)'
embedded='^src/(bindings\.ts|styles/tokens\.css|features/plugins/views/frame-bridge\.js|platform/keymaps/)'
# A job runs when any changed file falls outside the paths that can't affect it.
rust=false
if grep -Ev "$docs|$web" files.txt | grep -q . || grep -Eq "$embedded" files.txt; then rust=true; fi
frontend=false
if grep -Ev "$docs" files.txt | grep -q .; then frontend=true; fi
echo "rust=$rust frontend=$frontend"
echo "rust=$rust" >> "$GITHUB_OUTPUT"
echo "frontend=$frontend" >> "$GITHUB_OUTPUT"
# Plugin web pages are their own pnpm projects, checked by the Plugins job only.
plugin_web='^plugins/official/[^/]+/web-src/'
# Paths the frontend checks never read...
backend='^(crates/|src-tauri/|sdk/|wit/|java/|fixtures/|Cargo\.(toml|lock)$|deny\.toml$|rustfmt\.toml$|rust-toolchain(\.toml)?$|\.cargo/)'
# ...except these, which frontend tests and e2e fixtures load.
read_by_web='^(fixtures/(folding|django-app)/|crates/ide-plugin/tests/fixtures/|crates/ide-db/(src|tests/fixtures)/snowflake/|src-tauri/(icons|capabilities)/|src-tauri/tauri\.conf\.json$)'
# What the browser app and its e2e tests are built from.
app='^(src/|e2e/|public/|index\.html$|vite\.config\.ts$|tsconfig\.json$|playwright\.config\.ts$|package\.json$|pnpm-(lock|workspace)\.yaml$|crates/ide-plugin/tests/fixtures/|src-tauri/(icons|capabilities)/|src-tauri/tauri\.conf\.json$)'
# The plugin workspaces: the SDK, the plugins, their interface and the host's fixture plugins.
plugin_ws='^(sdk/|plugins/|wit/|crates/ide-plugin/tests/fixtures/|rust-toolchain(\.toml)?$)'
# Never compiled into the openidea-server binary.
not_server='^(src-tauri/|sdk/|fixtures/|crates/[^/]+/(tests|benches)/)'
deps='(^|/)Cargo\.(toml|lock)$|^deny\.toml$'
# The text catalog test reads the string literals of every Rust source.
rust_source='^(crates|src-tauri/src)/.*\.rs$'
any() { grep -Eq "$1" files.txt; }
outside() { [ -n "$(grep -Ev "$1" files.txt || true)" ]; }
set_job() { echo "$1=$2" | tee -a "$GITHUB_OUTPUT"; }
if any "$ci"; then
for job in $jobs; do set_job "$job" true; done
exit 0
fi
on() { if "${@:2}"; then set_job "$1" true; else set_job "$1" false; fi; }
rust_build() { outside "$1" || any "$embedded"; }
web_checks() { outside "$docs|$plugin_web|$backend" || any "$read_by_web"; }
catalog_only() { ! web_checks && any "$rust_source"; }
on rust rust_build "$docs|$web|$plugin_web"
on server rust_build "$docs|$web|$plugin_web|$not_server"
on plugins any "$plugin_ws"
on deny any "$deps"
on frontend web_checks
on e2e any "$app"
on catalog catalog_only
rust:
name: Rust (${{ matrix.os }})
@@ -98,17 +134,36 @@ jobs:
# Test fixtures write LF files; keep Git from converting them on checkout.
- run: git config --global core.autocrlf false
- run: cargo nextest run --workspace --no-fail-fast
# nextest skips doctests; ide-command's are its compile-fail tests.
- if: runner.os == 'Linux'
run: cargo test --doc -p ide-command
# nextest ran export_bindings, which rewrites src/bindings.ts and the command snapshot.
- name: Bindings and command snapshot are up to date
if: runner.os == 'Linux'
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:
name: Remote server (linux musl)
needs: changes
if: needs.changes.outputs.rust == 'true'
if: needs.changes.outputs.server == 'true'
timeout-minutes: 40
runs-on: ubuntu-22.04
steps:
@@ -126,7 +181,7 @@ jobs:
plugins:
name: Plugins (SDK, official, fixtures)
needs: changes
if: needs.changes.outputs.rust == 'true'
if: needs.changes.outputs.plugins == 'true'
timeout-minutes: 30
runs-on: ubuntu-22.04
env:
@@ -178,7 +233,7 @@ jobs:
deny:
name: Cargo deny
needs: changes
if: needs.changes.outputs.rust == 'true'
if: needs.changes.outputs.deny == 'true'
timeout-minutes: 15
runs-on: ubuntu-latest
steps:
@@ -207,10 +262,26 @@ jobs:
- run: pnpm test
- run: pnpm build
# A backend-only change can still drop a string the text catalog uses: run that one test.
catalog:
name: Text catalog
needs: changes
if: needs.changes.outputs.catalog == 'true'
timeout-minutes: 15
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v5
- uses: pnpm/action-setup@v5
with: { version: 11 }
- uses: actions/setup-node@v5
with: { node-version: 22, cache: pnpm }
- run: pnpm install --frozen-lockfile
- run: pnpm vitest run src/platform/locales/textCatalog.test.ts
e2e:
name: E2E (${{ matrix.shard }}/2)
needs: changes
if: needs.changes.outputs.frontend == 'true'
if: needs.changes.outputs.e2e == 'true'
timeout-minutes: 30
runs-on: ubuntu-24.04
strategy:
+67 -1
Переглянути файл
@@ -15,6 +15,7 @@ on:
- "crates/**"
- "languages/**"
- "fixtures/**"
- "java/**"
- "Cargo.toml"
- "Cargo.lock"
- "src/features/run/**"
@@ -41,12 +42,77 @@ env:
CARGO_INCREMENTAL: 0
jobs:
# The languages a pull request can affect: a change to one language's fixture, definition or
# JDT LS bundle runs that language; crates the smoke doesn't exercise and other crates' tests
# run none; anything else runs them all. Pushes and manual runs always run them all.
changes:
name: Changes
runs-on: ubuntu-latest
timeout-minutes: 5
permissions:
pull-requests: read
outputs:
languages: ${{ steps.classify.outputs.languages }}
steps:
- id: classify
env:
GH_TOKEN: ${{ github.token }}
PR: ${{ github.event.pull_request.number }}
run: |
set -euo pipefail
all="typescript python rust go java kotlin php c cpp"
emit() { tr ' ' '\n' <<< "$1" | { grep . || true; } | sort -u | jq -Rsc 'split("\n") | map(select(. != ""))'; }
if [ "$GITHUB_EVENT_NAME" != pull_request ]; then
echo "languages=$(emit "$all")" | tee -a "$GITHUB_OUTPUT"
exit 0
fi
gh api --paginate "repos/$GITHUB_REPOSITORY/pulls/$PR/files" \
--jq '.[] | .filename, (.previous_filename // empty)' > files.txt
cat files.txt
# Crates outside what the smoke runs (language servers, debuggers, run configurations,
# SDKs, build tools and the project model): cargo metadata, deps of ide-lsp/dap/run/sdk/tools.
unused='^crates/(ide-agent|ide-analysis|ide-android|ide-cli|ide-clipboard|ide-coverage|ide-db|ide-docker|ide-fonts|ide-github|ide-http|ide-mcp|ide-notebook|ide-profiler|ide-scaffold|ide-search|ide-spell|ide-ssh|ide-streams|ide-vcs|ide-web)/'
# The workflow's paths, less those handled per language below.
smoke='^(crates/|Cargo\.(toml|lock)$|src/features/(run|debugger)/|src/platform/|smoke/|package\.json$|pnpm-lock\.yaml$|\.github/workflows/language-smoke\.yml$|\.github/tool-versions\.env$)'
langs=""
while read -r f; do
case "$f" in
crates/ide-host/tests/language_smoke.rs | crates/ide-host/tests/project_smoke.rs) langs="$all"; break ;;
crates/*/tests/* | crates/*/benches/*) ;;
fixtures/ts-app/*) langs+=" typescript" ;;
fixtures/python-app/*) langs+=" python" ;;
fixtures/rust-app/*) langs+=" rust" ;;
fixtures/go-app/*) langs+=" go" ;;
fixtures/java-app/*) langs+=" java" ;;
fixtures/kotlin-gradle/*) langs+=" kotlin" ;;
fixtures/php-app/*) langs+=" php" ;;
fixtures/c-app/*) langs+=" c cpp" ;;
fixtures/*) ;;
languages/typescript.toml | languages/typescriptreact.toml | languages/javascript.toml | languages/javascriptreact.toml) langs+=" typescript" ;;
languages/python.toml) langs+=" python" ;;
languages/rust.toml) langs+=" rust" ;;
languages/go.toml | languages/gomod.toml | languages/gowork.toml) langs+=" go" ;;
languages/java.toml) langs+=" java" ;;
languages/kotlin.toml) langs+=" kotlin" ;;
languages/php.toml) langs+=" php" ;;
languages/c.toml) langs+=" c" ;;
languages/cpp.toml) langs+=" cpp" ;;
languages/*) ;;
java/kotlin-bridge/*) langs+=" kotlin" ;;
java/*) langs+=" java kotlin" ;;
*) if grep -Eq "$smoke" <<< "$f" && ! grep -Eq "$unused" <<< "$f"; then langs="$all"; break; fi ;;
esac
done < files.txt
echo "languages=$(emit "$langs")" | tee -a "$GITHUB_OUTPUT"
smoke:
name: Language smoke (${{ matrix.language }})
needs: changes
if: needs.changes.outputs.languages != '[]'
strategy:
fail-fast: false
matrix:
language: [typescript, python, rust, go, java, kotlin, php, c, cpp]
language: ${{ fromJSON(needs.changes.outputs.languages) }}
# C/C++ debug with GDB, whose DAP interpreter needs 14+: 22.04 ships 12.1, 24.04 ships 15.
runs-on: ${{ (matrix.language == 'c' || matrix.language == 'cpp') && 'ubuntu-24.04' || 'ubuntu-22.04' }}
timeout-minutes: 40
-119
Переглянути файл
@@ -1,119 +0,0 @@
name: Nightly
# Twice a day, builds the newest main commit that passed CI as a prerelease tagged with its own
# version, so remote development finds the server of that version. The `nightly` release holds
# the manifest the nightly app updates from; its tag marks the commit last built, and a run with
# nothing newer stops there. Only the latest builds are kept.
on:
schedule:
- cron: "17 2,14 * * *"
workflow_dispatch:
inputs:
force:
description: "Build even if nothing is newer than the last nightly"
type: boolean
default: false
permissions:
contents: read
concurrency:
group: nightly
env:
GH_TOKEN: ${{ github.token }}
GH_REPO: ${{ github.repository }}
jobs:
prepare:
permissions:
actions: read
contents: write
if: github.repository == 'l0ng-ai/openidea'
runs-on: ubuntu-latest
outputs:
sha: ${{ steps.commit.outputs.sha }}
tag: ${{ steps.release.outputs.tag }}
release_id: ${{ steps.release.outputs.id }}
steps:
- id: commit
env:
FORCE: ${{ inputs.force }}
run: |
sha="$(gh run list --workflow ci.yml --branch main --event push --status success --limit 1 \
--json headSha --jq '.[0].headSha // ""')"
if [ -z "$sha" ]; then
echo "::notice::no main commit has passed CI"
exit 0
fi
# No `nightly` tag yet (the first run): compare fails and the build goes on.
status="$(gh api "repos/$GH_REPO/compare/nightly...$sha" --jq .status 2>/dev/null)" || status=ahead
if [ "$status" != ahead ] && [ "$FORCE" != true ]; then
echo "::notice::$sha is not newer than the last nightly"
exit 0
fi
echo "sha=$sha" >> "$GITHUB_OUTPUT"
- uses: actions/checkout@v5
if: steps.commit.outputs.sha != ''
with: { ref: "${{ steps.commit.outputs.sha }}" }
- uses: actions/setup-node@v5
if: steps.commit.outputs.sha != ''
with: { node-version: 22 }
- uses: dtolnay/rust-toolchain@stable
if: steps.commit.outputs.sha != ''
- id: release
if: steps.commit.outputs.sha != ''
env:
SHA: ${{ steps.commit.outputs.sha }}
run: |
version="$(node scripts/nightly-prepare.ts "$(date -u +%Y%m%d%H%M)")"
tag="v$version"
git config user.name "github-actions[bot]"
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
git commit -am "chore: $tag"
git tag "$tag"
git push origin "$tag"
id="$(gh api -X POST "repos/$GH_REPO/releases" -f tag_name="$tag" -f name="OpenIDEA Nightly $version" \
-F draft=true -F prerelease=true -f body="Built from $SHA." --jq .id)"
echo "tag=$tag" >> "$GITHUB_OUTPUT"
echo "id=$id" >> "$GITHUB_OUTPUT"
binaries:
permissions:
contents: write
needs: prepare
if: needs.prepare.outputs.tag != ''
uses: ./.github/workflows/release-build.yml
with:
tag: ${{ needs.prepare.outputs.tag }}
release_id: ${{ needs.prepare.outputs.release_id }}
secrets: inherit
publish:
permissions:
contents: write
needs: [prepare, binaries]
runs-on: ubuntu-latest
env:
TAG: ${{ needs.prepare.outputs.tag }}
SHA: ${{ needs.prepare.outputs.sha }}
KEEP: 14
steps:
- name: Publish the build
run: gh release edit "$TAG" --tag "$TAG" --draft=false
- name: Point the updater at it
run: |
gh release download "$TAG" -p latest.json -D "$RUNNER_TEMP"
gh release view nightly >/dev/null 2>&1 ||
gh release create nightly --prerelease --latest=false --target "$SHA" --title "OpenIDEA Nightly" \
--notes "The update manifest of the nightly builds, and the commit last built."
gh release upload nightly "$RUNNER_TEMP/latest.json" --clobber
gh api -X PATCH "repos/$GH_REPO/git/refs/tags/nightly" -f sha="$SHA" -F force=true --silent
# Failed builds' drafts go too, once they are this old.
- name: Delete old builds
run: |
gh release list --limit 200 --json tagName,createdAt --jq \
'[.[] | select(.tagName | contains("-nightly."))] | sort_by(.createdAt) | reverse | .[env.KEEP | tonumber:][].tagName' |
while read -r tag; do
gh release delete "$tag" --cleanup-tag --yes
done
+8 -9
Переглянути файл
@@ -1,7 +1,7 @@
name: Release build
# Builds a tag's desktop apps, remote servers and updater manifest into its draft release.
# Stable releases (release.yml) and nightly builds (nightly.yml) both run it.
# Builds a tag's desktop apps, remote servers and updater manifest into its draft release
# (run by release.yml).
on:
workflow_call:
inputs:
@@ -224,18 +224,17 @@ jobs:
return;
}
// Bundle suffix → updater platform keys, as tauri-action names them.
// Nightly versions don't fit MSI or RPM, so those builds offer NSIS on Windows.
const nightly = tag.includes("-nightly.");
const windows = (arch, msi, nsis) => nightly
? [[nsis, [`windows-${arch}`, `windows-${arch}-nsis`]]]
: [[msi, [`windows-${arch}`, `windows-${arch}-msi`]], [nsis, [`windows-${arch}-nsis`]]];
const windows = (arch, msi, nsis) => [
[msi, [`windows-${arch}`, `windows-${arch}-msi`]],
[nsis, [`windows-${arch}-nsis`]],
];
const kinds = [
[/_aarch64\.AppImage$/, ["linux-aarch64", "linux-aarch64-appimage"]],
[/_arm64\.deb$/, ["linux-aarch64-deb"]],
...(nightly ? [] : [[/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]]]),
[/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]],
[/_amd64\.AppImage$/, ["linux-x86_64", "linux-x86_64-appimage"]],
[/_amd64\.deb$/, ["linux-x86_64-deb"]],
...(nightly ? [] : [[/\.x86_64\.rpm$/, ["linux-x86_64-rpm"]]]),
[/\.x86_64\.rpm$/, ["linux-x86_64-rpm"]],
[/_aarch64\.app\.tar\.gz$/, ["darwin-aarch64", "darwin-aarch64-app"]],
[/_x64\.app\.tar\.gz$/, ["darwin-x86_64", "darwin-x86_64-app"]],
...windows("aarch64", /_arm64_en-US\.msi$/, /_arm64-setup\.exe$/),
+2 -3
Переглянути файл
@@ -1,7 +1,7 @@
name: Release
on:
push:
tags: ["v*", "!v*-nightly.*"]
tags: ["v*"]
workflow_dispatch:
inputs:
tag:
@@ -23,7 +23,6 @@ env:
jobs:
# Creates (or reuses) one draft release that every platform build uploads into.
create-release:
if: ${{ !contains(github.event.inputs.tag || github.ref_name, '-nightly.') }}
permissions:
contents: write
runs-on: ubuntu-latest
@@ -62,7 +61,7 @@ jobs:
core.setOutput("id", existing.id);
return;
}
// Nightly builds are prereleases: the notes span stable release to stable release.
// Prereleases are skipped: the notes span stable release to stable release.
const previous = releases.find((r) => !r.draft && !r.prerelease);
const { data: notes } = await github.rest.repos.generateReleaseNotes({
owner, repo, tag_name: tag, previous_tag_name: previous?.tag_name,
+1
Переглянути файл
@@ -9,6 +9,7 @@
"dist",
"target",
"src/bindings.ts",
"docs/snippets/plugin-catalog.jsx",
"evals/*/golden",
"src/editor/core/cm/angular/parser*.ts",
"src/editor/core/cm/jsp/parser*.ts",
+5 -1
Переглянути файл
@@ -9,7 +9,8 @@ Visual style: dark, low-contrast greys, one cool accent
- `crates/ide-*` — backend crates; one domain each. Depend on `ide-core` for shared
types; never reach into another crate's internals.
- `src-tauri/` — glue only: `state.rs` (AppState / Project), `commands/<domain>.rs`
(thin typed IPC adapters), `events.rs`. No domain logic here.
(desktop-only commands; the adapters of `ide-host` commands are derived), `events.rs`.
No domain logic here.
- `src/bindings.ts` — generated by tauri-specta (`pnpm gen:bindings`). Never edit.
- `src/platform/` — ipc (`call`, `onIdeEvent`, `nextRequestId`), actions registry,
keymap + dispatcher, context keys / `when` clauses, project store.
@@ -33,6 +34,9 @@ Visual style: dark, low-contrast greys, one cool accent
- IPC coordinates: 0-based lines, **UTF-16** columns/offsets everywhere (`ide-core::text`).
- Every command returns `IdeResult<T>`; convert internal errors at the crate edge.
- Declare a command once, on its implementation: `#[command(trust = …)]` in `ide-host::ops`
plus its module's `domain!` list (Tauri adapter, server handler and bindings are derived);
desktop-only commands use `#[desktop_command(trust = …)]` and `desktop_domain!`.
- Streaming → `tauri::ipc::Channel<T>`; cancellable → UI-allocated `RequestId` +
`cancel_request`. Backend → UI notifications → `IdeEvent` via `EventSink`.
- Long work never blocks the UI thread or a Tauri command thread: use
Створено
+136 -104
Переглянути файл
@@ -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.47"
version = "0.1.49"
dependencies = [
"blake3",
"dunce",
@@ -4169,7 +4169,7 @@ dependencies = [
[[package]]
name = "ide-analysis"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"ast-grep-core",
"ide-core",
@@ -4183,7 +4183,7 @@ dependencies = [
[[package]]
name = "ide-android"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"ide-core",
"serde",
@@ -4194,7 +4194,7 @@ dependencies = [
[[package]]
name = "ide-build"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"blake3",
"chardetng",
@@ -4212,7 +4212,7 @@ dependencies = [
[[package]]
name = "ide-cli"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"dirs 6.0.0",
"serde",
@@ -4226,7 +4226,7 @@ dependencies = [
[[package]]
name = "ide-clipboard"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"gtk",
"objc2 0.6.5",
@@ -4235,9 +4235,20 @@ dependencies = [
"png 0.18.1",
]
[[package]]
name = "ide-command"
version = "0.1.49"
dependencies = [
"heck 0.5.0",
"proc-macro2",
"quote",
"serde",
"syn 2.0.119",
]
[[package]]
name = "ide-core"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"dunce",
"encoding_rs",
@@ -4254,7 +4265,7 @@ dependencies = [
[[package]]
name = "ide-coverage"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-run",
@@ -4268,7 +4279,7 @@ dependencies = [
[[package]]
name = "ide-dap"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"base64 0.22.1",
"futures",
@@ -4297,7 +4308,7 @@ dependencies = [
[[package]]
name = "ide-db"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"base64 0.22.1",
"bb8",
@@ -4308,6 +4319,7 @@ dependencies = [
"futures",
"ide-core",
"ide-http",
"ide-sdk",
"ide-ssh",
"notify",
"open",
@@ -4329,11 +4341,12 @@ dependencies = [
"tracing",
"uuid",
"zeroize",
"zip",
]
[[package]]
name = "ide-docker"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"ide-core",
"serde",
@@ -4346,7 +4359,7 @@ dependencies = [
[[package]]
name = "ide-extension"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4365,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.47"
version = "0.1.49"
dependencies = [
"objc2-core-foundation",
"objc2-core-text",
@@ -4379,7 +4403,7 @@ dependencies = [
[[package]]
name = "ide-github"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-vcs",
@@ -4392,7 +4416,7 @@ dependencies = [
[[package]]
name = "ide-heap"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"criterion",
"ide-core",
@@ -4410,7 +4434,7 @@ dependencies = [
[[package]]
name = "ide-host"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4424,12 +4448,14 @@ dependencies = [
"ide-agent",
"ide-analysis",
"ide-build",
"ide-command",
"ide-core",
"ide-coverage",
"ide-dap",
"ide-db",
"ide-docker",
"ide-extension",
"ide-flutter",
"ide-heap",
"ide-http",
"ide-index",
@@ -4483,7 +4509,7 @@ dependencies = [
[[package]]
name = "ide-http"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-vfs",
@@ -4502,7 +4528,7 @@ dependencies = [
[[package]]
name = "ide-index"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"blake3",
"criterion",
@@ -4524,7 +4550,7 @@ dependencies = [
[[package]]
name = "ide-jdwp"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"ide-jvm-inspect",
"proptest",
@@ -4536,7 +4562,7 @@ dependencies = [
[[package]]
name = "ide-jsonrpc"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"encoding_rs",
"futures",
@@ -4553,7 +4579,7 @@ dependencies = [
[[package]]
name = "ide-jvm-attach"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"libc",
"tempfile",
@@ -4562,7 +4588,7 @@ dependencies = [
[[package]]
name = "ide-jvm-inspect"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"futures",
"serde",
@@ -4573,10 +4599,11 @@ dependencies = [
[[package]]
name = "ide-language"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"blake3",
"criterion",
"dunce",
"ide-core",
"ide-extension",
"ide-text",
@@ -4631,8 +4658,9 @@ dependencies = [
[[package]]
name = "ide-lsp"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"criterion",
"dunce",
"encoding_rs",
"futures",
@@ -4659,7 +4687,7 @@ dependencies = [
[[package]]
name = "ide-mcp"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"bytes",
"dunce",
@@ -4678,7 +4706,7 @@ dependencies = [
[[package]]
name = "ide-notebook"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"futures",
"ide-core",
@@ -4701,7 +4729,7 @@ dependencies = [
[[package]]
name = "ide-plugin"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"blake3",
"dunce",
@@ -4724,7 +4752,7 @@ dependencies = [
[[package]]
name = "ide-profiler"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-jvm-attach",
@@ -4738,7 +4766,7 @@ dependencies = [
[[package]]
name = "ide-remote"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"dunce",
"futures",
@@ -4758,7 +4786,7 @@ dependencies = [
[[package]]
name = "ide-run"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"dunce",
"encoding_rs",
@@ -4782,7 +4810,7 @@ dependencies = [
[[package]]
name = "ide-scaffold"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-tools",
@@ -4798,7 +4826,7 @@ dependencies = [
[[package]]
name = "ide-sdk"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"dunce",
"flate2",
@@ -4821,7 +4849,7 @@ dependencies = [
[[package]]
name = "ide-search"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"criterion",
"encoding_rs",
@@ -4842,7 +4870,7 @@ dependencies = [
[[package]]
name = "ide-spell"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"ide-core",
"parking_lot",
@@ -4855,7 +4883,7 @@ dependencies = [
[[package]]
name = "ide-ssh"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"dirs 6.0.0",
"flate2",
@@ -4880,7 +4908,7 @@ dependencies = [
[[package]]
name = "ide-streams"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-language",
@@ -4893,7 +4921,7 @@ dependencies = [
[[package]]
name = "ide-syntax"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"ide-core",
"ide-language",
@@ -4908,7 +4936,7 @@ dependencies = [
[[package]]
name = "ide-terminal"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"ide-core",
"libc",
@@ -4916,12 +4944,13 @@ dependencies = [
"portable-pty",
"serde",
"specta",
"tokio",
"tracing",
]
[[package]]
name = "ide-text"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"criterion",
"ide-core",
@@ -4934,7 +4963,7 @@ dependencies = [
[[package]]
name = "ide-tools"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"flate2",
"hex",
@@ -4955,7 +4984,7 @@ dependencies = [
[[package]]
name = "ide-vcs"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"blake3",
"dunce",
@@ -4976,7 +5005,7 @@ dependencies = [
[[package]]
name = "ide-vfs"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"chardetng",
"dunce",
@@ -5002,7 +5031,7 @@ dependencies = [
[[package]]
name = "ide-web"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"dirs 6.0.0",
"ide-core",
@@ -5018,7 +5047,7 @@ dependencies = [
[[package]]
name = "ide-workspace"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"blake3",
"dunce",
@@ -6647,7 +6676,7 @@ dependencies = [
[[package]]
name = "openidea"
version = "0.1.47"
version = "0.1.49"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -6661,6 +6690,7 @@ dependencies = [
"ide-build",
"ide-cli",
"ide-clipboard",
"ide-command",
"ide-core",
"ide-coverage",
"ide-dap",
@@ -6720,6 +6750,8 @@ dependencies = [
"tracing",
"tracing-appender",
"tracing-subscriber",
"webkit2gtk",
"webview2-com",
"windows",
"windows-sys 0.61.2",
]
@@ -7373,9 +7405,9 @@ dependencies = [
[[package]]
name = "pulley-interpreter"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d74df9e20cba0f6dd07f01c3140535a6b23e40aecccfcacfb921621b41d0acb"
checksum = "335e459f9c7809af04768799880504d014d07e8e2fc6ae682fe2a105d8ced33f"
dependencies = [
"cranelift-bitset",
"log",
@@ -7385,9 +7417,9 @@ dependencies = [
[[package]]
name = "pulley-macros"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8415513bfa407c06de6f11dbe9437f2352e075a5520ff491a131166d3d90aed1"
checksum = "dd492ac929a6ca0357362d9fa0a09e31290feac5914550ccfb539b21f89c4b9e"
dependencies = [
"proc-macro2",
"quote",
@@ -9729,7 +9761,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
dependencies = [
"fastrand",
"getrandom 0.4.3",
"getrandom 0.3.4",
"once_cell",
"rustix",
"windows-sys 0.61.2",
@@ -11066,9 +11098,9 @@ dependencies = [
[[package]]
name = "wasmtime"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d45bf3b13781b9febb0eef42e1e145146c92ef891f345fd918e0e0fa1568c992"
checksum = "f32390bdc8d7cdb6259a1b855178bfed88226b4004b209fd48fb30e0deb01cd3"
dependencies = [
"addr2line",
"async-trait",
@@ -11108,9 +11140,9 @@ dependencies = [
[[package]]
name = "wasmtime-environ"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "833f00f3dc6128159284c5b71e211f24c97d45e052230a14f767fd830a6fb8b0"
checksum = "9c10f8ef1c9ee5e0f125c775fe56a4d07b8525db30a96e6358c61d93bd11dee4"
dependencies = [
"anyhow",
"cpp_demangle",
@@ -11139,9 +11171,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-component-macro"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0d69c34412409072d2e8ec399101524c330e334ff313f77415e6984cc9c6a172"
checksum = "620c53182ebd26c9fff5b90dd53cf8ec3103c381403fd32f8d395da31a9e4a46"
dependencies = [
"anyhow",
"proc-macro2",
@@ -11154,15 +11186,15 @@ dependencies = [
[[package]]
name = "wasmtime-internal-component-util"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b168d39f2d6b896d89fe096afa4ccdd7a8e927b01469b590af84f02fca3126a1"
checksum = "011e31ca343d9ba0ec623153cd94131b6f03973ef1a0ab791161f642e4a16a93"
[[package]]
name = "wasmtime-internal-core"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ad86a65d12c6a9202584ceb658c9a20cf5b25c32eed61c9be5e5f863f88f0d9"
checksum = "ab15e50a060b746493e6e95ef3ce4e6e7ebfdd7cc336a7dff0f0277e01b447ef"
dependencies = [
"hashbrown 0.17.1",
"libm",
@@ -11171,9 +11203,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-cranelift"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a71f0fd1dd40e4e18d4a20cdba29ff8e0eb2c0f21b12c2eb5869e0fea789dd05"
checksum = "dc3d27440a83fba26dd2784a997e13d9acb3606a75fb127c324929b52221c5c5"
dependencies = [
"cranelift-codegen",
"cranelift-control",
@@ -11197,9 +11229,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-fiber"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa4dfa39e58735b24ce3d28bfc8c2b3041603cc8a941bb268395351beff90172"
checksum = "6e54b28d0d453ca8932e4504065ae66a78f01fcb22b1a2ee287128d732fa9d6f"
dependencies = [
"cc",
"libc",
@@ -11211,9 +11243,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-jit-debug"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2eb98d4486c7b0163447d77dea06f3cc87e5e5ba5fc93613f8ec42e27ea181d"
checksum = "9293e75a3048b900f7b7c524702abca16d8a2332f970324eefc519f454cd5d69"
dependencies = [
"cc",
"wasmtime-internal-versioned-export-macros",
@@ -11221,9 +11253,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-jit-icache-coherence"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "852cae234735d79db6c58fe0d04b32f4078ad01fdb3fd6d488ac366132ba9785"
checksum = "b852e568831b913d410541bb37edc45a5002e472208fbdbaf844ed801dd4255f"
dependencies = [
"libc",
"wasmtime-internal-core",
@@ -11232,9 +11264,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-unwinder"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b9289378c82b9db7e7cf933d6bb441ad968536ac48f3f38c55b7cf9d3e8d87e1"
checksum = "a1f7349c9834a542275ad757340079e6453fccb429efce581454d23f85af92c0"
dependencies = [
"cranelift-codegen",
"log",
@@ -11244,9 +11276,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-versioned-export-macros"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc5c60c732d99dbcc5d670b71ba6ccf2b015cd16fc828990eaad2c4b8805ebdb"
checksum = "30b3e0768a450d9dea3e16b83f2498f0b08db0e32bad695e35564eef017be3f1"
dependencies = [
"proc-macro2",
"quote",
@@ -11255,9 +11287,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-wit-bindgen"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c77e4fcc7cd22772578458c5e233df47190ebc9b8b65788797d99a02787c9000"
checksum = "b9d085c540b95d0ffebf98c266e6f152e1acf96a9f676f224a74307b9d422c15"
dependencies = [
"anyhow",
"bitflags 2.13.2",
@@ -11269,9 +11301,9 @@ dependencies = [
[[package]]
name = "wasmtime-wasi"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "705b90d1fa1084cc73df656868948da77711b97f6b895d145a4949f86bcea674"
checksum = "17f8ce6b9e77539b5f52d440346f876a84c513ec1b07162845282f8652f7f7f9"
dependencies = [
"async-trait",
"bitflags 2.13.2",
@@ -11293,9 +11325,9 @@ dependencies = [
[[package]]
name = "wasmtime-wasi-io"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f3d2b6a255be488639f450b380e7e0923789f946de3463696cd30f2fe8a65cc3"
checksum = "da9f90eb7ce6edbead27dba3a58843398875defa73b8dce4bbc29d0ce3dc9b40"
dependencies = [
"async-trait",
"bytes",
+8 -1
Переглянути файл
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
exclude = ["sdk", "plugins"]
[workspace.package]
version = "0.1.47"
version = "0.1.49"
edition = "2024"
rust-version = "1.96"
license = "Apache-2.0"
@@ -42,6 +42,7 @@ ide-fonts = { path = "crates/ide-fonts" }
ide-ssh = { path = "crates/ide-ssh" }
ide-remote = { path = "crates/ide-remote" }
ide-host = { path = "crates/ide-host" }
ide-command = { path = "crates/ide-command" }
ide-mcp = { path = "crates/ide-mcp" }
ide-scaffold = { path = "crates/ide-scaffold" }
ide-notebook = { path = "crates/ide-notebook" }
@@ -124,6 +125,12 @@ uuid = { version = "1", features = ["v4"] }
keyring = "4.2"
keyring-core = "1"
# proc macros
heck = "0.5"
proc-macro2 = "1"
quote = "1"
syn = { version = "2", features = ["full"] }
# testing
insta = { version = "1", features = ["yaml"] }
proptest = "1"
+68
Переглянути файл
@@ -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,
@@ -194,6 +232,36 @@ declarations, key and animation binding names (`(keydown.enter)`, `[@fade]`,
`(@fade.done)`), runs of text that entities split (`a && b`) parsed as one, and one
token for `{` and `}`.
## Julia CodeMirror language support
[`@plutojl/lang-julia`](https://github.com/JuliaPluto/lang-julia) 1.2.0 and its
[`@plutojl/lezer-julia`](https://github.com/JuliaPluto/lezer-julia) parser dependency
provide the Julia CodeMirror 6 language mode. Both packages are MIT licensed;
the full license text is below. The mode wraps a Lezer grammar and exposes its
syntax tags through `julia()`.
### MIT License (@plutojl/lang-julia and @plutojl/lezer-julia)
Copyright (c) 2021 Andrey Popp
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
## nvim-treesitter queries
`crates/ide-syntax/queries/<grammar>/locals.scm` are derived from the `locals.scm`
+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"]);
+80
Переглянути файл
@@ -0,0 +1,80 @@
//! Codex's asynchronous questions are answered by a user message, not a permission response.
use crate::AgentQuestion;
use ide_core::{IdeError, IdeResult};
use serde_json::json;
use std::collections::BTreeMap;
/// The wire reply and its readable record. Question ids, not wording, associate each answer.
pub(crate) fn reply(questions: &[AgentQuestion], answers: &str) -> IdeResult<(String, String)> {
let answers: BTreeMap<String, Vec<String>> =
serde_json::from_str(answers).map_err(|_| IdeError::invalid("invalid question answers"))?;
if questions.is_empty() || answers.len() != questions.len() {
return Err(IdeError::invalid("answer every question"));
}
let mut replies = Vec::new();
let mut record = Vec::new();
for question in questions {
let key = question.answer_key.as_deref().ok_or_else(|| IdeError::invalid("missing question id"))?;
let values = answers.get(key).ok_or_else(|| IdeError::invalid("missing question answer"))?;
if values.is_empty()
|| (!question.multi_select && values.len() != 1)
|| values.iter().any(|v| v.trim().is_empty())
{
return Err(IdeError::invalid("empty or invalid question answer"));
}
let answer = values.iter().map(|v| v.trim()).collect::<Vec<_>>().join(", ");
let mut title = question.question.clone();
let mut end = title.len().min(512);
while !title.is_char_boundary(end) {
end -= 1;
}
title.truncate(end);
title = title.replace(['\n', '\r'], " ");
replies.push(json!({ "questionItemId": key, "question": title, "answer": answer }));
record.push(format!("{}: {}", question.question, answer));
}
Ok((
format!("<send_user_message_question_reply>\n{}\n</send_user_message_question_reply>", json!(replies)),
record.join("\n"),
))
}
#[cfg(test)]
mod tests {
use super::*;
fn question(key: &str) -> AgentQuestion {
AgentQuestion {
answer_key: Some(key.into()),
header: String::new(),
question: "Which?".into(),
multi_select: false,
options: Vec::new(),
}
}
#[test]
fn identical_wording_keeps_answers_associated_with_ids() {
let (wire, record) =
reply(&[question("first"), question("second")], r#"{"first":[" One "],"second":["Two"]}"#).unwrap();
let body = wire
.strip_prefix("<send_user_message_question_reply>\n")
.unwrap()
.strip_suffix("\n</send_user_message_question_reply>")
.unwrap();
let replies: serde_json::Value = serde_json::from_str(body).unwrap();
assert_eq!(replies[0], json!({"questionItemId":"first","question":"Which?","answer":"One"}));
assert_eq!(replies[1]["answer"], "Two");
assert_eq!(record, "Which?: One\nWhich?: Two");
}
#[test]
fn malformed_missing_and_empty_answers_are_rejected() {
for answers in
["no", "{}", r#"{"other":["One"]}"#, r#"{"first":[]}"#, r#"{"first":[" "]}"#, r#"{"first":["One","Two"]}"#]
{
assert!(reply(&[question("first")], answers).is_err(), "{answers}");
}
}
}
+57
Переглянути файл
@@ -213,6 +213,31 @@ impl AgentCatalogs {
.unwrap_or_else(|| Self::fallback(shared, provider))
}
/// Availability for an explicit session switch must come from a recent discovery for this
/// launch, not from the display fallback or a different project's session report.
pub(super) fn fresh_model(
&self,
shared: &Shared,
spec: &provider::ProviderSpec,
model: &str,
) -> Option<crate::AgentConfigValue> {
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
let select = |catalog: &CatalogData| {
let age = self.epoch_ms() - catalog.refreshed_at_ms?;
if !(0.0..FRESH_FOR.as_millis() as f64).contains(&age) {
return None;
}
catalog.model_option()?.values.iter().find(|value| value.value == model).cloned()
};
let state = self.state.lock();
if let Some(entry) = state.entries.get(&Self::key(shared, &spec.id)) {
return select(entry.catalog.as_ref().filter(|_| entry.context == context)?);
}
let cache = shared.known.lock();
let saved = cache.get(&spec.id)?.catalogs.get(&shared.root_key())?;
(saved.fingerprint == context.fingerprint()).then(|| select(&saved.catalog)).flatten()
}
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
let state = self.state.lock();
if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref())
@@ -231,6 +256,38 @@ impl AgentCatalogs {
.cloned()
}
pub(super) async fn load_levels(
self: &Arc<Self>,
shared: &Arc<Shared>,
provider: &str,
model: &str,
) -> Result<Vec<AgentConfigOption>, String> {
if let Some(levels) = self.levels(shared, provider, model) {
return Ok(levels);
}
let unavailable = || "The agent did not report settings for the selected model".to_owned();
let spec = shared.spec(provider).ok_or_else(unavailable)?;
let (_, flight) = self.request(shared, spec, false, Some(model));
if let Some(mut ready) = flight {
while !*ready.borrow_and_update() {
if ready.changed().await.is_err() {
break;
}
}
}
self.levels(shared, provider, model).ok_or_else(|| {
let state = self.state.lock();
state
.entries
.get(&Self::key(shared, provider))
.and_then(|entry| {
entry.model_failures.get(model).map(|failure| &failure.error).or(entry.error.as_ref())
})
.cloned()
.unwrap_or_else(unavailable)
})
}
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
let key = Self::key(shared, provider);
let mut state = self.state.lock();
+395 -2
Переглянути файл
@@ -11,6 +11,7 @@ const PROVIDER: &str = "catalog-test";
#[derive(Debug)]
struct Pending {
launch: usize,
method: String,
params: Value,
reply: oneshot::Sender<Result<Value, String>>,
@@ -44,7 +45,7 @@ impl Harness {
let launches = launches.clone();
let live = live.clone();
move |_, _, client, _| {
launches.fetch_add(1, Ordering::SeqCst);
let launch = launches.fetch_add(1, Ordering::SeqCst);
live.fetch_add(1, Ordering::SeqCst);
let guard = Live(live.clone());
let pending = pending_tx.clone();
@@ -75,10 +76,17 @@ impl Harness {
}
let response = match request["method"].as_str().unwrap() {
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }),
"session/new" | "session/set_config_option" | "session/set_model" => {
"session/new"
| "session/set_config_option"
| "session/set_model"
| "session/load"
| "session/resume"
| "session/prompt"
| "session/set_mode" => {
let (reply, mut result) = oneshot::channel();
pending
.send(Pending {
launch,
method: request["method"].as_str().unwrap().to_owned(),
params: request["params"].clone(),
reply,
@@ -290,6 +298,391 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
assert_eq!(efforts(&fresh, "second"), ["off", "auto"]);
}
#[tokio::test]
async fn discovered_model_is_confirmed_by_the_live_session() {
switch_chat_model(ChatSwitch::Live).await;
}
#[tokio::test]
async fn discovered_model_reloads_the_same_session_on_the_next_message() {
switch_chat_model(ChatSwitch::Resume).await;
}
#[tokio::test]
async fn discovered_model_leaves_the_original_session_intact_after_resume_failure() {
switch_chat_model(ChatSwitch::ResumeFails).await;
}
#[tokio::test]
async fn discovered_model_is_reverted_when_the_reloaded_session_does_not_offer_it() {
switch_chat_model(ChatSwitch::Unavailable).await;
}
#[tokio::test]
async fn discovered_model_can_be_selected_while_the_session_is_not_running() {
switch_chat_model(ChatSwitch::Idle).await;
}
#[tokio::test]
async fn discovered_model_effort_is_discovered_persisted_and_applied_before_the_first_reply() {
switch_chat_model(ChatSwitch::Uncached).await;
}
#[tokio::test]
async fn discovered_model_with_no_effort_can_be_selected() {
switch_chat_model(ChatSwitch::NoEffort).await;
}
#[tokio::test]
async fn discovered_model_settings_failure_leaves_the_chat_unchanged() {
switch_chat_model(ChatSwitch::DiscoveryFails).await;
}
#[tokio::test]
async fn discovered_model_withdrawn_effort_prevents_sending() {
switch_chat_model(ChatSwitch::EffortUnavailable).await;
}
#[tokio::test]
async fn discovered_model_rejected_effort_prevents_sending() {
switch_chat_model(ChatSwitch::EffortRejected).await;
}
#[tokio::test]
async fn discovered_model_lookup_does_not_overwrite_a_newer_selection() {
switch_chat_model(ChatSwitch::Superseded).await;
}
#[derive(Clone, Copy)]
enum ChatSwitch {
Live,
Resume,
ResumeFails,
Unavailable,
Idle,
Uncached,
NoEffort,
DiscoveryFails,
EffortUnavailable,
EffortRejected,
Superseded,
}
async fn switch_chat_model(scenario: ChatSwitch) {
use crate::{AgentPrompt, AgentStatus, Isolation, NewAgentTask};
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::with_initialize(json!({
"protocolVersion": 1, "agentCapabilities": { "loadSession": true }
}));
let mut manager = make_manager(tmp.path(), Arc::default(), &harness);
let task = manager
.create(NewAgentTask {
prompt: AgentPrompt { text: "first".into(), ..Default::default() },
provider: PROVIDER.into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
let next = harness.next().await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/new"));
let mut initial = response(&["old"], &["low", "high"]);
initial["sessionId"] = json!("saved-chat");
initial["modes"] = json!({
"currentModeId": "code", "availableModes": [{"id": "ask", "name": "Ask"}, {"id": "code", "name": "Code"}]
});
next.reply.send(Ok(initial.clone())).unwrap();
let next = harness.next().await;
assert_eq!(
(next.launch, next.method.as_str(), &next.params["sessionId"]),
(0, "session/prompt", &json!("saved-chat"))
);
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
{
let mode = manager.set_config(&task.id, "mode", "ask".into());
tokio::pin!(mode);
let set = next_chat_request(&mut harness, mode.as_mut()).await;
assert_eq!((set.launch, set.method.as_str()), (0, "session/set_mode"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
set.reply.send(Ok(json!({}))).unwrap();
mode.await.unwrap();
}
let before_entries = serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap();
let before_config = manager.task(&task.id).unwrap().state.lock().task.config.clone();
let offline = matches!(scenario, ChatSwitch::Idle | ChatSwitch::Uncached | ChatSwitch::Superseded);
let missing_settings = matches!(
scenario,
ChatSwitch::Uncached | ChatSwitch::NoEffort | ChatSwitch::DiscoveryFails | ChatSwitch::Superseded
);
let no_effort = matches!(scenario, ChatSwitch::NoEffort);
let effort_error = match scenario {
ChatSwitch::EffortUnavailable => Some("no longer offers effort value thorough"),
ChatSwitch::EffortRejected => Some("effort rejected by the agent"),
_ => None,
};
let choose_effort = matches!(scenario, ChatSwitch::Uncached) || effort_error.is_some();
let (catalog_models, catalog_effort): (&[&str], &[&str]) =
if missing_settings { (&["old", "new"], &["low", "high"]) } else { (&["new", "old"], &["quick", "thorough"]) };
if offline {
manager.shutdown();
manager = make_manager(tmp.path(), Arc::default(), &harness);
}
let mut events = events(&manager);
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
let next = harness.next().await;
assert_eq!((next.launch, next.method.as_str()), (1, "session/new"));
next.reply.send(Ok(response(catalog_models, catalog_effort))).unwrap();
let catalog = completed(&mut events).await;
assert_eq!(model_values(&catalog), catalog_models);
if missing_settings {
assert!(!catalog.thought_levels.contains_key("new"));
}
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
let live = matches!(scenario, ChatSwitch::Live);
let resumed_launch = if missing_settings { 3 } else { 2 };
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
{
let switching = manager.set_config(&task.id, "model", "new".into());
tokio::pin!(switching);
if !offline {
let next = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
if live {
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
} else {
next.reply.send(Err("not in this process's model list".into())).unwrap();
}
}
if missing_settings {
let discovery = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((discovery.launch, discovery.method.as_str()), (2, "session/new"));
discovery.reply.send(Ok(response(catalog_models, catalog_effort))).unwrap();
let set = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!(set.params, json!({"sessionId": "discovery-only", "configId": "model", "value": "new"}));
assert_eq!(set.method, "session/set_config_option");
assert!(
manager
.prompt(&task.id, AgentPrompt { text: "too early".into(), ..Default::default() }, false)
.await
.is_err()
);
if matches!(scenario, ChatSwitch::DiscoveryFails) {
set.reply.send(Err("Sign in required".into())).unwrap();
let error = switching.await.unwrap_err().to_string();
assert!(error.contains("Sign in required"), "{error}");
assert_eq!(manager.subscribe(Arc::new(|_| {})).remove(0).config, before_config);
assert!(harness.pending.try_recv().is_err());
manager.shutdown();
return;
}
if matches!(scenario, ChatSwitch::Superseded) {
manager.set_config(&task.id, "model", "old".into()).await.unwrap();
set.reply.send(Ok(response(&["new", "old"], &["quick", "thorough"]))).unwrap();
switching.await.unwrap();
let task = manager.subscribe(Arc::new(|_| {})).remove(0);
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
assert_eq!(task.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("low"));
assert!(harness.pending.try_recv().is_err());
manager.shutdown();
return;
}
let levels: &[&str] = if no_effort { &[] } else { &["quick", "thorough"] };
set.reply.send(Ok(response(&["new", "old"], levels))).unwrap();
}
tokio::select! {
result = &mut switching => result.unwrap(),
request = harness.next() => panic!("selection must not reopen the chat or send: {request:?}"),
}
}
assert_eq!(serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap(), before_entries);
if matches!(scenario, ChatSwitch::Uncached) {
let update = tokio::time::timeout(Duration::from_secs(5), async {
loop {
if let AgentEvent::Task { task: update } = events.recv().await.unwrap()
&& update.id == task.id
{
break update;
}
}
})
.await
.unwrap();
let effort = update.config.iter().find(|o| o.id == "effort").unwrap();
assert_eq!(effort.values.iter().map(|v| v.value.as_str()).collect::<Vec<_>>(), ["quick", "thorough"]);
}
let snapshot = |manager: &AgentManager| manager.subscribe(Arc::new(|_| {})).remove(0);
let current = snapshot(&manager);
assert_eq!(current.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("new"));
assert_eq!(current.model.as_deref(), Some(if live { "new" } else { "old" }));
let effort =
|task: &crate::AgentTask| task.config.iter().find(|o| o.id == "effort").and_then(|o| o.current.clone());
assert_eq!(
effort(&current).as_deref(),
if live {
Some("session-only")
} else if no_effort {
None
} else {
Some("quick")
},
"the new model's effort must be available before sending"
);
if choose_effort {
assert!(manager.set_config(&task.id, "effort", "high".into()).await.is_err());
manager.set_config(&task.id, "effort", "thorough".into()).await.unwrap();
assert_eq!(effort(&snapshot(&manager)).as_deref(), Some("thorough"));
if matches!(scenario, ChatSwitch::Uncached) {
manager.shutdown();
manager = make_manager(tmp.path(), Arc::default(), &harness);
let restored = snapshot(&manager);
assert_eq!(restored.id, task.id);
assert_eq!(effort(&restored).as_deref(), Some("thorough"));
}
}
manager.prompt(&task.id, AgentPrompt { text: "next".into(), ..Default::default() }, false).await.unwrap();
if !live {
let load = harness.next().await;
assert_eq!((load.launch, load.method.as_str()), (resumed_launch, "session/load"));
assert_eq!(load.params["sessionId"], "saved-chat");
load.notifications
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
"sessionId": "saved-chat",
"update": {"sessionUpdate": "agent_message_chunk", "content": {"type": "text", "text": "replay"}}
}}))
.unwrap();
if load_fails {
load.notifications
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
"sessionId": "saved-chat",
"update": {"sessionUpdate": "config_option_update",
"configOptions": response(&["other", "old"], &["low"])["configOptions"]}
}}))
.unwrap();
load.reply.send(Err("cannot resume saved-chat".into())).unwrap();
} else {
let models: &[&str] = if unavailable { &["old"] } else { &["old", "new"] };
let mut resumed = response(models, &["low", "high"]);
resumed["modes"] = initial["modes"].clone();
load.reply.send(Ok(resumed)).unwrap();
}
if load_fails || unavailable {
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
let task = snapshot(&manager);
assert_eq!(task.model.as_deref(), Some("old"));
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
assert_eq!(effort(&task).as_deref(), Some("low"));
let expected = if load_fails { "cannot resume saved-chat" } else { "does not offer model new" };
assert!(task.error.as_deref().unwrap().contains(expected), "{:?}", task.error);
assert!(harness.pending.try_recv().is_err(), "must not send on the previous model or create a session");
if load_fails {
manager
.prompt(&task.id, AgentPrompt { text: "retry".into(), ..Default::default() }, false)
.await
.unwrap();
let retry = harness.next().await;
assert_eq!((retry.launch, retry.method.as_str()), (3, "session/load"));
assert_eq!(retry.params["sessionId"], "saved-chat");
retry.reply.send(Ok(initial.clone())).unwrap();
let set = harness.next().await;
assert_eq!(set.method, "session/set_mode");
set.reply.send(Ok(json!({}))).unwrap();
let prompt = harness.next().await;
assert_eq!(prompt.method, "session/prompt");
assert_eq!(prompt.params["sessionId"], "saved-chat");
prompt.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
}
manager.shutdown();
return;
}
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_config_option"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
let levels: &[&str] = match scenario {
ChatSwitch::NoEffort => &[],
ChatSwitch::EffortUnavailable => &["session-only", "quick"],
_ if choose_effort => &["session-only", "thorough"],
_ => &["session-only"],
};
set.reply.send(Ok(response(&["new", "old"], levels))).unwrap();
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_mode"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
set.reply.send(Ok(json!({}))).unwrap();
if choose_effort && !matches!(scenario, ChatSwitch::EffortUnavailable) {
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_config_option"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "effort", "value": "thorough"}));
let reply = if effort_error.is_some() {
Err("effort rejected by the agent".into())
} else {
Ok(response(&["new", "old"], &["thorough", "session-only"]))
};
set.reply.send(reply).unwrap();
}
if let Some(expected) = effort_error {
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
let current = snapshot(&manager);
assert_eq!(current.model.as_deref(), Some("old"));
assert_eq!(effort(&current).as_deref(), Some("low"));
assert!(current.error.as_deref().unwrap().contains(expected), "{:?}", current.error);
assert!(harness.pending.try_recv().is_err(), "must not send using a fallback effort");
manager.shutdown();
return;
}
}
let next = harness.next().await;
assert_eq!(
(next.launch, next.method.as_str(), &next.params["sessionId"]),
(if live { 0 } else { resumed_launch }, "session/prompt", &json!("saved-chat"))
);
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
let current = snapshot(&manager);
assert_eq!(current.model.as_deref(), Some("new"));
assert_eq!(
effort(&current).as_deref(),
if choose_effort {
Some("thorough")
} else if no_effort {
None
} else {
Some("session-only")
}
);
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
manager.shutdown();
}
async fn wait_for_chat(manager: &AgentManager, id: &str, status: crate::AgentStatus) {
let task = manager.task(id).unwrap();
tokio::time::timeout(Duration::from_secs(5), async {
while task.state.lock().task.status != status || task.state.lock().busy {
tokio::task::yield_now().await;
}
})
.await
.unwrap();
}
async fn next_chat_request(
harness: &mut Harness,
switching: std::pin::Pin<&mut impl Future<Output = crate::IdeResult<()>>>,
) -> Pending {
tokio::select! {
result = switching => panic!("model switching ended before contacting the session: {result:?}"),
request = harness.next() => request,
}
}
#[tokio::test]
async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
let tmp = tempfile::tempdir().unwrap();
+39 -1
Переглянути файл
@@ -3,7 +3,7 @@
use crate::model::{
AgentCommand, AgentCommandSource, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit,
AgentModelPricing, AgentUsage,
AgentModelPricing, AgentTokens, AgentUsage,
};
use serde_json::{Value, json};
@@ -219,6 +219,23 @@ pub(crate) fn set_request(option: &AgentConfigOption, value: &str) -> (&'static
}
}
/// Legacy setters and agents that report the change in a notification may return no model.
pub(super) fn accepts_model(reply: &Value, id: &str, value: &str) -> bool {
reply
.get("configOptions")
.and_then(Value::as_array)
.and_then(|options| {
options.iter().find(|option| {
option.get("category").and_then(Value::as_str) == Some("model")
|| option.get("id").or_else(|| option.get("configId")).and_then(Value::as_str) == Some(id)
})
})
.and_then(|option| option.get("currentValue"))
.or_else(|| reply.pointer("/models/currentModelId"))
.and_then(Value::as_str)
.is_none_or(|current| current == value)
}
/// `available_commands_update`.
pub(crate) fn commands_of(update: &Value, provider: &str) -> Vec<AgentCommand> {
update
@@ -255,6 +272,18 @@ pub(crate) fn usage_of(update: &Value) -> Option<AgentUsage> {
Some(AgentUsage { used: tokens("used")?, size: tokens("size").filter(|s| *s > 0)?, cost })
}
/// The `usage` of a `session/prompt` result: `{ inputTokens, cachedReadTokens, outputTokens }`.
pub(crate) fn tokens_of(result: &Value) -> Option<AgentTokens> {
let usage = result.get("usage")?;
let tokens = |key: &str| usage.get(key).and_then(Value::as_u64).map_or(0, |n| u32::try_from(n).unwrap_or(u32::MAX));
let tokens = AgentTokens {
input: tokens("inputTokens"),
cached: tokens("cachedReadTokens"),
output: tokens("outputTokens"),
};
(tokens != AgentTokens::default()).then_some(tokens)
}
/// The usage-limit windows a [`crate::LIMITS_UPDATE`] carries; malformed entries are skipped.
pub(crate) fn limits_of(update: &Value) -> Vec<AgentLimit> {
let limits = update.get("limits").and_then(Value::as_array).into_iter().flatten();
@@ -351,6 +380,15 @@ mod tests {
c.iter().map(|o| (o.id.as_str(), o.current.as_deref())).collect()
}
#[test]
fn a_hermes_prompt_result_reports_the_turns_tokens() {
let result = json!({"stopReason": "end_turn", "usage": {"cachedReadTokens": 51306, "inputTokens": 77284,
"outputTokens": 509, "thoughtTokens": 0, "totalTokens": 77793}});
assert_eq!(tokens_of(&result), Some(AgentTokens { input: 77284, cached: 51306, output: 509 }));
assert_eq!(tokens_of(&json!({"stopReason": "end_turn"})), None);
assert_eq!(tokens_of(&json!({"usage": {}})), None);
}
#[test]
fn config_options_win_over_the_older_fields() {
let r = json!({
+111
Переглянути файл
@@ -0,0 +1,111 @@
//! Hermes Agent profiles on disk: `default` is the Hermes home itself, the others are
//! `<home>/profiles/<name>` directories holding one of Hermes' identity files.
use std::path::{Path, PathBuf};
use serde::Serialize;
use specta::Type;
const PROFILE_FILES: &[&str] = &["config.yaml", ".env", "SOUL.md", "profile.yaml", "auth.json", "state.db"];
/// Hermes' home directory (`~/.hermes`; `%LOCALAPPDATA%\hermes` on Windows).
pub fn root(home: Option<&Path>) -> Option<PathBuf> {
#[cfg(windows)]
if let Some(local) = std::env::var_os("LOCALAPPDATA") {
return Some(PathBuf::from(local).join("hermes"));
}
home.map(|h| h.join(".hermes"))
}
/// The profile names under `root`: `default` first, then the others by name; none without `root`.
pub fn profiles(root: &Path) -> Vec<String> {
if !root.is_dir() {
return Vec::new();
}
let mut named: Vec<String> = std::fs::read_dir(root.join("profiles"))
.into_iter()
.flatten()
.flatten()
.filter(|e| PROFILE_FILES.iter().any(|f| e.path().join(f).exists()))
.filter_map(|e| e.file_name().to_str().map(str::to_owned))
.filter(|name| name != "default")
.collect();
named.sort();
std::iter::once("default".to_owned()).chain(named).collect()
}
/// A profile and the name Hermes shows for it (`hermes profile list`).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Type)]
pub struct HermesProfile {
/// What `hermes -p` takes; `default` is the Hermes home itself.
pub name: String,
/// `display_name` from the profile's `profile.yaml`, else the name.
pub label: String,
}
/// [`profiles`] with the names Hermes shows for them.
pub fn labeled_profiles(root: &Path) -> Vec<HermesProfile> {
profiles(root)
.into_iter()
.map(|name| {
let home = if name == "default" { root.to_path_buf() } else { root.join("profiles").join(&name) };
let label = display_name(&home).unwrap_or_else(|| name.clone());
HermesProfile { name, label }
})
.collect()
}
/// The top-level `display_name:` of `<home>/profile.yaml`, the only key read (no YAML parser).
fn display_name(home: &Path) -> Option<String> {
let text = std::fs::read_to_string(home.join("profile.yaml")).ok()?;
let value = text.lines().find_map(|l| l.strip_prefix("display_name:"))?;
let value = value.trim().trim_matches(['"', '\'']).trim();
(!value.is_empty()).then(|| value.to_owned())
}
/// The home of the profile an agent id stands for: `hermes` and `hermes-default` are the
/// default profile, `hermes-<slug>` the profile whose name slugifies to `<slug>`.
pub fn profile_home(root: &Path, provider: &str) -> Option<PathBuf> {
let slug = match provider {
"hermes" | "hermes-default" => return Some(root.to_path_buf()),
_ => provider.strip_prefix("hermes-")?,
};
profiles(root).into_iter().find(|p| crate::provider::slugify_id(p) == slug).map(|p| root.join("profiles").join(p))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn lists_default_and_profiles_with_an_identity_file() {
let dir = tempfile::tempdir().unwrap();
assert!(profiles(&dir.path().join("missing")).is_empty());
let root = dir.path().join(".hermes");
std::fs::create_dir_all(root.join("profiles/empty")).unwrap();
assert_eq!(profiles(&root), ["default"]);
for (name, file) in [("work", "config.yaml"), ("Dom 2", "SOUL.md"), ("db", "state.db")] {
std::fs::create_dir_all(root.join("profiles").join(name)).unwrap();
std::fs::write(root.join("profiles").join(name).join(file), "").unwrap();
}
std::fs::write(root.join("profiles/stray.yaml"), "").unwrap();
assert_eq!(profiles(&root), ["default", "Dom 2", "db", "work"]);
assert_eq!(profile_home(&root, "hermes"), Some(root.clone()));
assert_eq!(profile_home(&root, "hermes-dom-2"), Some(root.join("profiles/Dom 2")));
assert_eq!(profile_home(&root, "hermes-empty"), None);
assert_eq!(profile_home(&root, "claude"), None);
}
#[test]
fn labels_profiles_with_their_display_name() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().join(".hermes");
std::fs::create_dir_all(root.join("profiles/work")).unwrap();
std::fs::write(root.join("profile.yaml"), "description: mine\ndisplay_name: \"qb\"\n").unwrap();
std::fs::write(root.join("profiles/work/profile.yaml"), "ui_meta:\n display_name: nested\n").unwrap();
let label = |name: &str, label: &str| HermesProfile { name: name.into(), label: label.into() };
assert_eq!(labeled_profiles(&root), [label("default", "qb"), label("work", "work")]);
std::fs::remove_file(root.join("profile.yaml")).unwrap();
assert_eq!(labeled_profiles(&root)[0], label("default", "default"));
}
}
File diff suppressed because it is too large. Load diff
+503 -69
Переглянути файл
@@ -10,7 +10,7 @@ use crate::{
};
use ide_core::IpcPath;
use serde_json::{Value, json};
use std::collections::{BTreeMap, HashSet};
use std::collections::{BTreeMap, BTreeSet, HashSet};
use std::path::{Path, PathBuf};
use std::time::{Duration, Instant};
@@ -89,24 +89,61 @@ fn matches_agent(agents: &[String], provider: &str) -> bool {
/// The configured servers off for this session: off by default and not switched on for it, or
/// switched off for it. Named so an agent that also loads its own configuration can keep a
/// same-named server of it off too. Workspace entries take precedence, as in [`acp_mcp_servers`].
pub(crate) fn servers_off(all: &[McpServer], overrides: &BTreeMap<String, bool>) -> Vec<String> {
let mut seen = HashSet::new();
let ordered =
all.iter().filter(|s| s.scope == McpScope::Workspace).chain(all.iter().filter(|s| s.scope == McpScope::User));
let configured: Vec<String> = ordered
.filter(|s| seen.insert(s.name.as_str()))
.filter(|s| !overrides.get(&s.name).copied().unwrap_or(s.enabled))
.map(|s| s.name.clone())
.collect();
// A server switched off that the IDE doesn't configure may still be the agent's own.
let switched = overrides
pub(crate) fn servers_off(all: &[McpServer], provider: &str, overrides: &BTreeMap<String, bool>) -> Vec<String> {
let mut seen_configured = HashSet::new();
let mut enabled_names = HashSet::new();
let mut off = BTreeSet::new();
let ordered = all
.iter()
.filter(|(name, on)| !**on && name.as_str() != BUILTIN_MCP_NAME && !seen.contains(name.as_str()))
.map(|(name, _)| name.clone());
let mut off: Vec<String> = configured.into_iter().chain(switched).collect();
off.sort();
off.dedup();
off
.filter(|s| s.scope == McpScope::Workspace && !s.unapproved)
.chain(all.iter().filter(|s| s.scope == McpScope::User));
for srv in ordered {
if !seen_configured.insert(srv.name.as_str()) {
continue;
}
let explicit = overrides.get(&srv.name).copied();
let matches = explicit == Some(true) || matches_agent(&srv.agents, provider);
let active = explicit.unwrap_or(srv.enabled) && matches;
if active {
enabled_names.insert(srv.name.as_str());
} else {
off.insert(srv.name.clone());
}
}
for srv in all.iter().filter(|s| s.scope == McpScope::Workspace && s.unapproved) {
if !enabled_names.contains(srv.name.as_str()) {
off.insert(srv.name.clone());
}
}
// A server switched off that the IDE doesn't configure may still be the agent's own.
for (name, &on) in overrides {
if !on && name.as_str() != BUILTIN_MCP_NAME && !enabled_names.contains(name.as_str()) {
off.insert(name.clone());
}
}
off.into_iter().collect()
}
/// Names of MCP servers present in Codex's own TOML configuration files (`~/.codex/config.toml`
/// and `<workspace_root>/.codex/config.toml`).
pub(crate) fn codex_external_server_names(home_dir: Option<&Path>, workspace_root: &Path) -> BTreeSet<String> {
let mut names = BTreeSet::new();
let mut paths = Vec::new();
if let Some(home) = home_dir {
paths.push(home.join(".codex").join("config.toml"));
}
paths.push(workspace_root.join(".codex").join("config.toml"));
for path in paths {
if let Ok(text) = std::fs::read_to_string(&path) {
names.extend(parse_codex_toml_servers(&text).into_keys());
}
}
names
}
/// Builds the ACP `mcpServers` array for `session/new`, `session/load`, and `session/fork`.
@@ -362,163 +399,429 @@ pub fn apply_save_json(
Ok(saved_names)
}
#[derive(Clone, Copy, PartialEq, Eq)]
const COPILOT_PLUGIN_MANIFESTS: &[&str] = &[
".github/plugin/plugin.json",
".plugin/plugin.json",
".claude-plugin/plugin.json",
".cursor-plugin/plugin.json",
"plugin.json",
];
#[derive(Clone, PartialEq, Eq)]
enum SourceFormat {
Jsonc,
CodexToml,
CopilotPlugin { root: PathBuf },
}
#[derive(Clone)]
struct SourceSpec {
id: &'static str,
label: &'static str,
id: String,
label: String,
path: PathBuf,
format: SourceFormat,
suggested_scope: McpScope,
native_provider: Option<&'static str>,
claude_project_lookup: bool,
disabled_servers: std::sync::Arc<BTreeSet<String>>,
}
#[derive(Default)]
struct CopilotSettings {
disabled_mcp_servers: std::sync::Arc<BTreeSet<String>>,
disabled_plugins: BTreeSet<String>,
}
fn external_source_specs(home_dir: Option<&Path>, workspace_root: Option<&Path>) -> Vec<SourceSpec> {
let mut specs = Vec::new();
let no_disabled: std::sync::Arc<BTreeSet<String>> = std::sync::Arc::new(BTreeSet::new());
if let Some(root) = workspace_root {
specs.push(SourceSpec {
id: "workspace-mcp",
label: "Project (.mcp.json)",
id: "workspace-mcp".into(),
label: "Project (.mcp.json)".into(),
path: root.join(".mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: Some("claude"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "vscode-mcp",
label: "VS Code (.vscode/mcp.json)",
id: "vscode-mcp".into(),
label: "VS Code (.vscode/mcp.json)".into(),
path: root.join(".vscode").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: None,
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "cursor-project",
label: "Cursor Project (.cursor/mcp.json)",
id: "cursor-project".into(),
label: "Cursor Project (.cursor/mcp.json)".into(),
path: root.join(".cursor").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: Some("cursor"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "codex-project",
label: "Codex Project (.codex/config.toml)",
id: "codex-project".into(),
label: "Codex Project (.codex/config.toml)".into(),
path: root.join(".codex").join("config.toml"),
format: SourceFormat::CodexToml,
suggested_scope: McpScope::Workspace,
native_provider: Some("codex"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "gemini-project",
label: "Gemini Project (.gemini/settings.json)",
id: "gemini-project".into(),
label: "Gemini Project (.gemini/settings.json)".into(),
path: root.join(".gemini").join("settings.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: Some("gemini"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
}
if let Some(home) = home_dir {
let copilot_dir = home.join(".copilot");
let copilot_settings = read_copilot_settings(&copilot_dir);
specs.push(SourceSpec {
id: "copilot-cli",
label: "GitHub Copilot CLI",
path: home.join(".copilot").join("mcp-config.json"),
id: "copilot-cli".into(),
label: "GitHub Copilot CLI".into(),
path: copilot_dir.join("mcp-config.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("copilot"),
claude_project_lookup: false,
disabled_servers: copilot_settings.disabled_mcp_servers.clone(),
});
specs.extend(copilot_plugin_source_specs(&copilot_dir, &copilot_settings));
specs.push(SourceSpec {
id: "claude-code",
label: "Claude Code",
id: "claude-code".into(),
label: "Claude Code".into(),
path: home.join(".claude.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("claude"),
claude_project_lookup: true,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "codex",
label: "Codex",
id: "codex".into(),
label: "Codex".into(),
path: home.join(".codex").join("config.toml"),
format: SourceFormat::CodexToml,
suggested_scope: McpScope::User,
native_provider: Some("codex"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "cursor",
label: "Cursor",
id: "cursor".into(),
label: "Cursor".into(),
path: home.join(".cursor").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("cursor"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "gemini",
label: "Gemini CLI",
id: "gemini".into(),
label: "Gemini CLI".into(),
path: home.join(".gemini").join("settings.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("gemini"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "jetbrains-air",
label: "JetBrains Air",
id: "jetbrains-air".into(),
label: "JetBrains Air".into(),
path: home.join(".jetbrains").join("mcp").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: None,
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "copilot-intellij",
label: "GitHub Copilot (JetBrains)",
id: "copilot-intellij".into(),
label: "GitHub Copilot (JetBrains)".into(),
path: home.join(".config").join("github-copilot").join("intellij").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: None,
claude_project_lookup: false,
disabled_servers: no_disabled,
});
}
specs
}
fn read_source_servers(spec: &SourceSpec, workspace_root: Option<&Path>) -> BTreeMap<String, AgentMcpServer> {
let Ok(text) = std::fs::read_to_string(&spec.path) else {
return BTreeMap::new();
fn read_copilot_settings(copilot_dir: &Path) -> CopilotSettings {
let Ok(text) = std::fs::read_to_string(copilot_dir.join("settings.json")) else {
return CopilotSettings::default();
};
if spec.format == SourceFormat::CodexToml {
return parse_codex_toml_servers(&text);
}
let Ok(root) = parse_jsonc_value(&text) else {
return BTreeMap::new();
return CopilotSettings::default();
};
let mut servers = extract_servers_from_root(&root, None);
if spec.claude_project_lookup
&& let Some(ws) = workspace_root
&& let Some(projects) = root.get("projects").and_then(Value::as_object)
{
let ws_canon = dunce::canonicalize(ws).unwrap_or_else(|_| ws.to_path_buf());
for (proj_key, proj_val) in projects {
let matches = Path::new(proj_key) == ws || dunce::canonicalize(proj_key).is_ok_and(|c| c == ws_canon);
if matches {
for (name, srv) in extract_servers_from_root(proj_val, None) {
servers.insert(name, srv);
let disabled_mcp_servers = root
.get("disabledMcpServers")
.and_then(Value::as_array)
.map(|arr| {
arr.iter()
.filter_map(|v| v.as_str().map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned))
.collect::<BTreeSet<_>>()
})
.unwrap_or_default();
let disabled_plugins = root
.get("enabledPlugins")
.and_then(Value::as_object)
.map(|obj| {
obj.iter()
.filter(|(_, v)| v.as_bool() == Some(false))
.map(|(k, _)| k.trim().to_owned())
.filter(|k| !k.is_empty())
.collect::<BTreeSet<_>>()
})
.unwrap_or_default();
CopilotSettings { disabled_mcp_servers: std::sync::Arc::new(disabled_mcp_servers), disabled_plugins }
}
fn copilot_plugin_source_specs(copilot_dir: &Path, settings: &CopilotSettings) -> Vec<SourceSpec> {
let Ok(text) = std::fs::read_to_string(copilot_dir.join("config.json")) else {
return Vec::new();
};
let Ok(root) = parse_jsonc_value(&text) else {
return Vec::new();
};
let Some(installed) = root.get("installedPlugins").and_then(Value::as_array) else {
return Vec::new();
};
let mut seen_ids = HashSet::new();
let mut specs = Vec::new();
for entry in installed {
let Some(obj) = entry.as_object() else { continue };
if obj.get("enabled").and_then(Value::as_bool) == Some(false) {
continue;
}
let Some(name) = obj.get("name").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty()) else {
continue;
};
let marketplace = obj.get("marketplace").and_then(Value::as_str).map(str::trim).unwrap_or_default();
if settings.disabled_plugins.contains(name)
|| (!marketplace.is_empty()
&& (settings.disabled_plugins.contains(&format!("{name}@{marketplace}"))
|| settings.disabled_plugins.contains(&format!("{marketplace}/{name}"))))
{
continue;
}
let Some(raw_cache) = obj.get("cache_path").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty())
else {
continue;
};
let plugin_root =
if Path::new(raw_cache).is_relative() { copilot_dir.join(raw_cache) } else { PathBuf::from(raw_cache) };
if !plugin_root.is_dir() {
continue;
}
let Some((manifest_path, _)) = read_copilot_plugin_servers(&plugin_root) else {
continue;
};
let base_id = if marketplace.is_empty() {
format!("copilot-plugin:{name}")
} else {
format!("copilot-plugin:{marketplace}/{name}")
};
let mut id = base_id.clone();
let mut suffix = 2usize;
while !seen_ids.insert(id.clone()) {
id = format!("{base_id}#{suffix}");
suffix += 1;
}
let label = if marketplace.is_empty() {
format!("GitHub Copilot Plugin ({name})")
} else {
format!("GitHub Copilot Plugin ({name} · {marketplace})")
};
specs.push(SourceSpec {
id,
label,
path: manifest_path,
format: SourceFormat::CopilotPlugin { root: plugin_root },
suggested_scope: McpScope::User,
native_provider: Some("copilot"),
claude_project_lookup: false,
disabled_servers: settings.disabled_mcp_servers.clone(),
});
}
specs
}
fn resolve_within_dir(base_dir: &Path, candidate: &Path) -> Option<PathBuf> {
if candidate.as_os_str().is_empty() {
return None;
}
let base_canon = dunce::canonicalize(base_dir).ok()?;
let clean = candidate.strip_prefix(".").unwrap_or(candidate);
let joined = if clean.is_relative() { base_dir.join(clean) } else { clean.to_path_buf() };
let meta = std::fs::metadata(&joined).ok()?;
if !meta.is_file() {
return None;
}
let target_canon = dunce::canonicalize(&joined).ok()?;
target_canon.starts_with(&base_canon).then_some(joined)
}
fn expand_plugin_root_vars(value: &str, root: &str) -> String {
value.replace("${COPILOT_PLUGIN_ROOT}", root).replace("${CLAUDE_PLUGIN_ROOT}", root).replace("${PLUGIN_ROOT}", root)
}
fn expand_plugin_servers(servers: &mut BTreeMap<String, AgentMcpServer>, plugin_root: &Path) {
let root = plugin_root.to_string_lossy();
for srv in servers.values_mut() {
if let Some(cmd) = srv.command.as_mut() {
*cmd = expand_plugin_root_vars(cmd, &root);
}
for arg in &mut srv.args {
*arg = expand_plugin_root_vars(arg, &root);
}
if let Some(url) = srv.url.as_mut() {
*url = expand_plugin_root_vars(url, &root);
}
for val in srv.env.values_mut() {
*val = expand_plugin_root_vars(val, &root);
}
for val in srv.headers.values_mut() {
*val = expand_plugin_root_vars(val, &root);
}
}
}
fn extract_plugin_manifest_servers(
plugin_root: &Path,
manifest_path: &Path,
mcp_val: &Value,
) -> (PathBuf, BTreeMap<String, AgentMcpServer>) {
match mcp_val {
Value::String(rel) => {
if let Some(path) = resolve_within_dir(plugin_root, Path::new(rel.trim())) {
let map = read_external_file(&path);
return (path, map);
}
(manifest_path.to_path_buf(), BTreeMap::new())
}
Value::Object(_) => {
let wrapper = json!({ "mcpServers": mcp_val });
(manifest_path.to_path_buf(), extract_servers_from_root(&wrapper, None))
}
Value::Array(items) => {
let mut merged = BTreeMap::new();
let mut first_path: Option<PathBuf> = None;
for item in items {
match item {
Value::String(rel) => {
if let Some(path) = resolve_within_dir(plugin_root, Path::new(rel.trim())) {
let map = read_external_file(&path);
if !map.is_empty() && first_path.is_none() {
first_path = Some(path);
}
merged.extend(map);
}
}
Value::Object(_) => {
let map = extract_servers_from_root(item, None);
if !map.is_empty() && first_path.is_none() {
first_path = Some(manifest_path.to_path_buf());
}
merged.extend(map);
}
_ => {}
}
}
(first_path.unwrap_or_else(|| manifest_path.to_path_buf()), merged)
}
_ => (manifest_path.to_path_buf(), BTreeMap::new()),
}
}
fn read_copilot_plugin_servers(plugin_root: &Path) -> Option<(PathBuf, BTreeMap<String, AgentMcpServer>)> {
if let Some(dot_mcp) = resolve_within_dir(plugin_root, Path::new(".mcp.json")) {
let mut servers = read_external_file(&dot_mcp);
if !servers.is_empty() {
expand_plugin_servers(&mut servers, plugin_root);
return Some((dot_mcp, servers));
}
}
for rel in COPILOT_PLUGIN_MANIFESTS {
let Some(manifest_path) = resolve_within_dir(plugin_root, Path::new(rel)) else {
continue;
};
let Ok(text) = std::fs::read_to_string(&manifest_path) else {
continue;
};
let Ok(manifest) = parse_jsonc_value(&text) else {
continue;
};
let Some(mcp_val) = manifest.get("mcpServers") else {
continue;
};
let (source_path, mut servers) = extract_plugin_manifest_servers(plugin_root, &manifest_path, mcp_val);
if !servers.is_empty() {
expand_plugin_servers(&mut servers, plugin_root);
return Some((source_path, servers));
}
}
None
}
fn read_source_servers(spec: &SourceSpec, workspace_root: Option<&Path>) -> BTreeMap<String, AgentMcpServer> {
let mut servers = match &spec.format {
SourceFormat::CopilotPlugin { root } => {
read_copilot_plugin_servers(root).map(|(_, map)| map).unwrap_or_default()
}
SourceFormat::CodexToml => {
let Ok(text) = std::fs::read_to_string(&spec.path) else {
return BTreeMap::new();
};
parse_codex_toml_servers(&text)
}
SourceFormat::Jsonc => {
let Ok(text) = std::fs::read_to_string(&spec.path) else {
return BTreeMap::new();
};
let Ok(root) = parse_jsonc_value(&text) else {
return BTreeMap::new();
};
let mut map = extract_servers_from_root(&root, None);
if spec.claude_project_lookup
&& let Some(ws) = workspace_root
&& let Some(projects) = root.get("projects").and_then(Value::as_object)
{
let ws_canon = dunce::canonicalize(ws).unwrap_or_else(|_| ws.to_path_buf());
for (proj_key, proj_val) in projects {
let matches =
Path::new(proj_key) == ws || dunce::canonicalize(proj_key).is_ok_and(|c| c == ws_canon);
if matches {
for (name, srv) in extract_servers_from_root(proj_val, None) {
map.insert(name, srv);
}
}
}
}
map
}
};
for name in spec.disabled_servers.iter() {
if let Some(srv) = servers.get_mut(name) {
srv.enabled = false;
}
}
servers
@@ -575,8 +878,8 @@ pub fn discover_external_sources(home_dir: Option<&Path>, workspace_root: Option
})
.collect();
out.push(McpExternalSource {
id: spec.id.to_owned(),
label: spec.label.to_owned(),
id: spec.id,
label: spec.label,
path: IpcPath(spec.path),
suggested_scope: spec.suggested_scope,
native_provider: spec.native_provider.map(str::to_owned),
@@ -604,7 +907,7 @@ pub fn apply_import_selected(
let mut by_source: BTreeMap<&str, BTreeMap<String, AgentMcpServer>> = BTreeMap::new();
for spec in &specs {
if selections.iter().any(|s| s.source_id == spec.id) {
by_source.insert(spec.id, read_source_servers(spec, workspace_root));
by_source.insert(spec.id.as_str(), read_source_servers(spec, workspace_root));
}
}
let target = match scope {
@@ -1058,6 +1361,11 @@ mod tests {
#[test]
fn servers_off_follow_the_effective_state() {
let mut claude_only = configured("claude-only", McpScope::User, true);
claude_only.agents = vec!["claude".into()];
let mut unapproved_ws = configured("unapproved-ws", McpScope::Workspace, false);
unapproved_ws.unapproved = true;
let all = [
configured("default-off", McpScope::User, false),
configured("switched-on", McpScope::User, false),
@@ -1066,6 +1374,8 @@ mod tests {
// The workspace entry decides for its name.
configured("both", McpScope::User, true),
configured("both", McpScope::Workspace, false),
claude_only,
unapproved_ws,
];
let overrides = BTreeMap::from([
("switched-on".to_owned(), true),
@@ -1073,8 +1383,11 @@ mod tests {
("agent-own".to_owned(), false),
(BUILTIN_MCP_NAME.to_owned(), false),
]);
assert_eq!(servers_off(&all, &overrides), ["agent-own", "both", "default-off", "switched-off"]);
assert_eq!(servers_off(&all[2..4], &BTreeMap::new()), Vec::<String>::new());
assert_eq!(
servers_off(&all, "copilot", &overrides),
["agent-own", "both", "claude-only", "default-off", "switched-off", "unapproved-ws"]
);
assert_eq!(servers_off(&all[2..4], "copilot", &BTreeMap::new()), Vec::<String>::new());
}
#[test]
@@ -1323,4 +1636,125 @@ mod tests {
assert_eq!(workspace["events-sse"].transport, McpTransport::Sse);
assert_eq!(workspace["events-sse"].url.as_deref(), Some("https://sse.example.com/events"));
}
#[test]
fn discovers_and_imports_copilot_installed_plugin_mcp_servers() {
let tmp = tempfile::tempdir().unwrap();
let home = tmp.path().join("home");
let copilot = home.join(".copilot");
let azure_root = copilot.join("installed-plugins/_direct/azure-skills");
let inline_root = copilot.join("installed-plugins/awesome-copilot/inline-tools");
let disabled_root = copilot.join("installed-plugins/_direct/disabled-plug");
let outside_root = tmp.path().join("outside");
std::fs::create_dir_all(azure_root.join(".plugin")).unwrap();
std::fs::create_dir_all(inline_root.join(".claude-plugin")).unwrap();
std::fs::create_dir_all(&disabled_root).unwrap();
std::fs::create_dir_all(&outside_root).unwrap();
std::fs::write(
azure_root.join(".plugin/plugin.json"),
r#"{"name":"azure","version":"1.2.106","mcpServers":"./.mcp.json"}"#,
)
.unwrap();
std::fs::write(
azure_root.join(".mcp.json"),
r#"{"mcpServers":{"azure":{"command":"npx","args":["-y","@azure/mcp@latest","${COPILOT_PLUGIN_ROOT}/cfg"],"env":{"PLUG_DIR":"${CLAUDE_PLUGIN_ROOT}"}}}}"#,
)
.unwrap();
std::fs::write(
inline_root.join(".claude-plugin/plugin.json"),
r#"{"name":"inline-tools","version":"0.1.0","mcpServers":{"inline-srv":{"command":"${PLUGIN_ROOT}/bin/run","args":["--stdio"]},"muted-srv":{"command":"echo","args":["off"]}}}"#,
)
.unwrap();
std::fs::write(
disabled_root.join(".mcp.json"),
r#"{"mcpServers":{"never":{"command":"npx","args":["never"]}}}"#,
)
.unwrap();
std::fs::write(outside_root.join("secret.json"), r#"{"mcpServers":{"escaped":{"command":"sh"}}}"#).unwrap();
let escape_root = copilot.join("installed-plugins/_direct/escape-plug");
std::fs::create_dir_all(escape_root.join(".plugin")).unwrap();
std::fs::write(
escape_root.join(".plugin/plugin.json"),
r#"{"name":"escape-plug","mcpServers":"../../../../outside/secret.json"}"#,
)
.unwrap();
// `~/.copilot/config.json` includes leading `//` comments in Copilot CLI.
let config_json = format!(
"// Managed automatically.\n{}",
serde_json::json!({
"installedPlugins": [
{
"name": "azure",
"marketplace": "",
"enabled": true,
"cache_path": azure_root,
},
{
"name": "inline-tools",
"marketplace": "awesome-copilot",
"enabled": true,
"cache_path": inline_root,
},
{
"name": "disabled-plug",
"marketplace": "",
"enabled": false,
"cache_path": disabled_root,
},
{
"name": "escape-plug",
"marketplace": "",
"enabled": true,
"cache_path": escape_root,
}
]
})
);
std::fs::write(copilot.join("config.json"), config_json).unwrap();
std::fs::write(copilot.join("settings.json"), r#"{"disabledMcpServers":["muted-srv"]}"#).unwrap();
let sources = discover_external_sources(Some(&home), None);
assert_eq!(sources.len(), 2);
let azure_src = sources.iter().find(|s| s.id == "copilot-plugin:azure").unwrap();
assert_eq!(azure_src.label, "GitHub Copilot Plugin (azure)");
assert_eq!(azure_src.native_provider.as_deref(), Some("copilot"));
assert_eq!(azure_src.path.0, azure_root.join(".mcp.json"));
assert_eq!(azure_src.servers.len(), 1);
assert!(azure_src.servers[0].enabled);
assert_eq!(
azure_src.servers[0].args,
vec!["-y", "@azure/mcp@latest", &format!("{}/cfg", azure_root.display())]
);
let inline_src = sources.iter().find(|s| s.id == "copilot-plugin:awesome-copilot/inline-tools").unwrap();
assert_eq!(inline_src.label, "GitHub Copilot Plugin (inline-tools · awesome-copilot)");
assert_eq!(inline_src.path.0, inline_root.join(".claude-plugin/plugin.json"));
let active = inline_src.servers.iter().find(|s| s.name == "inline-srv").unwrap();
assert!(active.enabled);
assert_eq!(active.command.as_deref(), Some(format!("{}/bin/run", inline_root.display()).as_str()));
let muted = inline_src.servers.iter().find(|s| s.name == "muted-srv").unwrap();
assert!(!muted.enabled);
let mut user = BTreeMap::new();
let mut workspace = BTreeMap::new();
let imported = apply_import_selected(
&mut user,
&mut workspace,
Some(&home),
None,
McpScope::User,
&[McpImportSelection { source_id: "copilot-plugin:azure".into(), name: "azure".into() }],
false,
)
.unwrap();
assert_eq!(imported, vec!["azure".to_string()]);
assert_eq!(user["azure"].env.get("PLUG_DIR").map(String::as_str), Some(azure_root.to_str().unwrap()));
}
}
+61
Переглянути файл
@@ -108,6 +108,29 @@ pub struct AgentTask {
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`), including `"openidea"`.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub mcp_overrides: BTreeMap<String, bool>,
/// Token counts of the last turn and context compressions, when the agent reports them.
// Boxed so that `AgentEvent::Task` stays within clippy's `large_enum_variant` bound on Windows.
#[serde(default)]
pub stats: Box<AgentSessionStats>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentSessionStats {
/// The last turn's tokens (`session/prompt` result `usage`).
#[serde(default)]
pub tokens: Option<AgentTokens>,
/// How many times the agent compressed the conversation (Hermes `compressionDepth`).
#[serde(default)]
pub compressions: u32,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentTokens {
pub input: u32,
pub cached: u32,
pub output: u32,
}
/// A task the agent runs in the background while the conversation goes on.
@@ -281,6 +304,22 @@ pub struct AgentImage {
pub name: Option<String>,
}
impl AgentImage {
/// The type the bytes are in. Agents reject an image whose declared type doesn't match its
/// bytes, and a pasted image's declared type can be wrong (a browser's JPEG or WebP copied as
/// `image/png`). Falls back to `mime_type` for formats not recognised here.
pub fn media_type(&self) -> &str {
let head = crate::acp::normalize_base64(&self.data[..self.data.len().min(16)]);
match head.as_slice() {
[0x89, b'P', b'N', b'G', ..] => "image/png",
[0xFF, 0xD8, 0xFF, ..] => "image/jpeg",
[b'G', b'I', b'F', b'8', ..] => "image/gif",
[b'R', b'I', b'F', b'F', _, _, _, _, b'W', b'E', b'B', b'P', ..] => "image/webp",
_ => &self.mime_type,
}
}
}
/// A message to the agent: text, plus files to look at and images.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -453,8 +492,19 @@ pub enum AgentEntry {
Agent {
text: String,
},
/// A question that can be answered while the agent keeps working, or after the turn ends.
Question {
id: String,
title: String,
questions: Vec<AgentQuestion>,
/// The submitted answers, or `Skipped`; `None` while unanswered.
chosen: Option<String>,
},
Thought {
text: String,
/// When the reasoning started (ms since the epoch); `None` in tasks saved before.
#[serde(default)]
started_ms: Option<f64>,
},
Tool {
id: String,
@@ -466,6 +516,11 @@ pub enum AgentEntry {
/// Text the tool reported (command output…), truncated.
output: Option<String>,
diffs: Vec<AgentToolDiff>,
/// When the call started and ended (ms since the epoch); `None` in tasks saved before.
#[serde(default)]
started_ms: Option<f64>,
#[serde(default)]
ended_ms: Option<f64>,
},
Plan {
items: Vec<AgentPlanItem>,
@@ -609,6 +664,10 @@ pub struct NewAgentTask {
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
#[serde(default)]
pub mcp_overrides: BTreeMap<String, bool>,
/// Creates the task without sending `prompt` (it only names the task): the composer's
/// `!` command runs in it first.
#[serde(default)]
pub idle: bool,
}
/// A file the task changed: against [`AgentTask::base_commit`], or against `HEAD` in the
@@ -648,6 +707,8 @@ pub enum AgentChangesView {
SinceStart,
/// The uncommitted files against `HEAD`; commits made since the start stay.
Group,
/// What the last turn changed, against the checkout as that turn started.
LastTurn,
}
/// A task's uncommitted files and the commits made since it started.
+5
Переглянути файл
@@ -1028,6 +1028,11 @@ impl CodexShim {
}
Some(t.chunk(kind, &id, &text))
});
if ty == "agentMessage"
&& let Some(update) = translate::question_update(item)
{
self.emit(thread, update);
}
}
"subAgentActivity" => {
let child = item.get("agentThreadId").and_then(Value::as_str).unwrap_or_default();
+61
Переглянути файл
@@ -473,6 +473,56 @@ fn history_replays_turns() {
assert_eq!(updates[4]["status"], "completed");
}
#[test]
fn history_preserves_async_questions_with_stable_answer_ids() {
let updates = history(
&json!({"turns": [{"items": [{
"type": "agentMessage", "id": "call-1", "text": "Which?",
"questions": [{"title": "Which?", "options": ["One", "Two"]}, {"title": "Why?"}]
}]}]}),
None,
);
let asked = updates.iter().find(|u| u["sessionUpdate"] == "user_question").expect("question update");
assert_eq!(asked["id"], "call-1");
assert_eq!(asked["questions"][0]["answerKey"], r#"["request_user_input_async","call-1",0]"#);
assert_eq!(asked["questions"][0]["options"][1]["label"], "Two");
assert_eq!(asked["questions"][1]["options"], json!([]));
}
#[tokio::test]
async fn completing_a_streamed_message_still_delivers_its_async_questions() {
let shim = Arc::new(CodexShim {
runtime: tokio::runtime::Handle::current(),
codex: OnceLock::new(),
client: OnceLock::new(),
state: Mutex::default(),
models: tokio::sync::Mutex::new(None),
skills: tokio::sync::Mutex::new(()),
});
shim.state.lock().threads.insert("thread".into(), Thread::default());
let client = Arc::new(Client::default());
let peer = crate::native::serve(shim.clone(), client.clone());
shim.text("thread", &json!({"itemId":"call-1","delta":"Which?"}), "agent_message_chunk", false);
shim.item(
"thread",
&json!({"type":"agentMessage","id":"call-1","text":"Which?",
"questions":[{"title":"Which?","options":["One","Two"]}]}),
true,
);
tokio::time::timeout(Duration::from_secs(2), async {
while client.of("thread").len() < 2 {
tokio::time::sleep(Duration::from_millis(5)).await;
}
})
.await
.unwrap();
assert_eq!(client.text("thread", "agent_message_chunk"), "Which?");
assert!(client.of("thread").iter().any(|u| u["sessionUpdate"] == "user_question"));
assert!(client.asked.lock().is_empty(), "an asynchronous question must not block on a permission response");
peer.kill();
shim.client.get().unwrap().kill();
}
// ---- Transcripts ---------------------------------------------------------------------
/// The ACP client: records updates and answers permission requests in order.
@@ -1671,6 +1721,17 @@ fn session_mcp_servers_become_thread_configuration() {
json!({"mcp_servers":{"OpenIDEA":{"command":"/app/openidea","args":["--mcp-stdio","--project","/project"],"env":{"K":"V"}}}})
)
);
let external = std::collections::BTreeSet::from(["linear".to_owned()]);
assert_eq!(
super::translate::mcp_config_with_external(
&json!({
"mcpServers": [],
"_meta": { "openidea": { "mcpServersOff": ["linear", "not-in-codex"] } }
}),
&external,
),
Some(json!({ "mcp_servers": { "linear": { "enabled": false } } }))
);
}
#[tokio::test(flavor = "multi_thread")]
+53 -1
Переглянути файл
@@ -871,6 +871,7 @@ pub(super) fn history(thread: &Value, cwd: Option<&str>) -> Vec<Value> {
if !text.is_empty() {
out.push(chunk("agent_message_chunk", text));
}
out.extend(question_update(item));
}
Some("reasoning") => {
let text = reasoning_text(item);
@@ -890,6 +891,36 @@ pub(super) fn history(thread: &Value, cwd: Option<&str>) -> Vec<Value> {
out
}
/// Structured async questions accompany a completed message, even when its text streamed already.
pub(super) fn question_update(item: &Value) -> Option<Value> {
let id = item.get("id")?.as_str().filter(|id| !id.is_empty())?;
let questions: Vec<Value> = item
.get("questions")?
.as_array()?
.iter()
.enumerate()
.filter_map(|(index, q)| {
let title = q.get("title")?.as_str().filter(|title| !title.trim().is_empty())?;
let options: Vec<Value> = q
.get("options")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(Value::as_str)
.filter(|label| !label.trim().is_empty())
.map(|label| json!({ "label": label, "description": "" }))
.collect();
Some(json!({ "answerKey": json!(["request_user_input_async", id, index]).to_string(),
"question": title, "header": "", "multiSelect": false, "options": options }))
})
.collect();
if questions.is_empty() {
return None;
}
Some(json!({ "sessionUpdate": "user_question", "id": id,
"title": questions[0]["question"], "questions": questions }))
}
/// A reasoning item's summary (or, without one, its raw text).
pub(super) fn reasoning_text(item: &Value) -> String {
let parts = |k: &str| -> Vec<String> {
@@ -923,8 +954,18 @@ fn str_of(v: &Value, key: &str) -> Option<String> {
/// Session-scoped MCP configuration, carried in thread/start, resume and fork.
pub(super) fn mcp_config(params: &Value) -> Option<Value> {
let home = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(std::path::PathBuf::from);
let cwd = params.get("cwd").and_then(Value::as_str).map_or_else(|| std::path::Path::new("."), std::path::Path::new);
let external = crate::mcp::codex_external_server_names(home.as_deref(), cwd);
mcp_config_with_external(params, &external)
}
pub(super) fn mcp_config_with_external(
params: &Value,
external_names: &std::collections::BTreeSet<String>,
) -> Option<Value> {
let mut servers = serde_json::Map::new();
for server in params.get("mcpServers")?.as_array()? {
for server in params.get("mcpServers").and_then(Value::as_array).into_iter().flatten() {
if server.get("type").and_then(Value::as_str).is_some_and(|t| t != "stdio") {
continue;
}
@@ -946,5 +987,16 @@ pub(super) fn mcp_config(params: &Value) -> Option<Value> {
"args":server.get("args").cloned().unwrap_or_else(||json!([])),"env":env}),
);
}
for name in params
.pointer("/_meta/openidea/mcpServersOff")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(Value::as_str)
{
if !servers.contains_key(name) && external_names.contains(name) {
servers.insert(name.to_owned(), json!({ "enabled": false }));
}
}
(!servers.is_empty()).then(|| json!({"mcp_servers":servers}))
}
+107 -31
Переглянути файл
@@ -19,6 +19,7 @@ mod translate;
mod tests;
use super::Shim;
use crate::BACKGROUND_TASKS_UPDATE;
use crate::acp::AUTH_REQUIRED;
use crate::provider::ProviderSpec;
use ide_jsonrpc::{Framing, Handler, Peer, RpcError, codes};
@@ -296,6 +297,25 @@ struct SessionEntry {
prompt: Option<oneshot::Sender<TurnTerminal>>,
early_cancel: Option<Instant>,
temp_files: Vec<PathBuf>,
/// Copilot's main agent loop is processing. It goes idle (`assistant.idle`) before the
/// turn ends (`session.idle`) while background shells or agents it started still run.
main_busy: bool,
/// Counts `session.tasks.list` requests, so only the latest answer is reported.
tasks_seq: u64,
}
impl SessionEntry {
fn new(settings: Settings) -> Self {
Self {
settings,
translator: EventTranslator::default(),
prompt: None,
early_cancel: None,
temp_files: Vec::new(),
main_busy: false,
tasks_seq: 0,
}
}
}
struct CopilotEvents(Weak<CopilotShim>);
@@ -411,6 +431,7 @@ impl CopilotShim {
"session/set_config_option" => self.set_config(&params).await,
"session/prompt" => self.prompt(&params, false).await,
"_openidea/steer" => self.prompt(&params, true).await,
"_openidea/stop_task" => self.stop_task(&params).await,
"session/close" => self.close_session(&params).await,
_ => Err(error(codes::METHOD_NOT_FOUND, format!("unsupported method {method}"))),
}
@@ -425,7 +446,7 @@ impl CopilotShim {
"promptCapabilities": { "image": true, "audio": false, "embeddedContext": true },
"mcpCapabilities": { "http": true, "sse": true, "stdio": true },
"sessionCapabilities": { "close": {}, "list": {} },
"_meta": { "openidea": { "steer": true } },
"_meta": { "openidea": { "steer": true, "backgroundTasks": true } },
},
"agentInfo": {
"name": "copilot",
@@ -471,6 +492,9 @@ impl CopilotShim {
if let Some(mcp) = translate::wire_mcp_servers(params.get("mcpServers")) {
req["mcpServers"] = mcp;
}
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
req["disabledMcpServers"] = disabled;
}
let created = self.call("session.create", req).await?;
let session_id = created
@@ -489,16 +513,7 @@ impl CopilotShim {
}
let options = models::config_options(&catalog, &settings);
self.state.lock().sessions.insert(
session_id.clone(),
SessionEntry {
settings,
translator: EventTranslator::default(),
prompt: None,
early_cancel: None,
temp_files: Vec::new(),
},
);
self.state.lock().sessions.insert(session_id.clone(), SessionEntry::new(settings));
self.publish_commands(&session_id, cwd);
Ok(json!({
"sessionId": session_id,
@@ -527,6 +542,9 @@ impl CopilotShim {
if let Some(mcp) = translate::wire_mcp_servers(params.get("mcpServers")) {
req["mcpServers"] = mcp;
}
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
req["disabledMcpServers"] = disabled;
}
let resumed = self.call("session.resume", req).await?;
if let Ok(current) = self.call("session.model.getCurrent", json!({ "sessionId": session_id })).await {
@@ -542,16 +560,7 @@ impl CopilotShim {
}
let actual_id = resumed.get("sessionId").and_then(Value::as_str).unwrap_or(&session_id).to_owned();
let options = models::config_options(&catalog, &settings);
self.state.lock().sessions.insert(
actual_id.clone(),
SessionEntry {
settings,
translator: EventTranslator::default(),
prompt: None,
early_cancel: None,
temp_files: Vec::new(),
},
);
self.state.lock().sessions.insert(actual_id.clone(), SessionEntry::new(settings));
self.publish_commands(&actual_id, cwd);
Ok(json!({
"sessionId": actual_id,
@@ -653,7 +662,11 @@ impl CopilotShim {
let (text, attachments, temp_files) = build_prompt_payload(&session_id, blocks);
if steer {
let is_running = self.state.lock().sessions.get(&session_id).is_some_and(|e| e.prompt.is_some());
let (is_running, main_busy) = {
let st = self.state.lock();
let entry = st.sessions.get(&session_id);
(entry.is_some_and(|e| e.prompt.is_some()), entry.is_some_and(|e| e.main_busy))
};
if !is_running {
cleanup_files(&temp_files);
return Err(error(codes::INVALID_PARAMS, "no turn running to steer"));
@@ -661,14 +674,25 @@ impl CopilotShim {
let mut send_req = json!({
"sessionId": session_id,
"prompt": text,
"mode": "immediate",
});
// Joins the running loop; once it went idle (only background work is left), a plain
// send starts the loop again with this message.
if main_busy {
send_req["mode"] = json!("immediate");
}
if !attachments.is_empty() {
send_req["attachments"] = Value::Array(attachments);
}
if !main_busy && let Some(entry) = self.state.lock().sessions.get_mut(&session_id) {
// Stop must abort the run this send starts, even before `assistant.turn_start`.
entry.main_busy = true;
}
let res = self.call("session.send", send_req).await;
if let Some(entry) = self.state.lock().sessions.get_mut(&session_id) {
entry.temp_files.extend(temp_files);
if res.is_err() && !main_busy {
entry.main_busy = false;
}
}
res?;
return Ok(json!({}));
@@ -685,6 +709,7 @@ impl CopilotShim {
let mode = entry.settings.mode.wire();
if !early {
entry.prompt = Some(done_tx);
entry.main_busy = true;
}
(mode, early)
};
@@ -734,19 +759,24 @@ impl CopilotShim {
}
fn cancel(&self, session_id: &str) {
let has_turn = {
let (has_turn, ended) = {
let mut st = self.state.lock();
if let Some(entry) = st.sessions.get_mut(session_id) {
if entry.prompt.is_none() {
match st.sessions.get_mut(session_id) {
Some(entry) if entry.prompt.is_none() => {
entry.early_cancel = Some(Instant::now());
false
} else {
true
(false, None)
}
} else {
false
// The agent is done with the turn and only its background work runs, which
// `session.idle` waits for: the turn ends now and that work keeps running
// (it shows as background tasks, stoppable one by one).
Some(entry) if !entry.main_busy => (false, entry.prompt.take()),
Some(_) => (true, None),
None => (false, None),
}
};
if let Some(tx) = ended {
let _ = tx.send(TurnTerminal::Idle { aborted: true });
}
if has_turn {
let peer = self.copilot().clone();
let sid = session_id.to_owned();
@@ -790,10 +820,23 @@ impl CopilotShim {
return;
}
let main_agent = event.get("agentId").and_then(Value::as_str).is_none_or(str::is_empty);
let event_type = event.get("type").and_then(Value::as_str).unwrap_or_default();
if main_agent && event_type == "session.background_tasks_changed" {
self.refresh_background_tasks(session_id);
}
let catalog_snapshot = self.catalog.try_lock().ok().and_then(|g| g.clone());
let (updates, done) = {
let mut st = self.state.lock();
let Some(entry) = st.sessions.get_mut(session_id) else { return };
if main_agent {
match event_type {
"assistant.turn_start" => entry.main_busy = true,
"assistant.idle" | "session.idle" | "session.error" => entry.main_busy = false,
_ => {}
}
}
let fallback_limit =
catalog_snapshot.as_deref().and_then(|models| entry.settings.active_context_tokens(models));
let translated = entry.translator.translate(session_id, event, fallback_limit);
@@ -803,11 +846,44 @@ impl CopilotShim {
for (target_session, update) in updates {
self.send_update(&target_session, update);
}
if main_agent && event_type == "session.idle" {
// Nothing runs in the background any more.
self.send_update(session_id, json!({ "sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": [] }));
}
if let Some((tx, outcome)) = done {
let _ = tx.send(outcome);
}
}
/// Reports the session's running background shells and agents (`session.tasks.list`).
fn refresh_background_tasks(self: &Arc<Self>, session_id: &str) {
let seq = {
let mut st = self.state.lock();
let Some(entry) = st.sessions.get_mut(session_id) else { return };
entry.tasks_seq += 1;
entry.tasks_seq
};
let shim = self.clone();
let sid = session_id.to_owned();
self.runtime.spawn(async move {
let Ok(list) = shim.call("session.tasks.list", json!({ "sessionId": sid })).await else { return };
let latest = shim.state.lock().sessions.get(&sid).is_some_and(|e| e.tasks_seq == seq);
if latest {
let tasks = translate::background_tasks(&list);
shim.send_update(&sid, json!({ "sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": tasks }));
}
});
}
/// Stops one background shell or agent (`session.tasks.cancel`).
async fn stop_task(self: &Arc<Self>, params: &Value) -> Result<Value, ResponseError> {
let session_id = str_param(params, "sessionId")?;
let task_id = str_param(params, "taskId")?;
self.call("session.tasks.cancel", json!({ "sessionId": session_id, "id": task_id })).await?;
self.refresh_background_tasks(session_id);
Ok(json!({}))
}
fn handle_permission_event(self: &Arc<Self>, session_id: &str, event: &Value) {
let data = &event["data"];
if data.get("resolvedByHook").and_then(Value::as_bool) == Some(true) {
+148 -1
Переглянути файл
@@ -6,6 +6,7 @@ use ide_jsonrpc::{Framing, Handler, Peer, codes};
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::sync::{Arc, OnceLock};
use std::time::Duration;
fn sample_models_list() -> Value {
json!({
@@ -340,6 +341,12 @@ fn headless_and_acp_args_roundtrip_while_preserving_user_flags() {
struct FakeCopilotServer {
peer: OnceLock<Peer>,
calls: Mutex<Vec<(String, Value)>>,
/// `session.send` leaves a shell running: the main loop goes idle but the session doesn't.
background_shell: bool,
}
fn copilot_event(sid: &str, event: Value) -> Value {
json!({ "sessionId": sid, "event": event })
}
impl Handler for FakeCopilotServer {
@@ -355,12 +362,36 @@ impl Handler for FakeCopilotServer {
"commands.list" => Ok(json!({ "commands": [{ "name": "compact", "description": "Compact context" }] })),
"skills.discover" => Ok(json!({ "skills": [] })),
"session.create" => Ok(json!({ "sessionId": "cop-sess-1" })),
"session.resume" => Ok(json!({ "sessionId": params["sessionId"] })),
"session.model.getCurrent" => Ok(json!({ "modelId": "gemini-4-carbon" })),
"session.model.switchTo" => Ok(json!({ "modelId": params["modelId"] })),
"session.mode.set" => Ok(json!({})),
"session.permissions.setApproveAll" => {
assert!(params.get("enabled").and_then(Value::as_bool).is_some());
Ok(json!({ "success": true }))
}
"session.tasks.list" => Ok(json!({ "tasks": [
{ "id": "shell-1", "type": "shell", "status": "running", "description": "",
"command": "gh pr checks 3819 --watch", "attachmentMode": "attached" },
{ "id": "shell-0", "type": "shell", "status": "completed", "description": "ls", "command": "ls" },
] })),
"session.tasks.cancel" => Ok(json!({ "cancelled": true })),
"session.abort" => Ok(json!({})),
"session.send" if self.background_shell => {
if let Some(peer) = self.peer.get().cloned() {
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
std::thread::spawn(move || {
for event in [
json!({ "id": "b1", "type": "assistant.turn_start", "data": { "turnId": "t1" } }),
json!({ "id": "b2", "type": "assistant.idle", "data": {} }),
json!({ "id": "b3", "type": "session.background_tasks_changed", "data": {} }),
] {
let _ = peer.notify("session.event", copilot_event(&sid, event));
}
});
}
Ok(json!({ "messageId": "msg-1" }))
}
"session.send" => {
if let Some(peer) = self.peer.get().cloned() {
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
@@ -423,7 +454,8 @@ impl Handler for CollectUpdates {
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_turns() {
let server = Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()) });
let server =
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: false });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates.clone(), move |events| {
@@ -538,3 +570,118 @@ async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_t
.any(|u| u["sessionUpdate"] == "usage_update" && u["size"] == 200_000 && u["used"] == 42_000)
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn shim_forwards_disabled_mcp_servers_on_create_and_resume() {
let server =
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: false });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates, move |events| {
let (a, b) = tokio::io::duplex(1 << 16);
let (ar, aw) = tokio::io::split(a);
let (br, bw) = tokio::io::split(b);
let srv_peer = Peer::connect_framed(br, bw, server_clone.clone(), Framing::ContentLength);
let _ = server_clone.peer.set(srv_peer);
Ok(Peer::connect_framed(ar, aw, events, Framing::ContentLength))
})
.unwrap();
let _: Value = client.request("initialize", json!({}), None).await.unwrap();
let disabled = json!(["datadog", "github-mcp-server", "linear", "playwright", "slack-official"]);
let _: Value = client
.request(
"session/new",
json!({
"cwd": "/tmp",
"mcpServers": [],
"_meta": { "openidea": { "mcpServersOff": disabled } }
}),
None,
)
.await
.unwrap();
let _: Value = client
.request(
"session/load",
json!({
"sessionId": "cop-sess-1",
"cwd": "/tmp",
"mcpServers": [],
"_meta": { "openidea": { "mcpServersOff": disabled } }
}),
None,
)
.await
.unwrap();
let calls = server.calls.lock();
let (_, create_params) = calls.iter().find(|(m, _)| m == "session.create").unwrap();
assert_eq!(create_params["disabledMcpServers"], disabled);
let (_, resume_params) = calls.iter().find(|(m, _)| m == "session.resume").unwrap();
assert_eq!(resume_params["disabledMcpServers"], disabled);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn stop_ends_a_turn_left_running_only_by_background_shells() {
let server =
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: true });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates.clone(), move |events| {
let (a, b) = tokio::io::duplex(1 << 16);
let (ar, aw) = tokio::io::split(a);
let (br, bw) = tokio::io::split(b);
let srv_peer = Peer::connect_framed(br, bw, server_clone.clone(), Framing::ContentLength);
let _ = server_clone.peer.set(srv_peer);
Ok(Peer::connect_framed(ar, aw, events, Framing::ContentLength))
})
.unwrap();
let init: Value = client.request("initialize", json!({}), None).await.unwrap();
assert_eq!(init["agentCapabilities"]["_meta"]["openidea"]["backgroundTasks"], true);
let _: Value = client.request("session/new", json!({ "cwd": "/tmp", "mcpServers": [] }), None).await.unwrap();
let prompt_client = client.clone();
let turn = tokio::spawn(async move {
prompt_client
.request::<_, Value>(
"session/prompt",
json!({ "sessionId": "cop-sess-1", "prompt": [{ "type": "text", "text": "watch CI" }] }),
None,
)
.await
});
// The running shell shows as a background task.
let mut shown = None;
for _ in 0..500 {
shown = updates.0.lock().iter().find(|u| u["sessionUpdate"] == crate::BACKGROUND_TASKS_UPDATE).cloned();
if shown.is_some() {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
assert_eq!(
shown.unwrap()["tasks"],
json!([{ "task_id": "shell-1", "task_type": "local_bash", "description": "gh pr checks 3819 --watch" }])
);
let _: Value = client
.request("_openidea/stop_task", json!({ "sessionId": "cop-sess-1", "taskId": "shell-1" }), None)
.await
.unwrap();
assert!(
server
.calls
.lock()
.iter()
.any(|(m, p)| m == "session.tasks.cancel" && p["sessionId"] == "cop-sess-1" && p["id"] == "shell-1")
);
// The main loop is idle, so Stop ends the turn even though `session.idle` never comes.
assert!(!turn.is_finished());
client.notify("session/cancel", json!({ "sessionId": "cop-sess-1" })).unwrap();
let res = tokio::time::timeout(Duration::from_secs(5), turn).await.unwrap().unwrap().unwrap();
assert_eq!(res["stopReason"], "cancelled");
assert!(!server.calls.lock().iter().any(|(m, _)| m == "session.abort"));
}
+30
Переглянути файл
@@ -522,6 +522,14 @@ pub(super) fn wire_mcp_servers(acp_servers: Option<&Value>) -> Option<Value> {
(!out.is_empty()).then_some(Value::Object(out))
}
/// Extracts `_meta.openidea.mcpServersOff` into Copilot's `disabledMcpServers` string array.
pub(super) fn wire_disabled_mcp_servers(params: &Value) -> Option<Value> {
let list = params.pointer("/_meta/openidea/mcpServersOff")?.as_array()?;
let names: Vec<Value> =
list.iter().filter_map(|v| v.as_str().map(str::trim).filter(|s| !s.is_empty()).map(|s| json!(s))).collect();
(!names.is_empty()).then_some(Value::Array(names))
}
/// Converts `commands.list` + `skills.discover` results into ACP `availableCommands`.
pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Option<&Value>) -> Vec<Value> {
let mut seen = HashSet::new();
@@ -568,6 +576,28 @@ pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Optio
out
}
/// The running entries of a `session.tasks.list` result, in the background-task shape the
/// app shows (`task_id`, `task_type`, `description`).
pub(super) fn background_tasks(list: &Value) -> Vec<Value> {
let tasks = list.get("tasks").and_then(Value::as_array).map(Vec::as_slice).unwrap_or_default();
tasks
.iter()
.filter(|t| matches!(str_of(t, "status"), Some("running" | "idle")))
.filter_map(|t| {
let id = str_of(t, "id")?;
let kind = str_of(t, "type").unwrap_or_default();
let task_type = match kind {
"shell" => "local_bash",
"agent" => "local_agent",
other => other,
};
let description =
str_of(t, "description").filter(|d| !d.is_empty()).or_else(|| str_of(t, "command")).unwrap_or(kind);
Some(json!({ "task_id": id, "task_type": task_type, "description": description }))
})
.collect()
}
fn trim_tail(text: &mut String) {
if text.len() > MAX_OUTPUT {
let mut cut = text.len() - MAX_OUTPUT;
+11 -1
Переглянути файл
@@ -82,6 +82,7 @@ const BUILTIN: &[(&str, &str, Driver, &[&str], &str)] = &[
("kiro", "Kiro", Driver::Acp, &["kiro-cli", "acp"], "Run `kiro-cli login` in a terminal."),
("vibe", "Mistral Vibe", Driver::Acp, &["vibe-acp"], "Run `vibe` in a terminal and sign in."),
("omp", "OMP", Driver::Acp, &["omp", "acp"], "Run `omp` in a terminal and sign in."),
("hermes", "Hermes Agent", Driver::Acp, &["hermes", "acp"], "Run `hermes model` in a terminal."),
];
fn builtins() -> Vec<ProviderSpec> {
@@ -503,7 +504,7 @@ fn validated_custom_id(id: &str) -> IdeResult<String> {
}
/// Turns an `acp.json` server name into a file-stem id (`"My Agent!"` → `"my-agent"`).
fn slugify_id(name: &str) -> String {
pub(crate) fn slugify_id(name: &str) -> String {
let mut id = String::with_capacity(name.len());
for c in name.chars() {
if c.is_ascii_alphanumeric() {
@@ -716,6 +717,15 @@ mod tests {
use super::*;
use serde_json::json;
#[test]
fn hermes_is_built_in_over_acp() {
let spec = builtin_spec("hermes").unwrap();
assert_eq!(spec.driver, Driver::Acp);
let info = describe(&spec);
assert_eq!((info.name.as_str(), info.command.as_str()), ("Hermes Agent", "hermes acp"));
assert_eq!(info.login_hint.as_deref(), Some("Run `hermes model` in a terminal."));
}
#[test]
fn qoder_global_and_cn_editions_are_both_built_in() {
let info = |id: &str| describe(&load(None, None).into_iter().find(|s| s.id == id).unwrap());
+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"));
}
}
+33 -1
Переглянути файл
@@ -1,6 +1,7 @@
//! Claude Code's slash commands on disk, for completion before (or without) a session:
//! skills (`.claude/skills/<dir>/SKILL.md`) and custom commands (`.claude/commands/**/*.md`)
//! of the working directory and every directory above it, then the user's `~/.claude`.
//! of the working directory and every directory above it, then the user's `~/.claude`; and
//! the skills of a Hermes profile (`<profile>/skills`).
use crate::{AgentCommand, AgentCommandSource};
use std::collections::HashSet;
@@ -34,6 +35,19 @@ pub(crate) fn discover(cwd: &Path, home: Option<&Path>) -> Vec<AgentCommand> {
out
}
/// The skills of a Hermes profile: `<profile>/skills/<skill>` and `<profile>/skills/<category>/<skill>`;
/// the first of a name wins.
pub(crate) fn hermes(profile: &Path) -> Vec<AgentCommand> {
let root = profile.join("skills");
let mut found = skills(&root);
for category in sorted(&root).into_iter().filter(|p| !p.join("SKILL.md").exists()) {
found.extend(skills(&category));
}
let mut seen = HashSet::new();
found.retain(|c| seen.insert(c.name.clone()));
found
}
/// `first` (the agent's own list) plus the commands of `more` it lacks.
pub(crate) fn merge(first: Vec<AgentCommand>, more: Vec<AgentCommand>) -> Vec<AgentCommand> {
let mut out = first;
@@ -256,6 +270,24 @@ mod tests {
);
}
#[test]
fn hermes_skills_flat_and_in_categories() {
let tmp = tempfile::tempdir().unwrap();
let profile = tmp.path();
assert!(hermes(profile).is_empty());
for dir in ["skills/plan", "skills/dev/review", "skills/dev/plan", "skills/empty"] {
std::fs::create_dir_all(profile.join(dir)).unwrap();
}
for dir in ["skills/plan", "skills/dev/review", "skills/dev/plan"] {
std::fs::write(profile.join(dir).join("SKILL.md"), "---\ndescription: d\n---\n").unwrap();
}
let names: Vec<_> = hermes(profile).into_iter().map(|c| (c.name, c.source)).collect();
assert_eq!(
names,
[("plan".to_owned(), AgentCommandSource::Skill), ("review".to_owned(), AgentCommandSource::Skill)]
);
}
#[test]
fn nothing_without_claude_dirs() {
let tmp = tempfile::tempdir().unwrap();
+510 -27
Переглянути файл
@@ -39,6 +39,8 @@ struct FakeAgent {
authenticate_method: Option<String>,
authenticated: AtomicBool,
request_error: Option<(i64, String)>,
/// `session/load` fails with this, as OMP does for a session whose model it can't restore.
load_error: Option<(i64, String)>,
auth_methods: Vec<Value>,
/// Hold the late mode reply until the prompt's permission request is already waiting.
hold_late_mode: bool,
@@ -57,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 {
@@ -212,6 +216,7 @@ impl Handler for FakeAgent {
let outcome = if text == "too late" { "promptRequired" } else { "injected" };
Ok(json!({"outcome": outcome, "queue": "steering"}))
}
"session/load" if self.load_error.is_some() => Err(self.load_error.clone().unwrap()),
"session/load" => {
self.say(&session, "replayed history");
Ok(json!({}))
@@ -244,7 +249,21 @@ 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"}));
}
if text == "again" {
self.say(&session, "second turn");
return Ok(json!({"stopReason": "end_turn"}));
@@ -866,7 +885,7 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
["session/load", "authenticate", "authenticate github_oauth", "session/load", "session/prompt"],
);
// If `authenticate` fails during `session/load`, fallback to `session/new` does not try it again.
// If `authenticate` fails during `session/load`, the sign-in error stands: no new session replaces it.
mgr2.shutdown();
let agent3 = Arc::new(FakeAgent {
auth_on_load: true,
@@ -885,11 +904,32 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
.iter()
.filter(|c| c.starts_with("session/") || c.starts_with("authenticate"))
.collect::<Vec<_>>(),
["session/load", "authenticate", "session/new"],
["session/load", "authenticate"],
);
mgr3.shutdown();
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread")]
async fn hermes_profiles_complete_their_own_skills() {
let tmp = tempfile::tempdir().unwrap();
let skill = |dir: &str, name: &str| {
let dir = tmp.path().join(dir).join(name);
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join("SKILL.md"), format!("---\nname: {name}\ndescription: d\n---\n")).unwrap();
};
skill(".hermes/skills", "plan");
skill(".hermes/profiles/dom/skills/home", "lights");
std::fs::write(tmp.path().join(".hermes/profiles/dom/config.yaml"), "").unwrap();
let mgr = manager_at(tmp.path(), &tmp.path().join("models.json"), Arc::new(FakeAgent::default()));
let names = |c: Vec<AgentCommand>| c.into_iter().map(|c| c.name).collect::<Vec<_>>();
assert!(names(mgr.commands("hermes", None).await.unwrap()).contains(&"plan".to_owned()));
let dom = names(mgr.commands("hermes-dom", None).await.unwrap());
assert!(dom.contains(&"lights".to_owned()) && !dom.contains(&"plan".to_owned()));
assert!(!names(mgr.commands("claude", None).await.unwrap()).contains(&"plan".to_owned()));
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
let tmp = tempfile::tempdir().unwrap();
@@ -1150,10 +1190,127 @@ async fn a_task_runs_asks_for_permission_and_survives_a_restart() {
assert!(calls.contains(&"session/set_mode \"code\"".to_owned()), "{calls:?}");
}
#[tokio::test(flavor = "multi_thread")]
async fn a_session_that_fails_to_load_is_reported_and_replaced_only_when_sent_again() {
let tmp = tempfile::tempdir().unwrap();
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let saved = mgr.task(&task.id).unwrap().state.lock().session_id.clone().expect("a session");
mgr.shutdown();
// OMP: "Could not restore model …" for a session saved with a model it can't restore.
let agent = Arc::new(FakeAgent {
load_error: Some((codes::INTERNAL_ERROR, "Could not restore model x".into())),
..Default::default()
});
let mgr = manager(tmp.path(), agent.clone());
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Failed).await;
let calls = |agent: &FakeAgent| -> Vec<String> {
agent.calls.lock().iter().filter(|c| c.starts_with("session/")).cloned().collect()
};
assert_eq!(calls(&agent), ["session/load"], "no new session behind the user's back");
let handle = mgr.task(&task.id).unwrap();
assert_eq!(handle.state.lock().session_id.as_deref(), Some(saved.as_str()));
assert!(mgr.entries(&task.id, None).unwrap().iter().any(|e| matches!(e,
AgentEntry::Error { message } if message.contains("Could not restore model x") && message.contains("Send the message again"))));
// Sending again is the user's choice to continue without the earlier conversation.
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
assert_eq!(calls(&agent), ["session/load", "session/new", "session/prompt"]);
}
fn text(t: &str) -> AgentPrompt {
AgentPrompt { text: t.into(), ..AgentPrompt::default() }
}
fn asynchronous_question() -> Value {
json!({"sessionUpdate":"user_question","id":"call-1","title":"Which?",
"questions":[{"answerKey":"q1","question":"Which?","options":[]}]})
}
#[tokio::test(flavor = "multi_thread")]
async fn async_question_answers_join_the_turn_and_skipping_does_not_cancel_it() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent { session_steering: true, ..Default::default() });
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("wait"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Running).await;
let handle = mgr.task(&task.id).unwrap();
handle.on_update(Some("s1"), &asynchronous_question());
assert!(mgr.answer_question(&task.id, "call-1", Some("{}".into())).await.is_err());
handle.live.lock().as_mut().unwrap().capabilities.steer = false;
assert!(mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.is_err());
assert!(handle.state.lock().task.queue.is_empty());
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
handle.live.lock().as_mut().unwrap().capabilities.steer = true;
mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.unwrap();
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
assert!(
agent.calls.lock().iter().any(|call| call.starts_with("_session/steering ") && call.contains("questionItemId"))
);
assert!(!agent.calls.lock().iter().any(|call| call == "session/cancel"));
assert!(mgr.answer_question(&task.id, "call-1", None).await.is_err());
let mut question = asynchronous_question();
question["id"] = json!("call-2");
handle.on_update(Some("s1"), &question);
mgr.answer_question(&task.id, "call-2", None).await.unwrap();
assert!(
matches!(mgr.entries(&task.id, None).unwrap().last(), Some(AgentEntry::Question { chosen: Some(chosen), .. }) if chosen == "Skipped")
);
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
mgr.cancel(&task.id, None).unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
}
#[tokio::test(flavor = "multi_thread")]
async fn async_questions_can_be_answered_after_the_turn_ends() {
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("again"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.task(&task.id).unwrap().on_update(Some("s1"), &asynchronous_question());
mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
assert!(
mgr.entries(&task.id, None)
.unwrap()
.iter()
.any(|entry| matches!(entry, AgentEntry::Question { chosen: Some(answer), .. } if answer == "Which?: One"))
);
let entries = mgr.entries(&task.id, None).unwrap();
assert!(
entries.iter().any(|entry| matches!(entry, AgentEntry::User { text, .. } if text.contains("questionItemId")))
);
}
#[tokio::test(flavor = "multi_thread")]
async fn steers_through_session_steering() {
let tmp = tempfile::tempdir().unwrap();
@@ -1214,25 +1371,15 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
assert_eq!(queue.iter().map(|q| q.prompt.text.as_str()).collect::<Vec<_>>(), ["again"]);
assert!(mgr.prompt(&task.id, text(" "), false).await.is_err());
mgr.send_queued_now(&task.id, &queue[0].id).unwrap();
for _ in 0..500 {
if mgr.entries(&task.id, None).unwrap().iter().any(|e| *e == AgentEntry::Agent { text: "second turn".into() }) {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let users: Vec<String> = mgr
.entries(&task.id, None)
.unwrap()
.into_iter()
.filter_map(|e| match e {
AgentEntry::User { text, .. } => Some(text),
_ => None,
})
.collect();
assert_eq!(users, ["wait", "again"]);
// Sending it now joins the running turn when the agent takes messages mid-turn.
mgr.send_queued_now(&task.id, &queue[0].id).await.unwrap();
assert!(agent.calls.lock().iter().any(|c| c == "_openidea/steer \"again\""));
assert!(!agent.calls.lock().iter().any(|c| c == "session/cancel"));
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
let entries = mgr.entries(&task.id, None).unwrap();
assert!(entries.iter().any(|e| matches!(e, AgentEntry::User { text, steered: true, .. } if text == "again")));
mgr.cancel(&task.id, None).unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
// Stopping a turn keeps the queue for later.
mgr.prompt(&task.id, text("wait"), false).await.unwrap();
@@ -1247,6 +1394,113 @@ 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();
let agent = Arc::new(FakeAgent { session_steering: true, ..FakeAgent::default() });
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("wait"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Running).await;
mgr.prompt(&task.id, text("too late"), false).await.unwrap();
let queued = mgr.task(&task.id).unwrap().state.lock().task.queue[0].id.clone();
mgr.send_queued_now(&task.id, &queued).await.unwrap();
// The fake agent's next turn asks for permission.
wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
let calls = agent.calls.lock().clone();
assert!(calls.contains(&"_session/steering \"too late\"".to_owned()), "{calls:?}");
assert!(calls.contains(&"session/cancel".to_owned()), "{calls:?}");
let entries = mgr.entries(&task.id, None).unwrap();
assert!(entries.iter().any(|e| matches!(e, AgentEntry::User { text, steered: false, .. } if text == "too late")));
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
mgr.cancel(&task.id, None).unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
}
#[tokio::test(flavor = "multi_thread")]
async fn subagents_get_their_own_conversation() {
let tmp = tempfile::tempdir().unwrap();
@@ -1311,6 +1565,25 @@ async fn subagents_get_their_own_conversation() {
check(&manager(tmp.path(), Arc::new(FakeAgent::default())));
}
#[test]
fn image_blocks_declare_the_type_of_their_bytes() {
let image = |mime: &str, data: &str| AgentImage { mime_type: mime.into(), data: data.into(), name: None };
let cases = [
// A browser's JPEG pasted as PNG.
(image("image/png", "/9j/4AAQSkZJRgABAQ"), "image/jpeg"),
(image("image/jpeg", "iVBORw0KGgoAAAANSUhEUg"), "image/png"),
(image("image/png", "R0lGODlhAQABAIAAAP"), "image/gif"),
(image("image/png", "UklGRiQAAABXRUJQVlA4"), "image/webp"),
// Not recognised: as declared.
(image("image/bmp", "Qk02AAAAAAAAADYAAA"), "image/bmp"),
(image("image/png", "AAA"), "image/png"),
];
for (image, expected) in cases {
let p = AgentPrompt { text: String::new(), files: vec![], images: vec![image] };
assert_eq!(blocks(&p, &[])[0]["mimeType"], expected, "{:?}", p.images[0].data);
}
}
#[test]
fn prompts_become_acp_content_blocks() {
let p = AgentPrompt {
@@ -1625,6 +1898,32 @@ async fn real_claude_task_in_a_worktree() {
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn hermes_session_info_names_the_task_and_counts_compressions() {
let tmp = tempfile::tempdir().unwrap();
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
let task = mgr
// "again" ends the turn at once; the default prompt waits for a permission answer.
.create(NewAgentTask { prompt: text("again"), provider: "claude".into(), ..Default::default() })
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let handle = mgr.task(&task.id).unwrap();
let info = |title: &str, depth: u32| {
json!({"sessionUpdate": "session_info_update", "title": title, "updatedAt": "2026-11-18T18:35:32.068362+00:00",
"_meta": {"hermes": {"sessionProvenance": {"sessionKind": "root", "parentHermesSessionId": null,
"compressionDepth": depth}}}})
};
handle.on_update(None, &info("Make a 3-step plan and carry it out: 1) list the…", 0));
handle.on_update(None, &info("List files and edit notes.txt", 0));
let t = handle.state.lock().task.clone();
assert_eq!(t.title, "List files and edit notes.txt", "the agent's latest title wins");
assert_eq!(t.stats.compressions, 0);
handle.on_update(None, &info("List files and edit notes.txt", 2));
assert_eq!(handle.state.lock().task.stats.compressions, 2);
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn renamed_titles_survive_updates_forks_and_restart() {
let tmp = tempfile::tempdir().unwrap();
@@ -1683,7 +1982,7 @@ async fn startup_warnings_survive_replay_and_restart_without_failing_the_task()
let handle = mgr.task(&task.id).unwrap();
handle.replaying.store(true, Ordering::Release);
handle.turn_started.store(false, Ordering::Release);
let client = Client { task: Arc::downgrade(&handle) };
let client = Client::new(&handle, None);
client.on_notification(WARNING_NOTIFICATION, json!({"message": "Project MCP config is disabled until trusted."}));
client.on_notification(WARNING_NOTIFICATION, json!({"message": " "}));
client.on_notification(WARNING_NOTIFICATION, json!({}));
@@ -2685,7 +2984,10 @@ async fn task_project_root_controls_local_and_worktree_repositories() {
let changes = mgr.changes(&task.id).await.unwrap();
assert_eq!(changes.len(), 1);
assert_eq!(changes[0].path.0, task.cwd.0.join("file.txt"));
assert_eq!(mgr.base_text(&task.id, changes[0].path.0.clone()).await.unwrap().as_deref(), Some("original\n"));
assert_eq!(
mgr.base_text(&task.id, changes[0].path.0.clone(), AgentChangesView::SinceStart).await.unwrap().as_deref(),
Some("original\n")
);
let saved = std::fs::read(root.join("store").join(format!("{}.json", task.id))).unwrap();
assert!(String::from_utf8(saved).unwrap().contains("projectRoot"));
let mut old = serde_json::to_value(&task).unwrap();
@@ -3276,11 +3578,13 @@ fn streamed_text_is_sent_as_appends() {
);
let replaced = entry_event("t", &mut streamed, None, 3, &agent("Other"));
assert!(matches!(replaced, AgentEvent::Entry { .. }), "text that doesn't extend the sent text is sent whole");
let thought = entry_event("t", &mut streamed, None, 4, &AgentEntry::Thought { text: "hmm…".into() });
let thought = AgentEntry::Thought { text: "hmm…".into(), started_ms: None };
let thought = entry_event("t", &mut streamed, None, 4, &thought);
assert!(matches!(thought, AgentEvent::Entry { index: 4, .. }), "a new message starts whole");
let tool = AgentEntry::Error { message: "x".into() };
entry_event("t", &mut streamed, None, 4, &tool);
let again = entry_event("t", &mut streamed, None, 4, &AgentEntry::Thought { text: "hmm… ok".into() });
let again = AgentEntry::Thought { text: "hmm… ok".into(), started_ms: None };
let again = entry_event("t", &mut streamed, None, 4, &again);
assert!(matches!(again, AgentEvent::Entry { .. }), "an entry replaced by another kind forgets its text");
let long = "é".repeat(5000);
@@ -3469,6 +3773,178 @@ async fn changed(mgr: &AgentManager, id: &str) -> Vec<String> {
mgr.changes(id).await.unwrap().into_iter().map(|c| c.rel_path).collect()
}
/// Waits until the turn asks for permission, runs `work` (what the agent does), then stops it.
async fn one_turn(mgr: &AgentManager, id: &str, prompt: Option<&str>, work: impl FnOnce()) {
if let Some(prompt) = prompt {
mgr.prompt(id, text(prompt), false).await.unwrap();
}
wait_for(mgr, id, AgentStatus::NeedsInput).await;
work();
mgr.cancel(id, None).unwrap();
wait_for(mgr, id, AgentStatus::Ready).await;
}
async fn turn_changed(mgr: &AgentManager, id: &str) -> Vec<(String, ide_vcs::ChangeKind, u32, u32)> {
let changes = mgr.turn_changes(id).await.unwrap();
changes.into_iter().map(|c| (c.rel_path, c.kind, c.added, c.removed)).collect()
}
#[tokio::test(flavor = "multi_thread")]
async fn the_last_turn_lists_and_rolls_back_only_its_own_changes() {
use ide_vcs::ChangeKind::{Added, Deleted, Modified};
for isolation in [Isolation::Local, Isolation::Worktree] {
for eol in EOLS {
let repo = Checkout::new(eol);
repo.write("a.txt", "base\n");
repo.write("gone.txt", "base\n");
repo.write("mine.txt", "base\n");
repo.commit("init");
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask {
prompt: text("Hello"),
provider: "claude".into(),
isolation,
..Default::default()
})
.await
.unwrap();
let cwd = task.cwd.0.clone();
let write = |rel: &str, text: &str| {
let text = match eol {
Eol::Lf => text.to_owned(),
Eol::Crlf => text.replace('\n', "\r\n"),
};
std::fs::write(cwd.join(rel), text).unwrap();
};
let read = |rel: &str| std::fs::read_to_string(cwd.join(rel)).unwrap().replace("\r\n", "\n");
let case = format!("{isolation:?} {eol:?}");
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty(), "{case}: no turn has ended yet");
one_turn(&mgr, &task.id, None, || {
write("a.txt", "base\nturn 1\n");
write("one.txt", "one\n");
})
.await;
// The user's own work between the turns belongs to neither.
write("mine.txt", "base\nmine\n");
one_turn(&mgr, &task.id, Some("more"), || {
write("a.txt", "base\nturn 1\nturn 2\n");
write("one.txt", "one\ntwo\n");
write("two.txt", "two\n");
std::fs::remove_file(cwd.join("gone.txt")).unwrap();
})
.await;
// And after the turn.
write("later.txt", "mine\n");
assert_eq!(
turn_changed(&mgr, &task.id).await,
[
("a.txt".into(), Modified, 1, 0),
("gone.txt".into(), Deleted, 0, 1),
("one.txt".into(), Modified, 1, 0),
("two.txt".into(), Added, 1, 0),
],
"{case}"
);
let turn_base = |rel: &str| {
let path = cwd.join(rel);
let mgr = &mgr;
let id = task.id.clone();
async move {
let text = mgr.base_text(&id, path, AgentChangesView::LastTurn).await.unwrap();
text.map(|t| t.replace("\r\n", "\n"))
}
};
assert_eq!(turn_base("a.txt").await.as_deref(), Some("base\nturn 1\n"), "{case}");
assert_eq!(turn_base("gone.txt").await.as_deref(), Some("base\n"), "{case}");
assert_eq!(turn_base("two.txt").await, None, "{case}");
let whole: Vec<String> = changed(&mgr, &task.id).await;
assert!(["a.txt", "one.txt"].iter().all(|f| whole.iter().any(|w| w == f)), "{case}: {whole:?}");
// One file, then the rest, after a restart: from the copies saved as the turn started.
mgr.rollback_changes(&task.id, Some(vec!["one.txt".into()]), AgentChangesView::LastTurn).await.unwrap();
assert_eq!(read("one.txt"), "one\n", "{case}");
assert_eq!(turn_changed(&mgr, &task.id).await.len(), 3, "{case}");
mgr.shutdown();
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
mgr.rollback_changes(&task.id, None, AgentChangesView::LastTurn).await.unwrap();
assert_eq!(read("a.txt"), "base\nturn 1\n", "{case}");
assert_eq!(read("gone.txt"), "base\n", "{case}");
assert!(!cwd.join("two.txt").exists(), "{case}");
assert_eq!(read("mine.txt"), "base\nmine\n", "{case}: the user's edit between turns stays");
assert_eq!(read("later.txt"), "mine\n", "{case}: and the one after");
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty(), "{case}");
// The task's own changes from its first turn stay.
let whole: Vec<String> = changed(&mgr, &task.id).await;
assert!(["a.txt", "one.txt"].iter().all(|f| whole.iter().any(|w| w == f)), "{case}: {whole:?}");
mgr.delete(&task.id, true).await.unwrap();
assert!(!repo.dir.join("store").join(format!("{}.turn", task.id)).exists(), "{case}");
}
}
}
#[tokio::test(flavor = "multi_thread")]
async fn rolling_back_the_whole_task_leaves_the_last_turn_nothing_to_list() {
let repo = Checkout::new(Eol::Lf);
repo.write("a.txt", "base\n");
repo.commit("init");
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask { prompt: text("Hello"), provider: "claude".into(), ..Default::default() })
.await
.unwrap();
one_turn(&mgr, &task.id, None, || repo.write("a.txt", "base\nturn 1\n")).await;
one_turn(&mgr, &task.id, Some("more"), || repo.write("a.txt", "base\nturn 1\nturn 2\n")).await;
assert_eq!(turn_changed(&mgr, &task.id).await.len(), 1);
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
assert_eq!(repo.read("a.txt"), "base\n");
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty());
}
#[tokio::test(flavor = "multi_thread")]
async fn a_commit_made_in_the_last_turn_is_among_its_changes() {
let repo = Checkout::new(Eol::Lf);
repo.write("a.txt", "base\n");
repo.commit("init");
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask {
prompt: text("Hello"),
provider: "claude".into(),
isolation: Isolation::Worktree,
..Default::default()
})
.await
.unwrap();
let cwd = task.cwd.0.clone();
let git = |args: &[&str]| {
let ok = std::process::Command::new("git")
.args(["-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false"])
.args(args)
.current_dir(&cwd)
.status()
.unwrap()
.success();
assert!(ok, "{args:?}");
};
one_turn(&mgr, &task.id, None, || {
std::fs::write(cwd.join("a.txt"), "base\nagent\n").unwrap();
std::fs::write(cwd.join("new.txt"), "new\n").unwrap();
git(&["add", "."]);
git(&["commit", "-q", "-m", "agent"]);
})
.await;
let rel: Vec<String> = mgr.turn_changes(&task.id).await.unwrap().into_iter().map(|c| c.rel_path).collect();
assert_eq!(rel, ["a.txt", "new.txt"]);
mgr.rollback_changes(&task.id, None, AgentChangesView::LastTurn).await.unwrap();
assert_eq!(std::fs::read_to_string(cwd.join("a.txt")).unwrap(), "base\n");
assert!(!cwd.join("new.txt").exists());
mgr.delete(&task.id, true).await.unwrap();
}
#[tokio::test(flavor = "multi_thread")]
async fn work_uncommitted_by_a_reset_during_a_local_task_is_not_rolled_back() {
for eol in EOLS {
@@ -3485,7 +3961,7 @@ async fn work_uncommitted_by_a_reset_during_a_local_task_is_not_rolled_back() {
repo.git(&["reset", "-q", "--soft", "HEAD~1"]);
assert_eq!(changed(&mgr, &task.id).await, ["a.txt"], "{eol:?}");
let base = mgr.base_text(&task.id, repo.dir.join("a.txt")).await.unwrap();
let base = mgr.base_text(&task.id, repo.dir.join("a.txt"), AgentChangesView::SinceStart).await.unwrap();
assert_eq!(base.map(|b| b.replace("\r\n", "\n")).as_deref(), Some("base\n"), "{eol:?}");
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
assert_eq!(repo.read("a.txt"), "base\n", "{eol:?}");
@@ -3625,7 +4101,11 @@ async fn a_local_task_in_a_repository_without_commits_lists_and_rolls_back_its_c
let (mgr, task) = repo.task().await;
repo.write("new.txt", "agent\n");
assert_eq!(changed(&mgr, &task.id).await, ["new.txt"], "{eol:?}");
assert_eq!(mgr.base_text(&task.id, repo.dir.join("new.txt")).await.unwrap(), None, "{eol:?}");
assert_eq!(
mgr.base_text(&task.id, repo.dir.join("new.txt"), AgentChangesView::SinceStart).await.unwrap(),
None,
"{eol:?}"
);
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
assert!(!repo.dir.join("new.txt").exists(), "{eol:?}");
@@ -3972,6 +4452,7 @@ async fn per_session_mcp_overrides_filter_session_and_reload_when_idle() {
isolation: Isolation::Local,
base: None,
mcp_overrides: BTreeMap::from([("slack".into(), false)]),
idle: false,
})
.await
.unwrap();
@@ -4099,6 +4580,7 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
isolation: Isolation::Local,
base: None,
mcp_overrides: BTreeMap::new(),
idle: false,
})
.await
.unwrap();
@@ -4123,6 +4605,7 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
isolation: Isolation::Local,
base: None,
mcp_overrides: BTreeMap::new(),
idle: false,
})
.await
.unwrap();
+77 -4
Переглянути файл
@@ -54,6 +54,23 @@ impl Timeline {
let mut out = Applied::default();
let kind = update.get("sessionUpdate").and_then(Value::as_str).unwrap_or_default();
match kind {
"user_question" => {
let id = str_field(update, "id");
let Ok(questions) = serde_json::from_value::<Vec<crate::model::AgentQuestion>>(
update.get("questions").cloned().unwrap_or(Value::Null),
) else {
return out;
};
if id.is_empty()
|| questions.is_empty()
|| self.entries.iter().any(|e| matches!(e, AgentEntry::Question { id: known, .. } if known == &id))
{
return out;
}
let index =
self.push(AgentEntry::Question { id, title: str_field(update, "title"), questions, chosen: None });
out.changed.push(index);
}
"agent_message_chunk" | "agent_thought_chunk" => {
let Some(text) = content_text(update.get("content")) else { return out };
out.changed.push(self.append_text(kind == "agent_thought_chunk", &text));
@@ -68,6 +85,8 @@ impl Timeline {
locations: locations(update.get("locations")),
output: None,
diffs: Vec::new(),
started_ms: Some(crate::now_ms()),
ended_ms: None,
};
let index = match self.tools.get(&id) {
Some(&i) => {
@@ -117,17 +136,22 @@ impl Timeline {
fn append_text(&mut self, thought: bool, text: &str) -> usize {
match self.entries.last_mut() {
Some(AgentEntry::Agent { text: t }) if !thought => t.push_str(text),
Some(AgentEntry::Thought { text: t }) if thought => t.push_str(text),
Some(AgentEntry::Thought { text: t, .. }) if thought => t.push_str(text),
_ => {
let text = text.to_owned();
return self.push(if thought { AgentEntry::Thought { text } } else { AgentEntry::Agent { text } });
return self.push(if thought {
AgentEntry::Thought { text, started_ms: Some(crate::now_ms()) }
} else {
AgentEntry::Agent { text }
});
}
}
self.entries.len() - 1
}
fn merge_tool(&mut self, index: usize, update: &Value) {
let AgentEntry::Tool { title, kind, status, locations: locs, output, diffs, .. } = &mut self.entries[index]
let AgentEntry::Tool { title, kind, status, locations: locs, output, diffs, ended_ms, .. } =
&mut self.entries[index]
else {
return;
};
@@ -139,6 +163,9 @@ impl Timeline {
}
if let Some(s) = tool_status(update.get("status")) {
*status = s;
if matches!(s, AgentToolStatus::Completed | AgentToolStatus::Failed) && ended_ms.is_none() {
*ended_ms = Some(crate::now_ms());
}
}
if update.get("locations").is_some_and(Value::is_array) {
*locs = locations(update.get("locations"));
@@ -166,6 +193,11 @@ impl Timeline {
}
}
if !text.is_empty() {
// The command a call announced (`$ cmd`) stays above the result that replaces it.
let command = output.as_deref().and_then(|o| o.lines().next()).filter(|l| l.starts_with("$ "));
if let Some(command) = command.filter(|c| !text.starts_with(c)) {
text = format!("{command}\n{text}");
}
*output = Some(tail(text));
}
if !new_diffs.is_empty() {
@@ -388,6 +420,25 @@ mod tests {
use super::*;
use serde_json::json;
#[test]
fn asynchronous_questions_survive_turn_end_restart_and_duplicate_notifications() {
let mut t = Timeline::default();
let update = json!({"sessionUpdate":"user_question","id":"call-1","title":"Which?",
"questions":[{"answerKey":"q1","question":"Which?","options":[]}]});
assert_eq!(t.apply(&update).changed, vec![0]);
assert!(t.end_turn(None).is_empty());
assert!(matches!(&t.entries[0], AgentEntry::Question { chosen: None, .. }));
let saved = serde_json::to_string(&t.entries).unwrap();
let mut t = Timeline::from_entries(serde_json::from_str(&saved).unwrap());
assert!(t.apply(&update).changed.is_empty());
assert_eq!(t.entries.len(), 1);
if let AgentEntry::Question { chosen, .. } = &mut t.entries[0] {
*chosen = Some("One".into());
}
assert!(t.apply(&update).changed.is_empty());
assert!(matches!(&t.entries[0], AgentEntry::Question { chosen: Some(answer), .. } if answer == "One"));
}
#[test]
fn chunks_merge_into_one_message_until_another_entry_comes() {
let mut t = Timeline::default();
@@ -396,11 +447,14 @@ mod tests {
assert_eq!(t.apply(&chunk("lo")).changed, vec![0]);
t.apply(&json!({"sessionUpdate": "agent_thought_chunk", "content": {"type": "text", "text": "hmm"}}));
t.apply(&chunk("again"));
// The thought's start is the clock's: it is there, and the rest compares exactly.
let AgentEntry::Thought { started_ms, .. } = &mut t.entries[1] else { panic!("{:?}", t.entries) };
assert!(started_ms.take().is_some());
assert_eq!(
t.entries,
vec![
AgentEntry::Agent { text: "Hello".into() },
AgentEntry::Thought { text: "hmm".into() },
AgentEntry::Thought { text: "hmm".into(), started_ms: None },
AgentEntry::Agent { text: "again".into() },
]
);
@@ -492,6 +546,25 @@ mod tests {
assert!(matches!(t.entries[2], AgentEntry::User { done_ms: None, .. }));
}
#[test]
fn a_hermes_terminal_call_keeps_its_command_and_times() {
let text = |t: &str| serde_json::json!([{"type": "content", "content": {"type": "text", "text": t}}]);
let mut t = Timeline::default();
t.apply(&serde_json::json!({"sessionUpdate": "tool_call", "toolCallId": "tc-0b98b5e30a28",
"kind": "execute", "title": "terminal: echo ok + 2 commands", "locations": [],
"content": text("$ echo ok >> notes.txt && wc -l notes.txt")}));
let AgentEntry::Tool { started_ms, ended_ms, .. } = &t.entries[0] else { panic!() };
assert!(started_ms.is_some() && ended_ms.is_none());
t.apply(&serde_json::json!({"sessionUpdate": "tool_call_update", "toolCallId": "tc-0b98b5e30a28",
"kind": "execute", "status": "completed",
"content": text("terminal result\n- **output:** 3 notes.txt\n- **exit_code:** 0")}));
let AgentEntry::Tool { output, status, ended_ms, .. } = &t.entries[0] else { panic!() };
assert_eq!(*status, AgentToolStatus::Completed);
assert!(ended_ms.is_some());
let expected = "$ echo ok >> notes.txt && wc -l notes.txt\nterminal result\n- **output:** 3 notes.txt\n";
assert_eq!(output.as_deref(), Some(format!("{expected}- **exit_code:** 0").as_str()));
}
#[test]
fn long_output_keeps_its_tail() {
let s = tail("é".repeat(MAX_OUTPUT));
+249 -2
Переглянути файл
@@ -3,6 +3,7 @@
use crate::model::{AgentChange, AgentChanges, AgentCommit};
use ide_core::{IdeError, IdeResult, IpcPath};
use ide_vcs::{ChangeKind, LogQuery, Repo};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};
use std::time::{Duration, UNIX_EPOCH};
@@ -610,7 +611,6 @@ pub(crate) fn restore(
before: &BTreeMap<String, Stamp>,
saved: Option<&Path>,
) -> IdeResult<()> {
let path = &change.path.0;
let content = match before.get(&change.rel_path) {
Some(None) => None,
Some(Some(_)) => {
@@ -626,11 +626,16 @@ pub(crate) fn restore(
None => match rev {
Some(rev) => {
let repo = Repo::discover(cwd)?.ok_or_else(|| IdeError::invalid("not in a git repository"))?;
repo.file_bytes_at(path, Some(rev))?
repo.file_bytes_at(&change.path.0, Some(rev))?
}
None => None,
},
};
put(&change.path.0, content)
}
/// Writes `content` to `path`, or removes the file when there is none.
fn put(path: &Path, content: Option<Vec<u8>>) -> IdeResult<()> {
match content {
Some(bytes) => {
if let Some(parent) = path.parent() {
@@ -646,6 +651,187 @@ pub(crate) fn restore(
Ok(())
}
/// The bytes of the copy of `rel` saved in `dir`, if there is one.
pub(crate) fn saved_copy(dir: &Path, rel: &str) -> Option<Vec<u8>> {
std::fs::read(dir.join(saved_name(rel))).ok()
}
/// The checkout as the task's last turn started: what that turn's changes are compared with
/// and rolled back to. Recorded like the task's own start: `HEAD`, the files already changed,
/// and copies of those.
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct TurnStart {
/// `HEAD` then (`None` outside a repository or before its first commit).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub head: Option<String>,
/// The files already changed then, stamped.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub before: BTreeMap<String, Stamp>,
/// The files among `before` with a copy in the task's turn folder.
#[serde(default, skip_serializing_if = "BTreeSet::is_empty")]
pub saved: BTreeSet<String>,
/// The files that changed while the turn ran, recorded as it ended (`None` while it runs).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub changed: Option<BTreeSet<String>>,
}
/// Records the checkout at `cwd` as a turn starts, with copies of its changed files in `dir`.
/// The copies `previous` saved of files unchanged since are kept rather than made again, so
/// starting a turn copies little more than what the turn before it changed.
pub(crate) fn start_turn(cwd: &Path, dir: &Path, previous: Option<&TurnStart>) -> IdeResult<TurnStart> {
let Some(repo) = discover(cwd)? else { return Ok(TurnStart::default()) };
let head = repo.head()?.1;
// As the turn's end is read, so the two compare.
let before = snapshot(cwd)?;
let mut saved = BTreeSet::new();
match previous {
Some(previous) => {
for rel in &previous.saved {
let unchanged =
before.get(rel).is_some_and(|now| now.is_some() && previous.before.get(rel) == Some(now));
if unchanged {
saved.insert(rel.clone());
} else {
let _ = std::fs::remove_file(dir.join(saved_name(rel)));
}
}
}
None => {
let _ = std::fs::remove_dir_all(dir);
}
}
for (rel, stamp) in &before {
let path = repo.root().join(rel);
if stamp.is_none()
|| saved.contains(rel)
|| !std::fs::metadata(&path).is_ok_and(|m| m.is_file() && m.len() <= SAVED_MAX)
{
continue;
}
std::fs::create_dir_all(dir)?;
// One that can't be copied is listed but can't be rolled back, as a large one.
if std::fs::copy(&path, dir.join(saved_name(rel))).is_ok() {
saved.insert(rel.clone());
}
}
Ok(TurnStart { head, before, saved, changed: None })
}
/// The files that changed in `cwd` since the turn `start` began: in the working tree (as
/// `changed_between` sees them), and in the commits made since.
pub(crate) fn changed_in_turn(cwd: &Path, start: &TurnStart) -> IdeResult<(Vec<String>, BTreeSet<String>)> {
let end = snapshot(cwd)?;
let worktree = changed_between(&start.before, &end);
let mut all: BTreeSet<String> = worktree.iter().cloned().collect();
if let Some(repo) = discover(cwd)?
&& let (Some(from), Some(to)) = (&start.head, repo.head()?.1)
&& *from != to
{
for f in repo.diff_revisions(from, &to)? {
all.extend(f.old_path);
all.insert(f.path);
}
}
Ok((worktree, all))
}
/// The content of `rel` as the turn `start` began (`None`: no file), its copies in `dir`.
fn at_turn_start(repo: &Repo, rel: &str, start: &TurnStart, dir: &Path) -> IdeResult<Option<Vec<u8>>> {
match start.before.get(rel) {
Some(None) => Ok(None),
Some(Some(_)) => match start.saved.contains(rel).then(|| saved_copy(dir, rel)).flatten() {
Some(bytes) => Ok(Some(bytes)),
None => Err(IdeError::invalid(format!(
"{rel} had changes when the turn started that weren't saved; roll it back in Git instead"
))),
},
None => match &start.head {
Some(head) => repo.file_bytes_at(&repo.root().join(rel), Some(head)),
None => Ok(None),
},
}
}
/// Added and removed lines from `old` to `new`; none for binary content.
fn line_stats(old: Option<&[u8]>, new: Option<&[u8]>) -> (u32, u32) {
if [old, new].iter().flatten().any(|b| b.contains(&0)) {
return (0, 0);
}
let text = |b: Option<&[u8]>| b.map(|b| String::from_utf8_lossy(b).into_owned()).unwrap_or_default();
ide_vcs::diff_hunks(&text(old), &text(new))
.iter()
.fold((0, 0), |(added, removed), h| (added + h.lines, removed + h.old_lines))
}
/// The files among `changed` that differ from how they were as the turn `start` began.
pub(crate) fn turn_changes(
cwd: &Path,
start: &TurnStart,
dir: &Path,
changed: &BTreeSet<String>,
) -> IdeResult<Vec<AgentChange>> {
let Some(repo) = discover(cwd)? else { return Ok(Vec::new()) };
let mut out = Vec::new();
for rel in changed {
let path = repo.root().join(rel);
// A folder (a submodule, say) or a file that can't be read has nothing to compare.
let Some(now) = existing(&path) else { continue };
let (kind, (added, removed)) = match at_turn_start(&repo, rel, start, dir) {
Ok(then) if then == now => continue,
Ok(then) => {
let kind = match (&then, &now) {
(None, _) => ChangeKind::Added,
(_, None) => ChangeKind::Deleted,
_ => ChangeKind::Modified,
};
(kind, line_stats(then.as_deref(), now.as_deref()))
}
// Its start wasn't saved: listed, without counts.
Err(_) => (ChangeKind::Modified, (0, 0)),
};
out.push(AgentChange { path: IpcPath(path), rel_path: rel.clone(), kind, added, removed, old_path: None });
}
Ok(out)
}
/// The text of `path` as the turn `start` began, `None` when there was no file.
pub(crate) fn turn_text(cwd: &Path, path: &Path, start: &TurnStart, dir: &Path) -> IdeResult<Option<String>> {
let Some(repo) = discover(cwd)? else { return Ok(None) };
let rel = rel_in(repo.root(), path)?;
if let (None, Some(head)) = (start.before.get(&rel), &start.head) {
return file_at(cwd, path, head);
}
let Some(bytes) = at_turn_start(&repo, &rel, start, dir)? else { return Ok(None) };
let encoding = match ide_vfs::load_text(path) {
Ok(loaded) => encoding_rs::Encoding::for_label(loaded.encoding.as_bytes()).unwrap_or(encoding_rs::UTF_8),
Err(_) => ide_vfs::detect_encoding(&bytes, None),
};
Ok(Some(encoding.decode(&bytes).0.into_owned()))
}
/// `path` relative to the repository at `root`, with `/` separators.
fn rel_in(root: &Path, path: &Path) -> IdeResult<String> {
let rel = path
.strip_prefix(root)
.map(Path::to_path_buf)
.ok()
.or_else(|| {
// Another spelling of the same place (a link, `/var` and `/private/var`); the file may be gone.
let root = dunce::canonicalize(root).ok()?;
let parent = dunce::canonicalize(path.parent()?).ok()?;
Some(parent.strip_prefix(&root).ok()?.join(path.file_name()?))
})
.ok_or_else(|| IdeError::invalid(format!("{} is outside the repository", path.display())))?;
Ok(rel.components().map(|c| c.as_os_str().to_string_lossy()).collect::<Vec<_>>().join("/"))
}
/// Puts `change` back as it was when the turn `start` began.
pub(crate) fn restore_turn(cwd: &Path, start: &TurnStart, dir: &Path, change: &AgentChange) -> IdeResult<()> {
let repo = repo_at(cwd)?;
put(&change.path.0, at_turn_start(&repo, &change.rel_path, start, dir)?)
}
pub(crate) fn file_at(cwd: &Path, path: &Path, rev: &str) -> IdeResult<Option<String>> {
let Some(repo) = discover(cwd)? else { return Ok(None) };
let encoding = match ide_vfs::load_text(path) {
@@ -815,6 +1001,67 @@ mod tests {
assert!(!created.path.exists());
}
#[test]
fn a_turn_copies_only_what_changed_since_the_last_one() {
let tmp = tempfile::tempdir().unwrap();
let repo = tmp.path().join("repo");
std::fs::create_dir(&repo).unwrap();
git(&repo, &["init", "-q", "-b", "main"]);
std::fs::write(repo.join("a.txt"), "base\n").unwrap();
git(&repo, &["add", "."]);
git(&repo, &["commit", "-q", "-m", "init"]);
let dir = tmp.path().join("turn");
let set = |names: &[&str]| names.iter().map(|n| (*n).to_owned()).collect::<BTreeSet<_>>();
std::fs::write(repo.join("a.txt"), "turn 1\n").unwrap();
std::fs::write(repo.join("b.txt"), "b\n").unwrap();
let first = start_turn(&repo, &dir, None).unwrap();
assert_eq!(first.saved, set(&["a.txt", "b.txt"]));
// A copy made again would replace this mark.
std::fs::write(dir.join(saved_name("b.txt")), "kept\n").unwrap();
std::thread::sleep(std::time::Duration::from_millis(10));
std::fs::write(repo.join("a.txt"), "turn two\n").unwrap();
let second = start_turn(&repo, &dir, Some(&first)).unwrap();
assert_eq!(second.saved, set(&["a.txt", "b.txt"]));
assert_eq!(saved_copy(&dir, "a.txt").as_deref(), Some(&b"turn two\n"[..]));
assert_eq!(saved_copy(&dir, "b.txt").as_deref(), Some(&b"kept\n"[..]));
// Back as committed: nothing to keep a copy of.
git(&repo, &["checkout", "--", "a.txt"]);
let third = start_turn(&repo, &dir, Some(&second)).unwrap();
assert_eq!(third.saved, set(&["b.txt"]));
assert_eq!(saved_copy(&dir, "a.txt"), None);
// Without a record of the last turn (a task from before), every copy is made afresh.
let fresh = start_turn(&repo, &dir, None).unwrap();
assert_eq!(fresh.saved, set(&["b.txt"]));
assert_eq!(saved_copy(&dir, "b.txt").as_deref(), Some(&b"b\n"[..]));
}
#[cfg(unix)]
#[test]
fn a_turns_start_is_found_through_another_spelling_of_the_checkout() {
let tmp = tempfile::tempdir().unwrap();
let repo = dunce::canonicalize(tmp.path()).unwrap().join("repo");
std::fs::create_dir(&repo).unwrap();
git(&repo, &["init", "-q", "-b", "main"]);
std::fs::write(repo.join("a.txt"), "base\n").unwrap();
git(&repo, &["add", "."]);
git(&repo, &["commit", "-q", "-m", "init"]);
std::fs::write(repo.join("a.txt"), "turn 1\n").unwrap();
let dir = tmp.path().join("turn");
let start = start_turn(&repo, &dir, None).unwrap();
std::fs::write(repo.join("a.txt"), "turn 2\n").unwrap();
std::fs::write(repo.join("new.txt"), "new\n").unwrap();
let link = tmp.path().join("link");
std::os::unix::fs::symlink(&repo, &link).unwrap();
for at in [&repo, &link] {
assert_eq!(turn_text(&repo, &at.join("a.txt"), &start, &dir).unwrap().as_deref(), Some("turn 1\n"));
assert_eq!(turn_text(&repo, &at.join("new.txt"), &start, &dir).unwrap(), None);
}
assert!(turn_text(&repo, &tmp.path().join("elsewhere.txt"), &start, &dir).is_err());
}
#[test]
fn commits_since_the_base_are_listed_with_their_files() {
let tmp = tempfile::tempdir().unwrap();
+23 -6
Переглянути файл
@@ -120,7 +120,7 @@ fn collect(
break;
}
}
let program = process::program_path(&step.program, &step.env);
let program = process::program_path(&step.program, &step.env, &step.cwd);
inputs.push(program.clone());
// Maven installed via a symlink still reads conf from its distribution.
if let Ok(program) = dunce::canonicalize(program)
@@ -131,7 +131,7 @@ fn collect(
}
}
if !environment.contains_key("JAVA_HOME") {
let java = process::program_path(if cfg!(windows) { "java.exe" } else { "java" }, &step.env);
let java = process::program_path(if cfg!(windows) { "java.exe" } else { "java" }, &step.env, &step.cwd);
inputs.push(java.clone());
if let Ok(java) = dunce::canonicalize(java)
&& let Some(home) = java.parent().and_then(Path::parent)
@@ -171,7 +171,7 @@ fn collect(
let steps = plan
.steps
.iter()
.map(|s| (process::program_path(&s.program, &s.env), s.args.clone(), s.cwd.clone(), s.env.clone()))
.map(|s| (process::program_path(&s.program, &s.env, &s.cwd), s.args.clone(), s.cwd.clone(), s.env.clone()))
.collect();
// Profiles and plugins can read arbitrary environment variables. Keep a signature
// of the inherited environment without persisting unrelated credentials.
@@ -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> {
+189 -43
Переглянути файл
@@ -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) {
@@ -536,7 +552,9 @@ impl PathMap {
let abs = if p.is_absolute() {
p.to_path_buf()
} else {
let in_base = base.map(|b| Path::new(b).join(p)).filter(|c| c.exists());
// rustc prints workspace members' files relative to the workspace root, above
// the member's manifest directory (`base`) when a member is built on its own.
let in_base = base.and_then(|b| Path::new(b).ancestors().map(|a| a.join(p)).find(|c| c.exists()));
in_base.unwrap_or_else(|| cwd.join(p))
};
let abs = normalize(&abs);
@@ -713,7 +731,7 @@ pub fn run(
}
}
};
let out = process::run(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
let out = process::run_bounded(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
let parsed = parser.feed(line);
match parsed.console {
Some(text) if text.is_empty() => {}
@@ -755,7 +773,7 @@ pub fn run(
if !out.success {
success = false;
if !messages.iter().any(|m| m.severity == Severity::Error) {
let summary = crate::sync::error_summary(&out.text);
let summary = crate::sync::error_summary(&out);
let text = if summary.is_empty() { last_error_line.clone() } else { summary };
let m = BuildMessage { severity: Severity::Error, text, path: None, range: None, code: None };
on_event(BuildEvent::Message { message: m.clone() });
@@ -879,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() {
@@ -907,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
@@ -972,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)
@@ -998,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"]) {
@@ -1013,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]
@@ -1047,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"));
@@ -1064,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]
@@ -1090,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::*;
@@ -1142,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,
@@ -1163,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);
@@ -1171,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,
[
@@ -1193,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);
@@ -1218,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()][..])
@@ -1233,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),
@@ -1258,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"],
@@ -1270,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<_>>(),
@@ -1289,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]
@@ -1303,6 +1430,22 @@ mod tests {
assert_eq!(identifier_len("x é_1 c", 2), 3);
}
#[test]
fn resolves_a_member_build_s_workspace_relative_paths() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().to_path_buf();
write(&root, "client/src/main.rs", "fn main() {}\n");
write(&root, "client/src/lib.rs", "\n");
write(&root, "src/lib.rs", "\n");
let map = PathMap { root: root.clone(), canonical: None };
let member = root.join("client");
let base = member.to_str();
// Build Module runs in the member; rustc names its files from the workspace root.
assert_eq!(map.resolve("client/src/main.rs", &member, base), root.join("client/src/main.rs"));
// A crate built from its own directory names them from there.
assert_eq!(map.resolve("src/lib.rs", &member, base), member.join("src/lib.rs"));
}
// Uses Unix absolute paths for the canonical root.
#[cfg(unix)]
#[test]
@@ -1472,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");
@@ -1493,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"));
}
}
+84 -17
Переглянути файл
@@ -10,11 +10,14 @@ use std::process::Command as ProcCommand;
/// Output file of the `dependency:build-classpath` probe, relative to each module.
const CP_FILE: &str = "target/ide-compile-cp.txt";
// Older records include undeclared reactor test outputs even in runtime classpaths.
const CLASSPATH_CACHE_VERSION: u32 = 1;
/// The resolved dependency classpath for one module and scope, tied to the same
/// inputs as its launch build so POM, JDK, settings and profile changes invalidate it.
#[derive(Debug, Deserialize, Serialize)]
struct CachedClasspath {
version: u32,
fingerprint: LaunchFingerprint,
classpath: String,
}
@@ -132,6 +135,7 @@ pub fn module_classpath(
if let (Some(fingerprint), Some(path)) = (&fingerprint, &cache_path)
&& let Ok(bytes) = fs::read(path)
&& let Ok(cached) = serde_json::from_slice::<CachedClasspath>(&bytes)
&& cached.version == CLASSPATH_CACHE_VERSION
&& cached.fingerprint == *fingerprint
&& classpath_entries_exist(root, &cached.classpath)
{
@@ -142,7 +146,7 @@ pub fn module_classpath(
return Err(IdeError::cancelled());
}
if let (Some(fingerprint), Some(path)) = (fingerprint, cache_path) {
let cached = CachedClasspath { fingerprint, classpath: classpath.clone() };
let cached = CachedClasspath { version: CLASSPATH_CACHE_VERSION, fingerprint, classpath: classpath.clone() };
if let Err(error) = cache_classpath(&path, &cached) {
tracing::debug!(path = %path.display(), %error, "Cannot cache the Java launch classpath");
}
@@ -208,11 +212,11 @@ fn classpath(
if dir == target.module {
continue;
}
for classes in ["target/classes", "target/test-classes"] {
let path = dir.join(classes);
if path.is_dir() {
entries.push(path.to_string_lossy().into_owned());
}
// A dependency's tests are not exported with its main artifact. Any explicitly
// declared test artifact is supplied by Maven's resolved classpath below.
let path = dir.join("target/classes");
if path.is_dir() {
entries.push(path.to_string_lossy().into_owned());
}
}
}
@@ -232,10 +236,9 @@ fn classpath(
}
args.extend(["dependency:build-classpath", output_arg.as_str(), scope_arg.as_str(), "-q"]);
let top_dir = subdir(root, &target.top.dir);
let status = ProcCommand::new(&target.top.command)
.args(&args)
.envs(&target.top.env)
.current_dir(&top_dir)
let mut command = ProcCommand::new(&target.top.command);
command.args(&args).envs(&target.top.env).current_dir(&top_dir);
let status = ide_core::process::prepare(&mut command)
.output()
.map_err(|e| IdeError::internal(format!("cannot resolve the compile classpath: {e}")))?;
if !status.status.success() {
@@ -337,13 +340,19 @@ mod tests {
root,
"pom.xml",
r#"<project><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version>
<packaging>pom</packaging><modules><module>lib</module><module>app</module></modules></project>"#,
<packaging>pom</packaging><modules><module>shared</module><module>lib</module><module>app</module></modules></project>"#,
);
write(
root,
"lib/pom.xml",
r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>
<artifactId>lib</artifactId></project>"#,
<artifactId>lib</artifactId><dependencies><dependency><groupId>demo</groupId><artifactId>shared</artifactId><version>1</version></dependency></dependencies></project>"#,
);
write(
root,
"shared/pom.xml",
r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>
<artifactId>shared</artifactId></project>"#,
);
write(
root,
@@ -354,6 +363,7 @@ mod tests {
write(root, "app/src/main/java/demo/Main.java", "class Main {}");
write(root, "app/src/test/java/demo/MainTest.java", "class MainTest {}");
write(root, "lib/target/classes/Lib.class", "built");
write(root, "shared/target/classes/Shared.class", "built");
crate::load(root, &root.join("cache"), None)
}
@@ -436,7 +446,9 @@ mod tests {
let target = single_file_target(root, &model, &file).unwrap();
assert!(target.top.command.ends_with("mvnw"));
assert_eq!(target.pl, "app");
fs::create_dir_all(root.join("lib/target/test-classes")).unwrap();
let cp = single_file_classpath(root, &model, &target).unwrap();
assert!(!std::env::split_paths(&cp).any(|p| p == root.join("lib/target/test-classes")), "{cp}");
let separator = ':';
// Reactor class directories first, so fresh outputs shadow installed snapshots.
let lib = root.join("lib/target/classes").to_string_lossy().into_owned();
@@ -451,9 +463,16 @@ mod tests {
assert!(cp.split(separator).count() >= 3, "{cp}");
let args = fs::read_to_string(root.join("args.txt")).unwrap();
assert!(!args.lines().any(|a| a == "compile" || a == "package"), "{args}");
fs::create_dir_all(root.join("app/target/test-classes")).unwrap();
let target = single_file_target(root, &model, &root.join("app/src/test/java/demo/MainTest.java")).unwrap();
let cp = single_file_classpath(root, &model, &target).unwrap();
let paths: Vec<_> = std::env::split_paths(&cp).collect();
assert_eq!(paths[0], root.join("app/target/test-classes"));
assert!(paths.contains(&root.join("app/target/classes")), "{cp}");
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{cp}");
}
/// A launch uses runtime dependencies, while tests additionally see test-scope ones.
/// Launches request Maven's matching scope without adding reactor test outputs.
#[cfg(unix)]
#[test]
fn launch_module_classpath_uses_the_matching_dependency_scope() {
@@ -465,15 +484,29 @@ mod tests {
let script = root.join("mvnw");
fs::write(
&script,
"#!/bin/sh\nprintf '%s\\n' \"$@\" > args.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/runtime.jar:/repo/test.jar' > \"$pl/target/ide-compile-cp.txt\"\n",
"#!/bin/sh\nprintf '%s\\n' \"$@\" > args.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/runtime.jar:/repo/fixture-tests.jar:/repo/fixture/target/test-classes' > \"$pl/target/ide-compile-cp.txt\"\n",
)
.unwrap();
fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
let model = crate::load(root, &root.join("cache"), None);
for dir in
["app/target/classes", "app/target/test-classes", "lib/target/test-classes", "shared/target/test-classes"]
{
fs::create_dir_all(root.join(dir)).unwrap();
}
let cache = root.join("cache");
let runtime =
module_classpath(root, &model, &root.join("app"), false, None, &cache, &CancellationToken::new()).unwrap();
let paths: Vec<_> = std::env::split_paths(&runtime).collect();
assert!(paths.contains(&root.join("app/target/classes")), "{runtime}");
assert!(paths.contains(&root.join("lib/target/classes")), "{runtime}");
assert!(!paths.contains(&root.join("app/target/test-classes")), "{runtime}");
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{runtime}");
assert!(paths.contains(&root.join("shared/target/classes")), "{runtime}");
assert!(!paths.contains(&root.join("shared/target/test-classes")), "{runtime}");
assert!(paths.contains(&PathBuf::from("/repo/fixture-tests.jar")), "{runtime}");
assert!(paths.contains(&PathBuf::from("/repo/fixture/target/test-classes")), "{runtime}");
assert!(runtime.contains("/repo/runtime.jar"), "{runtime}");
let args = fs::read_to_string(root.join("args.txt")).unwrap();
assert!(args.lines().any(|a| a == "compile"), "{args}");
@@ -482,7 +515,15 @@ mod tests {
let test =
module_classpath(root, &model, &root.join("app"), true, None, &cache, &CancellationToken::new()).unwrap();
assert!(test.contains("/repo/test.jar"), "{test}");
assert!(test.contains("/repo/fixture-tests.jar"), "{test}");
let paths: Vec<_> = std::env::split_paths(&test).collect();
assert!(paths.contains(&root.join("app/target/test-classes")), "{test}");
assert!(paths.contains(&root.join("app/target/classes")), "{test}");
assert!(paths.contains(&root.join("lib/target/classes")), "{test}");
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{test}");
assert!(paths.contains(&root.join("shared/target/classes")), "{test}");
assert!(!paths.contains(&root.join("shared/target/test-classes")), "{test}");
assert!(paths.contains(&PathBuf::from("/repo/fixture/target/test-classes")), "{test}");
let args = fs::read_to_string(root.join("args.txt")).unwrap();
assert!(args.lines().any(|a| a == "-Dmdep.includeScope=test"), "{args}");
}
@@ -491,7 +532,7 @@ mod tests {
/// build input changes; the probe does not run packaging plugins.
#[cfg(unix)]
#[test]
fn launch_classpath_cache_follows_the_runner_jdk() {
fn launch_classpath_cache_follows_the_runner_jdk_and_format() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().unwrap();
@@ -513,6 +554,7 @@ mod tests {
fs::write(home.join("release"), format!("JAVA_VERSION=\"{version}\"\n")).unwrap();
fs::write(home.join("bin/java"), "").unwrap();
}
fs::create_dir_all(root.join("app/target/classes")).unwrap();
let cache = root.join("classpath-cache");
let cancel = CancellationToken::new();
let jdk21 = root.join("jdk21");
@@ -526,6 +568,30 @@ mod tests {
assert_eq!(second, first);
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), "x");
let record = classpath_cache_path(root, &cache, &root.join("app"), false).unwrap();
let current: serde_json::Value = serde_json::from_slice(&fs::read(&record).unwrap()).unwrap();
let test_output = root.join("lib/target/test-classes");
fs::create_dir_all(&test_output).unwrap();
let polluted = std::env::join_paths(std::env::split_paths(&first).chain([test_output])).unwrap();
let mut calls = "x".to_owned();
for version in [None, Some(0), Some(u32::MAX)] {
let mut stale = current.clone();
stale["classpath"] = polluted.to_string_lossy().as_ref().into();
if let Some(version) = version {
stale["version"] = version.into();
} else {
stale.as_object_mut().unwrap().remove("version");
}
fs::write(&record, serde_json::to_vec(&stale).unwrap()).unwrap();
let rebuilt = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
assert_eq!(rebuilt, first, "incompatible cache format {version:?} must be rebuilt");
calls.push('x');
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
let reused = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
assert_eq!(reused, rebuilt);
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
}
let jdk8 = root.join("jdk8");
for project in &mut model.maven.as_mut().unwrap().projects {
project.env.insert("JAVA_HOME".into(), jdk8.to_string_lossy().into_owned());
@@ -533,6 +599,7 @@ mod tests {
let switched = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
assert!(switched.contains("jdk8/classpath/jdk.jar"), "{switched}");
assert!(!switched.contains("jdk21/classpath/jdk.jar"), "{switched}");
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), "xx");
calls.push('x');
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
}
}
+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);
+1
Переглянути файл
@@ -30,6 +30,7 @@ def processedResources = { Project p, s ->
def describe = { Project p ->
def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
if (p.gradle.parent != null) m.build = identity(p.rootProject)
m.resolvableConfigurations = p.configurations.findAll { it.canBeResolved }.collect { it.name }.sort()
// Gradle 4.x has it as a convention property, not an extension.
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
if (sets != null) {
+19
Переглянути файл
@@ -41,6 +41,10 @@ pub struct GradleProject {
/// Project-relative build script, if any.
pub build_file: Option<String>,
pub tasks: Vec<GradleTask>,
/// Configurations Gradle can resolve, or null before Gradle reports the project.
#[serde(default)]
#[specta(optional)]
pub resolvable_configurations: Option<Vec<String>>,
/// Identity path of the nested build holding the project (`:lib` for `includeBuild`,
/// `:buildSrc`); null for the opened build.
#[serde(default)]
@@ -301,6 +305,7 @@ fn project_at(root: &Path, path: String, name: String, pdir: &Path) -> GradlePro
path,
name,
tasks,
resolvable_configurations: None,
build: None,
}
}
@@ -317,6 +322,8 @@ pub struct ReportedProject {
pub build_dir: Option<String>,
#[serde(default)]
pub source_sets: Vec<ReportedSourceSet>,
#[serde(default)]
pub resolvable_configurations: Option<Vec<String>>,
/// Toolchain language version, else target compatibility.
#[serde(default)]
pub java: Option<u32>,
@@ -412,6 +419,7 @@ pub fn merge_reported_projects(root: &Path, model: &mut GradleModel, reported: &
if p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc")) {
project.tasks.clear();
}
project.resolvable_configurations = p.resolvable_configurations.clone();
project.build = p.build.clone();
project
})
@@ -1630,6 +1638,11 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
path: path.into(),
dir: ws.join(d).to_string_lossy().into_owned(),
build: build.map(Into::into),
resolvable_configurations: match path {
":" => Some(vec!["reviewTools".into(), "runtimeClasspath".into()]),
":lib:core" => Some(Vec::new()),
_ => None,
},
..ReportedProject::default()
};
format!("{MODEL_LINE}{}\n", serde_json::to_string(&project).unwrap())
@@ -1658,6 +1671,12 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
);
let build_src = &model.projects[2];
assert!(build_src.tasks.is_empty(), "buildSrc tasks cannot run from the root build");
assert_eq!(
model.projects[0].resolvable_configurations,
Some(vec!["reviewTools".into(), "runtimeClasspath".into()])
);
assert_eq!(model.projects[1].resolvable_configurations, None);
assert_eq!(model.projects[4].resolvable_configurations, Some(Vec::new()));
assert!(!model.projects[4].tasks.is_empty());
assert!(build_files(&root, &model).contains(&ws.join("lib/settings.gradle")));
}
+8 -5
Переглянути файл
@@ -135,7 +135,7 @@ pub fn gradle_dependencies(
configuration: &str,
cancel: &CancellationToken,
) -> IdeResult<Vec<GradleDependency>> {
if !configuration.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-') || configuration.is_empty() {
if configuration.is_empty() || !configuration.chars().all(|c| c.is_alphanumeric() || matches!(c, '_' | '-' | '.')) {
return Err(IdeError::invalid(format!("not a configuration name: {configuration}")));
}
if !project.starts_with(':') || project.chars().any(char::is_whitespace) {
@@ -143,7 +143,7 @@ pub fn gradle_dependencies(
}
let task = if project == ":" { ":dependencies".to_owned() } else { format!("{project}:dependencies") };
let mut args: Vec<String> =
vec!["--console=plain".into(), "-q".into(), task, "--configuration".into(), configuration.into()];
vec!["--console=plain".into(), "-q".into(), task, format!("--configuration={configuration}")];
if options.offline {
args.push("--offline".into());
}
@@ -156,7 +156,10 @@ pub fn gradle_dependencies(
|_, _| {},
)?;
if !out.success {
return Err(IdeError::unavailable(error_summary(&out.text)));
return Err(IdeError::unavailable(error_summary(&out)));
}
if let Some(note) = sync::truncation_note(&out) {
return Err(IdeError::unavailable(note));
}
Ok(parse_report(&out.text))
}
@@ -337,14 +340,14 @@ runtimeClasspath - Runtime classpath of source set 'main'.
&gradle::load(root).unwrap(),
&options,
":app",
"testRuntimeClasspath",
"review.tools",
&CancellationToken::new(),
)
.unwrap();
assert_eq!(tree, vec![dep("org.a", "b", Some("1.0"))]);
assert_eq!(
std::fs::read_to_string(root.join("args")).unwrap().trim(),
"--console=plain -q :app:dependencies --configuration testRuntimeClasspath --offline"
"--console=plain -q :app:dependencies --configuration=review.tools --offline"
);
}
}
+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]
+4 -1
Переглянути файл
@@ -13,6 +13,8 @@ pub mod kotlin_bridge;
pub mod maven;
pub mod pom_edit;
mod process;
#[cfg(test)]
mod process_numbers;
pub mod sbt;
mod sync;
pub mod web;
@@ -23,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};
+29 -6
Переглянути файл
@@ -1241,10 +1241,13 @@ fn file_stamp(path: &Path) -> FileStamp {
std::fs::metadata(path).ok().map(|m| (m.modified().ok(), m.len()))
}
/// The POM files a reactor walk read or looked for, and the module folders it found outside the root.
/// The POM files a reactor walk read or looked for, the module folders it found outside the
/// root, and the folders of every project in the reactor (canonical, the root's first).
#[derive(Clone)]
struct ReactorScan {
stamps: Vec<(PathBuf, FileStamp)>,
dirs: Vec<PathBuf>,
members: Vec<PathBuf>,
}
/// Folders of the modules that the reactor of `root/pom.xml` lists outside `root`
@@ -1254,18 +1257,28 @@ struct ReactorScan {
/// Callers keep the outermost directory only. Memoized on the POMs' modification times and
/// sizes: content roots are read on hot paths (every references search, Find in Files).
pub fn reactor_external_dirs(root: &Path, profiles: &[String], unlinked: &[String]) -> Vec<PathBuf> {
reactor(root, profiles, unlinked).dirs
}
/// Folders of every project in the reactor of `root/pom.xml` (canonical): `root` itself and its
/// modules, theirs in turn, including those of the active `profiles`. A POM elsewhere below `root`
/// that no `<module>` reaches is a separate build.
pub fn reactor_member_dirs(root: &Path, profiles: &[String]) -> Vec<PathBuf> {
reactor(root, profiles, &[]).members
}
fn reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> ReactorScan {
type Memo = HashMap<(PathBuf, Vec<String>, Vec<String>), ReactorScan>;
static MEMO: std::sync::LazyLock<Mutex<Memo>> = std::sync::LazyLock::new(Default::default);
let key = (root.to_path_buf(), profiles.to_vec(), unlinked.to_vec());
if let Some(scan) = MEMO.lock().unwrap_or_else(|e| e.into_inner()).get(&key)
&& scan.stamps.iter().all(|(path, stamp)| file_stamp(path) == *stamp)
{
return scan.dirs.clone();
return scan.clone();
}
let scan = scan_reactor(root, profiles, unlinked);
let dirs = scan.dirs.clone();
MEMO.lock().unwrap_or_else(|e| e.into_inner()).insert(key, scan);
dirs
MEMO.lock().unwrap_or_else(|e| e.into_inner()).insert(key, scan.clone());
scan
}
/// Reads only the POMs the reactor lists (no parent resolution and no directory walk).
@@ -1274,7 +1287,8 @@ fn scan_reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> Reacto
let chosen = Resolver::new(None, profiles);
let unlinked: HashSet<String> = unlinked.iter().map(|p| normalized_pom(p.trim())).collect();
let first = root.join("pom.xml");
let mut scan = ReactorScan { stamps: vec![(first.clone(), file_stamp(&first))], dirs: Vec::new() };
let mut scan =
ReactorScan { stamps: vec![(first.clone(), file_stamp(&first))], dirs: Vec::new(), members: Vec::new() };
let mut seen: HashSet<PathBuf> = HashSet::new();
let mut pending = vec![first];
while let Some(path) = pending.pop() {
@@ -1288,6 +1302,7 @@ fn scan_reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> Reacto
let Some(pom) = xml::read_text(&path).as_deref().and_then(parse_pom) else { continue };
let dir = path.parent().unwrap_or(root).to_path_buf();
let dir_canon = dunce::canonicalize(&dir).unwrap_or_else(|_| dir.clone());
scan.members.push(dir_canon.clone());
if !dir_canon.starts_with(&canonical_root) {
if canonical_root.starts_with(&dir_canon) {
continue;
@@ -1860,6 +1875,14 @@ pub fn goto_declaration(text: &str, path: &Path, pos: Pos, local_repo: Option<Pa
goto_declaration_in(text, path, pos, local_repo, Vec::new)
}
/// The declaration of the property `name` in the pom at `path`, for files it configures
/// outside the pom itself (a YAML resource's `@name@`): the first `<properties>` entry
/// along the parent chain declaring it, `project.*` built-ins included.
pub fn property_declaration(pom: &Path, name: &str, local_repo: Option<PathBuf>) -> Option<PomGoto> {
let text = xml::read_text(pom)?;
property_target(&text, pom, name, local_repo)
}
/// [`goto_declaration`], where a `<parent>` and a dependency or plugin whose version no
/// management entry provides (or a management entry itself) go to the artifact's own
/// POM: the project module among `modules` with its coordinates, else the local
+349 -24
Переглянути файл
@@ -17,16 +17,79 @@ pub(crate) enum Stream {
Stderr,
}
/// A single line longer than this without a newline is delivered as several lines: the pump
/// buffer stays bounded whatever the child prints (progress bars, minified bundles, binary
/// output), and every byte still arrives.
pub(crate) const MAX_LINE_BYTES: usize = 1024 * 1024;
/// `Output::text` stops growing past this while the pipes keep draining: a chatty build can
/// print far more than is ever parsed back out of the retained copy.
pub(crate) const MAX_TEXT_BYTES: usize = 32 * 1024 * 1024;
pub(crate) struct Output {
pub success: bool,
/// Every line, stdout and stderr interleaved as received.
/// Every line, stdout and stderr interleaved as received, up to [`MAX_TEXT_BYTES`].
pub text: String,
/// More output followed the retained `text`; the lines were still fed to `on_line`.
pub truncated: bool,
}
/// Bounded pump for callers that stream every line and only summarize errors: reads fixed
/// 64 KiB chunks, splits newline-free runs at a UTF-8 char boundary at the line cap, and
/// never grows one line buffer without bound.
fn pump_bounded(stream: Box<dyn Read + Send>, kind: Stream, tx: &mpsc::Sender<(Stream, String)>) {
let mut reader = BufReader::new(stream);
// `terminated`: the buffer ends in the stream's newline. A segment cut from a
// newline-free run at the line cap must keep a trailing `\r` — it is data.
let send = |buf: &mut Vec<u8>, terminated: bool, tx: &mpsc::Sender<(Stream, String)>| {
let line = ide_core::output_encoding::decode_tool_output(buf);
let line = if terminated { line.trim_end_matches(['\n', '\r']).to_owned() } else { line };
buf.clear();
tx.send((kind, line)).is_ok()
};
let mut chunk = vec![0u8; 64 * 1024];
let mut line: Vec<u8> = Vec::with_capacity(256);
'read: loop {
let n = match reader.read(&mut chunk) {
Ok(0) | Err(_) => break,
Ok(n) => n,
};
let mut start = 0;
for (i, &b) in chunk[..n].iter().enumerate() {
if b == b'\n' {
line.extend_from_slice(&chunk[start..=i]);
if !send(&mut line, true, tx) {
break 'read;
}
start = i + 1;
}
}
line.extend_from_slice(&chunk[start..n]);
while line.len() > MAX_LINE_BYTES {
let mut at = MAX_LINE_BYTES;
while at > 0 && line[at] & 0xC0 == 0x80 {
at -= 1;
}
// Malformed input with no boundary at all: split raw and let decoding say so.
if at == 0 {
at = MAX_LINE_BYTES;
}
let rest = line.split_off(at);
if !send(&mut line, false, tx) {
break 'read;
}
line = rest;
}
}
if !line.is_empty() {
send(&mut line, true, tx);
}
}
/// `program` as spawnable: a bare name (`mvn`, `mvn.cmd`) resolves on the IDE's
/// search path — the login shell's `PATH` plus version-manager shims — since the
/// app's own `PATH` can be minimal and `Command` would not see `mvn` there.
pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>) -> std::path::PathBuf {
/// app's own `PATH` can be minimal and `Command` would not see `mvn` there. The `PATH`
/// of the project holding `cwd` (its direnv `.envrc`) comes first.
pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>, cwd: &Path) -> std::path::PathBuf {
let path = std::path::Path::new(program);
if !path.is_relative() || path.components().count() > 1 {
return path.to_path_buf();
@@ -35,12 +98,13 @@ pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>) -> std
.iter()
.find(|(k, _)| k.eq_ignore_ascii_case("PATH"))
.map(|(_, v)| std::ffi::OsString::from(v))
.unwrap_or_else(ide_core::tool_path::search_path);
.unwrap_or_else(|| ide_core::tool_path::search_path_in(cwd));
ide_core::process::find_executable(program, &search).unwrap_or_else(|| path.to_path_buf())
}
/// Runs `program args` in `cwd`, feeding each output line to `on_line`; kills
/// the process group and returns `cancelled` when `cancel` fires.
/// the process group and returns `cancelled` when `cancel` fires. `Output.text`
/// keeps every line: callers that parse a complete model from it use this.
pub(crate) fn run(
program: &str,
args: &[String],
@@ -52,6 +116,20 @@ pub(crate) fn run(
run_with_env(program, args, cwd, env, false, cancel, on_line)
}
/// Like [`run`], but bounds both the per-line buffer and the retained copy. For callers
/// that stream every line to `on_line` and use `Output.text` only for error summaries:
/// sync/model listings must be kept whole and use [`run`] instead.
pub(crate) fn run_bounded(
program: &str,
args: &[String],
cwd: &Path,
env: &BTreeMap<String, String>,
cancel: &CancellationToken,
on_line: impl FnMut(Stream, &str),
) -> IdeResult<Output> {
run_with_env_capture(program, args, cwd, env, RunOptions { bounded: true, ..Default::default() }, cancel, on_line)
}
pub(crate) fn run_with_env(
program: &str,
args: &[String],
@@ -59,14 +137,39 @@ pub(crate) fn run_with_env(
env: &BTreeMap<String, String>,
clear_env: bool,
cancel: &CancellationToken,
on_line: impl FnMut(Stream, &str),
) -> IdeResult<Output> {
run_with_env_capture(program, args, cwd, env, RunOptions { clear_env, ..Default::default() }, cancel, on_line)
}
#[derive(Clone, Copy, Default)]
struct RunOptions {
clear_env: bool,
bounded: bool,
}
fn run_with_env_capture(
program: &str,
args: &[String],
cwd: &Path,
env: &BTreeMap<String, String>,
options: RunOptions,
cancel: &CancellationToken,
mut on_line: impl FnMut(Stream, &str),
) -> IdeResult<Output> {
let RunOptions { clear_env, bounded } = options;
tracing::info!("build: {program} {} (in {})", args.join(" "), cwd.display());
// Output is read as UTF-8: JVMs on Windows are told to write it (see `ide_core::output_encoding`).
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);
let mut command = Command::new(&program);
let program = program_path(program, env, cwd);
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.
@@ -79,17 +182,22 @@ pub(crate) fn run_with_env(
let (tx, rx) = mpsc::channel::<(Stream, String)>();
let pump = |stream: Box<dyn Read + Send>, kind: Stream, tx: mpsc::Sender<(Stream, String)>| {
std::thread::spawn(move || {
let mut reader = BufReader::new(stream);
let mut buf = Vec::new();
loop {
buf.clear();
match reader.read_until(b'\n', &mut buf) {
Ok(0) | Err(_) => break,
Ok(_) => {
let line = ide_core::output_encoding::decode_tool_output(&buf);
let line = line.trim_end_matches(['\n', '\r']).to_owned();
if tx.send((kind, line)).is_err() {
break;
if bounded {
pump_bounded(stream, kind, &tx);
} else {
// Model listings are parsed from Output.text: keep every line whole, however long.
let mut reader = BufReader::new(stream);
let mut buf = Vec::new();
loop {
buf.clear();
match reader.read_until(b'\n', &mut buf) {
Ok(0) | Err(_) => break,
Ok(_) => {
let line = ide_core::output_encoding::decode_tool_output(&buf);
let line = line.trim_end_matches(['\n', '\r']).to_owned();
if tx.send((kind, line)).is_err() {
break;
}
}
}
}
@@ -101,7 +209,17 @@ pub(crate) fn run_with_env(
child.stderr.take().map(|s| pump(Box::new(s), Stream::Stderr, tx.clone())),
];
drop(tx);
let mut text = String::new();
// Retained copy of the output: the first half of the cap, then — once output overflows —
// a rolling tail instead of the middle. Error summaries read the end of the output, while
// listings parsed out of a successful run read from the start. The pipes keep draining
// either way: `on_line` still sees every line, so the child never blocks on a full pipe.
let cap = MAX_TEXT_BYTES / 2;
let mut head = String::new();
let mut tail: std::collections::VecDeque<Vec<u8>> = Default::default();
let mut chunk: Vec<u8> = Vec::new();
let mut tail_bytes = 0usize;
let mut total = 0usize;
let mut truncated = false;
loop {
if cancel.is_cancelled() {
kill_tree(&mut child);
@@ -111,8 +229,34 @@ pub(crate) fn run_with_env(
Ok((_, line)) if encoding.notice.as_ref() == Some(&line) => {}
Ok((stream, line)) => {
on_line(stream, &line);
text.push_str(&line);
text.push('\n');
if !bounded {
// The caller parses a complete model from `text`, so keep every line.
head.push_str(&line);
head.push('\n');
continue;
}
total += line.len() + 1;
if !truncated {
if head.len() + line.len() < cap {
head.push_str(&line);
head.push('\n');
continue;
}
truncated = true;
}
// Fixed-size chunks, not per-line buffers: a chatty build pushes millions of
// lines past the cap, and the tail must add no allocation per line.
chunk.extend_from_slice(line.as_bytes());
chunk.push(b'\n');
if chunk.len() >= 64 * 1024 {
tail_bytes += chunk.len();
tail.push_back(std::mem::take(&mut chunk));
chunk.reserve_exact(64 * 1024);
while tail_bytes > cap {
let Some(front) = tail.pop_front() else { break };
tail_bytes -= front.len();
}
}
}
Err(mpsc::RecvTimeoutError::Timeout) => {}
Err(mpsc::RecvTimeoutError::Disconnected) => break,
@@ -122,13 +266,85 @@ pub(crate) fn run_with_env(
let _ = r.join();
}
let status = child.wait()?;
Ok(Output { success: status.success(), text })
let mut text = head;
if truncated {
if !chunk.is_empty() {
tail_bytes += chunk.len();
tail.push_back(std::mem::take(&mut chunk));
}
// The last partial chunk may sit past the cap; drop whole front chunks back under it.
while tail_bytes > cap {
let Some(front) = tail.pop_front() else { break };
tail_bytes -= front.len();
}
// Tail chunks are flushed only right after a completed line, so the tail always begins
// at a line boundary — no leading fragment to drop.
let tail = ide_core::output_encoding::decode_tool_output(&tail.into_iter().flatten().collect::<Vec<u8>>());
let omitted = total.saturating_sub(text.len() + tail.len());
if omitted == 0 {
// Everything that overflowed the head still fits in the tail: nothing was lost.
truncated = false;
} else {
text.push_str(&format!("[{omitted} bytes of build output between these lines were not retained]\n"));
}
text.push_str(&tail);
}
Ok(Output { success: status.success(), text, truncated })
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_model_line_over_one_mebibyte_is_kept_whole_for_the_parsers() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// A Gradle MODEL_LINE JSON line longer than the bounded pump's 1 MiB line cap,
// surrounded by ordinary output.
let script = "echo start; head -c 1048576 /dev/zero | tr '\\0' a; printf '\\n{\"id\":\"big\"}\\n'; echo end";
let mut lines = Vec::new();
let out = run(
"sh",
&["-c".into(), script.into()],
tmp.path(),
&BTreeMap::new(),
&CancellationToken::new(),
|_, line| lines.push(line.to_owned()),
)
.unwrap();
assert!(out.success);
assert!(!out.truncated);
// The long line is one line, not segments that a JSON-line parser would skip.
assert_eq!(lines.len(), 4);
assert_eq!(lines[1].len(), 1_048_576);
assert!(out.text.contains("{\"id\":\"big\"}"));
let models: Vec<serde_json::Value> = out.text.lines().filter_map(|l| serde_json::from_str(l).ok()).collect();
assert_eq!(models.len(), 1, "the model line must survive full retention");
}
#[test]
fn a_successful_report_over_the_text_cap_is_retained_in_full() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
let args = ["-c".into(), r"awk 'BEGIN{for(i=1;i<=6000000;i++)print i}'".into()];
let mut fed = 0usize;
let out = run("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
fed += line.len() + 1;
})
.unwrap();
assert!(out.success);
assert!(!out.truncated);
// Every line of a large successful dependency/model report is still there.
assert_eq!(out.text.len(), fed);
assert!(out.text.starts_with("1\n"));
assert!(out.text.ends_with("6000000\n"));
}
#[test]
fn runs_and_cancels_processes() {
if cfg!(windows) {
@@ -147,10 +363,11 @@ mod tests {
)
.unwrap();
assert!(!out.success);
assert!(!out.truncated);
lines.sort_by(|a, b| a.1.cmp(&b.1));
assert_eq!(lines, [(Stream::Stdout, "one".to_owned()), (Stream::Stderr, "two".to_owned())]);
cancel.cancel();
let err = run("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
let err = run_bounded("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
.err()
.unwrap();
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
@@ -170,9 +387,117 @@ mod tests {
std::thread::sleep(Duration::from_millis(200));
c.cancel();
});
let err = run("sh", &["-c".into(), script], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {}).err().unwrap();
let err =
run_bounded("sh", &["-c".into(), script], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {}).err().unwrap();
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
std::thread::sleep(Duration::from_millis(1300));
assert!(!marker.exists(), "the background child must be killed with the group");
}
#[test]
fn output_past_the_text_cap_keeps_head_and_tail_and_drains() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// Numbered lines 1..=6,000,000 ≈ 45 MB: past the 32 MiB retained cap.
let args = ["-c".into(), r"awk 'BEGIN{for(i=1;i<=6000000;i++)print i}'".into()];
let mut fed = 0usize;
let mut last_seen = String::new();
let out = run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
fed += line.len() + 1;
last_seen = line.to_owned();
})
.unwrap();
assert!(out.success);
assert!(out.truncated);
// The pipes drained to the end: the callback saw the last line.
assert_eq!(last_seen, "6000000");
assert_eq!(fed, out_success_bytes());
// The retained copy is bounded, keeps the head and the tail, and says what was dropped.
assert!(out.text.len() <= MAX_TEXT_BYTES + 128, "{}", out.text.len());
assert!(out.text.starts_with("1\n"));
assert!(out.text.ends_with("6000000\n"));
assert!(out.text.contains("were not retained]"));
assert!(!out.text.contains("\n3000000\n"), "a middle line must be the dropped part");
}
/// Lines `1..=6_000_000` emit exactly this many bytes (digit count + newline each).
fn out_success_bytes() -> usize {
(1..=6_000_000u64).map(|n| n.checked_ilog10().unwrap() as usize + 2).sum()
}
#[test]
fn a_newline_free_run_longer_than_the_line_cap_arrives_as_split_lines() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// 2.5 MiB of `x` without a single newline.
let args = ["-c".into(), "head -c 2621440 /dev/zero | tr '\\0' x".into()];
let mut lines = Vec::new();
let out = run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
lines.push(line.to_owned())
})
.unwrap();
assert!(out.success);
assert!(!out.truncated);
// Split at the cap, not dropped: the segments carry every byte and none is unbounded.
assert!(lines.len() >= 3, "{}", lines.len());
assert_eq!(lines.iter().map(String::len).sum::<usize>(), 2_621_440);
assert!(lines.iter().all(|l| l.len() <= MAX_LINE_BYTES));
}
#[test]
fn a_line_split_never_cuts_a_multibyte_character() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// `x` up to one byte before the 1 MiB cap, then `é` (two bytes) straddling it, then more `x`.
let script =
"head -c 1048575 /dev/zero | tr '\\0' x; printf '\\303\\251'; head -c 1048575 /dev/zero | tr '\\0' x";
let mut lines = Vec::new();
let out = run_bounded(
"sh",
&["-c".into(), script.into()],
tmp.path(),
&BTreeMap::new(),
&CancellationToken::new(),
|_, line| lines.push(line.to_owned()),
)
.unwrap();
assert!(out.success);
// The é straddles the 1 MiB split point: segments shift to keep it whole.
assert!(lines.len() >= 2, "{}", lines.len());
// The character survived the split: present whole, never as U+FFFD halves.
assert!(lines.iter().any(|l| l.contains('é')));
assert!(lines.iter().all(|l| !l.contains('\u{FFFD}')));
assert_eq!(lines.iter().map(String::len).sum::<usize>(), 1_048_575 + 2 + 1_048_575);
}
#[test]
fn output_just_past_the_head_cap_loses_nothing() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// 4-byte `pad` lines up to just past the 16 MiB head cap, then the real last line:
// the overflow fits the tail whole, so nothing is dropped and nothing is marked.
let script = "yes pad | head -c 16777213; echo 'FATAL: the real error'";
let out = run_bounded(
"sh",
&["-c".into(), script.into()],
tmp.path(),
&BTreeMap::new(),
&CancellationToken::new(),
|_, _| {},
)
.unwrap();
assert!(out.success);
assert!(!out.truncated);
assert!(!out.text.contains("were not retained]"));
assert!(out.text.starts_with("pad\n"));
assert!(out.text.ends_with("FATAL: the real error\n"));
}
}
+36
Переглянути файл
@@ -0,0 +1,36 @@
//! Timed evidence for the bounded build-output capture (issue #3936). Not an assertion:
//! run it on both revisions of `process.rs` and compare the printed numbers.
//!
//! ```text
//! cargo test -p ide-build --release --lib -- --ignored --nocapture numbers
//! ```
use crate::process;
use ide_core::CancellationToken;
use std::collections::BTreeMap;
use std::time::Instant;
/// 256 MiB of 17-byte lines from `yes`, drained by `process::run` with a counting callback.
#[test]
#[ignore = "prints elapsed time and retained bytes; see the module docs"]
fn high_output_process_numbers() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
let args = ["-c".into(), "yes 0123456789abcdef | head -c 268435456".into()];
let start = Instant::now();
let mut lines = 0u64;
let mut fed = 0usize;
let out = process::run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
lines += 1;
fed += line.len() + 1;
})
.unwrap();
println!(
"elapsed {:?} | success {} | retained {} bytes | fed {lines} lines / {fed} bytes",
start.elapsed(),
out.success,
out.text.len()
);
}
+128 -25
Переглянути файл
@@ -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)
}
@@ -268,8 +293,20 @@ fn run(
process::run(program, args, cwd, env, cancel, |_, line| on_line(line))
}
/// What a sync records when a *successful* child run's output was truncated: parsing a
/// truncated listing would silently produce an incomplete model, so it is surfaced, not hidden.
pub(crate) fn truncation_note(out: &Output) -> Option<String> {
out.truncated.then(|| {
format!(
"the build printed more than the retained {} MiB of output; the model may be incomplete",
crate::process::MAX_TEXT_BYTES / (1024 * 1024)
)
})
}
/// The first error lines of a failed build, for the tool window.
pub(crate) fn error_summary(text: &str) -> String {
pub(crate) fn error_summary(output: &Output) -> String {
let text = &output.text;
// The JVM's "could not find or load main class" (localized) when `gradlew` has no jar.
if text.contains("org.gradle.wrapper.GradleWrapperMain") {
return "gradle/wrapper/gradle-wrapper.jar is missing (often excluded by a `*.jar` rule in .gitignore). \
@@ -289,11 +326,15 @@ pub(crate) fn error_summary(text: &str) -> String {
.filter(|l| !l.is_empty() && !l.starts_with("Re-run Maven") && !l.starts_with("To see the full stack trace"))
.take(4)
.collect();
if lines.is_empty() {
let mut summary = if lines.is_empty() {
text.lines().rev().find(|l| !l.trim().is_empty()).unwrap_or("the build failed").trim().to_owned()
} else {
lines.join("\n")
};
if output.truncated {
summary.push_str("\n[the build printed more than the retained output; this summary may miss lines]");
}
summary
}
/// `[INFO] Building core 1.0-SNAPSHOT [2/3]` → ("core 1.0-SNAPSHOT", 2, 3).
@@ -366,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| {
@@ -397,7 +439,9 @@ pub fn sync_maven(
}
}
if !out.success {
errors.push(error_summary(&out.text));
errors.push(error_summary(&out));
} else if let Some(note) = truncation_note(&out) {
errors.push(note);
}
}
cache.at_ms = now_ms();
@@ -437,6 +481,8 @@ pub fn sync_gradle_model(
let mut args: Vec<String> = vec![
"--console=plain".into(),
"-q".into(),
// The init script reports the evaluated projects, even when a build enables the configuration cache.
"-Dorg.gradle.configuration-cache=false".into(),
"--init-script".into(),
init_script.to_string_lossy().into_owned(),
"tasks".into(),
@@ -457,7 +503,7 @@ pub fn sync_gradle_model(
Ok(out) => out,
Err(_) if cancel.is_cancelled() => return Err(IdeError::cancelled()),
Err(error) if error.kind == ide_core::error::ErrorKind::Unavailable => {
Output { success: false, text: error.message }
Output { success: false, text: error.message, truncated: false }
}
Err(error) => return Err(error),
};
@@ -470,7 +516,7 @@ pub fn sync_gradle_model(
let cache = GradleCache {
hash: hash_gradle_files(&gradle::build_files(root, &model)),
at_ms: now_ms(),
error: (!out.success).then(|| error_summary(&out.text)),
error: if !out.success { Some(error_summary(&out)) } else { truncation_note(&out) },
tasks: if out.success { gradle::parse_tasks(&out.text) } else { Vec::new() },
projects,
resources: true,
@@ -512,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!(
@@ -888,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]
@@ -914,10 +983,22 @@ mod tests {
);
assert_eq!(maven_building("[INFO] Building jar: x.jar"), None);
let text = "[INFO] x\n[ERROR] Failed to execute goal\n[ERROR] \n[ERROR] Re-run Maven using -X\n";
assert_eq!(error_summary(text), "Failed to execute goal");
assert_eq!(error_summary("one\nlast line\n\n"), "last line");
let out = |text: &str, truncated| crate::process::Output { success: false, text: text.to_owned(), truncated };
assert_eq!(error_summary(&out(text, false)), "Failed to execute goal");
assert_eq!(error_summary(&out("one\nlast line\n\n", false)), "last line");
let missing_jar = "错误: 找不到或无法加载主类 org.gradle.wrapper.GradleWrapperMain\n";
assert!(error_summary(missing_jar).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
assert!(error_summary(&out(missing_jar, false)).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
// A truncated capture says so instead of hiding that lines are missing.
assert!(error_summary(&out(text, true)).ends_with("this summary may miss lines]"));
}
#[test]
fn a_truncated_successful_run_is_surfaced_not_silent() {
let out = |truncated| crate::process::Output { success: true, text: String::new(), truncated };
assert!(truncation_note(&out(false)).is_none());
let note = truncation_note(&out(true)).unwrap();
assert!(note.starts_with("the build printed more than the retained 32 MiB"), "{note}");
assert!(note.ends_with("the model may be incomplete"));
}
#[test]
@@ -933,6 +1014,28 @@ mod tests {
assert!(sync_maven_options(&[]).is_empty());
}
#[cfg(unix)]
#[test]
fn maven_sync_runs_a_wrapper_without_the_execute_bit() {
use std::os::unix::fs::PermissionsExt;
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("p");
std::fs::create_dir_all(&root).unwrap();
std::fs::write(root.join("pom.xml"), "<project><groupId>g</groupId><artifactId>a</artifactId></project>")
.unwrap();
let mvnw = root.join("mvnw");
std::fs::write(&mvnw, "#!/bin/sh\nprintf '%s\\n' \"$@\" > mvnw-args\n").unwrap();
std::fs::set_permissions(&mvnw, std::fs::Permissions::from_mode(0o644)).unwrap();
let cache = tmp.path().join("cache");
sync_maven(&root, &cache, &SyncOptions::default(), &CancellationToken::new(), &|_| {}).unwrap();
let args = std::fs::read_to_string(root.join("mvnw-args")).unwrap();
assert!(args.contains("help:effective-pom"), "args: {args}");
let loaded = crate::load_linked(&root, &cache, None, &Default::default(), &Default::default());
let maven = loaded.maven.unwrap();
assert!(maven.synced_at.is_some() && maven.sync_error.is_none(), "{:?}", maven.sync_error);
assert_eq!(std::fs::metadata(&mvnw).unwrap().permissions().mode() & 0o777, 0o644);
}
#[cfg(unix)]
#[test]
fn maven_sync_runs_the_daemon_command_serially() {
+36
Переглянути файл
@@ -348,6 +348,35 @@ mod imp {
paths
}
/// `Preferred DropEffect`: a `DWORD` saying whether the files were copied or cut.
/// Explorer writes it with every file list, and paste targets that move files
/// between machines (Remote Desktop's clipboard redirection, #3863) read it.
fn drop_effect_format() -> u32 {
let name: Vec<u16> = "Preferred DropEffect\0".encode_utf16().collect();
unsafe { RegisterClipboardFormatW(name.as_ptr()) }
}
/// `DROPEFFECT_COPY`.
const DROPEFFECT_COPY: u32 = 1;
/// An `HGLOBAL` holding a copy of `bytes`. Null when the allocation failed.
fn global_bytes(bytes: &[u8]) -> Handle {
unsafe {
let memory = GlobalAlloc(GMEM_MOVEABLE, bytes.len());
if memory.is_null() {
return ptr::null_mut();
}
let data = GlobalLock(memory);
if data.is_null() {
GlobalFree(memory);
return ptr::null_mut();
}
ptr::copy_nonoverlapping(bytes.as_ptr(), data as *mut u8, bytes.len());
GlobalUnlock(memory);
memory
}
}
/// An `HGLOBAL` holding `text` as UTF-16 with a terminating NUL, and its
/// byte size. Null when the allocation failed.
fn global_text(text: &str) -> (Handle, usize) {
@@ -430,6 +459,13 @@ mod imp {
if !taken {
GlobalFree(memory);
}
let effect = drop_effect_format();
if effect != 0 {
let effect_memory = global_bytes(&DROPEFFECT_COPY.to_le_bytes());
if !effect_memory.is_null() && SetClipboardData(effect, effect_memory).is_null() {
GlobalFree(effect_memory);
}
}
let (text_memory, _) = global_text(&text);
if !text_memory.is_null() {
// The text alone still pastes somewhere useful.
+18
Переглянути файл
@@ -0,0 +1,18 @@
[package]
name = "ide-command"
description = "Declares OpenIDEA's backend commands once and derives their adapters, trust class and placement"
version.workspace = true
edition.workspace = true
license.workspace = true
[lib]
proc-macro = true
[dependencies]
heck.workspace = true
proc-macro2.workspace = true
quote.workspace = true
syn.workspace = true
[dev-dependencies]
serde.workspace = true
+92
Переглянути файл
@@ -0,0 +1,92 @@
// Stand-in for the parts of `ide-host` that the code generated by `#[command]`, `domain!` and
// `domains!` names; doctests `include!` it at their crate root.
pub type IdeResult<T> = Result<T, IdeError>;
#[derive(Debug)]
pub struct IdeError(pub String);
impl IdeError {
pub fn unavailable(m: impl Into<String>) -> Self {
Self(m.into())
}
}
pub struct Host;
impl Host {
pub fn plugin_host(&self) -> Option<std::sync::Arc<plugins::PluginHost>> {
None
}
}
pub mod plugins {
pub struct PluginHost;
}
pub mod catalogue {
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TrustClass {
Always,
OutsideRestricted,
Trusted,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Placement {
Desktop,
ProjectHost,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mode {
Sync,
Async,
Spawn,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Command {
pub name: &'static str,
pub trust: TrustClass,
pub placement: Placement,
pub bindings: bool,
pub mode: Mode,
}
}
pub mod ops {
pub struct Channel<T>(pub std::marker::PhantomData<T>);
pub type Emit<T> = std::sync::Arc<dyn Fn(T) + Send + Sync>;
}
pub mod rpc {
use crate::catalogue::TrustClass;
use crate::{IdeResult, ops::Channel};
pub struct Call {
pub host: std::sync::Arc<crate::Host>,
pub window: String,
}
impl Call {
pub fn arg<T: Default>(&self, _name: &str) -> IdeResult<T> {
Ok(T::default())
}
pub fn sender<T>(&self, _name: &str) -> IdeResult<Channel<T>> {
Ok(Channel(std::marker::PhantomData))
}
}
#[derive(Default)]
pub struct Dispatcher(pub Vec<(&'static str, TrustClass)>);
impl Dispatcher {
pub fn add<F, Fut, T>(&mut self, name: &'static str, trust: TrustClass, _f: F) -> &mut Self
where
F: Fn(Call) -> Fut + Send + Sync + 'static,
Fut: Future<Output = IdeResult<T>> + Send + 'static,
T: serde::Serialize,
{
self.0.push((name, trust));
self
}
}
}
+884
Переглянути файл
@@ -0,0 +1,884 @@
//! Declares OpenIDEA's backend commands once, on the fn that implements them.
//!
//! A command that runs on the project host is an `ide-host` fn with `#[command]`; its module
//! lists it in `domain!`, and `ide-host` lists its domains in `domains!`. From that `src-tauri`
//! derives the Tauri adapter and its bindings entry, and `ide-host` derives the JSON-RPC handler
//! `openidea-server` answers. A command only the desktop runs keeps its hand-written Tauri fn,
//! with `#[desktop_command]`, and its module lists it in `desktop_domain!`. Every command
//! declares its trust class, and each declaration yields a `COMMAND`
//! (`ide_host::catalogue::Command`): its name, trust class, placement, bindings entry and
//! execution mode.
//!
//! The examples below build against a stand-in for `ide-host` (`src/doctest_host.rs`). Every
//! `compile_fail` example differs from the example before it only by the mistake it names.
use heck::ToLowerCamelCase;
use proc_macro::TokenStream;
use proc_macro2::TokenStream as T2;
use quote::{ToTokens, format_ident, quote};
use syn::ext::IdentExt;
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::{FnArg, GenericArgument, Ident, ItemFn, Pat, PathArguments, ReturnType, Token, Type};
/// `#[command(trust = …)]` on a project-host command's implementation in `ide-host`.
///
/// The fn's name is the command's name and its `///` lines are the bindings' docs. Parameters
/// of type `&Host` or `&Arc<Host>`, `window: &str` and `plugins: &Arc<PluginHost>` are injected;
/// every other parameter is an argument, owned, whose key is its camelCase name, and
/// `Channel<T>` streams values back. `async fn` gives an async Tauri adapter, `fn` a sync one.
/// A result of type `IdeResult<T>` is returned as is; any other result is a success. A JSON-RPC
/// request that leaves out an argument marked `#[default]` gets the type's default, so servers
/// keep answering clients older than the argument.
///
/// Options:
/// - `trust = always | outside_restricted | trusted` (required): where the command may run;
/// `always` includes Restricted Mode, `outside_restricted` needs no project or a trusted
/// one, `trusted` needs a trusted project.
/// - `desktop_body = async | sync | spawn`: the Tauri adapter calls the hand-written fn of the
/// same name in `src-tauri` instead of this one, which stays the server's implementation.
/// `spawn` runs that sync body off the invoking thread.
///
/// ```
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// use crate::{Host, IdeResult, ops::Channel};
/// use ide_command::command;
///
/// /// Renames a branch.
/// #[command(trust = trusted)]
/// pub async fn vcs_rename_branch(
/// host: &Host,
/// window: &str,
/// from: String,
/// to: String,
/// unset_upstream: bool,
/// ) -> IdeResult<()> {
/// Ok(())
/// }
///
/// #[command(trust = always)]
/// pub fn vcs_watch(window: &str, #[default] depth: u32, on_event: Channel<u32>) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_rename_branch, vcs_watch);
/// }
///
/// ide_command::domains!(vcs: crate::vcs);
///
/// fn main() {
/// use catalogue::{Mode, Placement, TrustClass};
/// let mut d = rpc::Dispatcher::default();
/// register_domains(&mut d);
/// assert_eq!(d.0, [("vcs_rename_branch", TrustClass::Trusted), ("vcs_watch", TrustClass::Always)]);
/// let watch = vcs::__cmd_vcs_watch::COMMAND;
/// assert_eq!((watch.placement, watch.bindings, watch.mode), (Placement::ProjectHost, true, Mode::Sync));
/// }
/// ```
///
/// A command without a trust class:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A command its module doesn't list:
///
/// ```compile_fail,E0425
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// #[ide_command::command(trust = always)]
/// pub fn vcs_unwatch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// Two commands with one name, in different modules:
///
/// ```compile_fail,E0428
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
///
/// pub mod search {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(search: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A borrowed argument:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str, path: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A stream that isn't a `Channel<T>`:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// use crate::ops::Emit;
///
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str, on_event: Emit<u32>) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
#[proc_macro_attribute]
pub fn command(attr: TokenStream, item: TokenStream) -> TokenStream {
let opts = syn::parse_macro_input!(attr as Opts);
let f = syn::parse_macro_input!(item as ItemFn);
expand_command(opts, f).unwrap_or_else(|e| e.to_compile_error()).into()
}
fn expand_command(opts: Opts, mut f: ItemFn) -> syn::Result<T2> {
opts.only(&["trust", "desktop_body"])?;
let trust = opts.trust()?;
// `#[default]` is read here and not emitted.
let defaulted: Vec<bool> = f
.sig
.inputs
.iter_mut()
.map(|input| match input {
FnArg::Typed(pt) => {
let before = pt.attrs.len();
pt.attrs.retain(|a| !a.path().is_ident("default"));
pt.attrs.len() != before
}
FnArg::Receiver(_) => false,
})
.collect();
let name = &f.sig.ident;
if !f.sig.generics.params.is_empty() {
return Err(syn::Error::new_spanned(&f.sig.generics, "a command is not generic"));
}
let is_async = f.sig.asyncness.is_some();
let (run, body) = match opts.value("desktop_body") {
None if is_async => (format_ident!("async"), quote!(derived)),
None => (format_ident!("sync"), quote!(derived)),
Some(Some(m)) if ["async", "sync", "spawn"].contains(&m.to_string().as_str()) => (m, quote!(desktop)),
Some(v) => return Err(error(v.as_ref().unwrap_or(name), "`desktop_body = async | sync | spawn`")),
};
let mode = match run.to_string().as_str() {
"async" => quote!(Async),
"spawn" => quote!(Spawn),
_ => quote!(Sync),
};
let mut aliases = Vec::new(); // one type alias per argument, resolved in the fn's own scope
let mut args = Vec::new(); // the arguments, for the Tauri adapter's signature
let mut call = Vec::new(); // every parameter in declared order, for the Tauri adapter's call
let mut rpc_call = Vec::new(); // the same, for the JSON-RPC handler
let mut needs_plugins = false;
for (input, defaulted) in f.sig.inputs.iter().zip(defaulted) {
let FnArg::Typed(pt) = input else {
return Err(error(input, "a command is a free fn"));
};
let Pat::Ident(pi) = &*pt.pat else {
return Err(error(&pt.pat, "command parameters are plain identifiers"));
};
let ident = &pi.ident;
let plain_only = || error(ident, "`#[default]` marks a plain argument");
if defaulted && injected(ident, &pt.ty).is_some() {
return Err(plain_only());
}
match injected(ident, &pt.ty) {
Some(Injected::Host) => {
call.push(quote!((inj host)));
rpc_call.push(quote!(&c.host));
continue;
}
Some(Injected::Window) => {
call.push(quote!((inj window)));
rpc_call.push(quote!(&c.window));
continue;
}
Some(Injected::Plugins) => {
needs_plugins = true;
call.push(quote!((inj plugins)));
rpc_call.push(quote!(&plugins));
continue;
}
None => {}
}
if matches!(&*pt.ty, Type::Reference(_)) {
return Err(error(
&pt.ty,
"command arguments are owned; the injected references are `&Host`, `window: &str` and `plugins: &Arc<PluginHost>`",
));
}
let seg = last_segment(&pt.ty);
if seg.is_some_and(|s| s.ident == "Emit") {
return Err(error(&pt.ty, "a command streams through `Channel<T>`, not `Emit<T>`"));
}
let key = ident.unraw().to_string().to_lower_camel_case();
let alias = format_ident!("A{}", args.len());
if let Some(inner) = seg.filter(|s| s.ident == "Channel").and_then(type_argument) {
if defaulted {
return Err(plain_only());
}
aliases.push(quote!(pub type #alias = #inner;));
args.push(quote!((#ident channel #alias)));
call.push(quote!((arg channel #ident)));
rpc_call.push(quote!(c.sender(#key)?));
} else {
let ty = &pt.ty;
aliases.push(quote!(pub type #alias = #ty;));
args.push(quote!((#ident plain #alias)));
call.push(quote!((arg plain #ident)));
rpc_call.push(if defaulted {
quote!(c.arg::<::core::option::Option<#ty>>(#key)?.unwrap_or_default())
} else {
quote!(c.arg(#key)?)
});
}
}
let ret: Type = match &f.sig.output {
ReturnType::Default => syn::parse_quote!(()),
ReturnType::Type(_, t) => (**t).clone(),
};
let fallible = last_segment(&ret).is_some_and(|s| s.ident == "IdeResult");
// specta exports `fn f()` as `void` and `fn f() -> ()` as `null`: keep which one was written.
let ret_alias = match &f.sig.output {
ReturnType::Default => quote!(),
ReturnType::Type(..) => quote!(Ret),
};
let shape = if fallible { quote!(fallible [#ret_alias]) } else { quote!(infallible [#ret_alias]) };
let await_ = is_async.then(|| quote!(.await));
let invoke = quote!(super::#name(#(#rpc_call),*) #await_);
let invoke = if fallible { invoke } else { quote!(Ok(#invoke)) };
let plugins = needs_plugins.then(|| {
quote! {
let plugins = c.host.plugin_host()
.ok_or_else(|| crate::IdeError::unavailable("the plugin host has shut down"))?;
}
});
let docs: Vec<_> = f.attrs.iter().filter(|a| a.path().is_ident("doc")).collect();
let module = format_ident!("__cmd_{}", name);
let tokens = format_ident!("__catalogue_{}", name);
let name_str = name.unraw().to_string();
Ok(quote! {
#f
// Resolves only if this module's `domain!` lists the command.
const _: () = self::__listed::#name;
#[doc(hidden)]
#[allow(non_snake_case)]
pub mod #module {
#[allow(unused_imports)]
use super::*;
#(#aliases)*
pub type Ret = #ret;
pub const COMMAND: crate::catalogue::Command = crate::catalogue::Command {
name: #name_str,
trust: crate::catalogue::TrustClass::#trust,
placement: crate::catalogue::Placement::ProjectHost,
bindings: true,
mode: crate::catalogue::Mode::#mode,
};
/// The JSON-RPC handler.
pub async fn rpc(c: crate::rpc::Call) -> crate::IdeResult<impl ::serde::Serialize + use<>> {
#plugins
#invoke
}
}
/// The command's signature, handed to `$cb!` for `src-tauri` to derive its Tauri adapter.
#[doc(hidden)]
#[macro_export]
macro_rules! #tokens {
([$($cb:tt)*] { $($ctx:tt)* }) => {
$($cb)*! { { $($ctx)* } {
name: #name,
module: #module,
docs: [ #(#docs)* ],
run: #run,
result: #shape,
body: #body,
args: [ #(#args)* ],
call: [ #(#call)* ],
} }
};
}
})
}
/// `domain!(vcs: vcs_status, vcs_rename_branch, …)`: the commands one `ide-host` module
/// declares with `#[command]`, in any order. It goes once at the end of that module and gives it
/// the server's `register`; `domains!` names the domain.
///
/// ```
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A listed name that isn't a command:
///
/// ```compile_fail,E0433
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch, vcs_unwatch);
/// }
/// # fn main() {}
/// ```
#[proc_macro]
pub fn domain(input: TokenStream) -> TokenStream {
let Domain { name, commands } = syn::parse_macro_input!(input as Domain);
let modules: Vec<_> = commands.iter().map(|c| format_ident!("__cmd_{}", c)).collect();
let tokens: Vec<_> = commands.iter().map(|c| format_ident!("__catalogue_{}", c)).collect();
let list = format_ident!("__domain_{}", name);
let names = commands.iter();
let listed = commands.iter();
let d = quote!($);
quote! {
#[doc(hidden)]
#[allow(non_upper_case_globals)]
mod __listed {
#( pub(super) const #listed: () = (); )*
}
// Resolves only from the `domains!` entry that names this domain.
#[doc(hidden)]
#[allow(non_upper_case_globals)]
pub(crate) const #list: () = ();
/// Adds this module's commands to the server.
pub(crate) fn register(d: &mut crate::rpc::Dispatcher) {
#( d.add(#modules::COMMAND.name, #modules::COMMAND.trust, #modules::rpc); )*
}
/// `@each`: each command's signature, in list order. `@names`: the list.
#[doc(hidden)]
#[macro_export]
macro_rules! #list {
(@each [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#( #d crate::#tokens!{ [#d (#d cb)*] { #d (#d ctx)* } } )*
};
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#d (#d cb)*! { { #d (#d ctx)* } [ #(#names)* ] }
};
}
}
.into()
}
/// `domains!(vcs: crate::ops::vcs::commands, …)`, once in `ide-host`: every domain, by the name
/// its `domain!` gives it and the crate path of its module. It gives the server
/// `register_domains`, and hands `src-tauri` the list of domains through `__domains!`.
///
/// ```
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
///
/// ide_command::domains!(vcs: crate::vcs);
/// # fn main() {}
/// ```
///
/// A domain under another name than its `domain!` gives it:
///
/// ```compile_fail,E0425
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
///
/// ide_command::domains!(git: crate::vcs);
/// # fn main() {}
/// ```
#[proc_macro]
pub fn domains(input: TokenStream) -> TokenStream {
let entries = syn::parse_macro_input!(input with Punctuated::<DomainPath, Token![,]>::parse_terminated);
let mut names = Vec::new();
let mut paths = Vec::new();
let mut from_crate = Vec::new();
for DomainPath { name, path } in entries {
let mut segments = path.segments.iter();
if path.leading_colon.is_some() || segments.next().is_none_or(|s| s.ident != "crate") {
return error(&path, "a domain's path starts with `crate::`").to_compile_error().into();
}
let rest: Vec<_> = segments.map(|s| &s.ident).collect();
from_crate.push(quote!(#(#rest)::*));
names.push(name);
paths.push(path);
}
let lists: Vec<_> = names.iter().map(|n| format_ident!("__domain_{}", n)).collect();
let d = quote!($);
quote! {
#( const _: () = #paths::#lists; )*
/// Adds every domain's commands to the server.
pub(crate) fn register_domains(d: &mut crate::rpc::Dispatcher) {
#( #paths::register(d); )*
}
/// `@names`: each domain as `(name __domain_name { path })`.
#[doc(hidden)]
#[macro_export]
macro_rules! __domains {
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#d (#d cb)*! { { #d (#d ctx)* } [ #( (#names #lists { #d crate::#from_crate }) )* ] }
};
}
}
.into()
}
/// `#[desktop_command(trust = …)]` on a command only the desktop runs, above its
/// `#[tauri::command]` in `src-tauri`, whose `(async)` it reads. The fn is left as written.
///
/// Options: `trust` as for `#[command]` (required), and `bindings = none` for a command that is
/// registered outside tauri-specta; such a command isn't listed in `desktop_domain!`.
///
/// ```
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// ide_command::desktop_domain!(clipboard_text);
/// }
///
/// fn main() {
/// let text = clipboard::clipboard_text::COMMAND;
/// assert_eq!((text.name, text.placement), ("clipboard_text", catalogue::Placement::Desktop));
/// }
/// ```
///
/// A command without a trust class:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// pub mod clipboard {
/// #[ide_command::desktop_command]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// ide_command::desktop_domain!(clipboard_text);
/// }
/// # fn main() {}
/// ```
///
/// A command its module doesn't list:
///
/// ```compile_fail,E0425
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_html() -> Option<String> {
/// None
/// }
///
/// ide_command::desktop_domain!(clipboard_text);
/// }
/// # fn main() {}
/// ```
#[proc_macro_attribute]
pub fn desktop_command(attr: TokenStream, item: TokenStream) -> TokenStream {
let opts = syn::parse_macro_input!(attr as Opts);
let f = syn::parse_macro_input!(item as ItemFn);
expand_desktop_command(opts, f).unwrap_or_else(|e| e.to_compile_error()).into()
}
fn expand_desktop_command(opts: Opts, f: ItemFn) -> syn::Result<T2> {
opts.only(&["trust", "bindings"])?;
let trust = opts.trust()?;
let bindings = match opts.value("bindings") {
None => true,
Some(Some(v)) if v == "none" => false,
Some(v) => return Err(error(v.as_ref().unwrap_or(&f.sig.ident), "`bindings = none`")),
};
// `#[tauri::command(async)]` runs a sync fn off the invoking thread.
let spawned = f.attrs.iter().any(|a| {
let path = a.path();
path.segments.len() == 2
&& path.segments[0].ident == "tauri"
&& path.segments[1].ident == "command"
&& a.parse_args::<Ident>().is_ok_and(|i| i == "async")
});
let mode = if f.sig.asyncness.is_some() {
quote!(Async)
} else if spawned {
quote!(Spawn)
} else {
quote!(Sync)
};
let name = &f.sig.ident;
let name_str = name.unraw().to_string();
let listed = bindings.then(|| quote!(const _: () = self::__listed::#name;));
Ok(quote! {
#f
#listed
#[doc(hidden)]
pub mod #name {
pub const COMMAND: ::ide_host::catalogue::Command = ::ide_host::catalogue::Command {
name: #name_str,
trust: ::ide_host::catalogue::TrustClass::#trust,
placement: ::ide_host::catalogue::Placement::Desktop,
bindings: #bindings,
mode: ::ide_host::catalogue::Mode::#mode,
};
}
})
}
/// `desktop_domain!(clipboard_text, clipboard_write_text, …)`: the `#[desktop_command]`s of one
/// `src-tauri` module that are in the bindings, in any order. It goes once at the end of that
/// module and gives it `__desktop_domain!(@names …)`.
#[proc_macro]
pub fn desktop_domain(input: TokenStream) -> TokenStream {
let commands = syn::parse_macro_input!(input with Punctuated::<Ident, Token![,]>::parse_terminated);
let names = commands.iter();
let listed = commands.iter();
let d = quote!($);
quote! {
#[doc(hidden)]
#[allow(non_upper_case_globals)]
mod __listed {
#( pub(super) const #listed: () = (); )*
}
#[doc(hidden)]
macro_rules! __desktop_domain {
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#d (#d cb)*! { { #d (#d ctx)* } [ #(#names)* ] }
};
}
#[allow(unused_imports)]
pub(crate) use __desktop_domain;
}
.into()
}
/// `sorted_catalogue!(bindings: a::x, b::y, …; raw: c::z, …)`, in `src-tauri`: every command,
/// sorted by name, as `(collect_commands![…bindings…], [COMMAND, …every command…])`. Each path
/// names a command fn and the module of the same name that holds its `COMMAND`.
///
/// ```
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// # extern crate self as tauri_specta;
/// # #[macro_export]
/// # macro_rules! collect_commands { ($($p:path),*) => { [$(stringify!($p)),*] } }
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// #[ide_command::desktop_command(trust = always)]
/// pub fn clipboard_clear() {}
///
/// ide_command::desktop_domain!(clipboard_text, clipboard_clear);
/// }
///
/// fn main() {
/// let (commands, rows) = ide_command::sorted_catalogue!(
/// bindings: clipboard::clipboard_text, clipboard::clipboard_clear;
/// raw:
/// );
/// assert_eq!(commands, ["clipboard :: clipboard_clear", "clipboard :: clipboard_text"]);
/// assert_eq!(rows.map(|c| c.name), ["clipboard_clear", "clipboard_text"]);
/// }
/// ```
///
/// Two commands with one name:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// # extern crate self as tauri_specta;
/// # #[macro_export]
/// # macro_rules! collect_commands { ($($p:path),*) => { [$(stringify!($p)),*] } }
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// #[ide_command::desktop_command(trust = always)]
/// pub fn clipboard_clear() {}
///
/// ide_command::desktop_domain!(clipboard_text, clipboard_clear);
/// }
///
/// pub mod editor {
/// #[ide_command::desktop_command(trust = always)]
/// pub fn clipboard_clear() {}
///
/// ide_command::desktop_domain!(clipboard_clear);
/// }
///
/// fn main() {
/// let (commands, rows) = ide_command::sorted_catalogue!(
/// bindings: clipboard::clipboard_text, clipboard::clipboard_clear, editor::clipboard_clear;
/// raw:
/// );
/// }
/// ```
#[proc_macro]
pub fn sorted_catalogue(input: TokenStream) -> TokenStream {
let Catalogue { bindings, raw } = syn::parse_macro_input!(input as Catalogue);
let key = |p: &syn::Path| p.segments.last().map(|s| s.ident.unraw().to_string()).unwrap_or_default();
let mut bindings: Vec<_> = bindings.into_iter().collect();
bindings.sort_by_cached_key(key);
let mut all: Vec<_> = bindings.iter().chain(&raw).collect();
all.sort_by_cached_key(|p| key(p));
for pair in all.windows(2) {
if key(pair[0]) == key(pair[1]) {
let (a, b) = (pair[0], pair[1]);
let message = format!(
"command `{}` is declared twice: `{}` and `{}`",
key(b),
a.to_token_stream(),
b.to_token_stream()
);
return syn::Error::new_spanned(b, message).to_compile_error().into();
}
}
quote! {
(
::tauri_specta::collect_commands![ #(#bindings),* ],
[ #( #all::COMMAND ),* ],
)
}
.into()
}
struct Catalogue {
bindings: Punctuated<syn::Path, Token![,]>,
raw: Punctuated<syn::Path, Token![,]>,
}
impl Parse for Catalogue {
fn parse(input: ParseStream) -> syn::Result<Self> {
let paths = |input: ParseStream, label: &str| -> syn::Result<Punctuated<syn::Path, Token![,]>> {
let ident: Ident = input.parse()?;
if ident != label {
return Err(error(&ident, &format!("expected `{label}:`")));
}
input.parse::<Token![:]>()?;
let mut out = Punctuated::new();
while !input.is_empty() && !input.peek(Token![;]) {
out.push_value(input.parse()?);
if !input.peek(Token![,]) {
break;
}
out.push_punct(input.parse()?);
}
Ok(out)
};
let bindings = paths(input, "bindings")?;
input.parse::<Token![;]>()?;
let raw = paths(input, "raw")?;
let _ = input.parse::<Option<Token![;]>>()?;
Ok(Self { bindings, raw })
}
}
enum Injected {
Host,
Window,
Plugins,
}
/// `&Host` or `&Arc<Host>` under any name, `window: &str`, `plugins: &Arc<PluginHost>`.
fn injected(ident: &Ident, ty: &Type) -> Option<Injected> {
let Type::Reference(r) = ty else { return None };
if r.mutability.is_some() {
return None;
}
let seg = last_segment(&r.elem)?;
let arc_of =
|name: &str| seg.ident == "Arc" && type_argument(seg).and_then(last_segment).is_some_and(|s| s.ident == name);
if seg.ident == "Host" || arc_of("Host") {
Some(Injected::Host)
} else if ident == "window" && seg.ident == "str" {
Some(Injected::Window)
} else if ident == "plugins" && arc_of("PluginHost") {
Some(Injected::Plugins)
} else {
None
}
}
fn last_segment(ty: &Type) -> Option<&syn::PathSegment> {
match ty {
Type::Path(p) if p.qself.is_none() => p.path.segments.last(),
_ => None,
}
}
fn type_argument(seg: &syn::PathSegment) -> Option<&Type> {
match &seg.arguments {
PathArguments::AngleBracketed(a) => a.args.iter().find_map(|g| match g {
GenericArgument::Type(t) => Some(t),
_ => None,
}),
_ => None,
}
}
fn error(span: impl ToTokens, message: &str) -> syn::Error {
syn::Error::new_spanned(span, message)
}
/// `name: a, b, …`
struct Domain {
name: Ident,
commands: Punctuated<Ident, Token![,]>,
}
impl Parse for Domain {
fn parse(input: ParseStream) -> syn::Result<Self> {
let name = input.parse()?;
input.parse::<Token![:]>()?;
Ok(Self { name, commands: Punctuated::parse_terminated(input)? })
}
}
/// `name: crate::path`
struct DomainPath {
name: Ident,
path: syn::Path,
}
impl Parse for DomainPath {
fn parse(input: ParseStream) -> syn::Result<Self> {
let name = input.parse()?;
input.parse::<Token![:]>()?;
Ok(Self { name, path: input.parse()? })
}
}
/// An attribute's options: `key = value` and bare `key`.
struct Opts(Vec<(Ident, Option<Ident>)>);
impl Parse for Opts {
fn parse(input: ParseStream) -> syn::Result<Self> {
let mut out = Vec::new();
while !input.is_empty() {
let key: Ident = input.parse()?;
let value = if input.peek(Token![=]) {
input.parse::<Token![=]>()?;
// `async` is a keyword.
Some(Ident::parse_any(input)?)
} else {
None
};
out.push((key, value));
if !input.is_empty() {
input.parse::<Token![,]>()?;
}
}
Ok(Self(out))
}
}
impl Opts {
fn value(&self, key: &str) -> Option<Option<Ident>> {
self.0.iter().find(|(k, _)| k == key).map(|(_, v)| v.clone())
}
fn only(&self, known: &[&str]) -> syn::Result<()> {
match self.0.iter().map(|(k, _)| k).find(|k| !known.iter().any(|n| *k == n)) {
Some(k) => Err(error(k, &format!("unknown option; the options are {}", known.join(", ")))),
None => Ok(()),
}
}
fn trust(&self) -> syn::Result<T2> {
match self.value("trust").flatten().map(|t| t.to_string()).as_deref() {
Some("always") => Ok(quote!(Always)),
Some("outside_restricted") => Ok(quote!(OutsideRestricted)),
Some("trusted") => Ok(quote!(Trusted)),
_ => Err(syn::Error::new(
proc_macro2::Span::call_site(),
"every command declares its trust class: `trust = always | outside_restricted | trusted`",
)),
}
}
}
+6
Переглянути файл
@@ -446,6 +446,12 @@ pub struct LanguageCodeStyle {
/// Comment Code › Add a space at line comment start.
#[serde(skip_serializing_if = "Option::is_none")]
pub line_comment_add_space: Option<bool>,
/// PHP: align `=>` in multi-line arrays after formatting (other languages ignore it).
#[serde(skip_serializing_if = "Option::is_none")]
pub align_key_value_pairs: Option<bool>,
/// PHP: align `=` of consecutive assignment statements after formatting.
#[serde(skip_serializing_if = "Option::is_none")]
pub align_consecutive_assignments: Option<bool>,
}
/// Editor › Code Style (General tab + per-language overrides).
+98
Переглянути файл
@@ -36,6 +36,8 @@ pub enum IdeEvent {
},
/// Project window membership or selection changed.
WindowGroupsChanged,
/// A project was loaded or unloaded for the MCP server without a window of its own.
McpBackgroundProjectsChanged,
/// A window entered or left full screen, itself or as a member of a full-screen window group.
WindowFullscreenChanged,
/// This remote window's connection to its host ended on its own (network loss, the host or
@@ -47,6 +49,16 @@ pub enum IdeEvent {
root: crate::IpcPath,
trusted: bool,
},
/// The project's direnv environment (`.envrc`) could not be loaded, or a file it is read
/// from changed and it can be reloaded.
Direnv {
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>,
@@ -77,6 +89,8 @@ pub enum IdeEvent {
DocDirty {
doc: DocId,
dirty: bool,
/// Text version when this transition occurred, including when it was saved.
version: u32,
},
/// A complete workspace edit can be undone as one operation.
WorkspaceEditApplied {
@@ -147,6 +161,19 @@ pub enum IdeEvent {
server: ServerId,
kind: LspRefreshKind,
},
/// A language server asked the user to choose an action, e.g. Dart's
/// "Renamed field will be invisible in …" warning during a rename. Answered
/// with `lsp_message_request_answer`; the server cancels if we reply null.
LspMessageRequest {
id: u32,
server: String,
message: String,
actions: Vec<String>,
},
/// The request was answered or timed out; every window drops its dialog.
LspMessageRequestDone {
id: u32,
},
TerminalExited {
terminal: TerminalId,
code: Option<i32>,
@@ -215,6 +242,60 @@ 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")]
pub enum DirenvStatus {
/// `direnv` is not installed (on the search path).
NotInstalled,
/// direnv refuses the `.envrc` until the user approves it with `direnv allow`.
Blocked,
/// `direnv export` failed or took too long: what it printed last.
Failed { message: String },
/// `.envrc`, `flake.nix` or `flake.lock` (a file name in the project root) changed.
Changed { file: String },
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum ServerStatus {
@@ -235,6 +316,8 @@ pub enum LspRefreshKind {
InlayHints,
SemanticTokens,
CodeLens,
/// The Dart server published a document's Flutter outline.
FlutterOutline,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
@@ -290,6 +373,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`,
+1
Переглянути файл
@@ -19,6 +19,7 @@ pub mod output_encoding;
pub mod platform;
pub mod process;
pub mod project_dir;
pub mod project_env;
pub mod project_roots;
pub mod proxy_settings;
pub mod real_path;
+195 -14
Переглянути файл
@@ -1,6 +1,7 @@
//! Child-process helpers shared by every crate that spawns tools.
use std::ffi::{OsStr, OsString};
use std::path::Path;
#[cfg(windows)]
use std::process::Stdio;
use std::process::{Child, Command};
@@ -15,17 +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`.
/// 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
@@ -516,10 +555,13 @@ mod windows_job {
/// those of a manual HTTP proxy ([`crate::proxy_settings::ProxySettings::child_env`]),
/// and the login shell's variables this process lacks ([`shell_env`]: an app started from
/// Finder/Dock doesn't have what rc files export, such as `GOPATH`, `JAVA_HOME` or
/// `MAVEN_OPTS`). Variables the call site has already set are kept.
/// `MAVEN_OPTS`). A child whose `current_dir` is inside a project also gets the project's
/// environment ([`crate::project_env`]), so set it first. Variables the call site has
/// already set are kept.
pub fn host_env(cmd: &mut Command) -> &mut Command {
let fixes = child_env_changes();
let shell: Vec<_> = shell_env().collect();
let dir = cmd.get_current_dir().map(Path::to_path_buf);
let fixes = child_env_changes(dir.as_deref());
let shell: Vec<_> = shell_env_for(dir.as_deref()).collect();
if fixes.is_empty() && shell.is_empty() {
return cmd;
}
@@ -540,22 +582,40 @@ pub fn host_env(cmd: &mut Command) -> &mut Command {
/// that are not a `std::process::Command` (a PTY `CommandBuilder`). Apply before the call
/// site's own variables. Empty outside an AppImage without an overlay.
pub fn host_env_fixes() -> Vec<(OsString, Option<OsString>)> {
child_env_changes()
child_env_changes(None)
}
/// [`host_env_fixes`] for a child started in `dir`, the environment of the project holding it included.
pub fn host_env_fixes_in(dir: &Path) -> Vec<(OsString, Option<OsString>)> {
child_env_changes(Some(dir))
}
/// This process's environment as a child should inherit it (see [`host_env`]), for call
/// sites that build a child's environment from the IDE's own instead of inheriting it.
pub fn host_vars() -> impl Iterator<Item = (OsString, OsString)> {
apply_changes(std::env::vars_os().collect(), &child_env_changes()).into_iter()
apply_changes(std::env::vars_os().collect(), &child_env_changes(None)).into_iter()
}
/// [`host_vars`] for a child started in `dir`.
pub fn host_vars_in(dir: &Path) -> impl Iterator<Item = (OsString, OsString)> {
apply_changes(std::env::vars_os().collect(), &child_env_changes(Some(dir))).into_iter()
}
/// [`std::env::var_os`] as a child should see it (see [`host_env`]), the login shell's value
/// included when this process lacks the variable.
pub fn host_var_os(key: impl AsRef<OsStr>) -> Option<OsString> {
let key = key.as_ref();
match child_env_changes().into_iter().find(|(k, _)| k == key) {
host_var_os_for(None, key.as_ref())
}
/// [`host_var_os`] for a child started in `dir`.
pub fn host_var_os_in(dir: &Path, key: impl AsRef<OsStr>) -> Option<OsString> {
host_var_os_for(Some(dir), key.as_ref())
}
fn host_var_os_for(dir: Option<&Path>, key: &OsStr) -> Option<OsString> {
match child_env_changes(dir).into_iter().find(|(k, _)| k == key) {
Some((_, fixed)) => fixed,
None => std::env::var_os(key).or_else(|| shell_env().find(|(k, _)| k == key).map(|(_, v)| v)),
None => std::env::var_os(key).or_else(|| shell_env_for(dir).find(|(k, _)| k == key).map(|(_, v)| v)),
}
}
@@ -578,8 +638,9 @@ fn apply_changes(
vars
}
/// The AppImage fixes, the overlay, then the manual proxy's (a later one wins); one entry per name.
fn child_env_changes() -> Vec<(OsString, Option<OsString>)> {
/// The AppImage fixes, the overlay, the manual proxy's, then those of the project holding
/// `dir` (a later one wins); one entry per name.
fn child_env_changes(dir: Option<&Path>) -> Vec<(OsString, Option<OsString>)> {
let mut changes = appimage_fixes();
let overlay = env_overlay();
changes.retain(|(k, _)| !overlay.iter().any(|(o, _)| o == k));
@@ -588,6 +649,11 @@ fn child_env_changes() -> Vec<(OsString, Option<OsString>)> {
let proxy = crate::proxy_settings::proxy().child_env();
changes.retain(|(k, _)| !proxy.iter().any(|(p, _)| p == k));
changes.extend(proxy);
if let Some(dir) = dir {
let project = crate::project_env::for_dir(dir);
changes.retain(|(k, _)| !project.iter().any(|(p, _)| p == k));
changes.extend(project.iter().cloned());
}
changes
}
@@ -667,11 +733,26 @@ pub fn login_env() -> Option<Vars> {
/// Apply before a call site's own variables so those win. Empty until the shell has been read.
/// Names the overlay sets are left out: [`host_env`] gives them their value.
pub fn shell_env() -> impl Iterator<Item = (OsString, OsString)> {
shell_env_for(None)
}
/// [`shell_env`] for a child started in `dir`: names the environment of the project holding
/// it sets are left out too.
pub fn shell_env_in(dir: &Path) -> impl Iterator<Item = (OsString, OsString)> {
shell_env_for(Some(dir))
}
fn shell_env_for(dir: Option<&Path>) -> impl Iterator<Item = (OsString, OsString)> {
let overlay = env_overlay();
let project = dir.map(crate::project_env::for_dir).unwrap_or_default();
let vars = login_env().unwrap_or_default();
let lacking: Vec<_> = vars
.iter()
.filter(|(k, _)| std::env::var_os(k).is_none() && !overlay.iter().any(|(o, _)| o == k))
.filter(|(k, _)| {
std::env::var_os(k).is_none()
&& !overlay.iter().any(|(o, _)| o == k)
&& !project.iter().any(|(p, _)| p == k)
})
.cloned()
.collect();
lacking.into_iter()
@@ -726,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");
@@ -841,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() {
@@ -1015,6 +1155,47 @@ mod tests {
set_env_overlay(Vec::new());
}
#[test]
fn a_child_inside_a_project_gets_its_environment() {
let root = std::path::Path::new("/openidea-test-process/project");
// Absolute on the platform: the search path drops relative entries.
let devshell = if cfg!(windows) { r"C:\nix\store\x-devshell\bin" } else { "/nix/store/x-devshell/bin" };
crate::project_env::set(
root,
vec![
("OPENIDEA_PROJECT_VAR".into(), Some("devshell".into())),
("PATH".into(), Some(devshell.into())),
("OPENIDEA_PROJECT_UNSET".into(), None),
],
);
let get = |cmd: &Command, k: &str| cmd.get_envs().find(|(n, _)| *n == k).map(|(_, v)| v.map(OsStr::to_owned));
let mut inside = Command::new("true");
inside.current_dir(root.join("src")).env("OPENIDEA_PROJECT_VAR", "call site");
host_env(&mut inside);
assert_eq!(get(&inside, "PATH"), Some(Some(devshell.into())));
assert_eq!(get(&inside, "OPENIDEA_PROJECT_UNSET"), Some(None));
assert_eq!(get(&inside, "OPENIDEA_PROJECT_VAR"), Some(Some("call site".into())), "the call site's value wins");
let mut outside = Command::new("true");
outside.current_dir("/openidea-test-process/other");
host_env(&mut outside);
assert_eq!(get(&outside, "OPENIDEA_PROJECT_VAR"), None);
let mut no_dir = Command::new("true");
host_env(&mut no_dir);
assert_eq!(get(&no_dir, "OPENIDEA_PROJECT_VAR"), None);
// Spawners that build the environment themselves (PTYs, runs) and `PATH` lookups.
assert!(host_env_fixes_in(root).iter().any(|(k, v)| k == "OPENIDEA_PROJECT_VAR" && v.is_some()));
assert!(host_vars_in(root).any(|(k, v)| k == "OPENIDEA_PROJECT_VAR" && v == "devshell"));
assert_eq!(host_var_os_in(root, "OPENIDEA_PROJECT_VAR"), Some("devshell".into()));
assert_eq!(host_var_os("OPENIDEA_PROJECT_VAR"), None);
let search = crate::tool_path::search_path_in(root);
assert_eq!(std::env::split_paths(&search).next(), Some(devshell.into()));
crate::project_env::remove(root);
assert!(host_vars_in(root).all(|(k, _)| k != "OPENIDEA_PROJECT_VAR"));
}
#[test]
fn changes_apply_in_order() {
let vars = apply_changes(
+138
Переглянути файл
@@ -0,0 +1,138 @@
//! Environments of project folders (a project's direnv `.envrc`), for the children started
//! inside them. One process can hold several projects (desktop windows), so unlike the
//! process-wide overlay ([`crate::process::set_env_overlay`]) these are kept per root and
//! found from a child's working directory: see [`crate::process::host_env`] and the `_in`
//! variants next to it.
use crate::CancellationToken;
use std::ffi::OsString;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Condvar, Mutex, MutexGuard};
use std::time::Duration;
pub type Changes = Arc<Vec<(OsString, Option<OsString>)>>;
struct Entry {
root: PathBuf,
changes: Changes,
loading: bool,
}
static ENTRIES: Mutex<Vec<Entry>> = Mutex::new(Vec::new());
static SETTLED: Condvar = Condvar::new();
fn entries() -> MutexGuard<'static, Vec<Entry>> {
ENTRIES.lock().unwrap_or_else(|e| e.into_inner())
}
/// `root`'s environment is being read: [`wait`] blocks until [`set`] or [`remove`]. Children
/// started meanwhile keep getting the last one read.
pub fn begin_loading(root: &Path) {
let mut entries = entries();
match entries.iter_mut().find(|e| e.root == root) {
Some(entry) => entry.loading = true,
None => entries.push(Entry { root: root.to_path_buf(), changes: Changes::default(), loading: true }),
}
}
/// What children started in `root` (or below it) get on top of the IDE's own environment
/// (`None`: removed). Ends a [`begin_loading`].
pub fn set(root: &Path, changes: Vec<(OsString, Option<OsString>)>) {
let mut entries = entries();
let changes = Arc::new(changes);
match entries.iter_mut().find(|e| e.root == root) {
Some(entry) => {
entry.changes = changes;
entry.loading = false;
}
None => entries.push(Entry { root: root.to_path_buf(), changes, loading: false }),
}
SETTLED.notify_all();
}
/// Ends a [`begin_loading`] that read nothing new (an error): the last environment stays.
pub fn settle(root: &Path) {
if let Some(entry) = entries().iter_mut().find(|e| e.root == root) {
entry.loading = false;
}
SETTLED.notify_all();
}
/// `root` has no environment of its own any more (closed, or not trusted).
pub fn remove(root: &Path) {
entries().retain(|e| e.root != root);
SETTLED.notify_all();
}
/// The innermost root holding `dir`.
fn find<'a>(entries: &'a [Entry], dir: &Path) -> Option<&'a Entry> {
entries.iter().filter(|e| dir.starts_with(&e.root)).max_by_key(|e| e.root.components().count())
}
/// The environment of the project holding `dir` (empty outside every project, or before it was read).
pub fn for_dir(dir: &Path) -> Changes {
find(&entries(), dir).map(|e| e.changes.clone()).unwrap_or_default()
}
/// Whether the environment of the project holding `dir` is being read.
pub fn is_loading(dir: &Path) -> bool {
find(&entries(), dir).is_some_and(|e| e.loading)
}
/// Blocks while the environment of the project holding `dir` is being read, or until `cancel`.
/// For what must not start without it: language servers.
pub fn wait(dir: &Path, cancel: &CancellationToken) {
let mut entries = entries();
while !cancel.is_cancelled() && find(&entries, dir).is_some_and(|e| e.loading) {
entries = SETTLED.wait_timeout(entries, Duration::from_millis(200)).unwrap_or_else(|e| e.into_inner()).0;
}
}
#[cfg(test)]
mod tests {
use super::*;
fn change(k: &str, v: Option<&str>) -> (OsString, Option<OsString>) {
(k.into(), v.map(Into::into))
}
#[test]
fn the_innermost_project_holding_a_folder_applies() {
let outer = Path::new("/openidea-test-env/outer");
let inner = Path::new("/openidea-test-env/outer/inner");
set(outer, vec![change("A", Some("outer"))]);
set(inner, vec![change("A", Some("inner")), change("B", None)]);
assert_eq!(*for_dir(&outer.join("src")), [change("A", Some("outer"))]);
assert_eq!(*for_dir(&inner.join("src/deep")), [change("A", Some("inner")), change("B", None)]);
assert!(for_dir(Path::new("/openidea-test-env/outer-sibling")).is_empty(), "whole components only");
remove(inner);
assert_eq!(*for_dir(inner), [change("A", Some("outer"))]);
remove(outer);
assert!(for_dir(inner).is_empty());
}
#[test]
fn waiting_ends_once_the_environment_is_read() {
let root = Path::new("/openidea-test-env/waiting");
set(root, vec![change("OLD", Some("1"))]);
begin_loading(root);
assert!(is_loading(&root.join("src")));
assert_eq!(*for_dir(root), [change("OLD", Some("1"))], "the last one read stays until then");
let reader = std::thread::spawn(|| {
std::thread::sleep(Duration::from_millis(100));
set(Path::new("/openidea-test-env/waiting"), vec![change("NEW", Some("2"))]);
});
wait(&root.join("src"), &CancellationToken::new());
assert_eq!(*for_dir(root), [change("NEW", Some("2"))]);
reader.join().unwrap();
begin_loading(root);
let cancel = CancellationToken::new();
cancel.cancel();
wait(root, &cancel);
settle(root);
assert!(!is_loading(root));
assert_eq!(*for_dir(root), [change("NEW", Some("2"))]);
remove(root);
}
}
+188 -1
Переглянути файл
@@ -34,6 +34,8 @@ pub struct Settings {
pub project_structure: ProjectStructureSettings,
/// Version Control (Git, Commit, Confirmation, Issue Navigation).
pub vcs: VcsSettings,
/// Build, Execution, Deployment › Compiler (Build tool window).
pub build: BuildSettings,
/// Build, Execution, Deployment › Console.
pub console: ConsoleSettings,
pub debugger: DebuggerSettings,
@@ -50,6 +52,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.
@@ -315,6 +319,20 @@ pub enum NewTaskApprovals {
Ask,
}
/// Which folders without an open window the MCP server still serves tools for.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum McpBackgroundProjects {
/// Only projects open in a window.
#[default]
Off,
/// Also folders the user trusts: trusted projects, recent projects and the repositories inside
/// trusted locations.
Trusted,
/// Only the folders in [`McpServerSettings::background_project_paths`] (and below them).
Listed,
}
/// Agents › MCP Server: agents use the IDE's built-in tools.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
@@ -339,6 +357,21 @@ pub struct McpServerSettings {
/// Keep the bearer token across runs (in the app data, readable by this user only) rather than
/// make a new one each run.
pub fixed_token: bool,
/// Serve tools for folders that have no open window (see [`McpBackgroundProjects`]); the
/// project loads when an agent first asks for it.
#[serde(deserialize_with = "or_default")]
#[specta(type = McpBackgroundProjects)]
pub background_projects: McpBackgroundProjects,
/// The folders [`McpBackgroundProjects::Listed`] serves, and the ones `Trusted` serves even
/// when untrusted.
#[serde(deserialize_with = "or_default")]
#[specta(type = Vec<String>)]
pub background_project_paths: Vec<String>,
/// Minutes a background project may go without a tool call before it is unloaded, at most
/// 1440; 0 keeps it until the IDE quits.
pub background_idle_minutes: u32,
/// Background projects loaded at once, 1 to 32; the least recently used one makes room.
pub background_project_limit: u32,
}
/// The default of [`McpServerSettings::port`].
@@ -357,10 +390,30 @@ impl Default for McpServerSettings {
fixed_port: true,
port: DEFAULT_MCP_PORT,
fixed_token: false,
background_projects: McpBackgroundProjects::Off,
background_project_paths: Vec::new(),
background_idle_minutes: 30,
background_project_limit: 8,
}
}
}
/// 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")]
@@ -490,6 +543,7 @@ impl Default for Settings {
languages: LanguagesSettings::default(),
project_structure: ProjectStructureSettings::default(),
vcs: VcsSettings::default(),
build: BuildSettings::default(),
console: ConsoleSettings::default(),
debugger: DebuggerSettings::default(),
run: RunSettings::default(),
@@ -499,6 +553,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 +807,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 +827,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,
@@ -783,6 +842,35 @@ pub struct AppearanceSettings {
pub main_toolbar: Option<MainToolbarSettings>,
/// Appearance › Background Image: an image shown through the IDE window.
pub background_image: BackgroundImageSettings,
/// Appearance › Presentation Assistant: the name and shortcut of each action run.
pub presentation_assistant: PresentationAssistantSettings,
}
/// Appearance › Presentation Assistant: shows the name and shortcut of each action the user runs.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct PresentationAssistantSettings {
pub enabled: bool,
/// `small` | `medium` | `large`.
pub size: String,
/// How long each popup stays, in seconds.
pub duration_seconds: u32,
/// `top-left`, `top`, `top-right`, `bottom-left`, `bottom` or `bottom-right` of the window.
pub position: String,
/// Also show the shortcut of the other platform's keymap (macOS ⇄ Windows/Linux).
pub alternate_keymap: bool,
}
impl Default for PresentationAssistantSettings {
fn default() -> Self {
Self {
enabled: false,
size: "medium".into(),
duration_seconds: 4,
position: "bottom".into(),
alternate_keymap: false,
}
}
}
/// Appearance › Background Image. An empty `path` shows no image.
@@ -856,6 +944,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,
@@ -869,12 +958,14 @@ 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,
status_bar_widgets: BTreeMap::new(),
main_toolbar: None,
background_image: BackgroundImageSettings::default(),
presentation_assistant: PresentationAssistantSettings::default(),
}
}
}
@@ -1139,11 +1230,31 @@ pub struct ArduinoSettings {
}
/// Languages & Frameworks › Markdown. Like IDEA's, it is application-level only.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct MarkdownSettings {
/// Preview (and notebook Markdown cell) font size in px; unset follows the editor font size.
pub preview_font_size: Option<u32>,
/// "Detect commands that can be run right from Markdown files": gutter run icons on
/// shell code blocks and on command lines in code blocks.
pub run_commands: bool,
/// Where those commands run; unset asks when the project and the file's folder differ.
pub command_directory: Option<MarkdownCommandDirectory>,
}
impl Default for MarkdownSettings {
fn default() -> Self {
Self { preview_font_size: None, run_commands: true, command_directory: None }
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "lowercase")]
pub enum MarkdownCommandDirectory {
/// The project's root folder.
Project,
/// The Markdown file's parent folder.
File,
}
impl LanguagesSettings {
@@ -1348,6 +1459,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,
}
@@ -1474,6 +1587,13 @@ pub struct MavenSettings {
pub active_profiles: String,
/// Delegate IDE build/run actions to Maven: launches build with Maven (`javac`) instead of jdtls (ECJ).
pub delegate_build: bool,
/// Download `-sources.jar` of dependencies when the Java language server imports the
/// 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 {
@@ -1718,6 +1838,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}}"#] {
@@ -2043,6 +2173,63 @@ mod tests {
let restored: Settings = serde_json::from_value(value).unwrap();
assert_eq!(restored, settings);
}
#[test]
fn background_projects_default_to_off_with_no_paths_30_idle_minutes_and_a_limit_of_8() {
for settings in [Settings::default(), serde_json::from_str(r#"{"mcpServer":{"enabled":true}}"#).unwrap()] {
let mcp = settings.mcp_server;
assert_eq!(mcp.background_projects, McpBackgroundProjects::Off);
assert!(mcp.background_project_paths.is_empty());
assert_eq!((mcp.background_idle_minutes, mcp.background_project_limit), (30, 8));
}
}
#[test]
fn a_bad_background_mode_or_path_list_reads_as_its_default_and_keeps_the_rest() {
for (key, bad) in
[("backgroundProjects", serde_json::json!("bogus")), ("backgroundProjectPaths", serde_json::json!(5))]
{
let mut json = serde_json::json!({
"appearance": { "theme": "solarized-dark" },
"mcpServer": {
"enabled": true,
"port": 7000,
"backgroundProjects": "listed",
"backgroundProjectPaths": ["/projects/inventory"],
"backgroundIdleMinutes": 10,
"backgroundProjectLimit": 3,
},
});
json["mcpServer"][key] = bad;
let settings: Settings = serde_json::from_value(json).unwrap_or_else(|e| panic!("{key}: {e}"));
let mcp = settings.mcp_server;
let (mode, paths) = if key == "backgroundProjects" {
(McpBackgroundProjects::Off, vec!["/projects/inventory".to_owned()])
} else {
(McpBackgroundProjects::Listed, Vec::new())
};
assert_eq!((mcp.background_projects, mcp.background_project_paths), (mode, paths), "{key}");
assert_eq!((mcp.enabled, mcp.port), (true, 7000), "{key}");
assert_eq!((mcp.background_idle_minutes, mcp.background_project_limit), (10, 3), "{key}");
assert_eq!(settings.appearance.theme, "solarized-dark", "{key}");
}
}
#[test]
fn background_project_settings_round_trip() {
for mode in [McpBackgroundProjects::Off, McpBackgroundProjects::Trusted, McpBackgroundProjects::Listed] {
let mut settings = Settings::default();
settings.mcp_server.background_projects = mode;
settings.mcp_server.background_project_paths =
vec!["/projects/inventory".into(), "/projects/billing".into()];
settings.mcp_server.background_idle_minutes = 0;
settings.mcp_server.background_project_limit = 32;
let json = serde_json::to_string(&settings).unwrap();
assert!(json.contains(r#""backgroundProjects":""#), "{json}");
let restored: Settings = serde_json::from_str(&json).unwrap();
assert_eq!(restored.mcp_server, settings.mcp_server);
}
}
}
#[cfg(test)]
+2
Переглянути файл
@@ -239,6 +239,8 @@ pub enum SymbolKind {
Event,
Operator,
Key,
/// A Flutter widget built in the code (Flutter outline only).
Widget,
Unknown,
}
+16 -2
Переглянути файл
@@ -2,7 +2,7 @@
//! their settings come from, installers. An app started from the desktop gets a
//! minimal `PATH`, and version managers set theirs up in shell rc files.
use crate::process::{host_var_os, login_env};
use crate::process::{host_var_os, host_var_os_in, login_env};
use crate::version_managers;
use std::collections::HashSet;
use std::ffi::{OsStr, OsString};
@@ -14,6 +14,16 @@ use std::path::{Path, PathBuf};
/// launchers, their settings hooks and tool detection all look here, so a settings
/// hook finds the executable its server is launched from.
pub fn search_path() -> OsString {
search_path_for(None)
}
/// [`search_path`] for a child started in `dir`: the `PATH` of the project holding it
/// ([`crate::project_env`], e.g. a Nix devshell's) comes first.
pub fn search_path_in(dir: &Path) -> OsString {
search_path_for(Some(dir))
}
fn search_path_for(dir: Option<&Path>) -> OsString {
let home = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(PathBuf::from);
let shell_path = login_env().and_then(|env| env.iter().find(|(k, _)| k == "PATH").map(|(_, v)| v.clone()));
let shims: Vec<PathBuf> = version_managers::managers().iter().map(|m| m.shims()).collect();
@@ -21,7 +31,11 @@ pub fn search_path() -> OsString {
// entries after the inherited ones so missing user tools still resolve.
let user_path = crate::process::user_path();
let dirs = search_dirs(
host_var_os("PATH").as_deref(),
match dir {
Some(dir) => host_var_os_in(dir, "PATH"),
None => host_var_os("PATH"),
}
.as_deref(),
shell_path.as_deref(),
user_path.as_deref(),
home.as_deref(),
+72
Переглянути файл
@@ -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,
}
}
}
@@ -135,6 +168,14 @@ pub struct CommitSettings {
/// `Settings::default()`, or `SettingsStore::set` rejects the key as unknown.
#[specta(optional)]
pub double_click_opens_diff: Option<bool>,
/// Team conventions for Generate Commit Message with Agent, added to its prompt.
pub agent_instructions: String,
/// 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 {
@@ -156,6 +197,10 @@ impl Default for CommitSettings {
wrap_at_margin: false,
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(),
}
}
}
@@ -272,6 +317,23 @@ pub struct SqlResolutionScope {
pub schema: String,
}
/// Build, Execution, Deployment › Compiler (Build tool window behaviour).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct BuildSettings {
/// When to open the Build tool window: `always` | `onError` | `never`.
pub open_tool_window: String,
/// When to focus the Build tool window: `always` | `onError` | `never`.
pub focus_tool_window: String,
}
impl Default for BuildSettings {
fn default() -> Self {
// Builds open the tool window without taking focus.
Self { open_tool_window: "always".into(), focus_tool_window: "never".into() }
}
}
/// Build, Execution, Deployment › Console.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
@@ -331,6 +393,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,
}
@@ -351,6 +415,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(),
}
}
@@ -409,6 +474,9 @@ pub struct TerminalSettings {
/// Shell command line; empty = the login shell.
pub shell_path: String,
pub tab_name: String,
/// Title a program sets (OSC 0/2) as the tab's name: `running` (while a command runs),
/// `always`, or `off`.
pub app_title_as_tab_name: String,
pub audible_bell: bool,
pub close_on_exit: bool,
pub mouse_reporting: bool,
@@ -424,6 +492,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,
@@ -442,6 +512,7 @@ impl Default for TerminalSettings {
env: BTreeMap::new(),
shell_path: String::new(),
tab_name: "Local".into(),
app_title_as_tab_name: "running".into(),
audible_bell: true,
close_on_exit: true,
mouse_reporting: true,
@@ -455,6 +526,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,
+1 -2
Переглянути файл
@@ -214,9 +214,8 @@ pub fn collect(spec: &CoverageReportSpec) -> IdeResult<CoverageSuite> {
CoverageReportSpec::Exported { runner, argv, cwd, env, lcov } => {
let (program, args) =
argv.split_first().ok_or_else(|| IdeError::invalid("empty coverage export command"))?;
let out = ide_core::process::prepare(&mut Command::new(program))
let out = ide_core::process::prepare(Command::new(program).current_dir(cwd))
.args(args)
.current_dir(cwd)
.envs(env)
.output()
.map_err(|e| IdeError::unavailable(format!("cannot run {program}: {e}")))?;
+34 -14
Переглянути файл
@@ -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"],
@@ -281,15 +291,16 @@ fn managed_dirs(root: &Path) -> Vec<PathBuf> {
/// The `PATH` an adapter runs with, unless its launch sets one: the search path language servers
/// get, so what it starts in turn (js-debug's wrapper runs `node`, Delve runs `go build`) is
/// found like Run finds it, even when the login shell's `PATH` didn't reach the app.
fn adapter_path(env: &[(String, String)]) -> Option<std::ffi::OsString> {
fn adapter_path(env: &[(String, String)], cwd: &Path) -> Option<std::ffi::OsString> {
let own = env.iter().any(|(k, _)| if cfg!(windows) { k.eq_ignore_ascii_case("PATH") } else { k == "PATH" });
(!own).then(ide_core::tool_path::search_path)
(!own).then(|| ide_core::tool_path::search_path_in(cwd))
}
/// Directories searched for adapter binaries: managed tools first, then `PATH` and the usual install spots.
fn search_dirs() -> Vec<PathBuf> {
/// Directories searched for adapter binaries: managed tools first, then `PATH` (the project's
/// holding `cwd` first) and the usual install spots.
fn search_dirs(cwd: &Path) -> Vec<PathBuf> {
let mut dirs: Vec<PathBuf> = tools_root().map(|r| managed_dirs(&r)).unwrap_or_default();
dirs.extend(std::env::split_paths(&ide_core::tool_path::search_path()));
dirs.extend(std::env::split_paths(&ide_core::tool_path::search_path_in(cwd)));
if let Some(home) = std::env::var_os("HOME").map(PathBuf::from) {
for rel in [".cargo/bin", ".local/bin", "go/bin", ".dotnet/tools", ".bun/bin", ".npm-global/bin", ".volta/bin"]
{
@@ -318,7 +329,7 @@ fn is_executable(path: &Path, windows: bool) -> bool {
/// extensionless script next to a shim is never started as a program.
pub fn find_binary(command: &str, cwd: &Path) -> Option<PathBuf> {
let pathext = std::env::var("PATHEXT").ok();
find_binary_in(command, cwd, &search_dirs(), cfg!(windows), pathext.as_deref())
find_binary_in(command, cwd, &search_dirs(cwd), cfg!(windows), pathext.as_deref())
}
fn find_binary_in(
@@ -377,10 +388,10 @@ pub async fn prepare_debugpy(spec: &mut AdapterSpec) -> IdeResult<()> {
return Ok(()); // Reported as a missing adapter when it is started.
};
let mut probe = Command::new(&python);
probe.current_dir(&spec.cwd);
ide_core::process::prepare(probe.as_std_mut());
let probe = probe
.args(["-c", "import debugpy.adapter"])
.current_dir(&spec.cwd)
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
@@ -452,13 +463,13 @@ pub fn parse_gdb_version(output: &str) -> Option<(u32, u32)> {
/// Probe the already resolved and verified executable with its launch environment.
async fn gdb_version(binary: &Path, spec: &AdapterSpec) -> IdeResult<Option<(u32, u32)>> {
let mut probe = Command::new(binary);
if let Some(path) = adapter_path(&spec.env) {
if let Some(path) = adapter_path(&spec.env, &spec.cwd) {
probe.env("PATH", path);
}
probe.current_dir(&spec.cwd);
ide_core::process::prepare(probe.as_std_mut());
let probe = probe
.arg("--version")
.current_dir(&spec.cwd)
.envs(spec.env.iter().cloned())
.stdin(Stdio::null())
.stdout(Stdio::piped())
@@ -690,9 +701,11 @@ async fn spawn_adapter(
) -> IdeResult<AdapterIo> {
let stderr = Arc::new(parking_lot::Mutex::new(Vec::new()));
let mut cmd = Command::new(binary);
if let Some(path) = adapter_path(&spec.env) {
if let Some(path) = adapter_path(&spec.env, &spec.cwd) {
cmd.env("PATH", path);
}
// The working directory first: it picks the project's environment.
cmd.current_dir(&spec.cwd);
ide_core::process::prepare(cmd.as_std_mut());
// Every adapter leads its own process group: the program an adapter launches itself
// (java-debug's JVM) joins the group, so a forced stop reaches the whole tree with
@@ -700,7 +713,6 @@ async fn spawn_adapter(
ide_core::process::own_group(cmd.as_std_mut());
cmd.args(args)
.envs(spec.env.iter().map(|(k, v)| (k, v)))
.current_dir(&spec.cwd)
.stdin(if port.is_some() { Stdio::null() } else { Stdio::piped() })
.stdout(Stdio::piped())
.stderr(Stdio::piped())
@@ -843,10 +855,11 @@ mod tests {
#[test]
fn adapters_run_on_the_tool_search_path() {
let search = ide_core::tool_path::search_path();
assert_eq!(adapter_path(&[]), Some(search.clone()));
assert_eq!(adapter_path(&[("GOFLAGS".into(), "-mod=mod".into())]), Some(search));
let cwd = Path::new("/openidea-test-no-project");
assert_eq!(adapter_path(&[], cwd), Some(search.clone()));
assert_eq!(adapter_path(&[("GOFLAGS".into(), "-mod=mod".into())], cwd), Some(search));
// A launch that sets its own (a selected Go SDK's bin first) keeps it.
assert_eq!(adapter_path(&[("PATH".into(), "/sdk/go/bin:/usr/bin".into())]), None);
assert_eq!(adapter_path(&[("PATH".into(), "/sdk/go/bin:/usr/bin".into())], cwd), None);
// The search path reaches the usual install spots even when this process's `PATH` doesn't.
#[cfg(unix)]
{
@@ -917,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");
+1 -1
Переглянути файл
@@ -55,10 +55,10 @@ pub async fn build(
) -> IdeResult<PathBuf> {
let cargo = find_binary("cargo", cwd).ok_or_else(|| IdeError::unavailable("`cargo` not found on PATH"))?;
let mut cmd = tokio::process::Command::new(cargo);
cmd.current_dir(cwd);
ide_core::process::prepare(cmd.as_std_mut());
cmd.args(args)
.arg("--message-format=json-render-diagnostics")
.current_dir(cwd)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
+76 -9
Переглянути файл
@@ -68,10 +68,16 @@ pub enum Incoming {
Closed,
}
/// Bounded outgoing queue: an adapter that stops reading its input holds back `send`
/// instead of the IDE accumulating unbounded messages. The incoming queue stays unbounded:
/// the event loop awaits requests while handling events (`stopped` restores breakpoints), so
/// a reader parked on a full queue would never read the response that loop waits for.
const OUT_CAPACITY: usize = 256;
type Pending = HashMap<i64, (String, oneshot::Sender<Result<Value, DapError>>)>;
struct Inner {
out: mpsc::UnboundedSender<Vec<u8>>,
out: mpsc::Sender<Vec<u8>>,
pending: Mutex<Pending>,
seq: AtomicI64,
closed: AtomicBool,
@@ -114,7 +120,7 @@ impl Connection {
R: AsyncRead + Unpin + Send + 'static,
W: AsyncWrite + Unpin + Send + 'static,
{
let (out_tx, mut out_rx) = mpsc::unbounded_channel::<Vec<u8>>();
let (out_tx, mut out_rx) = mpsc::channel::<Vec<u8>>(OUT_CAPACITY);
let (in_tx, in_rx) = mpsc::unbounded_channel();
let inner = Arc::new(Inner {
out: out_tx,
@@ -183,17 +189,17 @@ impl Connection {
self.inner.closed.load(Ordering::Acquire)
}
fn send(&self, value: &Value) -> Result<(), DapError> {
async fn send(&self, value: &Value) -> Result<(), DapError> {
if self.is_closed() {
return Err(DapError::Closed);
}
let body = serde_json::to_vec(value).map_err(|e| DapError::Protocol(e.to_string()))?;
tracing::trace!(target: "ide_dap::wire", "--> {}", String::from_utf8_lossy(&body));
self.inner.out.send(body).map_err(|_| DapError::Closed)
self.inner.out.send(body).await.map_err(|_| DapError::Closed)
}
/// Sends a request and returns a receiver for its response body, without waiting.
pub fn send_request(
pub async fn send_request(
&self,
command: &str,
arguments: Value,
@@ -205,7 +211,7 @@ impl Connection {
if !arguments.is_null() {
msg["arguments"] = arguments;
}
if let Err(e) = self.send(&msg) {
if let Err(e) = self.send(&msg).await {
self.inner.pending.lock().remove(&seq);
return Err(e);
}
@@ -214,7 +220,7 @@ impl Connection {
/// Sends a request and waits for the response body (`null` when absent).
pub async fn request(&self, command: &str, arguments: Value) -> Result<Value, DapError> {
let rx = self.send_request(command, arguments)?;
let rx = self.send_request(command, arguments).await?;
rx.await.unwrap_or(Err(DapError::Closed))
}
@@ -226,7 +232,12 @@ impl Connection {
}
/// Answers a reverse request.
pub fn respond(&self, request_seq: i64, command: &str, result: Result<Value, String>) -> Result<(), DapError> {
pub async fn respond(
&self,
request_seq: i64,
command: &str,
result: Result<Value, String>,
) -> Result<(), DapError> {
let seq = self.inner.seq.fetch_add(1, Ordering::Relaxed);
let mut msg = json!({
"seq": seq,
@@ -240,7 +251,7 @@ impl Connection {
Ok(_) => {}
Err(message) => msg["message"] = Value::String(message),
}
self.send(&msg)
self.send(&msg).await
}
}
@@ -319,6 +330,62 @@ fn error_message(msg: &Value) -> String {
mod tests {
use super::*;
#[tokio::test]
async fn a_handler_awaiting_a_request_still_gets_its_response_behind_an_event_burst() {
// The event loop handles `stopped` by sending `setBreakpoints` and awaiting the reply
// while the adapter keeps printing: the reply arrives behind thousands of events.
let (client_in, mut adapter_out) = tokio::io::duplex(64 * 1024);
let (client_out, adapter_in) = tokio::io::duplex(64 * 1024);
let (conn, mut incoming) = Connection::start(client_in, client_out);
let adapter = tokio::spawn(async move {
let event =
|seq: i64, event: &str| json!({"seq": seq, "type": "event", "event": event, "body": {"output": "x"}});
framing::write_message(&mut adapter_out, event(0, "stopped").to_string().as_bytes()).await.unwrap();
for i in 1..=5000 {
framing::write_message(&mut adapter_out, event(i, "output").to_string().as_bytes()).await.unwrap();
}
let mut requests = BufReader::new(adapter_in);
let request = framing::read_message(&mut requests).await.unwrap().unwrap();
let request: Value = serde_json::from_slice(&request).unwrap();
let response = json!({"seq": 5001, "type": "response", "request_seq": request["seq"], "success": true, "command": request["command"], "body": {"breakpoints": []}});
framing::write_message(&mut adapter_out, response.to_string().as_bytes()).await.unwrap();
adapter_out
});
let Some(Incoming::Event { event, .. }) = incoming.recv().await else { panic!("no event") };
assert_eq!(event, "stopped");
let reply = tokio::time::timeout(Duration::from_secs(10), conn.request("setBreakpoints", json!({})))
.await
.expect("the reader stalled behind the events")
.unwrap();
assert_eq!(reply, json!({"breakpoints": []}));
let _ = adapter.await;
}
#[tokio::test]
async fn outgoing_commands_are_backpressured_when_the_adapter_is_slow() {
let (writer, _unread_peer) = tokio::io::duplex(32 * 1024);
let (reader, _idle_peer) = tokio::io::duplex(32 * 1024);
// Nobody reads the writer's pipe, so it fills and the writer task stalls.
let (conn, _incoming) = Connection::start(reader, writer);
let producer_conn = conn.clone();
let sent = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let count = sent.clone();
let producer = tokio::spawn(async move {
for i in 0..2000 {
let body = json!({"seq": i, "type": "event", "event": "output", "body": {"output": "x"}});
if producer_conn.send(&body).await.is_err() {
break;
}
count.fetch_add(1, Ordering::Relaxed);
}
});
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(sent.load(Ordering::Relaxed) < 2000);
// The bounded queue held `send` back; closing cancels the writer task.
conn.close();
producer.abort();
}
#[test]
fn parses_output_events_with_non_utf8_text() {
// "中文" in GBK inside an output event, as netcoredbg sends it on a Chinese Windows.
+15 -1
Переглянути файл
@@ -216,7 +216,21 @@ pub(crate) async fn serve(
}
}
if holding {
let _ = write.send(call("Fetch.disable", json!({})).1).await;
let (disable, command) = call("Fetch.disable", json!({}));
if write.send(command).await.is_ok() {
// Wait until the proxy has disabled interception before closing the
// socket. Dropping it with unread replies can reset the connection.
let _ = tokio::time::timeout(REQUEST_TIMEOUT, async {
while let Some(Ok(message)) = read.next().await {
let Ok(text) = message.to_text() else { continue };
let Ok(reply) = serde_json::from_str::<Value>(text) else { continue };
if reply.get("id").and_then(Value::as_u64) == Some(disable) {
break;
}
}
})
.await;
}
}
let _ = write.close().await;
}
+47 -8
Переглянути файл
@@ -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();
@@ -1105,7 +1144,7 @@ impl DebugManager {
let mut launch = if launch_in_config {
None
} else {
let reply = s.conn.send_request(request, arguments.clone())?;
let reply = s.conn.send_request(request, arguments.clone()).await?;
Some(Box::pin(async move { reply.await.unwrap_or(Err(DapError::Closed)) }))
};
let mut initialized = s.initialized.subscribe();
@@ -1183,7 +1222,7 @@ impl DebugManager {
}
if s.supports("supportsConfigurationDoneRequest") {
if s.adapter == kotlin::ADAPTER {
drop(s.conn.send_request("configurationDone", json!({}))?);
drop(s.conn.send_request("configurationDone", json!({})).await?);
} else {
s.conn.request_timeout("configurationDone", Value::Null, REQUEST_TIMEOUT).await?;
}
@@ -1197,7 +1236,7 @@ impl DebugManager {
}
None => {
// GDB 15: the breakpoints are in, so its `run` cannot miss them.
let reply = s.conn.send_request(request, arguments)?;
let reply = s.conn.send_request(request, arguments).await?;
reply.await.unwrap_or(Err(DapError::Closed))?;
}
}
@@ -1207,7 +1246,7 @@ impl DebugManager {
// never answered), and the page is already loading: its document and first scripts
// are not in the list.
if js_debug::is_page(s) {
let answer = s.conn.send_request("enableNetworking", js_debug::networking_arguments())?;
let answer = s.conn.send_request("enableNetworking", js_debug::networking_arguments()).await?;
let session = s.clone();
// Not waited for here: the page runs on. A refusal is told to the Network view,
// which would otherwise wait for requests that never come.
@@ -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(())
}
+93 -19
Переглянути файл
@@ -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}"),
}
}
@@ -892,7 +924,11 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
match command {
"runInTerminal" => {
let result = run_in_terminal(s, &args);
let _ = s.conn.respond(seq, command, result);
let conn = s.conn.clone();
let command = command.to_owned();
tokio::spawn(async move {
let _ = conn.respond(seq, &command, result).await;
});
}
"startDebugging" => {
let mgr = mgr.clone();
@@ -901,18 +937,22 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
let request = args.get("request").and_then(Value::as_str).unwrap_or("launch").to_owned();
let configuration = args.get("configuration").cloned().unwrap_or_else(|| json!({}));
let result = mgr.start_child(&s, request, configuration).await;
let _ = s.conn.respond(seq, "startDebugging", result.map(|_| Value::Null).map_err(|e| e.message));
let _ = s.conn.respond(seq, "startDebugging", result.map(|_| Value::Null).map_err(|e| e.message)).await;
});
}
_ => {
let _ = s.conn.respond(seq, command, Err(format!("unsupported reverse request {command}")));
let conn = s.conn.clone();
let command = command.to_owned();
tokio::spawn(async move {
let _ = conn.respond(seq, &command, Err(format!("unsupported reverse request {command}"))).await;
});
}
}
}
/// A `runInTerminal` program and the pseudo-terminal it runs in.
pub(crate) struct ProgramTerminal {
writer: ide_core::input::InputWriter,
writer: Arc<ide_core::input::InputWriter>,
killer: Box<dyn portable_pty::ChildKiller + Send + Sync>,
#[cfg_attr(not(unix), allow(dead_code))]
pid: Option<u32>,
@@ -979,20 +1019,18 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
let mut cmd = CommandBuilder::new(program);
// CodeLLDB's launcher clears the terminal first; the console keeps the session's earlier output.
cmd.args(rest.iter().filter(|a| *a != "--clear-screen"));
for (k, v) in ide_core::process::host_env_fixes() {
let cwd = args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()).map_or(s.spec.cwd.as_path(), Path::new);
for (k, v) in ide_core::process::host_env_fixes_in(cwd) {
match v {
Some(v) => cmd.env(k, v),
None => cmd.env_remove(k),
}
}
for (k, v) in ide_core::process::shell_env() {
for (k, v) in ide_core::process::shell_env_in(cwd) {
cmd.env(k, v);
}
cmd.env("TERM", "xterm-256color");
match args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()) {
Some(cwd) => cmd.cwd(cwd),
None => cmd.cwd(&s.spec.cwd),
}
cmd.cwd(cwd);
if let Some(env) = args.get("env").and_then(Value::as_object) {
for (k, v) in env {
match v.as_str() {
@@ -1027,10 +1065,12 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
let _ = child.wait();
})
.map_err(|e| format!("terminal input worker: {e}"))?;
let writer = Arc::new(writer);
let pid = child.process_id();
forward_terminal_output(
s,
reader,
writer.clone(),
#[cfg(unix)]
wait_readable,
);
@@ -1045,10 +1085,35 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
Ok(json!({ "processId": pid }))
}
/// The program's terminal output, as stdout lines (`\r\n` as `\n`; colours are kept).
/// A terminal's cursor position query (DSR). ConPTY sends one when it starts and runs the program
/// only once the terminal answers; programs that lay out a prompt ask it too.
const CURSOR_QUERY: &[u8] = b"\x1b[6n";
/// `chunk` without its cursor position queries, and how many there were.
pub(crate) fn take_cursor_queries(chunk: &[u8]) -> (Vec<u8>, usize) {
let mut out = Vec::with_capacity(chunk.len());
let mut queries = 0;
let mut rest = chunk;
while let Some(at) = rest.windows(CURSOR_QUERY.len()).position(|w| w == CURSOR_QUERY) {
out.extend_from_slice(&rest[..at]);
rest = &rest[at + CURSOR_QUERY.len()..];
queries += 1;
}
out.extend_from_slice(rest);
(out, queries)
}
/// Length of the end of `pending` that may begin a cursor position query the next read completes.
pub(crate) fn partial_cursor_query(pending: &[u8]) -> usize {
(1..CURSOR_QUERY.len()).rev().find(|&n| pending.ends_with(&CURSOR_QUERY[..n])).unwrap_or(0)
}
/// The program's terminal output, as stdout lines (`\r\n` as `\n`; colours are kept). The debug
/// console is no terminal, so cursor position queries are answered here (top-left corner).
fn forward_terminal_output(
s: &Session,
mut reader: Box<dyn std::io::Read + Send>,
answer: Arc<ide_core::input::InputWriter>,
#[cfg(unix)] mut wait_readable: impl FnMut() -> std::io::Result<()> + Send + 'static,
) {
let session = s.id;
@@ -1080,11 +1145,20 @@ fn forward_terminal_output(
break;
}
}
// Keep incomplete UTF-8 sequences, and a `\r` that may start a `\r\n`, for the next chunk.
let mut valid = match std::str::from_utf8(&pending) {
Ok(_) => pending.len(),
let (rest, queries) = take_cursor_queries(&pending);
pending = rest;
for _ in 0..queries {
if let Err(e) = answer.write(b"\x1b[1;1R") {
tracing::warn!(%session, "debug terminal cursor position: {e}");
}
}
// Keep incomplete UTF-8 sequences, a `\r` that may start a `\r\n`, and the start of
// a cursor position query for the next chunk.
let keep = partial_cursor_query(&pending);
let mut valid = match std::str::from_utf8(&pending[..pending.len() - keep]) {
Ok(_) => pending.len() - keep,
Err(e) if e.error_len().is_none() => e.valid_up_to(),
Err(_) => pending.len(),
Err(_) => pending.len() - keep,
};
if valid > 0 && pending[valid - 1] == b'\r' {
valid -= 1;
@@ -1163,6 +1237,7 @@ pub(crate) async fn start_kotlin_debuggee(s: &Arc<Session>, args: &mut Value) ->
let classpath =
std::env::join_paths(strings("classPaths")).map_err(|e| ide_core::IdeError::invalid(e.to_string()))?;
let mut cmd = tokio::process::Command::new(java);
cmd.current_dir(&s.spec.cwd);
ide_core::process::prepare(cmd.as_std_mut());
cmd.args(kotlin_jvm_args(strings("vmArguments"), cfg!(windows)))
// Let the JVM pick its own port (`:0`) and report it below: pre-picking a free
@@ -1181,8 +1256,7 @@ pub(crate) async fn start_kotlin_debuggee(s: &Arc<Session>, args: &mut Value) ->
.ok_or_else(|| ide_core::IdeError::invalid("Missing Kotlin main class"))?,
)
.args(strings("programArgs"))
.current_dir(&s.spec.cwd)
.envs(ide_core::process::shell_env())
.envs(ide_core::process::shell_env_in(&s.spec.cwd))
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
+98
Переглянути файл
@@ -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"}));
@@ -1010,6 +1028,44 @@ async fn run_in_terminal_spawns_debuggee() {
assert!(response["body"]["processId"].as_u64().unwrap() > 0);
}
/// The debug console answers a terminal's cursor position query: ConPTY asks one before it runs
/// the program at all (Windows debuggees never started), and programs that lay out a prompt ask too.
#[tokio::test]
async fn run_in_terminal_answers_cursor_position_queries() {
#[cfg(unix)]
let program = vec![
"sh".into(),
"-c".into(),
r"stty -echo -icanon min 6; printf '\033[6n'; reply=$(dd bs=6 count=1 2>/dev/null); stty sane; case $reply in *'[1;1R') echo answered;; esac".into(),
];
#[cfg(windows)]
let program = vec!["cmd".into(), "/c".into(), "echo answered".into()];
let h = harness(Script { run_in_terminal: Some(program), ..Script::default() });
h.start(config()).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Output { output, .. } if output.contains("answered"))).await;
let output: String = h
.events
.lock()
.iter()
.filter_map(|e| match e {
IdeEvent::Debug { event: DebugEvent::Output { output, .. }, .. } => Some(output.clone()),
_ => None,
})
.collect();
assert!(!output.contains("\x1b[6n"), "{output:?}");
}
#[test]
fn cursor_position_queries_are_taken_out_of_the_output() {
use crate::session::{partial_cursor_query, take_cursor_queries};
assert_eq!(take_cursor_queries(b"a\x1b[6nb\x1b[6n"), (b"ab".to_vec(), 2));
assert_eq!(take_cursor_queries(b"\x1b[0mtext"), (b"\x1b[0mtext".to_vec(), 0));
assert_eq!(partial_cursor_query(b"text\x1b["), 2);
assert_eq!(partial_cursor_query(b"text\x1b[6"), 3);
assert_eq!(partial_cursor_query(b"text\x1b[0m"), 0);
assert_eq!(partial_cursor_query(b"text"), 0);
}
#[cfg(unix)]
#[tokio::test]
async fn run_in_terminal_program_reads_typed_input() {
@@ -1853,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());
@@ -2242,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"] }
+351 -32
Переглянути файл
@@ -18,14 +18,21 @@ struct State {
database: String,
settings: Vec<(String, String)>,
read_only: bool,
session_id: String,
session: Mutex<bool>,
session: Mutex<Session>,
closed: CancellationToken,
}
#[derive(Default)]
struct Session {
id: Option<String>,
initialized: bool,
strict_read_only: bool,
}
/// 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 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")
@@ -36,11 +43,32 @@ impl ClickhousePool {
if source.options.transaction == DbTxMode::Manual {
return Err(transaction_error());
}
for (name, _) in &setup.params {
if reserved_setting(name) {
let mut use_http_session = None;
let mut settings = Vec::with_capacity(setup.params.len());
for (name, value) in setup.params {
if name.eq_ignore_ascii_case("use_http_session") {
if use_http_session.is_some() {
return Err(IdeError::invalid("ClickHouse use_http_session must be specified only once"));
}
use_http_session = Some(if value.eq_ignore_ascii_case("true") {
true
} else if value.eq_ignore_ascii_case("false") {
false
} else {
return Err(IdeError::invalid("ClickHouse use_http_session must be true or false"));
});
} else if reserved_setting(&name) {
return Err(IdeError::invalid(format!("ClickHouse HTTP manages the {name} setting")));
} else {
settings.push((name, value));
}
}
let use_http_session = use_http_session.unwrap_or(true);
if !use_http_session && (!setup.statements.is_empty() || !source.options.startup_script.trim().is_empty()) {
return Err(IdeError::invalid(
"ClickHouse use_http_session=false does not support startup scripts; configure database and settings on the data source for each request",
));
}
let secure = matches!(source.ssl, DbSslMode::Require | DbSslMode::VerifyCa | DbSslMode::VerifyFull);
let tls_files = [&source.ssl_ca_file, &source.ssl_cert_file, &source.ssl_key_file];
if !secure && tls_files.iter().any(|p| !p.trim().is_empty()) {
@@ -105,16 +133,50 @@ 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() },
settings: setup.params,
database: database.into(),
settings,
read_only: source.read_only,
session_id: uuid::Uuid::new_v4().to_string(),
session: Mutex::new(false),
session: Mutex::new(Session {
id: use_http_session.then(|| uuid::Uuid::new_v4().to_string()),
..Session::default()
}),
closed: CancellationToken::new(),
}));
let cancel = CancellationToken::new();
let initialize = async {
pool.execute("SELECT 1", 1, &cancel).await?;
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
if !rejects_driver_setting(&error) {
return Err(error);
}
if !use_http_session {
return Err(IdeError::new(
error.kind,
format!(
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
error.message
),
));
}
// Retry only the connection probe. Keep relying on the server for write protection
// only after verifying strict read-only mode in this same session.
{
let mut session = pool.0.session.lock().await;
// Start the proof in a fresh session: the rejected probe may have left
// its id on another replica without applying the configured database.
session.id = Some(uuid::Uuid::new_v4().to_string());
session.strict_read_only = true;
}
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
return Err(error);
}
}
// The HTTP database parameter applies to one request. A named session needs
// USE once so later queries inherit the selection (and may change it).
if use_http_session && !database.is_empty() {
let name = crate::sql::quote_ident(crate::DbDriver::Clickhouse, database);
pool.execute(&format!("USE {name}"), 0, &cancel).await?;
}
for sql in setup.statements {
pool.execute(&sql, 0, &cancel).await?;
}
@@ -151,27 +213,30 @@ impl ClickhousePool {
}
/// `max_rows`: the rows the server may send (the skipped ones included).
fn request(&self, client: &Client, query_id: &str, max_rows: usize, initialized: bool) -> RequestBuilder {
fn request(&self, client: &Client, query_id: &str, max_rows: usize, session: &Session) -> RequestBuilder {
let mut request = client
.post(self.0.endpoint.clone())
.basic_auth(&self.0.user, Some(&self.0.password))
.header(reqwest::header::CONTENT_TYPE, "text/plain; charset=utf-8")
.query(&self.0.settings)
.query(&[
("session_id", self.0.session_id.clone()),
("session_timeout", "3600".into()),
("query_id", query_id.to_owned()),
("default_format", FORMAT.into()),
.query(&[("query_id", query_id), ("default_format", FORMAT)]);
if !session.strict_read_only {
request = request.query(&[
("output_format_json_quote_denormals", "1".into()),
("max_result_rows", max_rows.saturating_add(1).to_string()),
("result_overflow_mode", "break".into()),
]);
if initialized {
request = request.query(&[("session_check", "1")]);
} else {
}
if let Some(session_id) = &session.id {
request = request.query(&[("session_id", session_id.as_str()), ("session_timeout", "3600")]);
if session.initialized {
request = request.query(&[("session_check", "1")]);
}
}
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
request = request.query(&[("database", &self.0.database)]);
}
if self.0.read_only {
if self.0.read_only && !session.strict_read_only {
request = request.query(&[("readonly", "1")]);
}
request
@@ -200,7 +265,7 @@ impl ClickhousePool {
};
let client = self.client()?;
let query_id = uuid::Uuid::new_v4().to_string();
let request = self.request(&client, &query_id, skip.saturating_add(max_rows), *session).body(sql.to_owned());
let request = self.request(&client, &query_id, skip.saturating_add(max_rows), &session).body(sql.to_owned());
let started = Instant::now();
let fetch = async {
let mut response = request.send().await.map_err(http_error)?;
@@ -254,7 +319,7 @@ impl ClickhousePool {
match result {
Some(result) => {
if result.is_ok() {
*session = true;
session.initialized = true;
}
result
}
@@ -307,11 +372,7 @@ impl ClickhousePool {
let auth = matches!(status, StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN)
|| matches!(code, Some("193" | "194" | "195" | "516" | "497"));
let detail = if message.is_empty() { status.canonical_reason().unwrap_or("request failed") } else { &message };
let detail = if detail.contains("SESSION_NOT_FOUND") || detail.contains("Session not found") {
"ClickHouse HTTP session expired; reconnect to restore session settings"
} else {
detail
};
let detail = if code == Some("372") || session_not_found(detail) { SESSION_LOST } else { detail };
self.redact_error(IdeError::new(
if auth { ErrorKind::PermissionDenied } else { ErrorKind::InvalidInput },
format!("ClickHouse HTTP {}: {detail}", status.as_u16()),
@@ -323,9 +384,9 @@ type DecodedResult = (Vec<ResultColumn>, Vec<Vec<Option<String>>>, bool);
/// Decodes a streamed [`FORMAT`] body. Reads past the first `skip` rows unparsed (a later
/// page), then keeps `max_rows` rows; later rows only set `has_more` and are read past
/// unparsed, so a grid limit bounds memory however large the block
/// `result_overflow_mode=break` lets the server send. A line that is not a JSON array
/// starts the exception ClickHouse writes when a query fails mid-stream.
/// unparsed, so a grid limit bounds memory even if a strict read-only server does not allow
/// per-query result limits. A line that is not a JSON array starts the exception ClickHouse
/// writes when a query fails mid-stream.
struct RowReader {
skip: usize,
max_rows: usize,
@@ -433,7 +494,11 @@ impl RowReader {
let rest = std::mem::take(&mut self.pending);
self.line(&rest)?;
if let Some(exception) = self.exception {
return Err(IdeError::invalid(format!("ClickHouse: {}", exception_text(&exception))));
let detail = exception_text(&exception);
return Err(IdeError::invalid(format!(
"ClickHouse: {}",
if session_not_found(detail) { SESSION_LOST } else { detail }
)));
}
let Some(names) = self.names else { return Ok((Vec::new(), Vec::new(), false)) };
let types = self.types.unwrap_or_default();
@@ -445,6 +510,13 @@ impl RowReader {
}
}
/// Whether a server message reports a named HTTP session this node doesn't have.
fn session_not_found(detail: &str) -> bool {
detail.starts_with("Code: 372.")
|| detail.starts_with("Session not found")
|| detail.starts_with("SESSION_NOT_FOUND")
}
/// The server's message in a failed response: rows already streamed and the
/// `__exception__` block markers ClickHouse wraps a mid-stream error in are dropped.
fn exception_text(body: &str) -> &str {
@@ -479,6 +551,20 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
}
fn rejects_driver_setting(error: &IdeError) -> bool {
error
.message
.split_once(": ")
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
.and_then(|detail| detail.split_once("' setting in readonly mode"))
.is_some_and(|(name, _)| {
matches!(
name,
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
)
})
}
fn reserved_setting(name: &str) -> bool {
let name = name.to_ascii_lowercase();
name.starts_with("output_format_json_")
@@ -575,6 +661,19 @@ mod tests {
DataSource { driver: DbDriver::Clickhouse, host: "127.0.0.1".into(), port: Some(port), ..Default::default() }
}
fn property(name: &str, value: &str) -> DbProperty {
DbProperty { name: name.into(), value: value.into() }
}
fn request_url(request: &str) -> Url {
let target = request.lines().next().unwrap().split_whitespace().nth(1).unwrap();
Url::parse(&format!("http://localhost{target}")).unwrap()
}
fn query_value(url: &Url, key: &str) -> Option<String> {
url.query_pairs().find(|(name, _)| name == key).map(|(_, value)| value.into_owned())
}
fn decode(body: &[u8], max_rows: usize, chunk: usize) -> IdeResult<DecodedResult> {
decode_from(body, 0, max_rows, chunk)
}
@@ -653,6 +752,7 @@ mod tests {
let (port, requests) = server(vec![
("200 OK", "X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n", ONE),
("200 OK", "", ""),
("200 OK", "", ""),
(
"200 OK",
"X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n",
@@ -664,7 +764,7 @@ mod tests {
user: "reader".into(),
read_only: true,
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
properties: vec![property("max_threads", "2"), property("use_http_session", "true")],
..source(port)
};
let pool = Pool::connect(&source, Some("mock-password"), None).await.unwrap();
@@ -687,7 +787,7 @@ mod tests {
assert_eq!(value(&urls[1], "session_check").as_deref(), Some("1"));
assert_eq!(value(&urls[0], "session_id"), value(&urls[2], "session_id"));
assert_ne!(value(&urls[0], "query_id"), value(&urls[2], "query_id"));
assert_eq!(value(&urls[2], "max_result_rows").as_deref(), Some("2"));
assert_eq!(value(&urls[3], "max_result_rows").as_deref(), Some("2"));
for (request, url) in requests.iter().zip(&urls) {
assert!(request.starts_with("POST /?"));
assert!(request.contains("Basic cmVhZGVyOm1vY2stcGFzc3dvcmQ="));
@@ -695,8 +795,10 @@ mod tests {
assert_eq!(value(url, "readonly").as_deref(), Some("1"));
assert_eq!(value(url, "session_timezone").as_deref(), Some("UTC"));
assert_eq!(value(url, "max_threads").as_deref(), Some("2"));
assert_eq!(value(url, "use_http_session"), None);
}
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[1].ends_with("USE `analytics`"));
assert!(pool.transaction(&[]).await.is_err());
let cancel = CancellationToken::new();
cancel.cancel();
@@ -706,6 +808,85 @@ 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;
let source = DataSource {
database: "configured_database".into(),
read_only: true,
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
..source(port)
};
let pool = Pool::connect(&source, None, None).await.unwrap();
pool.execute("SELECT 2", 2, &CancellationToken::new()).await.unwrap();
pool.execute("SELECT 3", 3, &CancellationToken::new()).await.unwrap();
let requests = requests.await.unwrap();
let mut query_ids = std::collections::HashSet::new();
for (index, request) in requests.iter().enumerate() {
let url = request_url(request);
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
assert_eq!(query_value(&url, name), None, "{name} must not be sent in stateless mode");
}
assert_eq!(query_value(&url, "database").as_deref(), Some("analytics"));
assert_eq!(query_value(&url, "session_timezone").as_deref(), Some("UTC"));
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
assert_eq!(query_value(&url, "max_result_rows"), Some((index + 2).to_string()));
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), Some("break"));
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), Some("1"));
assert_eq!(query_value(&url, "default_format").as_deref(), Some(FORMAT));
assert!(query_ids.insert(query_value(&url, "query_id").unwrap()));
assert!(request.ends_with(&format!("SELECT {}", index + 1)));
}
}
#[tokio::test]
async fn default_session_expiry_never_recreates_the_session_or_replays_sql() {
for failure in [
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 372\r\n", "session unavailable"),
("500 Internal Server Error", "", "Code: 372. DB::Exception: Session not found. (SESSION_NOT_FOUND)"),
("200 OK", "", "Code: 372. DB::Exception: Session not found. (SESSION_NOT_FOUND)"),
] {
let (port, requests) = server(vec![("200 OK", "", ONE), failure, ("200 OK", "", ONE)]).await;
let pool = Pool::connect(&source(port), None, None).await.unwrap();
let sql = "INSERT INTO events VALUES (1)";
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();
let requests = requests.await.unwrap();
assert_eq!(requests.len(), 3);
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[1].ends_with(sql));
assert!(requests[2].ends_with("SELECT 1"));
let session_id = query_value(&request_url(&requests[0]), "session_id").unwrap();
for request in &requests[1..] {
let url = request_url(request);
assert_eq!(query_value(&url, "session_id").as_deref(), Some(session_id.as_str()));
assert_eq!(query_value(&url, "session_check").as_deref(), Some("1"));
assert_eq!(query_value(&url, "database"), None);
}
}
}
#[tokio::test]
async fn sequential_queries_reuse_the_http_connection() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
@@ -726,6 +907,144 @@ mod tests {
task.await.unwrap();
}
#[tokio::test]
async fn connects_when_server_forbids_settings_in_readonly_mode() {
let (port, requests) = server(vec![
(
"500 Internal Server Error",
"X-ClickHouse-Exception-Code: 164\r\n",
"Code: 164. DB::Exception: Cannot modify 'output_format_json_quote_denormals' setting in readonly mode. (READONLY)",
),
("200 OK", "", ONE),
("200 OK", "", ""),
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[1]\n[2]\n"),
])
.await;
let source = DataSource {
database: "system".into(),
read_only: true,
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
..source(port)
};
let pool = Pool::connect(&source, None, None).await.unwrap();
let result = pool.execute("SELECT number FROM numbers(2)", 1, &CancellationToken::new()).await.unwrap();
assert_eq!(result.rows, vec![vec![Some("1".into())]]);
assert!(result.has_more);
let requests = requests.await.unwrap();
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[0].contains("output_format_json_quote_denormals=1"));
assert!(requests[1].ends_with("SELECT getSetting('readonly')"));
assert!(!requests[1].contains("session_check="));
assert_eq!(query_value(&request_url(&requests[1]), "database").as_deref(), Some("system"));
assert!(requests[2].contains("session_check=1"));
let session_id = query_value(&request_url(&requests[1]), "session_id").unwrap();
assert_ne!(query_value(&request_url(&requests[0]), "session_id").as_deref(), Some(session_id.as_str()));
for request in &requests[1..] {
assert_eq!(query_value(&request_url(request), "session_id").as_deref(), Some(session_id.as_str()));
assert!(request.contains("default_format=JSONCompactEachRowWithNamesAndTypes"));
assert!(request.contains("max_threads=2"));
for setting in
["output_format_json_quote_denormals=", "max_result_rows=", "result_overflow_mode=", "readonly="]
{
assert!(!request.contains(setting), "{setting} is not allowed in a strict read-only session");
}
}
}
#[tokio::test]
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
for read_only in [false, true] {
let (port, requests) = server(vec![(
"500 Internal Server Error",
"X-ClickHouse-Exception-Code: 164\r\n",
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
)])
.await;
let source =
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
assert!(error.message.contains("use_http_session=false requires per-request"));
let requests = requests.await.unwrap();
assert_eq!(requests.len(), 1);
assert!(requests[0].ends_with("SELECT 1"));
let url = request_url(&requests[0]);
assert_eq!(query_value(&url, "max_result_rows").as_deref(), Some("2"));
assert_eq!(query_value(&url, "readonly").as_deref(), read_only.then_some("1"));
assert_eq!(query_value(&url, "session_id"), None);
}
}
#[tokio::test]
async fn incompatible_stateless_options_are_rejected_before_connecting() {
for (properties, startup_script, expected) in [
(vec![property("use_http_session", "false")], "SET max_threads = 2", "does not support startup scripts"),
(vec![property("use_http_session", "invalid")], "", "must be true or false"),
(
vec![property("use_http_session", "false"), property("USE_HTTP_SESSION", "true")],
"",
"must be specified only once",
),
(
vec![property("use_http_session", "false"), property("session_id", "custom")],
"",
"manages the session_id",
),
(
vec![property("use_http_session", "false"), property("session_check", "0")],
"",
"manages the session_check",
),
(
vec![property("use_http_session", "false"), property("session_timeout", "60")],
"",
"manages the session_timeout",
),
] {
let source = DataSource {
properties,
options: DbOptions { startup_script: startup_script.into(), ..Default::default() },
..source(1)
};
let error = Pool::connect(&source, None, None).await.err().expect("incompatible options must fail");
assert!(error.message.contains(expected), "{}", error.message);
}
}
#[tokio::test]
async fn readonly_probe_does_not_disable_settings_on_a_writable_session() {
let (port, requests) = server(vec![
(
"500 Internal Server Error",
"X-ClickHouse-Exception-Code: 164\r\n",
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
),
("200 OK", "", "[\"readonly\"]\n[\"UInt64\"]\n[0]\n"),
])
.await;
let source = DataSource { read_only: true, ..source(port) };
let error = Pool::connect(&source, None, None).await.err().expect("writable session must stay rejected");
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
assert!(requests.await.unwrap()[1].ends_with("SELECT getSetting('readonly')"));
}
#[test]
fn readonly_probe_matches_only_the_driver_settings() {
for (code, setting, expected) in [
(164, "max_result_rows", true),
(164, "result_overflow_mode", true),
(164, "readonly", true),
(164, "max_threads", false),
(516, "max_result_rows", false),
] {
let error = IdeError::invalid(format!(
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
));
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
}
}
#[tokio::test]
async fn server_errors_keep_details_and_hide_passwords() {
let (port, requests) = server(vec![(
+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());
}
}
+97 -15
Переглянути файл
@@ -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())",
@@ -812,16 +820,16 @@ impl DbManager {
let password = self.password(&source).await;
// Holding the tunnel keeps it open while the tool runs, even if the tree disconnects.
let (target, _tunnel) = self.endpoint(&source, None, true).await?;
let prepared = tools::prepare(job, &target, password.as_deref());
tools::run(executable, &prepared.args, &prepared.env, cancel, on_output).await
let prepared = tools::prepare(job, executable, &target, password.as_deref())?;
tools::run(executable, &prepared.args, &prepared.env, prepared.input.as_deref(), cancel, on_output).await
}
/// The command [`DbManager::run_tool`] would run, for the dialogs' preview: the data source's
/// own host and port (not a tunnel's local end), and no password.
pub fn tool_preview(&self, id: &str, executable: &std::path::Path, job: &tools::DbToolJob) -> IdeResult<String> {
let source = self.source(id)?;
let prepared = tools::prepare(job, &source, None);
Ok(tools::command_line(executable, &prepared.args))
let prepared = tools::prepare(job, executable, &source, None)?;
Ok(tools::command_line(executable, &prepared.args, job.input()))
}
/// The PostgreSQL server's `server_version_num` (`150013` for 15.13).
@@ -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),
@@ -916,6 +924,37 @@ impl DbManager {
self.tunnels.lock().remove(id);
}
/// Creates a database on the server of data source `id` by running `statement` on the data
/// source's own database, after closing the IDE's connections to `template`, the database
/// the server copies (PostgreSQL and SQL Server refuse to copy one that has sessions).
pub async fn create_database(&self, id: &str, template: &str, statement: &str) -> IdeResult<()> {
let id = split_target(id).0;
if self.source(id)?.read_only {
return Err(IdeError::new(ErrorKind::PermissionDenied, "the data source is read-only"));
}
self.disconnect(&format!("{id}:{template}")).await;
self.pool(id).await?.execute(statement, 0, &CancellationToken::new()).await?;
self.remember_statement(id, statement);
Ok(())
}
/// Drops `database` of the server of data source `id` by running `statement` on the data
/// source's own database, after closing the IDE's connections to `database`.
/// Refuses the database the data source connects to and read-only data sources.
pub async fn drop_database(&self, id: &str, database: &str, statement: &str) -> IdeResult<()> {
let id = split_target(id).0;
if self.source(id)?.read_only {
return Err(IdeError::new(ErrorKind::PermissionDenied, "the data source is read-only"));
}
if self.databases(id).await?.current == database {
return Err(IdeError::invalid(format!("the data source connects to {database}; it cannot drop it")));
}
self.disconnect(&format!("{id}:{database}")).await;
self.pool(id).await?.execute(statement, 0, &CancellationToken::new()).await?;
self.remember_statement(id, statement);
Ok(())
}
/// The databases of the server of data source `id` (PostgreSQL), the connected one first.
pub async fn databases(&self, id: &str) -> IdeResult<Databases> {
let id = split_target(id).0;
@@ -1040,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())
}
@@ -1049,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| {
@@ -1066,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();
@@ -1080,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();
@@ -1240,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() {
@@ -1364,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()
@@ -1484,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!(
@@ -1523,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() {
@@ -1564,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"));
@@ -1583,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;
@@ -1618,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
@@ -1632,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 -4
Переглянути файл
@@ -2,6 +2,7 @@
//! The connection arguments come from [`super::connection`]; these are the rest.
use super::DbTool;
use ide_core::{IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
@@ -58,6 +59,8 @@ pub struct DbPgDumpOptions {
pub struct DbPgRestoreOptions {
pub content: DbDumpContent,
pub schemas: Vec<String>,
/// Creates the database the archive names; the target is only connected to.
pub create: bool,
pub clean: bool,
pub if_exists: bool,
pub no_owner: bool,
@@ -75,6 +78,40 @@ pub struct DbPsqlOptions {
pub stop_on_error: bool,
}
/// Switches that `mysqldump` turns on by default (`--opt`) only take a flag when turned off.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbMysqldumpOptions {
/// Empty: every database.
pub databases: Vec<String>,
/// Only with exactly one database.
pub tables: Vec<String>,
pub add_drop_table: bool,
pub disable_keys: bool,
pub add_locks: bool,
pub add_drop_trigger: bool,
pub no_data: bool,
pub complete_insert: bool,
pub create_options: bool,
pub routines: bool,
pub events: bool,
/// A consistent InnoDB snapshot without locks; needs no RELOAD privilege.
pub single_transaction: bool,
/// Wins over `single_transaction`.
pub lock_all_tables: bool,
/// `None`: the client has no `--masking-policies`.
pub masking_policies: Option<bool>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbMysqlOptions {
/// Empty: the databases the dump names.
pub database: String,
/// Runs the remaining statements after an error.
pub force: bool,
}
/// A run of a client tool: which one, the file it writes or reads, and its options.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "tool", rename_all = "camelCase")]
@@ -92,6 +129,15 @@ pub enum DbToolJob {
file: String,
options: DbPsqlOptions,
},
Mysqldump {
file: String,
options: DbMysqldumpOptions,
},
/// `file` goes to the standard input.
Mysql {
file: String,
options: DbMysqlOptions,
},
}
impl DbToolJob {
@@ -100,15 +146,38 @@ impl DbToolJob {
DbToolJob::PgDump { .. } => DbTool::PgDump,
DbToolJob::PgRestore { .. } => DbTool::PgRestore,
DbToolJob::Psql { .. } => DbTool::Psql,
DbToolJob::Mysqldump { .. } => DbTool::Mysqldump,
DbToolJob::Mysql { .. } => DbTool::Mysql,
}
}
/// The file piped to the tool's standard input.
pub fn input(&self) -> Option<&str> {
match self {
DbToolJob::Mysql { file, .. } if !file.is_empty() => Some(file),
_ => None,
}
}
/// Refuses names that the tool would read as options: `mysqldump` takes databases and tables
/// as plain arguments.
pub fn check(&self) -> IdeResult<()> {
if let DbToolJob::Mysqldump { options, .. } = self
&& let Some(name) = options.databases.iter().chain(&options.tables).find(|n| n.trim().starts_with('-'))
{
return Err(IdeError::invalid(format!("mysqldump cannot dump a database or table named {name}")));
}
Ok(())
}
/// The arguments after the connection ones.
pub fn args(&self) -> Vec<String> {
match self {
DbToolJob::PgDump { file, options } => pg_dump(options, file),
DbToolJob::PgRestore { file, options } => pg_restore(options, file),
DbToolJob::Psql { file, options } => psql(options, file),
DbToolJob::Mysqldump { file, options } => mysqldump(options, file),
DbToolJob::Mysql { options, .. } => mysql(options),
}
}
}
@@ -162,6 +231,7 @@ fn pg_dump(o: &DbPgDumpOptions, file: &str) -> Vec<String> {
fn pg_restore(o: &DbPgRestoreOptions, file: &str) -> Vec<String> {
let mut args: Vec<String> = content(o.content).into_iter().collect();
args.extend(each(&o.schemas, "schema"));
args.extend(flag(o.create, "--create"));
args.extend(flag(o.clean, "--clean"));
args.extend(flag(o.clean && o.if_exists, "--if-exists"));
args.extend(flag(o.no_owner, "--no-owner"));
@@ -187,8 +257,53 @@ fn psql(o: &DbPsqlOptions, file: &str) -> Vec<String> {
args
}
/// The command as a shell would need it typed: the dialogs' preview.
pub fn command_line(program: &Path, args: &[String]) -> String {
fn names(list: &[String]) -> impl Iterator<Item = String> {
list.iter().map(|n| n.trim()).filter(|n| !n.is_empty()).map(str::to_owned)
}
fn mysqldump(o: &DbMysqldumpOptions, file: &str) -> Vec<String> {
let skip = |on: bool, option: &str| (!on).then(|| format!("--skip-{option}"));
let mut args = vec![format!("--result-file={file}")];
args.extend(skip(o.add_drop_table, "add-drop-table"));
args.extend(skip(o.disable_keys, "disable-keys"));
args.extend(skip(o.add_locks, "add-locks"));
args.extend(skip(o.create_options, "create-options"));
args.extend(flag(o.add_drop_trigger, "--add-drop-trigger"));
args.extend(flag(o.no_data, "--no-data"));
args.extend(flag(o.complete_insert, "--complete-insert"));
args.extend(flag(o.routines, "--routines"));
args.extend(flag(o.events, "--events"));
args.extend(flag(o.lock_all_tables, "--lock-all-tables"));
args.extend(flag(!o.lock_all_tables && o.single_transaction, "--single-transaction"));
// On by default where it exists; reading the policies needs privileges most users lack.
args.extend(flag(o.masking_policies == Some(false), "--skip-masking-policies"));
// Tablespace statements need the PROCESS privilege and rarely matter in a dump.
args.push("--no-tablespaces".into());
args.push("--verbose".into());
let databases: Vec<String> = names(&o.databases).collect();
match databases.as_slice() {
[] => args.push("--all-databases".into()),
[one] => {
args.push(one.clone());
args.extend(names(&o.tables));
}
_ => {
args.push("--databases".into());
args.extend(databases);
}
}
args
}
fn mysql(o: &DbMysqlOptions) -> Vec<String> {
let database = o.database.trim();
let mut args: Vec<String> = (!database.is_empty()).then(|| format!("--database={database}")).into_iter().collect();
args.extend(flag(o.force, "--force"));
args
}
/// The command as a shell would need it typed: the dialogs' preview. `input` is piped in.
pub fn command_line(program: &Path, args: &[String], input: Option<&str>) -> String {
let quote = |s: &str| {
if !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || "@%+=:,./-_".contains(c)) {
s.to_owned()
@@ -196,11 +311,15 @@ pub fn command_line(program: &Path, args: &[String]) -> String {
format!("'{}'", s.replace('\'', "'\\''"))
}
};
std::iter::once(program.to_string_lossy().into_owned())
let line = std::iter::once(program.to_string_lossy().into_owned())
.chain(args.iter().cloned())
.map(|a| quote(&a))
.collect::<Vec<_>>()
.join(" ")
.join(" ");
match input {
Some(file) => format!("{line} < {}", quote(file)),
None => line,
}
}
#[cfg(test)]
@@ -228,6 +347,7 @@ mod tests {
DbPgRestoreOptions {
content: DbDumpContent::All,
schemas: vec![],
create: false,
clean: false,
if_exists: false,
no_owner: false,
@@ -308,6 +428,13 @@ mod tests {
);
}
#[test]
fn creates_the_database_of_the_archive_when_asked() {
let options = DbPgRestoreOptions { create: true, ..restore() };
let a = args(DbToolJob::PgRestore { file: "/tmp/shop.dump".into(), options });
assert_eq!(a, ["--create", "--exit-on-error", "--verbose", "/tmp/shop.dump"]);
}
#[test]
fn leaves_out_an_archive_not_chosen_yet() {
let a = args(DbToolJob::PgRestore { file: String::new(), options: restore() });
@@ -328,8 +455,92 @@ mod tests {
let line = command_line(
Path::new("/usr/bin/pg_dump"),
&["--port=5432".into(), "--file=/tmp/my dump.sql".into(), "--table=it's".into()],
None,
);
assert_eq!(line, r#"/usr/bin/pg_dump --port=5432 '--file=/tmp/my dump.sql' '--table=it'\''s'"#);
let line = command_line(Path::new("mysql"), &["--force".into()], Some("/tmp/my dump.sql"));
assert_eq!(line, "mysql --force < '/tmp/my dump.sql'");
}
fn mysqldump_options() -> DbMysqldumpOptions {
DbMysqldumpOptions {
databases: vec!["shop".into()],
tables: vec![],
add_drop_table: true,
disable_keys: true,
add_locks: true,
add_drop_trigger: false,
no_data: false,
complete_insert: false,
create_options: true,
routines: false,
events: false,
single_transaction: true,
lock_all_tables: false,
masking_policies: None,
}
}
#[test]
fn mysqldump_flags_only_what_differs_from_its_defaults() {
let job = DbToolJob::Mysqldump { file: "/tmp/shop.sql".into(), options: mysqldump_options() };
assert_eq!(
args(job),
["--result-file=/tmp/shop.sql", "--single-transaction", "--no-tablespaces", "--verbose", "shop"]
);
let options = DbMysqldumpOptions {
add_drop_table: false,
create_options: false,
routines: true,
lock_all_tables: true,
masking_policies: Some(false),
..mysqldump_options()
};
let a = args(DbToolJob::Mysqldump { file: "/tmp/x.sql".into(), options });
for expected in ["--skip-add-drop-table", "--skip-create-options", "--routines", "--lock-all-tables"] {
assert!(a.contains(&expected.to_owned()), "{expected} missing from {a:?}");
}
assert!(a.contains(&"--skip-masking-policies".to_owned()), "{a:?}");
assert!(!a.contains(&"--single-transaction".to_owned()), "{a:?}");
}
#[test]
fn mysqldump_names_tables_only_of_a_single_database() {
let tables = vec!["orders".to_owned(), "items".to_owned()];
let one = DbMysqldumpOptions { tables: tables.clone(), ..mysqldump_options() };
assert!(args(DbToolJob::Mysqldump { file: "f".into(), options: one }).ends_with(&[
"shop".into(),
"orders".into(),
"items".into()
]));
let two = DbMysqldumpOptions { databases: vec!["a".into(), "b".into()], tables, ..mysqldump_options() };
assert!(args(DbToolJob::Mysqldump { file: "f".into(), options: two }).ends_with(&[
"--databases".into(),
"a".into(),
"b".into()
]));
let all = DbMysqldumpOptions { databases: vec![], ..mysqldump_options() };
assert_eq!(args(DbToolJob::Mysqldump { file: "f".into(), options: all }).last().unwrap(), "--all-databases");
}
#[test]
fn mysqldump_refuses_names_it_would_read_as_options() {
let options = DbMysqldumpOptions { tables: vec!["--result-file=/etc/x".into()], ..mysqldump_options() };
assert!(DbToolJob::Mysqldump { file: "f".into(), options }.check().is_err());
assert!(DbToolJob::Mysqldump { file: "f".into(), options: mysqldump_options() }.check().is_ok());
}
#[test]
fn mysql_reads_the_dump_from_its_standard_input() {
let job = DbToolJob::Mysql {
file: "/tmp/shop.sql".into(),
options: DbMysqlOptions { database: " shop ".into(), force: true },
};
assert_eq!(args(job.clone()), ["--database=shop", "--force"]);
assert_eq!(job.input(), Some("/tmp/shop.sql"));
let none =
DbToolJob::Mysql { file: String::new(), options: DbMysqlOptions { database: String::new(), force: false } };
assert!(args(none.clone()).is_empty() && none.input().is_none());
}
#[test]
+336 -48
Переглянути файл
@@ -1,5 +1,6 @@
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`): finding installed copies, the
//! arguments and environment that connect them like the data source, and running them.
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`, `mysqldump`, `mysql`): finding
//! installed copies, the arguments and environment that connect them like the data source, and
//! running them.
mod jobs;
pub use jobs::*;
@@ -20,6 +21,8 @@ pub enum DbTool {
PgDump,
PgRestore,
Psql,
Mysqldump,
Mysql,
}
impl DbTool {
@@ -27,20 +30,25 @@ impl DbTool {
self.programs()[0]
}
/// Executable names.
/// Executable names, MariaDB's own after MySQL's.
pub fn programs(self) -> &'static [&'static str] {
match self {
DbTool::PgDump => &["pg_dump"],
DbTool::PgRestore => &["pg_restore"],
DbTool::Psql => &["psql"],
DbTool::Mysqldump => &["mysqldump", "mariadb-dump"],
DbTool::Mysql => &["mysql", "mariadb"],
}
}
pub fn driver(self) -> DbDriver {
DbDriver::Postgres
match self {
DbTool::PgDump | DbTool::PgRestore | DbTool::Psql => DbDriver::Postgres,
DbTool::Mysqldump | DbTool::Mysql => DbDriver::Mysql,
}
}
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`…).
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`, `mariadb-dump`…).
/// The data source's password is handed only to such a program.
pub fn is_program(self, path: &Path) -> bool {
let Some(stem) = path.file_stem().and_then(OsStr::to_str) else { return false };
@@ -53,6 +61,12 @@ impl DbTool {
}
}
/// Whether `executable` is MariaDB's client (`mariadb`, `mariadb-dump`), whose SSL options differ
/// from MySQL's.
fn is_mariadb(executable: &Path) -> bool {
executable.file_stem().and_then(OsStr::to_str).is_some_and(|s| s.starts_with("mariadb"))
}
/// An installed copy of a tool.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", rename = "DbToolInstall")]
@@ -70,28 +84,41 @@ pub struct ToolLine {
pub text: String,
}
/// Directories holding the tools that are often missing from `PATH`, by platform.
fn known_dirs() -> Vec<PathBuf> {
/// Directories holding the tools of `driver` that are often missing from `PATH`, by platform.
fn known_dirs(driver: DbDriver) -> Vec<PathBuf> {
let mysql = driver == DbDriver::Mysql;
let mut dirs = Vec::new();
if cfg!(target_os = "macos") {
for prefix in ["/opt/homebrew", "/usr/local"] {
dirs.push(PathBuf::from(format!("{prefix}/bin")));
let opt = PathBuf::from(format!("{prefix}/opt"));
for keg in ["libpq", "postgresql"] {
let kegs: &[&str] = if mysql { &["mysql-client", "mysql", "mariadb"] } else { &["libpq", "postgresql"] };
for keg in kegs {
dirs.extend(children(&opt, keg).into_iter().map(|d| d.join("bin")));
}
}
dirs.extend(
children(Path::new("/Applications/Postgres.app/Contents/Versions"), "").into_iter().map(|d| d.join("bin")),
);
if mysql {
dirs.push(PathBuf::from("/usr/local/mysql/bin"));
} else {
dirs.extend(
children(Path::new("/Applications/Postgres.app/Contents/Versions"), "")
.into_iter()
.map(|d| d.join("bin")),
);
}
} else if cfg!(windows) {
for var in ["ProgramFiles", "ProgramFiles(x86)"] {
if let Some(base) = std::env::var_os(var) {
let root = PathBuf::from(base).join("PostgreSQL");
dirs.extend(children(&root, "").into_iter().map(|d| d.join("bin")));
let base = PathBuf::from(base);
// MySQL installs to `MySQL\MySQL Server 8.4`, MariaDB to `MariaDB 11.4`.
let roots: &[(&str, &str)] =
if mysql { &[("MySQL", "MySQL"), ("", "MariaDB")] } else { &[("PostgreSQL", "")] };
for (dir, prefix) in roots {
dirs.extend(children(&base.join(dir), prefix).into_iter().map(|d| d.join("bin")));
}
}
}
} else {
} else if !mysql {
dirs.extend(children(Path::new("/usr/lib/postgresql"), "").into_iter().map(|d| d.join("bin")));
dirs.extend(children(Path::new("/usr"), "pgsql-").into_iter().map(|d| d.join("bin")));
}
@@ -121,7 +148,7 @@ fn version_key(text: &str) -> Vec<u32> {
pub fn find_installs(tool: DbTool) -> Vec<ToolInstall> {
let path = ide_core::process::host_var_os("PATH").unwrap_or_default();
let mut dirs: Vec<PathBuf> = std::env::split_paths(&path).collect();
dirs.extend(known_dirs());
dirs.extend(known_dirs(tool.driver()));
let mut seen = Vec::new();
let mut out = Vec::new();
for dir in dirs {
@@ -150,6 +177,29 @@ pub fn version_of(path: &Path) -> IdeResult<String> {
}
}
/// The long options `path --help` lists (`masking-policies` for `--masking-policies`), so a
/// dialog offers only options this copy knows. Blocking.
pub fn options_of(path: &Path) -> IdeResult<Vec<String>> {
let (_, text) = capture(path, "--help")?;
Ok(help_options(&text))
}
fn help_options(help: &str) -> Vec<String> {
let mut out: Vec<String> = help
.lines()
.filter(|l| l.starts_with(' ') && l.trim_start().starts_with('-'))
.filter_map(|l| {
let at = l.find("--")?;
let name: String =
l[at + 2..].chars().take_while(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_').collect();
(!name.is_empty()).then_some(name)
})
.collect();
out.sort();
out.dedup();
out
}
/// Runs `path arg` for at most five seconds; whether it succeeded, and its standard output.
fn capture(path: &Path, arg: &str) -> IdeResult<(bool, String)> {
if !path.is_file() {
@@ -189,23 +239,41 @@ pub enum DbDumpKind {
PostgresArchive,
/// Plain SQL from `pg_dump`: `psql`.
PostgresSql,
/// `mysqldump` / `mariadb-dump`: not for the PostgreSQL tools.
/// `mysqldump` / `mariadb-dump`: `mysql`.
MysqlSql,
Unknown,
}
/// Blocking: reads at most the first 4 KiB.
pub fn dump_kind(path: &Path) -> IdeResult<DbDumpKind> {
/// What a restore needs to know about a dump before it runs.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", rename = "DbDumpInfo")]
pub struct DumpInfo {
pub kind: DbDumpKind,
/// An SQL dump that runs `CREATE DATABASE` itself: `mysqldump --databases` / `--all-databases`,
/// or `pg_dump --create`. Archives say `false`; `pg_restore --create` decides for them.
pub creates_database: bool,
}
/// Blocking: reads at most the first 64 KiB, where both tools write their `CREATE DATABASE`.
pub fn dump_info(path: &Path) -> IdeResult<DumpInfo> {
use std::io::Read;
if path.is_dir() {
return Ok(if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown });
let kind = if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown };
return Ok(DumpInfo { kind, creates_database: false });
}
let mut head = Vec::with_capacity(4096);
let mut head = Vec::with_capacity(64 * 1024);
std::fs::File::open(path)
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?
.take(4096)
.take(64 * 1024)
.read_to_end(&mut head)?;
Ok(kind_of(&head))
Ok(info_of(&head))
}
fn info_of(head: &[u8]) -> DumpInfo {
let kind = kind_of(head);
let sql = matches!(kind, DbDumpKind::PostgresSql | DbDumpKind::MysqlSql);
let creates_database = sql && String::from_utf8_lossy(head).lines().any(|l| l.starts_with("CREATE DATABASE "));
DumpInfo { kind, creates_database }
}
fn kind_of(head: &[u8]) -> DbDumpKind {
@@ -224,9 +292,12 @@ fn kind_of(head: &[u8]) -> DbDumpKind {
}
}
/// Arguments and environment that connect `tool` to `source` (already resolved, through its
/// tunnel when it has one). The password is left to [`prepare`].
pub fn connection(tool: DbTool, source: &DataSource) -> (Vec<String>, Vec<(String, String)>) {
/// Arguments and environment that connect `tool` at `executable` to `source` (already resolved,
/// through its tunnel when it has one). The password is left to [`prepare`].
pub fn connection(tool: DbTool, executable: &Path, source: &DataSource) -> (Vec<String>, Vec<(String, String)>) {
if tool.driver() == DbDriver::Mysql {
return (mysql_connection(tool, executable, source), Vec::new());
}
let mut args = Vec::new();
let host = source.host.trim();
if !host.is_empty() {
@@ -271,6 +342,50 @@ pub fn connection(tool: DbTool, source: &DataSource) -> (Vec<String>, Vec<(Strin
(args, env)
}
/// The database is the job's: a dump may name several.
fn mysql_connection(tool: DbTool, executable: &Path, source: &DataSource) -> Vec<String> {
let mut args = Vec::new();
let host = source.host.trim();
if !host.is_empty() {
args.push(format!("--host={host}"));
}
args.push(format!("--port={}", source.port.or(source.driver.default_port()).unwrap_or(3306)));
if !source.user.trim().is_empty() {
args.push(format!("--user={}", source.user.trim()));
}
// `localhost` would otherwise mean the Unix socket, not the port or the tunnel.
args.push("--protocol=TCP".into());
if is_mariadb(executable) {
let flags: &[&str] = match source.ssl {
DbSslMode::Disable => &["--skip-ssl"],
DbSslMode::Prefer => &["--skip-ssl-verify-server-cert"],
DbSslMode::Require => &["--ssl", "--skip-ssl-verify-server-cert"],
DbSslMode::VerifyCa | DbSslMode::VerifyFull => &["--ssl", "--ssl-verify-server-cert"],
};
args.extend(flags.iter().map(|f| f.to_string()));
} else {
let mode = match source.ssl {
DbSslMode::Disable => "DISABLED",
DbSslMode::Prefer => "PREFERRED",
DbSslMode::Require => "REQUIRED",
DbSslMode::VerifyCa => "VERIFY_CA",
DbSslMode::VerifyFull => "VERIFY_IDENTITY",
};
args.push(format!("--ssl-mode={mode}"));
}
for (flag, file) in
[("--ssl-ca", &source.ssl_ca_file), ("--ssl-cert", &source.ssl_cert_file), ("--ssl-key", &source.ssl_key_file)]
{
if !file.trim().is_empty() {
args.push(format!("{flag}={}", ide_ssh::expand(file.trim()).to_string_lossy()));
}
}
if tool == DbTool::Mysql && source.read_only {
args.push("--init-command=SET SESSION TRANSACTION READ ONLY".into());
}
args
}
/// `--dbname` reads a connection string or URI as connection parameters: such a database name
/// goes in quoted as the string's `dbname`, so it cannot pick another host or credentials.
fn dbname_arg(name: &str) -> String {
@@ -281,36 +396,88 @@ fn dbname_arg(name: &str) -> String {
}
}
/// How a tool is started: connection arguments, then the job's, and the environment.
/// A MySQL client option file holding the password, readable by the user only; deleted on drop.
struct SecretFile(PathBuf);
impl SecretFile {
fn mysql_password(password: &str) -> IdeResult<Self> {
use std::io::Write;
let path = std::env::temp_dir().join(format!("openidea-mysql-{}.cnf", uuid::Uuid::new_v4()));
let mut options = std::fs::OpenOptions::new();
options.write(true).create_new(true);
#[cfg(unix)]
std::os::unix::fs::OpenOptionsExt::mode(&mut options, 0o600);
let mut file = options.open(&path)?;
let secret = SecretFile(path);
let escaped = password.replace('\\', "\\\\").replace('"', "\\\"");
writeln!(file, "[client]\npassword=\"{escaped}\"")?;
Ok(secret)
}
/// `mysqldump` / `mysql` accept it only as their first argument.
fn arg(&self) -> String {
format!("--defaults-extra-file={}", self.0.display())
}
}
impl Drop for SecretFile {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.0);
}
}
/// How a tool is started: connection arguments, then the job's, the environment, and the file
/// piped to its standard input. Keep it until the tool exits: it owns the password file.
pub struct Prepared {
pub args: Vec<String>,
pub env: Vec<(String, String)>,
pub input: Option<PathBuf>,
_secret: Option<SecretFile>,
}
/// The command for `job` against `source`. The password goes in `PGPASSWORD`, never in the
/// arguments, which other users of the machine can read in the process list.
pub fn prepare(job: &DbToolJob, source: &DataSource, password: Option<&str>) -> Prepared {
let (mut args, mut env) = connection(job.tool(), source);
/// The command for `job` at `executable` against `source`. The password goes in `PGPASSWORD` or
/// a MySQL option file, never in the arguments, which other users of the machine can read in the
/// process list.
pub fn prepare(job: &DbToolJob, executable: &Path, source: &DataSource, password: Option<&str>) -> IdeResult<Prepared> {
job.check()?;
let tool = job.tool();
let (mut args, mut env) = connection(tool, executable, source);
args.extend(job.args());
if let Some(p) = password.filter(|p| !p.is_empty()) {
env.push(("PGPASSWORD".into(), p.to_owned()));
let mut secret = None;
match password.filter(|p| !p.is_empty()) {
Some(p) if tool.driver() == DbDriver::Mysql => {
let file = SecretFile::mysql_password(p)?;
args.insert(0, file.arg());
secret = Some(file);
}
Some(p) => env.push(("PGPASSWORD".into(), p.to_owned())),
None => {}
}
Prepared { args, env }
Ok(Prepared { args, env, input: job.input().map(PathBuf::from), _secret: secret })
}
/// Runs `program` until it exits, passing its output in batches. Returns the exit code
/// (`None`: ended by a signal). Cancelling kills it and everything it started.
/// Runs `program` until it exits, passing its output in batches; `input` is piped to its standard
/// input. Returns the exit code (`None`: ended by a signal). Cancelling kills it and everything it
/// started.
pub async fn run(
program: &Path,
args: &[String],
env: &[(String, String)],
input: Option<&Path>,
cancel: &CancellationToken,
mut on_output: impl FnMut(Vec<ToolLine>),
) -> IdeResult<Option<i32>> {
let stdin = match input {
Some(path) => Stdio::from(
std::fs::File::open(path)
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?,
),
None => Stdio::null(),
};
let mut cmd = tokio::process::Command::new(program);
cmd.args(args)
.envs(env.iter().map(|(k, v)| (k, v)))
.stdin(Stdio::null())
.stdin(stdin)
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
@@ -408,7 +575,7 @@ mod tests {
#[test]
fn connects_like_the_data_source_without_prompting() {
let (args, env) = connection(DbTool::PgDump, &pg());
let (args, env) = connection(DbTool::PgDump, Path::new("pg_dump"), &pg());
assert_eq!(args, ["--host=db.example.test", "--port=6543", "--username=app", "--dbname=shop", "--no-password"]);
assert!(env.contains(&("PGSSLMODE".into(), "prefer".into())));
assert!(!env.iter().any(|(k, _)| k == "PGPASSWORD" || k == "PGOPTIONS"));
@@ -421,7 +588,8 @@ mod tests {
(r"it's=\x", r"--dbname=dbname='it\'s=\\x'"),
("postgresql://evil.example/p", "--dbname=dbname='postgresql://evil.example/p'"),
] {
let (args, _) = connection(DbTool::PgDump, &DataSource { database: name.into(), ..pg() });
let (args, _) =
connection(DbTool::PgDump, Path::new("pg_dump"), &DataSource { database: name.into(), ..pg() });
assert!(args.contains(&arg.to_owned()), "{args:?}");
}
}
@@ -429,14 +597,14 @@ mod tests {
#[test]
fn default_port_and_optional_fields() {
let source = DataSource { port: None, user: String::new(), database: String::new(), ..pg() };
let (args, _) = connection(DbTool::Psql, &source);
let (args, _) = connection(DbTool::Psql, Path::new("psql"), &source);
assert_eq!(args, ["--host=db.example.test", "--port=5432", "--no-password"]);
}
#[test]
fn read_only_sources_refuse_writes() {
let source = DataSource { read_only: true, ssl: DbSslMode::VerifyFull, ..pg() };
let (_, env) = connection(DbTool::PgRestore, &source);
let (_, env) = connection(DbTool::PgRestore, Path::new("pg_restore"), &source);
assert!(env.contains(&("PGOPTIONS".into(), "-c default_transaction_read_only=on".into())));
assert!(env.contains(&("PGSSLMODE".into(), "verify-full".into())));
}
@@ -451,6 +619,77 @@ mod tests {
}
}
#[test]
fn mysql_tools_accept_mariadb_names_only_for_themselves() {
assert!(DbTool::Mysqldump.is_program(Path::new("/usr/bin/mariadb-dump")));
assert!(DbTool::Mysql.is_program(Path::new("/opt/homebrew/opt/mysql-client/bin/mysql")));
assert!(!DbTool::Mysql.is_program(Path::new("/usr/bin/mysqldump")));
assert!(!DbTool::Mysql.is_program(Path::new("/usr/bin/mariadb-dump")));
assert!(!DbTool::Mysqldump.is_program(Path::new("/usr/bin/mysqlpump")));
}
#[test]
fn mysql_connects_over_tcp_with_the_ssl_flags_of_its_client() {
let source = DataSource {
driver: DbDriver::Mysql,
host: "localhost".into(),
port: None,
user: "app".into(),
read_only: true,
..DataSource::default()
};
let (args, env) = connection(DbTool::Mysql, Path::new("/usr/bin/mysql"), &source);
assert_eq!(
args,
[
"--host=localhost",
"--port=3306",
"--user=app",
"--protocol=TCP",
"--ssl-mode=PREFERRED",
"--init-command=SET SESSION TRANSACTION READ ONLY"
]
);
assert!(env.is_empty());
let (args, _) = connection(DbTool::Mysqldump, Path::new("/usr/bin/mariadb-dump"), &source);
assert!(args.contains(&"--skip-ssl-verify-server-cert".to_owned()));
assert!(!args.iter().any(|a| a.starts_with("--ssl-mode") || a.starts_with("--init-command")));
}
#[test]
fn the_password_file_is_private_and_removed() {
let file = SecretFile::mysql_password(r#"p"a\ss"#).unwrap();
let path = file.arg().trim_start_matches("--defaults-extra-file=").to_owned();
let text = std::fs::read_to_string(&path).unwrap();
assert_eq!(text, "[client]\npassword=\"p\\\"a\\\\ss\"\n");
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
assert_eq!(std::fs::metadata(&path).unwrap().permissions().mode() & 0o777, 0o600);
}
drop(file);
assert!(!Path::new(&path).exists());
}
#[test]
fn reads_long_options_from_help() {
let help = "Usage: mysqldump [OPTIONS]\n -A, --all-databases Dump all.\n --masking-policies Dump masking\n policies (--not-an-option).\n -y, --no-tablespaces \n -f, --file=FILENAME output file\n";
assert_eq!(help_options(help), ["all-databases", "file", "masking-policies", "no-tablespaces"]);
}
#[cfg(unix)]
#[tokio::test]
async fn pipes_the_input_file() {
let file = std::env::temp_dir().join(format!("openidea-input-{}", uuid::Uuid::new_v4()));
std::fs::write(&file, "from the file\n").unwrap();
let mut lines = Vec::new();
run(Path::new("/bin/cat"), &[], &[], Some(&file), &CancellationToken::new(), |b| lines.extend(b))
.await
.unwrap();
std::fs::remove_file(&file).unwrap();
assert_eq!(lines, [ToolLine { stderr: false, text: "from the file".into() }]);
}
#[test]
fn tells_dumps_apart_by_their_header() {
assert_eq!(kind_of(b"PGDMP\x01\x0f"), DbDumpKind::PostgresArchive);
@@ -461,6 +700,17 @@ mod tests {
assert_eq!(kind_of(b"CREATE TABLE t (id int);\n"), DbDumpKind::Unknown);
}
#[test]
fn sees_a_dump_that_creates_its_own_database() {
let one = b"-- MySQL dump 10.13\n--\n-- Host: localhost Database: shop\nCREATE TABLE `items` (id int);\n";
assert!(!info_of(one).creates_database);
let several = b"-- MySQL dump 10.13\n--\n-- Current Database: `shop`\n--\n\nCREATE DATABASE /*!32312 IF NOT EXISTS*/ `shop`;\nUSE `shop`;\n";
assert!(info_of(several).creates_database);
let pg = b"--\n-- PostgreSQL database dump\n--\nSET client_encoding = 'UTF8';\nCREATE DATABASE shop WITH TEMPLATE = template0;\n\\connect shop\n";
assert_eq!(info_of(pg), DumpInfo { kind: DbDumpKind::PostgresSql, creates_database: true });
assert!(!info_of(b"CREATE DATABASE x;\n").creates_database, "only for a dump the tools wrote");
}
#[test]
fn newer_versions_sort_first() {
assert!(version_key("pg_dump (PostgreSQL) 17.2") > version_key("pg_dump (PostgreSQL) 9.6.24"));
@@ -474,6 +724,7 @@ mod tests {
Path::new("/bin/sh"),
&["-c".into(), "echo out; echo err >&2; exit 3".into()],
&[],
None,
&CancellationToken::new(),
|batch| lines.extend(batch),
)
@@ -493,19 +744,25 @@ mod tests {
tokio::time::sleep(Duration::from_millis(100)).await;
stop.cancel();
});
let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], &cancel, |_| {}).await;
let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], None, &cancel, |_| {}).await;
assert!(result.is_err());
}
/// A stand-in for `tool` that prints each argument on a line, then whether `PGPASSWORD`
/// holds the expected password.
/// A stand-in for `tool` that prints each argument on a line, then whether it got a password
/// from `PGPASSWORD` or a MySQL option file.
#[cfg(unix)]
fn echo_tool(dir: &Path, tool: DbTool) -> PathBuf {
use std::os::unix::fs::PermissionsExt;
let path = dir.join(tool.program());
std::fs::write(
&path,
"#!/bin/sh\nfor a in \"$@\"; do echo \"arg:$a\"; done\necho \"env:${PGPASSWORD:+set}\"\n",
concat!(
"#!/bin/sh\n",
"for a in \"$@\"; do echo \"arg:$a\"; case \"$a\" in --defaults-extra-file=*)\n",
" grep -q '^password=' \"${a#*=}\" && echo env:set;; esac; done\n",
"[ -n \"$PGPASSWORD\" ] && echo env:set\n",
"exit 0\n",
),
)
.unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
@@ -541,17 +798,48 @@ mod tests {
file: file.clone(),
options: DbPsqlOptions { single_transaction: true, stop_on_error: true },
},
DbToolJob::Mysqldump {
file: file.clone(),
options: DbMysqldumpOptions {
databases: vec!["shop".into()],
tables: vec![],
add_drop_table: true,
disable_keys: true,
add_locks: true,
add_drop_trigger: false,
no_data: false,
complete_insert: false,
create_options: true,
routines: false,
events: false,
single_transaction: true,
lock_all_tables: false,
masking_policies: None,
},
},
DbToolJob::Mysql { file: String::new(), options: DbMysqlOptions { database: "shop".into(), force: false } },
];
for job in jobs {
let mysql = job.tool().driver() == DbDriver::Mysql;
let source = if mysql { DataSource { driver: DbDriver::Mysql, ..pg() } } else { pg() };
let program = echo_tool(&dir, job.tool());
let prepared = prepare(&job, &pg(), Some(SECRET));
let prepared = prepare(&job, &program, &source, Some(SECRET)).unwrap();
assert!(!prepared.args.iter().any(|a| a.contains(SECRET)), "{:?}", prepared.args);
assert!(!mysql || prepared.env.is_empty(), "{:?}", prepared.env);
let mut lines = Vec::new();
run(&program, &prepared.args, &prepared.env, &CancellationToken::new(), |b| lines.extend(b)).await.unwrap();
run(&program, &prepared.args, &prepared.env, None, &CancellationToken::new(), |b| lines.extend(b))
.await
.unwrap();
let text: Vec<&str> = lines.iter().map(|l| l.text.as_str()).collect();
assert!(text.contains(&"arg:--dbname=shop"), "{text:?}");
let database = if mysql { "shop" } else { "--dbname=shop" };
assert!(text.iter().any(|l| l.strip_prefix("arg:").is_some_and(|a| a.ends_with(database))), "{text:?}");
assert!(!text.iter().any(|l| l.contains(SECRET)), "{text:?}");
assert!(text.contains(&"env:set"), "the tool gets the password from PGPASSWORD: {text:?}");
assert!(text.contains(&"env:set"), "the tool gets the password: {text:?}");
if mysql {
let file = prepared.args[0].trim_start_matches("--defaults-extra-file=").to_owned();
drop(prepared);
assert!(!Path::new(&file).exists(), "the password file outlives the run");
}
}
std::fs::remove_dir_all(&dir).unwrap();
}
+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(())
}
+67
Переглянути файл
@@ -231,3 +231,70 @@ async fn servers_that_advertise_deprecate_eof_but_send_legacy_eof_packets() -> I
assert_eq!(r.rows, vec![vec![Some("a".into())], vec![Some("b".into())]]);
Ok(())
}
/// `mysqldump` into a file and `mysql` reading it back, with the data source's password.
#[tokio::test]
async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
use ide_db::tools::{DbMysqlOptions, DbMysqldumpOptions, DbTool, DbToolJob, find_installs};
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp, "").await else { return Ok(()) };
let (Some(dump), Some(client)) =
(find_installs(DbTool::Mysqldump).into_iter().next(), find_installs(DbTool::Mysql).into_iter().next())
else {
return Ok(());
};
let c = CancellationToken::new();
for stmt in [
"DROP DATABASE IF EXISTS oi_dump_src",
"DROP DATABASE IF EXISTS oi_dump_dst",
"CREATE DATABASE oi_dump_src",
"CREATE DATABASE oi_dump_dst",
"CREATE TABLE oi_dump_src.items (id INT PRIMARY KEY, tag VARCHAR(20))",
"INSERT INTO oi_dump_src.items VALUES (1, 'dumped')",
] {
db.execute("m", stmt, 1, &c).await?;
}
let file = tmp.path().join("src.sql").to_string_lossy().into_owned();
let run = |executable: String, job: DbToolJob| {
let db = &db;
async move {
let mut lines = Vec::new();
let code =
db.run_tool("m", executable.as_ref(), &job, &CancellationToken::new(), |b| lines.extend(b)).await?;
assert_eq!(code, Some(0), "{} failed: {lines:?}", job.tool().program());
IdeResult::Ok(())
}
};
let masking = ide_db::tools::options_of(dump.path.as_ref())?.iter().any(|o| o == "masking-policies");
let options = DbMysqldumpOptions {
databases: vec!["oi_dump_src".into()],
tables: vec![],
add_drop_table: true,
disable_keys: true,
add_locks: true,
add_drop_trigger: false,
no_data: false,
complete_insert: false,
create_options: true,
routines: false,
events: false,
single_transaction: true,
lock_all_tables: false,
masking_policies: masking.then_some(false),
};
run(dump.path.clone(), DbToolJob::Mysqldump { file: file.clone(), options: options.clone() }).await?;
assert!(!ide_db::tools::dump_info(file.as_ref())?.creates_database, "one database: restored into a chosen one");
let both = tmp.path().join("both.sql").to_string_lossy().into_owned();
let two = DbMysqldumpOptions { databases: vec!["oi_dump_src".into(), "oi_dump_dst".into()], ..options };
run(dump.path, DbToolJob::Mysqldump { file: both.clone(), options: two }).await?;
assert!(ide_db::tools::dump_info(both.as_ref())?.creates_database, "several databases: created by the dump");
let restore = DbMysqlOptions { database: "oi_dump_dst".into(), force: false };
run(client.path, DbToolJob::Mysql { file, options: restore }).await?;
let r = db.execute("m", "SELECT tag FROM oi_dump_dst.items", 1, &c).await?;
assert_eq!(r.rows[0][0].as_deref(), Some("dumped"));
for stmt in ["DROP DATABASE oi_dump_src", "DROP DATABASE oi_dump_dst"] {
db.execute("m", stmt, 1, &c).await?;
}
Ok(())
}
+39
Переглянути файл
@@ -230,6 +230,44 @@ async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
}
/// Runs `job` with the newest installed copy of its tool, the way the dialogs do.
#[tokio::test]
async fn drops_a_database_the_ide_holds_connections_to() -> IdeResult<()> {
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let c = CancellationToken::new();
db.execute("p", "DROP DATABASE IF EXISTS oi_drop_me", 0, &c).await?;
db.execute("p", "CREATE DATABASE oi_drop_me TEMPLATE template0", 0, &c).await?;
// What the tree and a manual-commit console leave open on the database.
db.schemas("p:oi_drop_me").await?;
db.set_manual_commit("p:oi_drop_me", true).await?;
db.execute("p:oi_drop_me", "SELECT 1", 1, &c).await?;
db.drop_database("p", "oi_drop_me", "drop database oi_drop_me").await?;
assert!(!db.is_connected("p:oi_drop_me"));
assert!(!db.databases("p").await?.names.iter().any(|n| n == "oi_drop_me"));
let current = db.databases("p").await?.current;
let refused = db.drop_database("p", &current, &format!("drop database \"{current}\"")).await;
assert!(refused.is_err());
Ok(())
}
#[tokio::test]
async fn creates_a_database_from_a_template_the_ide_holds_connections_to() -> IdeResult<()> {
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let c = CancellationToken::new();
db.execute("p", "DROP DATABASE IF EXISTS oi_from_template", 0, &c).await?;
db.schemas("p:template1").await?;
db.create_database("p", "template1", "create database oi_from_template").await?;
assert!(!db.is_connected("p:template1"));
assert!(db.databases("p").await?.names.iter().any(|n| n == "oi_from_template"));
db.execute("p", "DROP DATABASE oi_from_template", 0, &c).await?;
Ok(())
}
async fn run_tool(db: &DbManager, target: &str, job: ide_db::tools::DbToolJob) -> IdeResult<()> {
let install = ide_db::tools::find_installs(job.tool()).into_iter().next().expect("installed");
let mut lines = Vec::new();
@@ -282,6 +320,7 @@ async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
let restore = DbPgRestoreOptions {
content: DbDumpContent::All,
schemas: vec![],
create: false,
clean: false,
if_exists: false,
no_owner: false,
+41
Переглянути файл
@@ -95,3 +95,44 @@ async fn sqlserver_values_paging_transactions_and_cancellation() {
task.await.unwrap();
assert_eq!(pool.rows("SELECT 1", 1).await.unwrap()[0][0].as_deref(), Some("1"));
}
#[tokio::test]
async fn sqlserver_creates_from_a_held_model_and_force_drops_a_held_database() {
let Ok(server) = std::env::var("OPENIDEA_TEST_SQLSERVER") else { return };
let mut parts = server.splitn(4, ':');
let (host, port, user, password) = (
parts.next().unwrap(),
parts.next().unwrap().parse().unwrap(),
parts.next().unwrap(),
parts.next().unwrap_or(""),
);
let source = |database: &str| DataSource {
id: "s".into(),
name: "sqlserver".into(),
driver: DbDriver::SqlServer,
host: host.into(),
port: Some(port),
user: user.into(),
database: database.into(),
ssl: DbSslMode::Disable,
..Default::default()
};
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().to_path_buf();
let ssh = std::sync::Arc::new(ide_ssh::SshManager::new(root.join("ssh-passwords.json")));
let db = ide_db::DbManager::new(root.clone(), root.join("passwords.json"), root.join("history.json"), ssh);
db.save_sources(vec![source("master")]).await.unwrap();
db.set_password("s", Some(password.into()), false).await.unwrap();
let name = format!("oi_force_drop_{}", std::process::id());
// The tree's connection to `model` would keep SQL Server from copying it.
db.schemas("s:model").await.unwrap();
db.create_database("s", "model", &format!("create database {name};")).await.unwrap();
assert!(!db.is_connected("s:model"));
let other = Pool::connect(&source(&name), Some(password), None).await.unwrap();
let held = Held::acquire(&other).await.unwrap();
let force = format!("alter database {name} set single_user with rollback immediate;\ndrop database {name};");
db.drop_database("s", &name, &force).await.unwrap();
assert!(!db.databases("s").await.unwrap().names.contains(&name));
drop(held);
}
+33 -1
Переглянути файл
@@ -24,6 +24,16 @@ pub enum DockerEndpoint {
Tcp { host: String, tls_cert_dir: Option<String> },
/// A named `docker context`.
Context { name: String },
/// A daemon on the host of an SSH configuration (Settings › Tools › SSH Configurations),
/// reached with the IDE's own SSH client and its saved credentials. The host resolves it to
/// a local [`DockerEndpoint::Tcp`] tunnel before running docker; unresolved, the CLI is
/// pointed at an address it rejects rather than at another daemon.
Ssh { config: String },
}
/// What an unresolved [`DockerEndpoint::Ssh`] gives the CLI: an error, never a fallback daemon.
fn unresolved_ssh(config: &str) -> String {
format!("ssh-configuration://{}", config.trim())
}
impl DockerEndpoint {
@@ -55,6 +65,7 @@ impl DockerEndpoint {
args
}
Self::Context { name } => vec!["--context".into(), name.trim().to_owned()],
Self::Ssh { config } => vec!["--host".into(), unresolved_ssh(config)],
}
}
@@ -101,6 +112,11 @@ impl DockerEndpoint {
set("DOCKER_HOST", String::new());
set("DOCKER_TLS_VERIFY", String::new());
}
Self::Ssh { config } => {
set("DOCKER_HOST", unresolved_ssh(config));
set("DOCKER_CONTEXT", String::new());
set("DOCKER_TLS_VERIFY", String::new());
}
}
env
}
@@ -111,8 +127,13 @@ impl DockerEndpoint {
Self::Socket { path } => path.trim().is_empty(),
Self::Tcp { host, .. } => host.trim().is_empty(),
Self::Context { name } => name.trim().is_empty() || name.trim().starts_with('-'),
Self::Ssh { config } => config.trim().is_empty(),
};
if empty { Err(IdeError::invalid("the Docker connection needs a socket, host or context")) } else { Ok(()) }
if empty {
Err(IdeError::invalid("the Docker connection needs a socket, host, context or SSH configuration"))
} else {
Ok(())
}
}
}
@@ -325,6 +346,17 @@ fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
mod tests {
use super::*;
#[test]
fn an_unresolved_ssh_endpoint_never_falls_back_to_another_daemon() {
let ssh = DockerEndpoint::Ssh { config: "box".into() };
assert_eq!(ssh.global_args(), ["--host", "ssh-configuration://box"]);
let env = ssh.env_vars();
assert_eq!((env["DOCKER_HOST"].as_str(), env["DOCKER_CONTEXT"].as_str()), ("ssh-configuration://box", ""));
assert!(ssh.validate().is_ok());
assert!(DockerEndpoint::Ssh { config: " ".into() }.validate().is_err());
assert!(!crate::endpoint_is_local(&ssh).unwrap());
}
#[test]
fn endpoint_args() {
assert!(DockerEndpoint::Default.global_args().is_empty());
File diff suppressed because it is too large. Load diff
+28 -1
Переглянути файл
@@ -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 {
@@ -142,7 +153,7 @@ pub fn snapshot(ep: &DockerEndpoint) -> DockerSnapshot {
}
const FMT: &str = "{{json .}}";
let (containers, images, volumes, networks) = std::thread::scope(|s| {
let c = s.spawn(|| run(ep, &["ps", "--all", "--no-trunc", "--format", FMT], QUICK));
let c = s.spawn(|| run(ep, &["ps", "--all", "--no-trunc", "--format", PS_FORMAT], QUICK));
let i = s.spawn(|| run(ep, &["image", "ls", "--no-trunc", "--format", FMT], QUICK));
let v = s.spawn(|| run(ep, &["volume", "ls", "--format", FMT], QUICK));
let n = s.spawn(|| run(ep, &["network", "ls", "--no-trunc", "--format", FMT], QUICK));
@@ -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.
@@ -483,6 +509,7 @@ pub fn endpoint_is_local(ep: &DockerEndpoint) -> IdeResult<bool> {
|name| context_host(&DockerEndpoint::Default, name),
)?,
DockerEndpoint::Context { name } => context_host(&DockerEndpoint::Default, Some(name.trim()))?,
DockerEndpoint::Ssh { .. } => return Ok(false),
};
Ok(daemon_url_is_local(&url))
}
+16 -6
Переглянути файл
@@ -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) {
@@ -226,6 +226,16 @@ fn lines<T: for<'de> Deserialize<'de>>(text: &str) -> impl Iterator<Item = T> +
})
}
/// The `docker ps --format` template: only the fields [`RawContainer`] reads. `{{json .}}`
/// would also include `Size`, which makes the daemon compute every container's writable
/// layer and can take tens of seconds.
pub const PS_FORMAT: &str = concat!(
r#"{"ID":{{json .ID}},"Names":{{json .Names}},"Image":{{json .Image}},"#,
r#""Command":{{json .Command}},"State":{{json .State}},"Status":{{json .Status}},"#,
r#""Ports":{{json .Ports}},"CreatedAt":{{json .CreatedAt}},"Labels":{{json .Labels}},"#,
r#""Mounts":{{json .Mounts}},"Networks":{{json .Networks}}}"#,
);
#[derive(Deserialize, Default)]
#[serde(rename_all = "PascalCase", default)]
struct RawContainer {
@@ -243,11 +253,11 @@ 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()
}
/// `docker ps -a --no-trunc --format '{{json .}}'`.
/// `docker ps -a --no-trunc --format` [`PS_FORMAT`] (or `'{{json .}}'`).
pub fn parse_containers(text: &str) -> Vec<DockerContainer> {
let mut out: Vec<DockerContainer> = lines::<RawContainer>(text)
.map(|r| {
+23 -2
Переглянути файл
@@ -1,8 +1,8 @@
//! Parsing of recorded `docker … --format '{{json .}}'` output.
use ide_docker::{
parse_container_stats, parse_container_top, parse_containers, parse_image_history, parse_images, parse_networks,
parse_volumes,
PS_FORMAT, parse_container_stats, parse_container_top, parse_containers, parse_image_history, parse_images,
parse_networks, parse_volumes,
};
const PS: &str = include_str!("fixtures/ps.jsonl");
@@ -10,6 +10,27 @@ const IMAGES: &str = include_str!("fixtures/images.jsonl");
const VOLUMES: &str = include_str!("fixtures/volumes.jsonl");
const NETWORKS: &str = include_str!("fixtures/networks.jsonl");
/// Fills `{{json .Field}}` placeholders of a `--format` template from a `{{json .}}` line.
fn render(template: &str, line: &str) -> String {
let fields: serde_json::Map<String, serde_json::Value> = serde_json::from_str(line).unwrap();
let mut out = template.to_owned();
while let Some(start) = out.find("{{json .") {
let end = start + out[start..].find("}}").unwrap() + 2;
let key = &out[start + "{{json .".len()..end - 2];
let value = fields.get(key).unwrap_or_else(|| panic!("fixture lacks {key}"));
out.replace_range(start..end, &value.to_string());
}
out
}
#[test]
fn ps_format_carries_everything_the_parser_reads_but_size() {
assert!(!PS_FORMAT.contains("Size"), "Size makes the daemon compute container sizes");
let rendered: Vec<String> = PS.lines().filter(|l| l.starts_with('{')).map(|l| render(PS_FORMAT, l)).collect();
assert_eq!(rendered.len(), 2);
assert_eq!(parse_containers(&rendered.join("\n")), parse_containers(PS));
}
#[test]
fn containers_with_compose_labels() {
let c = parse_containers(PS);
+12 -1
Переглянути файл
@@ -38,6 +38,8 @@ pub enum Capability {
InputEvents,
/// The system clipboard, from the plugin's web views.
Clipboard,
/// Read the clipboard from commands and view actions the user ran (API 1.11).
ClipboardRead,
/// HTTPS (and loopback HTTP) to one host (`*.example.com` matches subdomains).
Net(String),
/// Ask the user when the first request goes to an HTTPS (or loopback) host
@@ -88,7 +90,8 @@ impl Capability {
| Self::NetHttp(_)
| Self::Secrets
| Self::InputEvents
| Self::Clipboard => Risk::Medium,
| Self::Clipboard
| Self::ClipboardRead => Risk::Medium,
// A trusted project's own files name the programs the IDE starts (its settings, its
// build scripts), so writing them is running code.
Self::ProjectWrite
@@ -127,6 +130,7 @@ impl Capability {
Self::Clipboard => {
"Copy to the clipboard from its commands, and read and write it from its web views".into()
}
Self::ClipboardRead => "Read the clipboard's text and images when you run one of its commands".into(),
Self::Net(host) => format!("Connect to {host} (from the machine the project is on)"),
Self::NetAsk => {
"Ask to connect to a host that is not on the list the first time it tries; you allow or refuse each host, and can revoke the allowed ones"
@@ -262,6 +266,7 @@ impl fmt::Display for Capability {
Self::Events => f.write_str("events"),
Self::InputEvents => f.write_str("events.input"),
Self::Clipboard => f.write_str("clipboard"),
Self::ClipboardRead => f.write_str("clipboard.read"),
Self::Net(h) => write!(f, "net:{h}"),
Self::NetAsk => f.write_str("net:ask"),
Self::NetHttp(h) => write!(f, "net.http:{h}"),
@@ -348,6 +353,7 @@ impl FromStr for Capability {
"events" => Self::Events,
"events.input" => Self::InputEvents,
"clipboard" => Self::Clipboard,
"clipboard.read" => Self::ClipboardRead,
"java.agent" => Self::JavaAgent,
_ => return Err(format!("unknown capability {s:?}")),
})
@@ -398,6 +404,7 @@ mod tests {
"project.write",
"vcs.write",
"build.read",
"clipboard.read",
"storage",
"secrets",
"events",
@@ -439,6 +446,10 @@ mod tests {
assert_eq!(Capability::InputEvents.risk(), Risk::Medium);
assert_eq!("clipboard".parse::<Capability>().unwrap(), Capability::Clipboard);
assert_eq!(Capability::Clipboard.risk(), Risk::Medium);
// Reading is its own grant: neither clipboard capability covers the other.
assert_eq!(Capability::ClipboardRead.risk(), Risk::Medium);
assert!(!Capability::Clipboard.covers(&Capability::ClipboardRead));
assert!(!Capability::ClipboardRead.covers(&Capability::Clipboard));
assert_eq!(Capability::Process("cargo".into()).risk(), Risk::High);
assert_eq!(Capability::Lsp("phoxite".into()).risk(), Risk::High);
assert_eq!(Capability::BuildRead.risk(), Risk::Low);
+12 -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.10.0";
pub const ENGINE_VERSION: &str = "1.14.0";
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
pub const LEGACY_API: &str = "0.1";
/// Marketplace categories, in the order they are shown.
@@ -363,6 +363,9 @@ impl Manifest {
if matches!(cap, Capability::BuildRead) {
self.needs_api(&format!("capability `{cap}`"), 10)?;
}
if matches!(cap, Capability::ClipboardRead) {
self.needs_api(&format!("capability `{cap}`"), 11)?;
}
if matches!(cap, Capability::JavaAgent) {
return Err(
"`java.agent` comes from `[[contributes.javaAgents]]`: remove it from [capabilities]".into()
@@ -746,6 +749,14 @@ required = [\"lsp:phoxite\"]
assert_eq!(m.capabilities.optional, [Capability::BuildRead]);
}
#[test]
fn the_clipboard_read_capability_needs_api_1_11() {
let caps = "[capabilities]\noptional = [\"clipboard.read\"]\n";
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).contains("new in plugin API 1.11"));
let m = Manifest::parse(&format!("{}{caps}", BASE.replace("^1.2", "^1.11"))).unwrap();
assert_eq!(m.capabilities.optional, [Capability::ClipboardRead]);
}
#[test]
fn java_agent_capability_is_not_declared() {
for list in ["required", "optional"] {
+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);
}
}
}
+2
Переглянути файл
@@ -11,6 +11,7 @@ path = "src/bin/server.rs"
[dependencies]
encoding_rs.workspace = true
ide-command.workspace = true
ide-core.workspace = true
ide-mcp.workspace = true
futures.workspace = true
@@ -57,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 }
+22 -5
Переглянути файл
@@ -1,6 +1,7 @@
//! `openidea-server --stdio`: the IDE backend for remote development, serving
//! one desktop client over stdin / stdout (started by the client over SSH).
use ide_host::catalogue::TrustClass;
use ide_host::plugins::remote::{RemotePluginLanguages, SYNC_COMMAND};
use ide_host::plugins::remote_host::RemotePlugins;
use ide_host::rpc::{self, Dispatcher};
@@ -10,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;
@@ -30,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.
@@ -38,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");
@@ -52,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] {
@@ -84,6 +96,10 @@ 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_background.serve_none();
host.mcp.apply(&host);
// The desktop's code plugins run here, next to the project (`plugin_sync_packages`).
let plugins = match RemotePlugins::start(&plugins_data, &host, peer.clone()) {
Ok(p) => Some(p),
@@ -102,7 +118,7 @@ async fn run(base: PathBuf) -> i32 {
if let Some(plugins) = &plugins {
plugins.register(&mut dispatcher);
}
dispatcher.add(SYNC_COMMAND, move |c| {
dispatcher.add(SYNC_COMMAND, TrustClass::Trusted, move |c| {
let remote = plugin_languages.clone();
async move {
let report = remote.sync(c.arg("languages")?);
@@ -111,6 +127,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();
}
+40
Переглянути файл
@@ -0,0 +1,40 @@
//! What every command declares: its trust class, where it runs, and how Tauri runs it.
//! `#[ide_command::command]` and `#[ide_command::desktop_command]` give each command a
//! [`Command`].
/// Where a command may run, from the trust decision of the window's project.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TrustClass {
/// Everywhere, including Restricted Mode.
Always,
/// With no project open, or in a trusted project.
OutsideRestricted,
/// Only in a trusted project.
Trusted,
}
/// Which backend runs a command for a remote window.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Placement {
Desktop,
ProjectHost,
}
/// How Tauri runs the command: on the invoking thread, as a future, or on its thread pool.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Mode {
Sync,
Async,
Spawn,
}
/// One command's declaration.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Command {
pub name: &'static str,
pub trust: TrustClass,
pub placement: Placement,
/// In `bindings.ts`; a command registered outside tauri-specta isn't.
pub bindings: bool,
pub mode: Mode,
}
+426
Переглянути файл
@@ -0,0 +1,426 @@
//! The project's direnv environment: when the project root has an `.envrc`, `direnv export
//! json` runs there and every child started in the project gets what it exports
//! ([`ide_core::project_env`]): terminals, runs, language servers (which wait for it), build
//! tools and debuggers, locally and on a remote host alike. An `.envrc` with `use flake`
//! loads a Nix flake's devshell this way.
//!
//! `.envrc` is project code: it runs in trusted projects only, and only once the user
//! allowed it with `direnv allow`, which the IDE never does for them.
use ide_core::event::DirenvStatus;
use ide_core::{CancellationToken, IdeEvent, SharedSink, TaskId};
use std::collections::BTreeMap;
use std::ffi::OsString;
use std::io::{BufRead, BufReader, Read};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::mpsc::RecvTimeoutError;
use std::time::{Duration, Instant};
pub(crate) const ENVRC: &str = ".envrc";
/// Files in the project root whose change offers a reload: the `.envrc` and the flake
/// `use flake` evaluates.
const WATCHED: [&str; 3] = [ENVRC, "flake.nix", "flake.lock"];
/// A cold `use flake` builds or downloads the devshell: minutes, not seconds.
pub(crate) const TIMEOUT: Duration = Duration::from_secs(10 * 60);
/// Output lines kept for a failure's notification.
const TAIL_LINES: usize = 12;
pub(crate) type Changes = Vec<(OsString, Option<OsString>)>;
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum Failure {
/// The user hasn't allowed this `.envrc` (`direnv allow`).
Blocked,
Failed(String),
Cancelled,
}
pub(crate) fn has_envrc(root: &Path) -> bool {
root.join(ENVRC).is_file()
}
/// `direnv` on the IDE's search path.
pub(crate) fn program() -> Option<PathBuf> {
ide_core::process::find_executable("direnv", &ide_core::tool_path::search_path())
}
/// The watched file among `paths` (changed or removed below `root`), when the project has an
/// `.envrc` or just lost it: what a reload would pick up.
pub(crate) fn reload_offer<'a>(root: &Path, paths: impl IntoIterator<Item = &'a PathBuf>) -> Option<String> {
let file = paths
.into_iter()
.filter(|p| p.parent() == Some(root))
.filter_map(|p| p.file_name()?.to_str())
.find(|name| WATCHED.contains(name))?;
(file == ENVRC || has_envrc(root)).then(|| file.to_owned())
}
/// Runs `program export json` in `root` from the environment children outside any project
/// get (not the project's last one: a reload must not see its own result), reporting
/// direnv's progress lines to `on_line`. Gives up after `timeout` or once `cancel` fires,
/// stopping what direnv started (`nix`) too.
pub(crate) fn export(
program: &Path,
root: &Path,
timeout: Duration,
cancel: &CancellationToken,
on_line: &dyn Fn(&str),
) -> Result<Changes, Failure> {
let mut cmd = Command::new(program);
ide_core::process::prepare(ide_core::process::own_group(&mut cmd));
let mut child = cmd
.args(["export", "json"])
.current_dir(root)
.env_clear()
.envs(ide_core::process::host_vars())
.envs(ide_core::process::shell_env())
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| Failure::Failed(format!("cannot start {}: {e}", program.display())))?;
let mut stdout = child.stdout.take().expect("piped");
let out = std::thread::spawn(move || {
let mut buf = Vec::new();
stdout.read_to_end(&mut buf).map(|_| buf)
});
let (tx, rx) = std::sync::mpsc::channel::<String>();
let stderr = child.stderr.take().expect("piped");
std::thread::spawn(move || {
for line in BufReader::new(stderr).split(b'\n').map_while(Result::ok) {
let line = ide_core::output_encoding::decode_tool_output(&line).trim_end_matches('\r').to_owned();
if tx.send(line).is_err() {
break;
}
}
});
let deadline = Instant::now() + timeout;
let mut tail: Vec<String> = Vec::new();
let mut keep = |line: String| {
on_line(&line);
tail.push(line);
let excess = tail.len().saturating_sub(TAIL_LINES);
tail.drain(..excess);
};
loop {
if cancel.is_cancelled() {
ide_core::process::kill_tree(&mut child);
return Err(Failure::Cancelled);
}
if Instant::now() > deadline {
ide_core::process::kill_tree(&mut child);
return Err(Failure::Failed(format!(
"direnv did not finish within {} minutes.\n\n{}",
timeout.as_secs() / 60,
tail.join("\n")
)));
}
match rx.recv_timeout(Duration::from_millis(50)) {
Ok(line) => keep(line),
Err(RecvTimeoutError::Timeout) => {}
Err(RecvTimeoutError::Disconnected) => break,
}
}
let status = child.wait().map_err(|e| Failure::Failed(e.to_string()))?;
let stdout = out.join().ok().and_then(Result::ok).unwrap_or_default();
if tail.iter().any(|l| l.contains("is blocked") || l.contains("is not allowed")) {
return Err(Failure::Blocked);
}
if !status.success() {
let tail = tail.join("\n");
return Err(Failure::Failed(if tail.is_empty() { format!("direnv exited with {status}") } else { tail }));
}
parse(&stdout).map_err(Failure::Failed)
}
/// `direnv export json`'s output: the variables to set, `null` for those to unset; nothing
/// when there is nothing to change.
fn parse(stdout: &[u8]) -> Result<Changes, String> {
if stdout.iter().all(u8::is_ascii_whitespace) {
return Ok(Changes::new());
}
let vars: BTreeMap<String, Option<String>> =
serde_json::from_slice(stdout).map_err(|e| format!("unexpected output from direnv: {e}"))?;
Ok(vars.into_iter().map(|(k, v)| (k.into(), v.map(Into::into))).collect())
}
/// Loads `root`'s environment with `program` (`None`: direnv isn't installed) into
/// [`ide_core::project_env`], as a cancellable background task; what went wrong is a
/// [`IdeEvent::Direnv`]. `current` says whether this load still owns `root` (not closed or
/// superseded by a newer one meanwhile) and is checked again before anything is applied.
pub(crate) fn load(
root: &Path,
program: Option<&Path>,
sink: &SharedSink,
cancel: &CancellationToken,
timeout: Duration,
hint_missing: bool,
current: &dyn Fn(&dyn Fn()),
) {
let report = |status: DirenvStatus| sink.emit(IdeEvent::Direnv { root: root.to_path_buf().into(), status });
let Some(program) = program else {
current(&|| ide_core::project_env::settle(root));
if hint_missing {
report(DirenvStatus::NotInstalled);
}
return;
};
let task = TaskId::next();
let _cancel_handle = ide_core::task::on_cancel(task, {
let cancel = cancel.clone();
move || cancel.cancel()
});
let progress = |message: Option<String>, done: bool| {
sink.emit(IdeEvent::Task {
id: task,
title: "Loading the direnv environment".into(),
message,
fraction: None,
done,
cancellable: !done,
});
};
progress(Some(format!("{} export json", program.display())), false);
let result = export(program, root, timeout, cancel, &|line| progress(Some(line.to_owned()), false));
progress(None, true);
match result {
Ok(changes) => {
tracing::info!("direnv: {} variables for {}", changes.len(), root.display());
current(&|| ide_core::project_env::set(root, changes.clone()));
}
Err(Failure::Blocked) => {
// As in a shell: a blocked `.envrc` isn't loaded.
current(&|| ide_core::project_env::set(root, Changes::new()));
report(DirenvStatus::Blocked);
}
Err(Failure::Failed(message)) => {
tracing::warn!("direnv in {}: {message}", root.display());
current(&|| ide_core::project_env::settle(root));
report(DirenvStatus::Failed { message });
}
// Closed or superseded (that one settles), or stopped from the task list.
Err(Failure::Cancelled) => current(&|| ide_core::project_env::settle(root)),
}
}
#[cfg(all(test, unix))]
mod tests {
use super::*;
use ide_core::EventSink;
use parking_lot::Mutex;
use std::os::unix::fs::PermissionsExt;
use std::sync::Arc;
/// A stand-in `direnv`: checks its arguments, then prints `stderr` and `out.json` of the
/// folder it runs in and exits with `code`, or blocks like direnv on an `.envrc` not allowed.
fn fake_direnv(dir: &Path) -> PathBuf {
let program = dir.join("direnv");
std::fs::write(
&program,
r#"#!/bin/sh
[ "$1 $2" = "export json" ] || { echo "direnv: unexpected arguments $*" >&2; exit 2; }
echo "direnv: loading $PWD/.envrc" >&2
[ -f slow ] && sleep 30
[ -f blocked ] && { echo "direnv: error $PWD/.envrc is blocked. Run \`direnv allow\` to approve its content" >&2; exit 1; }
[ -f stderr ] && cat stderr >&2
[ -f out.json ] && cat out.json
echo "direnv: export +NIX_DEV" >&2
exit "$(cat code 2>/dev/null || echo 0)"
"#,
)
.unwrap();
std::fs::set_permissions(&program, std::fs::Permissions::from_mode(0o755)).unwrap();
program
}
fn project() -> (tempfile::TempDir, PathBuf, PathBuf) {
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
std::fs::create_dir(&root).unwrap();
std::fs::write(root.join(ENVRC), "use flake\n").unwrap();
let program = fake_direnv(tmp.path());
(tmp, root, program)
}
fn run(program: &Path, root: &Path) -> (Result<Changes, Failure>, Vec<String>) {
let lines = Mutex::new(Vec::new());
let result = export(program, root, Duration::from_secs(20), &CancellationToken::new(), &|l| {
lines.lock().push(l.to_owned())
});
(result, lines.into_inner())
}
fn change(k: &str, v: Option<&str>) -> (OsString, Option<OsString>) {
(k.into(), v.map(Into::into))
}
#[test]
fn exported_variables_are_set_and_unset() {
let (_tmp, root, program) = project();
std::fs::write(
root.join("out.json"),
r#"{"PATH":"/nix/store/abc-devshell/bin:/usr/bin","IN_NIX_SHELL":"impure","OLD":null}"#,
)
.unwrap();
let (result, lines) = run(&program, &root);
assert_eq!(
result.unwrap(),
[
change("IN_NIX_SHELL", Some("impure")),
change("OLD", None),
change("PATH", Some("/nix/store/abc-devshell/bin:/usr/bin")),
]
);
assert_eq!(lines, [format!("direnv: loading {}/.envrc", root.display()), "direnv: export +NIX_DEV".into()]);
}
#[test]
fn nothing_to_export_changes_nothing() {
let (_tmp, root, program) = project();
assert_eq!(run(&program, &root).0, Ok(Changes::new()));
}
#[test]
fn a_blocked_envrc_is_reported_as_such() {
let (_tmp, root, program) = project();
std::fs::write(root.join("blocked"), "").unwrap();
assert_eq!(run(&program, &root).0, Err(Failure::Blocked));
}
#[test]
fn a_failure_reports_the_end_of_the_output() {
let (_tmp, root, program) = project();
std::fs::write(root.join("stderr"), "error: flake 'path:/p' does not provide attribute 'devShells'\n").unwrap();
std::fs::write(root.join("code"), "1").unwrap();
let Err(Failure::Failed(message)) = run(&program, &root).0 else { panic!("a failure") };
assert!(message.contains("does not provide attribute 'devShells'"), "{message}");
std::fs::remove_file(root.join("code")).unwrap();
std::fs::write(root.join("out.json"), "not json").unwrap();
let Err(Failure::Failed(message)) = run(&program, &root).0 else { panic!("a failure") };
assert!(message.starts_with("unexpected output from direnv"), "{message}");
}
#[test]
fn a_slow_direnv_times_out_or_is_cancelled() {
let (_tmp, root, program) = project();
std::fs::write(root.join("slow"), "").unwrap();
let started = Instant::now();
let result = export(&program, &root, Duration::from_secs(2), &CancellationToken::new(), &|_| {});
let Err(Failure::Failed(message)) = result else { panic!("a timeout") };
assert!(message.starts_with("direnv did not finish within"), "{message}");
assert!(message.contains("direnv: loading"), "{message}");
let cancel = CancellationToken::new();
let c = cancel.clone();
std::thread::spawn(move || {
std::thread::sleep(Duration::from_millis(200));
c.cancel();
});
assert_eq!(export(&program, &root, Duration::from_secs(60), &cancel, &|_| {}), Err(Failure::Cancelled));
assert!(started.elapsed() < Duration::from_secs(20));
}
#[test]
fn missing_program_is_a_start_failure() {
let (_tmp, root, _) = project();
let Err(Failure::Failed(message)) = run(Path::new("/openidea-no-such/direnv"), &root).0 else { panic!() };
assert!(message.starts_with("cannot start"), "{message}");
}
#[derive(Default)]
struct Events(Mutex<Vec<IdeEvent>>);
impl EventSink for Events {
fn emit(&self, e: IdeEvent) {
self.0.lock().push(e);
}
}
fn statuses(events: &Events) -> Vec<DirenvStatus> {
events
.0
.lock()
.iter()
.filter_map(|e| match e {
IdeEvent::Direnv { status, .. } => Some(status.clone()),
_ => None,
})
.collect()
}
fn load_with(root: &Path, program: Option<&Path>, hint: bool) -> Arc<Events> {
let events = Arc::new(Events::default());
let sink: SharedSink = events.clone();
ide_core::project_env::begin_loading(root);
load(root, program, &sink, &CancellationToken::new(), Duration::from_secs(20), hint, &|apply| apply());
events
}
#[test]
fn children_in_the_project_get_what_direnv_exported() {
let (_tmp, root, program) = project();
std::fs::write(root.join("out.json"), r#"{"OPENIDEA_TEST_DEVSHELL":"1"}"#).unwrap();
let events = load_with(&root, Some(&program), true);
assert!(statuses(&events).is_empty());
assert!(!ide_core::project_env::is_loading(&root));
let mut cmd = Command::new("true");
cmd.current_dir(root.join("src"));
ide_core::process::host_env(&mut cmd);
assert!(cmd.get_envs().any(|(k, v)| k == "OPENIDEA_TEST_DEVSHELL" && v == Some("1".as_ref())));
// A task shows the progress, and ends.
let tasks: Vec<_> = events
.0
.lock()
.iter()
.filter_map(|e| match e {
IdeEvent::Task { message, done, .. } => Some((message.clone(), *done)),
_ => None,
})
.collect();
assert!(tasks.iter().any(|(m, _)| m.as_deref() == Some("direnv: export +NIX_DEV")), "{tasks:?}");
assert_eq!(tasks.last(), Some(&(None, true)));
// Blocked after an edit: the environment goes, as in a shell.
std::fs::write(root.join("blocked"), "").unwrap();
let events = load_with(&root, Some(&program), true);
assert_eq!(statuses(&events), [DirenvStatus::Blocked]);
assert!(ide_core::project_env::for_dir(&root).is_empty());
// A failure keeps the last environment and says why.
std::fs::remove_file(root.join("blocked")).unwrap();
load_with(&root, Some(&program), true);
std::fs::write(root.join("stderr"), "error: syntax error in flake.nix\n").unwrap();
std::fs::write(root.join("code"), "1").unwrap();
let events = load_with(&root, Some(&program), true);
let [DirenvStatus::Failed { message }] = &statuses(&events)[..] else { panic!("{:?}", statuses(&events)) };
assert!(message.contains("syntax error in flake.nix"), "{message}");
assert!(!ide_core::project_env::for_dir(&root).is_empty());
ide_core::project_env::remove(&root);
}
#[test]
fn direnv_not_installed_is_hinted_once_and_does_not_block() {
let (_tmp, root, _) = project();
let events = load_with(&root, None, true);
assert_eq!(statuses(&events), [DirenvStatus::NotInstalled]);
assert!(!ide_core::project_env::is_loading(&root), "language servers start anyway");
assert!(statuses(&load_with(&root, None, false)).is_empty());
ide_core::project_env::remove(&root);
}
#[test]
fn changes_to_the_envrc_or_flake_offer_a_reload() {
let (_tmp, root, _) = project();
let paths = |names: &[&str]| names.iter().map(|n| root.join(n)).collect::<Vec<_>>();
assert_eq!(reload_offer(&root, &paths(&["src/main.rs", "flake.lock"])), Some("flake.lock".into()));
assert_eq!(reload_offer(&root, &paths(&[".envrc"])), Some(".envrc".into()));
assert_eq!(reload_offer(&root, &paths(&["sub/flake.nix", "src/main.rs"])), None, "the project root's only");
std::fs::remove_file(root.join(ENVRC)).unwrap();
assert_eq!(reload_offer(&root, &paths(&["flake.nix"])), None, "no .envrc: nothing loads the flake");
assert_eq!(reload_offer(&root, &paths(&[".envrc"])), Some(".envrc".into()), "removed: reload unloads");
}
}
+92 -11
Переглянути файл
@@ -1,9 +1,11 @@
//! The environment child processes get beyond this process's own: the login shell's as
//! re-read by Reload Environment, and (remote server) the project's
//! `devcontainer.json` `remoteEnv`, plus its `postStartCommand` once per server start.
//! re-read by Reload Environment, (remote server) the project's `devcontainer.json`
//! `remoteEnv`, plus its `postStartCommand` once per server start, and each trusted
//! project's direnv `.envrc` ([`crate::direnv`]).
//!
//! Both reach every child through `ide_core::process::set_env_overlay`: terminals, runs,
//! language servers, debug adapters, build tools and git all spawn through
//! The first two reach every child through `ide_core::process::set_env_overlay`, a project's
//! direnv environment the children started inside it (`ide_core::project_env`): terminals,
//! runs, language servers, debug adapters, build tools and git all spawn through
//! `ide_core::process::prepare` / `host_env`.
use ide_core::event::NotifyLevel;
@@ -18,6 +20,7 @@ use std::io::{BufRead, BufReader, Read};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::time::Duration;
type Changes = Vec<(OsString, Option<OsString>)>;
@@ -51,18 +54,87 @@ struct State {
post_commands: std::collections::HashMap<PathBuf, CancellationToken>,
}
/// Project roots whose direnv environment is loaded or loading, with the load that owns
/// each (a generation) and what stops it.
type DirenvLoads = Arc<Mutex<std::collections::HashMap<PathBuf, (u64, CancellationToken)>>>;
pub struct Environment {
/// Whether the open project's `devcontainer.json` applies (the remote server: one project per process).
project_env: bool,
data_dir: PathBuf,
state: Mutex<State>,
/// Stops running `postStartCommand`s when the host shuts down.
/// Stops running `postStartCommand`s and direnv loads when the host shuts down.
cancel: CancellationToken,
direnv: DirenvLoads,
/// "direnv is not installed" is said once per process.
direnv_hinted: AtomicBool,
}
impl Environment {
pub(crate) fn new(project_env: bool, data_dir: PathBuf) -> Self {
Self { project_env, data_dir, state: Mutex::default(), cancel: CancellationToken::new() }
Self {
project_env,
data_dir,
state: Mutex::default(),
cancel: CancellationToken::new(),
direnv: DirenvLoads::default(),
direnv_hinted: AtomicBool::new(false),
}
}
/// A trusted project at `root` opened or became trusted: loads its direnv environment in
/// the background, unless another window of it already did. Its language servers wait.
pub(crate) fn direnv_opened(&self, root: &Path, sink: &SharedSink) {
if !self.direnv.lock().contains_key(root) {
self.load_direnv(root, sink, true);
}
}
/// The project at `root` closed in its last window, or is no longer trusted.
pub(crate) fn direnv_closed(&self, root: &Path) {
if let Some((_, cancel)) = self.direnv.lock().remove(root) {
cancel.cancel();
}
ide_core::project_env::remove(root);
}
/// (Re)loads `root`'s direnv environment, replacing a load still running; on this thread
/// unless `background`. Without an `.envrc` the project has none.
fn load_direnv(&self, root: &Path, sink: &SharedSink, background: bool) {
static GENERATION: AtomicU64 = AtomicU64::new(0);
let generation = GENERATION.fetch_add(1, Ordering::Relaxed);
let cancel = self.cancel.child_token();
{
let mut loads = self.direnv.lock();
if let Some((_, previous)) = loads.insert(root.to_path_buf(), (generation, cancel.clone())) {
previous.cancel();
}
if !crate::direnv::has_envrc(root) {
ide_core::project_env::remove(root);
return;
}
// Before this returns: a language server starting next waits for it.
ide_core::project_env::begin_loading(root);
}
let program = crate::direnv::program();
let hint = program.is_none() && !self.direnv_hinted.swap(true, Ordering::AcqRel);
let (loads, dir, sink) = (self.direnv.clone(), root.to_path_buf(), sink.clone());
let run = move || {
let current = |apply: &dyn Fn()| {
let loads = loads.lock();
if loads.get(&dir).is_some_and(|(g, _)| *g == generation) {
apply();
}
};
crate::direnv::load(&dir, program.as_deref(), &sink, &cancel, crate::direnv::TIMEOUT, hint, &current);
};
if !background {
run();
} else if let Err(e) = std::thread::Builder::new().name("openidea-direnv".into()).spawn(run) {
tracing::warn!("direnv: {e}");
// Language servers must not wait for a load that never runs.
ide_core::project_env::settle(root);
}
}
pub(crate) fn shutdown(&self) {
@@ -118,11 +190,17 @@ impl Environment {
ide_core::process::set_env_overlay(merge(&state.login, &state.project));
}
/// Reload Environment: reads the login shell again and re-applies the project's
/// `remoteEnv` (`root`). Blocking (it runs the shell); children already running keep
/// their environment.
/// Reload Environment: reads the login shell again, re-applies the project's `remoteEnv`
/// and loads its direnv environment again (`root`, a trusted project). Blocking (it runs
/// the shell and direnv); children already running keep their environment.
pub fn reload(&self, root: Option<&Path>, sink: &SharedSink) -> IdeResult<EnvReloaded> {
let before: Vec<_> = ide_core::process::host_vars().collect();
let vars = || -> Vec<_> {
match root {
Some(root) => ide_core::process::host_vars_in(root).collect(),
None => ide_core::process::host_vars().collect(),
}
};
let before = vars();
let fresh = crate::shell_env::read_login_env_now().map_err(IdeError::unavailable)?;
let shell_read = fresh.is_some();
if let Some(fresh) = fresh {
@@ -146,7 +224,10 @@ impl Environment {
None
}
};
let after: Vec<_> = ide_core::process::host_vars().collect();
if let Some(root) = root {
self.load_direnv(root, sink, false);
}
let after = vars();
Ok(EnvReloaded { changed: changed_names(&before, &after), devcontainer, shell_read })
}
+244 -11
Переглянути файл
@@ -2,9 +2,9 @@
use crate::Host;
use ide_core::event::NotifyLevel;
use ide_core::settings::{ExternalFormatter, LanguagesSettings};
use ide_core::{DocId, IdeError, IdeEvent, IdeResult, Pos, Range, TextEdit};
use ide_language::LanguageConfig;
use ide_core::settings::{ExternalFormatter, LanguagesSettings, Settings};
use ide_core::{ChangeSet, DocId, IdeError, IdeEvent, IdeResult, LanguageId, Pos, Range, TextEdit};
use ide_language::{LanguageConfig, PhpAlignment, Syntax};
use ide_lsp::types::FormatOptions;
use ide_tools::{Tools, formatter};
use std::path::Path;
@@ -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,
@@ -129,12 +152,101 @@ pub async fn format(
let project = host.project(window)?;
let snap = project.documents.snapshot(doc)?;
let settings = project.settings.effective();
let alignment = php_alignment(&settings, &snap.language);
let original = alignment.any().then(|| (snap.language.clone(), snap.text.clone()));
let Some(edits) = provider_edits(host, window, &project, snap, settings, range, options).await? else {
return Ok(Vec::new());
};
let Some((language, text)) = original else {
return Ok(edits);
};
let syntax = host.syntax();
tokio::task::spawn_blocking(move || align_formatted(&syntax, &language, &text, edits, range, alignment))
.await
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// PHP Code Style › Align key-value pairs / Align consecutive assignments (off by default, as in PhpStorm).
fn php_alignment(settings: &Settings, language: &LanguageId) -> PhpAlignment {
let style = settings.editor.code_style.languages.get(language.as_str());
PhpAlignment {
key_value_pairs: style.and_then(|s| s.align_key_value_pairs).unwrap_or(false),
assignments: style.and_then(|s| s.align_consecutive_assignments).unwrap_or(false),
}
}
/// The formatter's `edits` to `text` followed by the alignment, as one set of edits to `text`.
/// With a `range`, only its lines (where the formatter left them) are aligned.
fn align_formatted(
syntax: &Syntax,
language: &LanguageId,
text: &str,
edits: Vec<TextEdit>,
range: Option<Range>,
alignment: PhpAlignment,
) -> IdeResult<Vec<TextEdit>> {
let mut formatted = ide_text::Document::new(text);
// Edits the editor has to sort out itself (overlapping ones) are passed on unaligned.
let Ok((changes, _)) = formatted.apply_edits(&edits) else {
return Ok(edits);
};
let lines = range.map(|range| {
let original = ide_text::Document::new(text);
let start = formatted.offset_to_pos(map_offset(&changes, original.pos_to_offset(range.start), false));
let end = formatted.offset_to_pos(map_offset(&changes, original.pos_to_offset(range.end), true));
let last = if end.col == 0 && end.line > start.line { end.line - 1 } else { end.line };
(start.line as usize, last as usize)
});
let Some(aligned) = syntax.align_php(language, &formatted.text(), lines, alignment) else {
return Ok(edits);
};
let original = ide_text::Document::new(text);
Ok(original
.diff(&aligned)
.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())
}
/// Where UTF-16 `offset` of the text before `changes` ends up after them; inside a replaced
/// part, at its start or (`end`) its end.
fn map_offset(changes: &ChangeSet, offset: u32, end: bool) -> u32 {
let mut shift: i64 = 0;
for c in &changes.changes {
let inserted = c.insert.encode_utf16().count() as i64;
if c.to < offset || (c.to == offset && (c.from < c.to || end)) {
shift += inserted - i64::from(c.to - c.from);
} else if c.from < offset {
return (i64::from(c.from) + shift + if end { inserted } else { 0 }) as u32;
} else {
break;
}
}
(i64::from(offset) + shift) as u32
}
/// The edits of the formatter that handles the document; `None` when it doesn't run
/// (formatting on save is off for it).
async fn provider_edits(
host: &Host,
window: &str,
project: &crate::Project,
snap: ide_workspace::documents::DocumentInfo,
settings: Settings,
range: Option<Range>,
options: FormatOptions,
) -> IdeResult<Option<Vec<TextEdit>>> {
let doc = snap.id;
let language = project.languages.get(&snap.language);
if options.tool.is_none()
&& let Some(id) = settings.languages.plugin_formatters.get(snap.language.as_str()).filter(|s| !s.is_empty())
{
if options.on_save && !settings.editor.format_on_save {
return Ok(Vec::new());
return Ok(None);
}
if snap.read_only {
return Err(IdeError::invalid("The file is read-only"));
@@ -160,7 +272,8 @@ pub async fn format(
)
})
.await
.map_err(|e| IdeError::internal(e.to_string()))?;
.map_err(|e| IdeError::internal(e.to_string()))?
.map(Some);
}
// A committed PHP-CS-Fixer configuration takes over Reformat Code for `.php` files.
if options.tool.is_none()
@@ -168,7 +281,7 @@ pub async fn format(
&& let Some(fixer) = formatter::php_cs_fixer(&snap.path)
{
if options.on_save && !settings.editor.format_on_save {
return Ok(Vec::new());
return Ok(None);
}
host.require_trust(window)?;
if snap.read_only {
@@ -188,7 +301,7 @@ pub async fn format(
body: Some("PHP-CS-Fixer does not support selection formatting; formatted the whole file".into()),
});
}
return Ok(edits);
return Ok(Some(edits));
}
let mut selected = external_tool(options.tool, language.as_ref(), &snap.path, &settings.languages)?;
if let Some(tool) = selected
@@ -200,13 +313,17 @@ pub async fn format(
}
let Some(selected) = selected else {
if options.on_save && !settings.editor.format_on_save {
return Ok(Vec::new());
return Ok(None);
}
return project.lsp.format(doc, range, options).await;
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 {
return Ok(Vec::new());
return Ok(None);
}
host.require_trust(window)?;
if snap.read_only {
@@ -262,7 +379,7 @@ pub async fn format(
)),
});
}
edits.map_err(|e| e.with_tool(tool))
edits.map(Some).map_err(|e| e.with_tool(tool))
}
#[cfg(test)]
@@ -413,6 +530,122 @@ mod tests {
);
}
fn after(text: &str, edits: &[TextEdit]) -> String {
let mut doc = ide_text::Document::new(text);
doc.apply_edits(edits).unwrap();
doc.text()
}
fn whole_file(text: &str, formatted: &str) -> Vec<TextEdit> {
let doc = ide_text::Document::new(text);
doc.diff(formatted)
.changes
.into_iter()
.map(|c| TextEdit {
range: Range::new(doc.offset_to_pos(c.from), doc.offset_to_pos(c.to)),
new_text: c.insert,
})
.collect()
}
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");
let mut settings = Settings::default();
assert_eq!(php_alignment(&settings, &php), PhpAlignment::default());
let style =
ide_core::editor_settings::LanguageCodeStyle { align_key_value_pairs: Some(true), ..Default::default() };
settings.editor.code_style.languages.insert("php".into(), style);
assert_eq!(php_alignment(&settings, &php), PhpAlignment { key_value_pairs: true, assignments: false });
assert_eq!(php_alignment(&settings, &LanguageId::new("javascript")), PhpAlignment::default());
}
#[test]
fn alignment_follows_the_formatter_edits_even_when_there_are_none() {
let syntax = Syntax::new();
let php = LanguageId::new("php");
let text = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
let edits = align_formatted(&syntax, &php, text, Vec::new(), None, ALIGN).unwrap();
assert_eq!(after(text, &edits), "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
// The language server re-indents the array: the alignment applies to its result.
let text = "<?php\n$a = [\n'a' => 1,\n'bbb' => 2,\n];\n";
let formatted = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
let edits = align_formatted(&syntax, &php, text, whole_file(text, formatted), None, ALIGN).unwrap();
assert_eq!(after(text, &edits), "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
let unchanged = whole_file(text, formatted);
let off = align_formatted(&syntax, &php, text, unchanged.clone(), None, PhpAlignment::default()).unwrap();
assert_eq!(off, unchanged);
let overlapping = vec![
TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 4)), new_text: "x".into() },
TextEdit { range: Range::new(Pos::new(1, 2), Pos::new(1, 6)), new_text: "y".into() },
];
let passed = align_formatted(&syntax, &php, text, overlapping.clone(), None, ALIGN).unwrap();
assert_eq!(passed, overlapping);
}
#[test]
fn a_selection_aligns_only_its_lines_whatever_the_formatter_changed() {
let syntax = Syntax::new();
let php = LanguageId::new("php");
let text = "<?php\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
// PHP-CS-Fixer formats the whole file (here: adds a line at the top) whatever the selection.
let formatted = format!("<?php\n\ndeclare(strict_types=1);\n{}", &text["<?php\n".len()..]);
let edits = whole_file(text, &formatted);
// Lines 3..=6 select the array, up to the start of the line after it.
let range = Range::new(Pos::new(3, 0), Pos::new(7, 0));
let aligned = align_formatted(&syntax, &php, text, edits, Some(range), ALIGN).unwrap();
assert_eq!(aligned.len(), 2, "one edit per changed region: {aligned:?}");
assert_eq!(
after(text, &aligned),
"<?php\n\ndeclare(strict_types=1);\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n"
);
let range = Range::new(Pos::new(1, 0), Pos::new(2, 9));
let aligned = align_formatted(&syntax, &php, text, Vec::new(), Some(range), ALIGN).unwrap();
assert_eq!(after(text, &aligned), "<?php\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
}
#[test]
fn offsets_map_through_changes() {
let changes = ChangeSet {
changes: vec![
ide_core::TextChange { from: 2, to: 2, insert: "ab".into() },
ide_core::TextChange { from: 5, to: 8, insert: "x".into() },
],
};
assert_eq!(map_offset(&changes, 0, false), 0);
assert_eq!(map_offset(&changes, 2, false), 2);
assert_eq!(map_offset(&changes, 2, true), 4);
assert_eq!(map_offset(&changes, 4, false), 6);
assert_eq!(map_offset(&changes, 6, false), 7);
assert_eq!(map_offset(&changes, 6, true), 8);
assert_eq!(map_offset(&changes, 8, false), 8);
assert_eq!(map_offset(&changes, 10, false), 10);
}
#[test]
fn ruff_ranges_are_one_based_unicode_columns() {
let text = ide_text::Document::new("😀x = 1\ny = 2\n");
+70 -16
Переглянути файл
@@ -4,8 +4,10 @@
//! runs one on a remote machine and serves it over JSON-RPC ([`rpc`]).
pub mod agent_secrets;
pub mod catalogue;
pub mod data_dirs;
pub mod diagnostics_store;
mod direnv;
pub mod environment;
mod formatter;
mod java_runtime;
@@ -23,7 +25,7 @@ pub mod rpc;
pub mod shell_env;
pub mod trust;
pub use project::{Project, apply_git_executable, apply_workspace_edit, history_retention};
pub use project::{Project, apply_git_executable, history_retention};
use ide_core::{CancellationToken, IdeError, IdeResult, RequestId, SharedSink};
use ide_language::{LanguageRegistry, Syntax};
@@ -57,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.
@@ -66,6 +69,8 @@ pub struct Host {
pub mcp_requests: mcp::Requests,
/// Commands agents run in the Run tool window (`run_command`).
pub mcp_agent_runs: mcp::AgentRuns,
/// Projects the MCP server serves without a window.
pub mcp_background: mcp::BackgroundProjects,
pub(crate) agent_catalogs: Arc<ide_agent::AgentCatalogs>,
pub trust: trust::TrustStore,
pub(crate) mcp_approvals: Arc<trust::McpServerApprovals>,
@@ -91,6 +96,8 @@ pub struct Host {
pub ssh: Arc<ide_ssh::SshManager>,
/// SFTP deployment, remote file editing and runs on run targets.
pub remote: Arc<ide_remote::RemoteService>,
/// Tunnels of Docker connections made through an SSH configuration.
pub docker_tunnels: ops::docker::DockerTunnels,
/// What child processes get beyond this process's environment (Reload Environment, `remoteEnv`).
pub environment: environment::Environment,
/// The built-in web server (Open In › Browser, the editor's browser bar). On a remote host the
@@ -120,10 +127,16 @@ pub struct Host {
const EXIT_SHUTDOWN_WAIT: std::time::Duration = std::time::Duration::from_secs(10);
impl Host {
/// Windows whose current project has this root.
/// Windows whose current project has this root. A project served without a window
/// has none.
pub(crate) fn windows_for_root(&self, root: &std::path::Path) -> Vec<String> {
let mut windows: Vec<_> =
self.projects.read().iter().filter(|(_, p)| p.root == root).map(|(w, _)| w.clone()).collect();
let mut windows: Vec<_> = self
.projects
.read()
.iter()
.filter(|(w, p)| p.root == root && !mcp::BackgroundProjects::is_key(w))
.map(|(w, _)| w.clone())
.collect();
windows.sort();
windows
}
@@ -148,11 +161,13 @@ 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(),
mcp_agent_runs: Default::default(),
mcp_background: Default::default(),
agent_catalogs: Arc::default(),
trust: trust::TrustStore::load(&config_dir, &data_dir),
mcp_approvals: Arc::new(trust::McpServerApprovals::load(&data_dir)),
@@ -161,6 +176,7 @@ impl Host {
agent_secrets: Arc::new(agent_secrets::AgentSecrets::new(&data_dir)),
remote: Arc::new(ide_remote::RemoteService::new(ssh.clone(), data_dir.join("remote"))),
ssh,
docker_tunnels: Default::default(),
environment: environment::Environment::new(project_environment, local_data_dir.clone()),
web: ide_web::WebServer::new(),
global_settings,
@@ -217,12 +233,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);
}
@@ -248,6 +264,16 @@ impl Host {
self.project(window)?.require_trust()
}
/// [`Self::require_trust`] for IDE-wide toolchain work (SDK detection, tool installs) that
/// also runs from a window without a project, such as Settings opened from the Welcome
/// screen: there is no project there to trust.
pub fn require_trust_if_project(&self, window: &str) -> IdeResult<()> {
match self.project(window) {
Ok(project) => project.require_trust(),
Err(_) => Ok(()),
}
}
/// The window that owns what `window` starts.
pub fn owner_window<'a>(&self, window: &'a str) -> &'a str {
(self.owner)(window)
@@ -305,15 +331,27 @@ impl Host {
}
project.files_events_active.store(false, std::sync::atomic::Ordering::Release);
project.plugin_diagnostics.close();
// A project served without a window shares its files with a window whose root lies
// around or below its own: their diagnostics stay.
let background = mcp::BackgroundProjects::is_key(window);
let shared = background
&& self.projects.read().values().any(|other| {
!other.light && (other.root.starts_with(&project.root) || project.root.starts_with(&other.root))
});
// The producers will re-report when a project reopens; until then the snapshot
// must not answer for files whose project is gone.
self.diagnostics.forget_root(&project.root);
if !shared {
self.diagnostics.forget_root(&project.root);
}
if let Some(plugins) = plugins::editor_plugin_host() {
plugins.invalidate_client_navigation(&project.root, Some(window), None);
plugins.set_active_file(window, None);
}
if !project.light {
self.environment.project_closed();
if self.windows_for_root(&project.root).is_empty() {
self.environment.direnv_closed(&project.root);
}
}
if let Some(bridge) = &project.kotlin_bridge {
bridge.stop();
@@ -323,6 +361,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
@@ -333,7 +373,8 @@ impl Host {
vec![project.notebooks.clone()],
project.kotlin_bridge.iter().cloned().collect(),
Some(project.lsp.clone()),
Some((self.debugger.clone(), window.to_owned(), project.root.clone())),
// Debug sessions under the root belong to windows: a project served without one starts none.
Some((self.debugger.clone(), window.to_owned(), (!background).then(|| project.root.clone()))),
Some(project),
))
}
@@ -346,7 +387,7 @@ impl Host {
notebooks: Vec<Arc<notebook::NotebookService>>,
bridges: Vec<Arc<kotlin_bridge::KotlinBridge>>,
lsp: Option<Arc<ide_lsp::LspManager>>,
debug: Option<(Arc<ide_dap::DebugManager>, String, std::path::PathBuf)>,
debug: Option<(Arc<ide_dap::DebugManager>, String, Option<std::path::PathBuf>)>,
retired: Option<Arc<Project>>,
) -> std::thread::JoinHandle<()> {
for bridge in &bridges {
@@ -373,7 +414,9 @@ impl Host {
}
if let Some((debug, key, root)) = debug {
debug.stop_key(&key).await;
debug.stop_under(&root).await;
if let Some(root) = root {
debug.stop_under(&root).await;
}
}
});
if let Some(retired) = retired {
@@ -392,17 +435,22 @@ impl Host {
}
fn wait_blocking(&self, shutdown: std::thread::JoinHandle<()>) {
let wait = move || {
Self::in_place(move || {
if let Err(error) = shutdown.join() {
tracing::error!("project shutdown thread failed: {error:?}");
}
};
});
}
/// Runs blocking work on this thread. On a worker of a multi-thread runtime the
/// runtime is told first, so the worker's other tasks move to another thread.
pub(crate) fn in_place<T>(work: impl FnOnce() -> T) -> T {
if tokio::runtime::Handle::try_current()
.is_ok_and(|handle| handle.runtime_flavor() == tokio::runtime::RuntimeFlavor::MultiThread)
{
tokio::task::block_in_place(wait);
tokio::task::block_in_place(work)
} else {
wait();
work()
}
}
@@ -441,6 +489,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.
@@ -462,6 +514,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();
+498
Переглянути файл
@@ -0,0 +1,498 @@
//! Projects the MCP server serves without a window ("background projects"): opened by a
//! client's first tool call under the key `mcp:<root>` in the host's projects, held by the
//! calls and runs in flight, unloaded when idle or when the limit needs room, and closed
//! when a window opens the same root or the settings and trust decisions stop serving it.
mod policy;
#[cfg(test)]
mod tests;
use crate::{Host, Project};
use ide_core::settings::McpBackgroundProjects;
use ide_core::{IdeError, IdeResult, IpcPath};
use parking_lot::{Mutex, RwLock};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::time::{Duration, Instant};
/// Starts the key of every background project; window labels never contain `:`.
const KEY_PREFIX: &str = "mcp:";
/// `mcpServer.backgroundIdleMinutes` counts up to a day.
const MAX_IDLE_MINUTES: u32 = 24 * 60;
/// `mcpServer.backgroundProjectLimit` stays within these bounds.
const MIN_PROJECTS: u32 = 1;
const MAX_PROJECTS: u32 = 32;
/// How often idle projects are looked for.
const SWEEP_EVERY: Duration = Duration::from_secs(30);
/// A project served without a window, as the IDE lists it.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpBackgroundProject {
pub root: IpcPath,
/// Seconds since its last tool call began or ended.
pub idle_seconds: u32,
/// Seconds until it is unloaded for being idle. Absent while something keeps it open
/// and when idle projects are never unloaded.
#[serde(default, skip_serializing_if = "Option::is_none")]
#[specta(optional)]
pub unloads_in_seconds: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[specta(optional)]
pub kept_open_by: Option<McpBackgroundHold>,
}
/// What keeps an idle background project loaded.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase")]
pub enum McpBackgroundHold {
/// A tool call is in flight.
Request,
/// A run it started is alive; `name` is the first one's.
Run { name: String },
}
type Observer = Arc<dyn Fn() + Send + Sync>;
/// The background projects of one [`Host`].
#[derive(Default)]
pub struct BackgroundProjects {
/// Serializes opens and unloads, and is held across the open itself. Taken before
/// `state`, never with it held.
gate: Mutex<()>,
state: Mutex<State>,
observer: RwLock<Option<Observer>>,
/// Set by [`BackgroundProjects::serve_none`].
serves_none: AtomicBool,
}
#[derive(Default)]
struct State {
entries: HashMap<PathBuf, Arc<Entry>>,
/// Windows that are opening a root right now, counted per root.
claims: HashMap<PathBuf, usize>,
/// The root a background open under way is opening; the gate allows one at a time.
opening: Option<PathBuf>,
}
/// Marks the root of the open under way in [`State::opening`] until that open is over.
struct Opening<'a>(&'a BackgroundProjects);
impl Drop for Opening<'_> {
fn drop(&mut self) {
self.0.state.lock().opening = None;
}
}
struct Entry {
/// Tool calls running in the project.
in_flight: AtomicUsize,
/// When a call last reached the project or left it.
last_used: Mutex<Instant>,
}
/// Keeps a background project loaded while a tool call runs in it.
pub(crate) struct ActivityGuard(Arc<Entry>);
/// What answers a tool call: the window label or background key, the project, and the
/// call's guard when the project is served in the background.
pub(crate) type Served = (String, Arc<Project>, Option<ActivityGuard>);
impl Drop for ActivityGuard {
fn drop(&mut self) {
// The time first: a sweep that sees no call in flight then sees a fresh time.
*self.0.last_used.lock() = Instant::now();
self.0.in_flight.fetch_sub(1, Ordering::AcqRel);
}
}
/// A window is opening the root: no background project of it is opened meanwhile.
pub(crate) struct Claim<'a> {
owner: &'a BackgroundProjects,
root: PathBuf,
}
impl Drop for Claim<'_> {
fn drop(&mut self) {
let mut state = self.owner.state.lock();
if let Some(count) = state.claims.get_mut(&self.root) {
*count -= 1;
if *count == 0 {
state.claims.remove(&self.root);
}
}
}
}
/// When [`BackgroundProjects::remove`] unloads a project.
#[derive(Clone, Copy)]
enum Only {
Always,
/// No call or run holds it.
Unheld,
/// Nothing holds it and it has been idle for the configured time at this moment.
Idle(Instant),
}
/// The inputs of [`policy::resolve`] at one moment.
struct Policy {
mode: McpBackgroundProjects,
listed: Vec<PathBuf>,
decisions: crate::trust::TrustDecisions,
recents: Vec<PathBuf>,
home: Option<PathBuf>,
}
impl Policy {
/// `None` when the MCP server or its background projects are off, and when the trust
/// decisions cannot be read.
fn current(host: &Host) -> Option<Self> {
let settings = host.global_settings.effective().mcp_server;
// Without the server no client is served, a request it accepted before it stopped included.
if !settings.enabled || host.mcp_background.serves_none.load(Ordering::Relaxed) {
return None;
}
let mode = settings.background_projects;
let by_trust = match mode {
McpBackgroundProjects::Off => return None,
McpBackgroundProjects::Trusted => true,
McpBackgroundProjects::Listed => false,
};
let recents = if by_trust { ide_workspace::RecentProjects::load(&host.config_dir).paths() } else { Vec::new() };
Some(Self {
mode,
listed: settings.background_project_paths.iter().map(PathBuf::from).collect(),
decisions: host.trust.decisions().ok()?,
recents,
home: dirs::home_dir(),
})
}
fn resolve(&self, path: &Path) -> Option<PathBuf> {
policy::resolve(self.mode, &self.listed, &self.decisions, &self.recents, self.home.as_deref(), path)
}
}
/// The root of the project that serves `path` in the background under the current
/// settings and trust decisions. Opens nothing.
pub(crate) fn serving_root(host: &Host, path: &Path) -> Option<PathBuf> {
Policy::current(host)?.resolve(path)
}
/// How long a project may stay idle; `None` when `minutes` is 0 (never unloaded).
fn idle_limit(minutes: u32) -> Option<Duration> {
(minutes > 0).then(|| Duration::from_secs(u64::from(minutes.min(MAX_IDLE_MINUTES)) * 60))
}
fn project_limit(limit: u32) -> usize {
limit.clamp(MIN_PROJECTS, MAX_PROJECTS) as usize
}
fn whole_seconds(time: Duration) -> u32 {
u32::try_from(time.as_secs()).unwrap_or(u32::MAX)
}
/// What keeps the project at `root` loaded, a call before a run.
fn hold(host: &Host, root: &Path, entry: &Entry) -> Option<McpBackgroundHold> {
if entry.in_flight.load(Ordering::Acquire) > 0 {
return Some(McpBackgroundHold::Request);
}
host.processes.running_in(root).into_iter().next().map(|run| McpBackgroundHold::Run { name: run.name })
}
impl BackgroundProjects {
/// The key of the background project at `root` in the host's projects.
pub fn key(root: &Path) -> String {
format!("{KEY_PREFIX}{}", root.display())
}
/// Serves no project in the background, whatever the settings say: the remote server,
/// which exists for its window's project and holds no trust decisions of its own.
pub fn serve_none(&self) {
self.serves_none.store(true, Ordering::Relaxed);
}
/// Whether `window` is the key of a background project and not a window's label.
pub fn is_key(window: &str) -> bool {
window.starts_with(KEY_PREFIX)
}
/// The loaded background project at `root`. Leaves its idle time alone.
pub(crate) fn project(&self, host: &Host, root: &Path) -> Option<Arc<Project>> {
self.state.lock().entries.contains_key(root).then(|| host.project(&Self::key(root)).ok()).flatten()
}
/// The project that answers a tool call for `root`, opened now unless it is loaded: its
/// key, the project and the guard of the call, which counts as in flight from here on,
/// so nothing unloads the project before the call runs. A window that opened the root
/// meanwhile answers instead, with its label and no guard. Refused while a window is
/// opening the root, when the settings and trust decisions do not serve it, and when
/// the limit is reached with every loaded project held.
pub(crate) fn open(&self, host: &Host, root: &Path) -> IdeResult<Served> {
let key = Self::key(root);
// Without the gate, which the open of another root may hold for seconds.
if let Some((project, call)) = self.reach(host, root, &key) {
return Ok((key, project, Some(call)));
}
let mut changed = false;
let opened = {
let _gate = self.gate.lock();
self.open_gated(host, root, &key, &mut changed)
};
if changed {
self.notify();
}
opened
}
/// The loaded project at `root`, with a call entered in it.
fn reach(&self, host: &Host, root: &Path, key: &str) -> Option<(Arc<Project>, ActivityGuard)> {
let call = {
// Under `state`, so an unload either sees the call or has removed the entry.
let state = self.state.lock();
let entry = state.entries.get(root)?.clone();
entry.in_flight.fetch_add(1, Ordering::AcqRel);
*entry.last_used.lock() = Instant::now();
ActivityGuard(entry)
};
// A project closed behind its entry drops the guard here; the gated open replaces both.
host.project(key).ok().map(|project| (project, call))
}
fn open_gated(&self, host: &Host, root: &Path, key: &str, changed: &mut bool) -> IdeResult<Served> {
// Another call opened it while this one waited for the gate.
if let Some((project, call)) = self.reach(host, root, key) {
return Ok((key.to_owned(), project, Some(call)));
}
if let Some((window, project)) = host.window_project(root) {
return Ok((window, project, None));
}
let _opening = {
let mut state = self.state.lock();
if state.claims.contains_key(root) {
return Err(IdeError::unavailable(format!("{} is opening in a window; retry", root.display())));
}
// An entry whose project was closed behind its back would count against the limit.
*changed |= state.entries.remove(root).is_some();
// In the same step as the look at the claims: a window that claims the root from
// here on sees this open and waits for it.
state.opening = Some(root.to_path_buf());
Opening(self)
};
if serving_root(host, root).as_deref() != Some(root) {
return Err(IdeError::unavailable(format!("{} is not served in the background", root.display())));
}
let limit = project_limit(host.global_settings.effective().mcp_server.background_project_limit);
while self.state.lock().entries.len() >= limit {
let Some(idle) = self.longest_idle(host) else {
return Err(IdeError::unavailable(format!(
"the limit of {limit} background projects is reached and all are busy"
)));
};
// A call that entered it meanwhile keeps it; the loop then looks again.
*changed |= self.remove(host, &idle, Only::Unheld);
}
let project = host.open_project(key, root)?;
// Entered from the start: the next open cannot evict it before this call runs.
let entry = Arc::new(Entry { in_flight: AtomicUsize::new(1), last_used: Mutex::new(Instant::now()) });
self.state.lock().entries.insert(root.to_path_buf(), entry.clone());
if let Some(plugins) = host.plugin_host() {
plugins.reopen_client(key);
}
*changed = true;
Ok((key.to_owned(), project, Some(ActivityGuard(entry))))
}
/// Unloads the background project at `root` and stops what it started; its workers
/// finish shutting down in the background. It waits for a background open that is under
/// way, so call it from a blocking context. With `only_if_idle`, a project that a call
/// or a run holds, or that is not idle for the configured time at that moment, stays.
/// `false` when nothing was unloaded, an unknown root included.
pub fn detach(&self, host: &Host, root: &Path, only_if_idle: Option<Instant>) -> bool {
let removed = {
let _gate = self.gate.lock();
self.remove(host, root, only_if_idle.map_or(Only::Always, Only::Idle))
};
if removed {
self.notify();
}
removed
}
/// The single way a background project closes. The caller holds the gate.
fn remove(&self, host: &Host, root: &Path, only: Only) -> bool {
// Before `state`: the runs have a lock of their own.
let running = !host.processes.running_in(root).is_empty();
let may_idle = idle_limit(host.global_settings.effective().mcp_server.background_idle_minutes);
{
let mut state = self.state.lock();
let Some(entry) = state.entries.get(root) else { return false };
let held = running || entry.in_flight.load(Ordering::Acquire) > 0;
let idle = |now: Instant| {
may_idle.is_some_and(|limit| now.saturating_duration_since(*entry.last_used.lock()) >= limit)
};
let stays = match only {
Only::Always => false,
Only::Unheld => held,
Only::Idle(now) => held || !idle(now),
};
if stays {
return false;
}
state.entries.remove(root);
}
let key = Self::key(root);
if let Some(plugins) = host.plugin_host() {
plugins.forget_client(&key);
}
host.close_project_detached(&key);
true
}
/// The projects no call or run holds that have been idle for the configured time at `now`.
pub(crate) fn sweep_candidates(&self, host: &Host, now: Instant) -> Vec<PathBuf> {
let minutes = host.global_settings.effective().mcp_server.background_idle_minutes;
let Some(limit) = idle_limit(minutes) else { return Vec::new() };
let idle = |entry: &Entry| now.saturating_duration_since(*entry.last_used.lock()) >= limit;
let entries = self.entries().into_iter();
entries.filter(|(root, entry)| idle(entry) && hold(host, root, entry).is_none()).map(|(root, _)| root).collect()
}
/// Unloads the projects that are idle at `now`; each is checked again as it is unloaded.
pub(crate) fn sweep(&self, host: &Host, now: Instant) {
for root in self.sweep_candidates(host, now) {
self.detach(host, &root, Some(now));
}
}
/// A window is about to open `root`: unloads the root's background project and keeps
/// another from opening until the claim drops. It waits for a background open only when
/// the root is loaded or is the one being opened; a window on any other folder goes on
/// at once.
pub(crate) fn claim(&self, host: &Host, root: &Path) -> Claim<'_> {
let contested = {
let mut state = self.state.lock();
// From here no background open of the root gets past its look at the claims.
*state.claims.entry(root.to_path_buf()).or_default() += 1;
state.entries.contains_key(root) || state.opening.as_deref() == Some(root)
};
let claim = Claim { owner: self, root: root.to_path_buf() };
if contested {
let removed = {
let _gate = self.gate.lock();
self.remove(host, root, Only::Always)
};
if removed {
self.notify();
}
}
claim
}
/// Waits for a background open that is under way. After it, the project that open
/// read its settings and trust for is registered, and an open that starts later reads
/// what is stored now.
pub(crate) fn wait_for_open(&self) {
drop(self.gate.lock());
}
/// The loaded background projects at `now`, sorted by root.
pub fn snapshot(&self, host: &Host, now: Instant) -> Vec<McpBackgroundProject> {
let may_idle = idle_limit(host.global_settings.effective().mcp_server.background_idle_minutes);
let mut projects: Vec<_> = self
.entries()
.into_iter()
.map(|(root, entry)| {
let idle = now.saturating_duration_since(*entry.last_used.lock());
let kept_open_by = hold(host, &root, &entry);
let unloads_in = may_idle.filter(|_| kept_open_by.is_none()).map(|limit| limit.saturating_sub(idle));
McpBackgroundProject {
root: root.into(),
idle_seconds: whole_seconds(idle),
unloads_in_seconds: unloads_in.map(whole_seconds),
kept_open_by,
}
})
.collect();
projects.sort_by(|a, b| a.root.cmp(&b.root));
projects
}
fn entries(&self) -> Vec<(PathBuf, Arc<Entry>)> {
self.state.lock().entries.iter().map(|(root, entry)| (root.clone(), entry.clone())).collect()
}
/// The project nothing holds that was used the longest ago.
fn longest_idle(&self, host: &Host) -> Option<PathBuf> {
let unheld = self.entries().into_iter().filter(|(root, entry)| hold(host, root, entry).is_none());
unheld.min_by_key(|(_, entry)| *entry.last_used.lock()).map(|(root, _)| root)
}
/// Tells the observer that the loaded projects changed. Never called with a lock of
/// this type held.
fn notify(&self) {
let observer = self.observer.read().clone();
if let Some(observer) = observer {
observer();
}
}
}
impl Host {
/// The window, and its project, that has `root` open as a project (not in LightEdit).
fn window_project(&self, root: &Path) -> Option<(String, Arc<Project>)> {
let projects = self.projects.read();
let windows = projects.iter().filter(|(w, p)| !BackgroundProjects::is_key(w) && !p.light && p.root == root);
windows.min_by_key(|(w, _)| w.as_str()).map(|(w, p)| (w.clone(), p.clone()))
}
/// Unloads the background projects the settings and trust decisions no longer serve:
/// all of them when the MCP server is off, otherwise each whose root no longer serves
/// itself. Call it after either changes, from a blocking context: it reads the recent
/// projects and waits for a background open that is under way.
pub fn apply_background_policy(&self) {
// First: a project that is being opened under the old settings has no entry yet.
self.mcp_background.wait_for_open();
let roots: Vec<PathBuf> = self.mcp_background.entries().into_iter().map(|(root, _)| root).collect();
if roots.is_empty() {
return;
}
let policy = Policy::current(self);
for root in roots {
if policy.as_ref().and_then(|policy| policy.resolve(&root)).as_deref() != Some(&root) {
self.mcp_background.detach(self, &root, None);
}
}
}
/// Starts the timer that unloads idle background projects for as long as the host lives.
pub fn start_background_sweeper(self: &Arc<Self>) {
let host = Arc::downgrade(self);
self.runtime.spawn(async move {
let mut tick = tokio::time::interval(SWEEP_EVERY);
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
tick.tick().await;
loop {
tick.tick().await;
let Some(host) = host.upgrade() else { break };
// The timer's clock, so a sweep and its tick agree on the time.
let now = tokio::time::Instant::now().into_std();
// An unload waits for the gate, which an open in flight holds: off the async workers.
let sweep = tokio::task::spawn_blocking(move || host.mcp_background.sweep(&host, now));
if let Err(error) = sweep.await {
tracing::warn!(%error, "sweeping idle background projects failed");
}
}
});
}
/// Sets what is told when a background project is opened or unloaded. It runs on the
/// thread that made the change, outside the locks of the background projects.
pub fn set_background_projects_observer(&self, observer: Arc<dyn Fn() + Send + Sync>) {
*self.mcp_background.observer.write() = Some(observer);
}
}
Loaded 100 of 1790 files, more files were not shown because too many files have changed in this diff. Show more