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

...
Автор SHA1 Повідомлення Дата
l0ng-ai 55cb9f11f7 feat(cucumber): behave and pytest-bdd step definitions in Python 2026-11-20 23:41:26 +08:00
l0ng-ai 1000ef0fa0 fix(editor): align code folding controls and arrow visibility (#4820)
Settings > Editor > General > Code Folding puts the outline visibility next to Show code folding outline (On hover / Always, new editor setting folding.outlineVisibility, default On hover) and lists the Fold by default options in one column. With Always, open fold arrows stay visible without hovering the gutter.
2026-11-20 23:40:32 +08:00
l0ng-ai 654da3e1ef feat(editor): spinner in progress hints (#4854)
Pending editor hints (Finding navigation target and other progress hints) start with the ring spinner used elsewhere in the UI; final hints are unchanged.
2026-11-20 23:21:16 +08:00
l0ng-ai ba6ccaf9b2 feat(vcs): option to open diffs in a separate window (#4853)
Adds Settings > Version Control > Confirmation > Open diff as editor tab (default on, client-side workflow setting vcs.diffAsEditorTab). When off, diffs opened from the Commit tool window, history, log and Compare show in a separate Diff window; combined multi-file diffs still open as a tab.
2026-11-20 23:17:37 +08:00
l0ng-ai 3ec631f0c0 fix(settings): pair inlay hint categories with a preview (#4815)
Settings › Editor › Inlay Hints lists the hint categories beside the selected category's toggle and a preview that uses the editor font and shows or hides the sample hint, instead of nested checkboxes. Searching selects the matching category.
2026-11-20 22:48:54 +08:00
Bert Verhelstтаbertyhell f64796607c fix(linux): keep selections while a dead key is pending on Wayland with IBus (#4830)
On Linux Wayland with IBus, a pending dead key made WebKitGTK collapse every new selection in the window (Select All, mouse drags, text fields) through GTK's compositor input method (text-input-v3). Startup now selects GTK's own IBus module (GTK_IM_MODULE=ibus) on a Wayland session whose input method is IBus, unless GTK_IM_MODULE is already set or ibus-gtk3 isn't installed.

Co-authored-by: bertyhell <[email protected]>
2026-11-20 22:45:56 +08:00
Shohruh Ismoilovтаshohruh-genius 5baaf5b7de fix(vcs): keep recent commits visible in workspace Git Log (#4826)
With Incoming Commits First, an older branch at the front of one repository's history could push that repository's latest commits out of the first page of a workspace Git Log. Each row now carries the newest commit time at or after it (logMergeTimeMs), and the multi-repository merge ranks by it, so recent commits stay visible while each repository keeps its selected order.

Co-authored-by: shohruh-genius <[email protected]>
2026-11-20 22:43:30 +08:00
faysouтаfaysou 95f88f6ffb fix(vcs): clarify Project tree Git indicators (#4818)
The Project tree's Git suffix shows the branch, then the incoming / outgoing commit counts, then the working-tree state after a slash: ∅ when no files changed (also when the branch is ahead or behind), else the changed-file count with Δ. The color scheme preview shows the same markers. The changed-files tooltip keeps its text-catalog key.

Co-authored-by: faysou <[email protected]>
2026-11-20 22:40:29 +08:00
Bert Verhelstтаbertyhell 06b7c3a826 feat(keymap): find actions by typing their shortcut in the search field (#4817)
The Keymap search field also matches typed shortcut text: ctrl+shift+n, Shift+Ctrl+N, ctrl shift n, cmd+shift+o and ⇧⌘O all work, with aliases such as control, cmd, option and esc. Modifiers alone list every shortcut holding them; once a key is typed the modifiers must match exactly, and chords match stroke by stroke. Plain words still search action names only.

Co-authored-by: bertyhell <[email protected]>
2026-11-20 22:40:19 +08:00
Vladislav Kuzmin e9335f032d fix(database): support strict read-only ClickHouse without affinity (#4788)
A strict read-only ClickHouse account rejects the driver's per-request result settings (code 164), so stateless sources behind a load balancer could not connect. With use_http_session=false and Read-only enabled, the connection check is repeated without the driver's result-limit and number-format settings; every request still sends readonly=1, the client-side write guard stays on, the grid keeps only the requested rows, and KILL QUERY also carries readonly=1.

Closes #4783

Co-authored-by: principalwater <[email protected]>
2026-11-20 22:36:23 +08:00
Vladislav Kuzmin d09fdc8c7e fix(database): clarify the JDBC cancellation timeout (#4749)
When a JDBC statement misses the cancellation deadline the session is closed; the error now says to check the statement's status on the server before running it again and that the next query reconnects on its own, instead of asking for a manual reconnect.

Closes #4742

Co-authored-by: principalwater <[email protected]>
2026-11-20 22:35:52 +08:00
l0ng-ai 54e69973c8 fix(settings): fit notification group controls in the settings pane (#4810)
Settings › Appearance & Behavior › Notifications shows the notification groups as a list beside the selected group's popup type and tool window option instead of a wide table, and stacks them in a narrow settings pane. Searching selects the matching group.
2026-11-20 22:32:08 +08:00
l0ng-ai 91d37aa4bf fix(templates): fit File and Code Templates in narrow settings (#4805)
Settings › Editor › File and Code Templates uses the shared compact tabs and a resizable list / editor split that keeps the editor usable in narrow settings windows.
2026-11-20 22:30:34 +08:00
l0ng-ai e149ba2ab3 fix(editor): keep completion aligned on first paint (#4797)
The completion list could paint one icon column right of the caret and then jump into place. The editor now positions it before the first paint, also when local suggestions arrive while a language server is still responding, and repositions it in the same frame when its size changes.
2026-11-20 22:28:14 +08:00
l0ng-ai fc6de7d0e4 fix(lsp): send language servers their configuration once initialized (#4831)
Pyright, given a client with workspace folders, asks for its configuration and loads the workspace only after workspace/didChangeConfiguration. The notification was sent only when a server had user settings, so Pyright stayed idle and navigation, references and diagnostics never answered. Send it to every server after initialized.
2026-11-20 22:27:10 +08:00
l0ng-ai 76ef8c9b05 fix(templates): stack the Live Templates list and editor (#4802)
Settings › Editor › Live Templates stacks the template list above the editor in a resizable split, puts Abbreviation and Description on one row (stacked in narrow settings), labels the template text, and keeps the variables table within the pane.
2026-11-20 22:25:10 +08:00
l0ng-ai 0344553652 fix(refactor): align the Safe Delete dialogs (#4800)
The Safe Delete confirmation and the Usages Detected question use the form layout: the usage count as a heading, the detail below it, and no question icon.
2026-11-20 22:19:48 +08:00
l0ng-ai cf15013b49 fix(templates): align and scroll the Surround With menu (#4796)
Surround With gets a separate shortcut column and uses the UI font for action labels. The list scrolls within the space beside the caret, and the title stays visible while the keyboard moves through it.
2026-11-20 22:18:11 +08:00
l0ng-ai eb985cda28 fix(project-view): keep the tree from scrolling sideways while dragging (#4828)
WebKit autoscrolls the pressed tree toward a pointer right of it, so dragging a file to the editor, terminal or out of the window scrolled long rows out of view. The drag now holds the horizontal scroll position for its whole length, as it already held the vertical one outside the tree.
2026-11-20 22:12:42 +08:00
Bert Verhelstтаbertyhell 212ee03d71 feat(project-view): drag files out to other apps (#4245)
When a drag from the Project view leaves the window it becomes an OS file drag (copy only) of the selected local files and folders: AppKit dragging session on macOS, OLE CF_HDROP on Windows, GTK on Linux, in the new ide-drag-out crate behind the window_drag_files command. A drop back on the window itself is ignored, and remote projects keep the in-window drag only.

Closes #2867

Co-authored-by: bertyhell <[email protected]>
2026-11-20 22:10:02 +08:00
l0ng-ai b721fe09db fix(debugger): drop grandchild sessions and overwrite progress lines (#4825)
Removing a debug session dropped only its direct children, so js-debug's grandchild sessions (pnpm run dev -> pnpm.cjs -> rspack.js) were orphaned and piled up with every rerun; a session now goes with all its descendants. The debug console also appended text after a carriage return instead of replacing the line; as in the Run console, a carriage return or erase-line now makes the next text replace it, so progress bars update in place.
2026-11-20 21:57:09 +08:00
l0ng-ai 6ffb4c22f0 fix(editor): keep syntax highlighting after reformatting JavaScript (#4822)
Re-parsing after an edit could reuse a whole doc comment (a skipped node) from the old tree. @lezer/lr's Stack.useNode then moved reducePos past it and storeNode didn't move reused skipped nodes out of the node being reduced, so the declaration before the comment swallowed the rest of the file and highlighting vanished until the next edit. A pnpm patch for @lezer/lr fixes both; a regression test compares the incremental tree with a fresh parse.
2026-11-20 21:50:50 +08:00
l0ng-ai dc38b0b081 fix(vcs): stop Git Log panes flashing a scrollbar while resizing (#4821)
The split panels' own overflow: auto showed a native scrollbar whenever a fractional panel height left 1px of rounding overflow, so it flickered while the tool window was dragged. The log's panes scroll themselves; their panels now clip instead.
2026-11-20 21:45:39 +08:00
l0ng-ai 3cbc9d7f75 perf(index,vcs): cut backend memory after indexing large folders (#4814)
Opening a folder with many large Git repositories kept the backend at about 2.2 GB after indexing. redb's page caches (1 GiB default per database) are capped at 64 MiB for the symbol index and 32 MiB per repository commit log, and after a full scan the backend returns freed heap pages to the OS (malloc_zone_pressure_relief on macOS, malloc_trim on glibc). On 16 repositories / 152k files the footprint after a cold index dropped from 2226 MB to 1078 MB with unchanged index and log query times.
2026-11-20 21:02:17 +08:00
l0ng-ai 2ec2a6c262 feat(run): insert path macros into a run configuration's working directory (#4816)
A + button next to the working directory field lists the supported path macros ($USER_HOME$ only on a local project) and inserts the chosen one at the caret.
2026-11-20 20:50:49 +08:00
C3B6 11dca3ab42 feat(agents): check and update local npm CLI installs (#4778)
A built-in agent's settings page can check its global npm installation for a newer release and update it. The backend (ide-agent cli_update) runs npm prefix/view/install as cancellable requests, and only touches the installation the launcher actually runs: the executable must be the npm-generated link of that exact package, the prefix must be writable, and the install verifies the version afterwards. Native installs and pre-release channels are left to their own installers.

Co-authored-by: 0xC3B6 <[email protected]>
2026-11-20 20:43:50 +08:00
faysouтаfaysou f9044dcc00 fix(markdown): scope the split divider cursor (#4811)
The splitter library applied a document-wide resize cursor while the pointer was near the divider, so it showed over the source editor's scrollbar. The Markdown split now keeps the divider's own hover cursor and shows the resize cursor only inside the split while dragging.

Co-authored-by: faysou <[email protected]>
2026-11-20 20:38:01 +08:00
l0ng-ai a7d7293b2f feat(run): expand path macros in a run configuration's working directory (#4813)
A run configuration's working directory may use $PROJECT_DIR$, $ContentRoot$, $MODULE_DIR$, $MODULE_WORKING_DIR$ and $USER_HOME$, expanded when it runs or is debugged; the stored value keeps them. An unknown macro, or one without a value in a remote project, stops the start with a notification naming it.
2026-11-20 20:35:24 +08:00
faysouтаfaysou a5280c50f7 feat(vcs): show changed file counts for repos and folders (#4806)
The Changes tree showed a file count only on change-list groups. Repository and directory rows now show how many changed files they hold, subdirectories included; repository rows keep the branch after the count.

Co-authored-by: faysou <[email protected]>
2026-11-20 20:23:47 +08:00
l0ng-ai dd0578979a feat(spelling): load custom Hunspell dictionaries with their affix rules (#4808)
Custom .dic files were read as flat word lists, dropping /FLAGS and ignoring the .aff beside them, so inflected forms and compounds were flagged and suggestions were English only. A .dic with a sibling .aff now loads as a full Hunspell dictionary, and suggestions merge the English and custom Hunspell dictionaries.
2026-11-20 20:22:23 +08:00
l0ng-ai e96b0483ac feat(go): show the values of constants as inlay hints (#4807)
gopls computes constant values, iota sequences included, but reports them as inlay hints only with its constantValues hint on; the Go language definition now enables it.
2026-11-20 20:16:41 +08:00
Yann 608b292510 fix(agents): keep context menus from switching conversations (#4804)
Right-clicking another task in Agents selected it through the same callback that opens conversations, replacing the current chat or file. Tree now marks context-menu selections (right-click, and Control-click on macOS) so the Agents view updates the menu target without navigating; ordinary clicks, keyboard activation and multi-selection are unchanged.

Co-authored-by: YannABC <[email protected]>
2026-11-20 20:02:25 +08:00
l0ng-ai dd6d83fd2c feat(services): show the debugger of a service in the Services tool window (#4803)
Debugging from Services showed only the console in the detail pane and the first breakpoint switched to the Debug tool window. The detail pane of a configuration being debugged now shows the whole debugger for that session (an attached run's console stays its Console tab), and a session started in place from Services reveals Services on a stop and reruns in place.
2026-11-20 20:01:08 +08:00
l0ng-ai b89febd61f fix(debugger): quick-evaluate the whole method call under the mouse (#4801)
Quick Evaluate built the expression from the identifier and its member chain only, so on o.getX() it sent o.getX, which Java adapters resolve as a field, and it evaluated with the hover context, in which adapters refuse to call methods. Quick Evaluate and the Evaluate dialog seed now take the call of the clicked identifier and member chains through calls and indexing, and Quick Evaluate uses the watch context. Plain hovers and value-on-selection stay side-effect free.
2026-11-20 19:55:07 +08:00
faysouтаfaysou 99ca421a0e fix(markdown): keep the preview live after scrolling (#4798)
The live preview plugin read editor geometry inside a CodeMirror update after the source scrolled, so CodeMirror threw and disabled the plugin and the preview stopped following Find and edits. The top-line read now goes through requestMeasure.

Co-authored-by: faysou <[email protected]>
2026-11-20 19:45:01 +08:00
l0ng-ai e6fd000bb7 fix(coverage): keep statistics aligned in the tool window (#4794)
The coverage tool window keeps its statistics columns aligned with the tree rows at every width.
2026-11-20 19:41:48 +08:00
l0ng-ai 9e2e229a56 fix(project-trust): show the selected trust scope in the open prompt (#4789)
The open-project trust prompt shows the selected trust scope: checking Trust projects in names the folder and the primary button becomes Trust Folder.
2026-11-20 19:41:39 +08:00
l0ng-ai 60564f4b33 Show an editor-sized tree for Quick Evaluate objects (#4784)
Quick Evaluate shows an object as an editor-sized tree that fits the window instead of a cramped popup.
2026-11-20 19:41:31 +08:00
l0ng-ai db1fff2f6a Align inline Git change previews with the editor (#4780)
Inline Git change previews from the gutter now use the editor's font, line height and widths, so the previewed lines line up with the editor.
2026-11-20 19:41:23 +08:00
l0ng-ai 1c09fbe28a Align the Rollback Changes dialog (#4770)
The Rollback Changes dialog gets a consistent layout with a change summary and an explanation of what rollback discards.
2026-11-20 19:40:42 +08:00
l0ng-ai 834fac89b4 Align selection history preview and revision table (#4764)
The selection history dialog aligns its preview and revision table and keeps both usable in narrow panes.
2026-11-20 19:40:33 +08:00
l0ng-ai 844e290729 Keep the scratch language chooser usable in short windows (#4750)
The scratch file language chooser keeps its search field and list usable in short windows instead of overflowing.
2026-11-20 19:40:24 +08:00
l0ng-ai a1ab5b6c29 Wrap diagnostic hovers and quick fixes inside the editor pane (#4745)
Diagnostic hovers now fit the editor pane: long messages and quick-fix labels wrap, text aligns with the severity icon, shortcuts are smaller and muted, and a divider separates overlapping diagnostics.
2026-11-20 19:40:16 +08:00
Yann 9797598864 feat(agents): open conversations in separate windows (#4790)
Open in New Window moves an agent conversation to a lightweight editor window while its task and agent process keep running. The agent manager now keeps one event sink per window instead of a single one, lightweight windows keep their launch across webview reloads, and the project window keeps the task list, notifications and a copy of the unsent draft; closing the window brings the conversation and its draft back.

Co-authored-by: YannABC <[email protected]>
2026-11-20 19:36:19 +08:00
faysouтаfaysou 21a8856dfd fix(markdown): render protected inline math (#4787)
GitHub-style protected inline math ($`...`$) passed the backticks to KaTeX. The math tokenizer now matches the protected form first, passes only the formula, and keeps nearby prices, emphasis and unfinished delimiters intact.

Co-authored-by: faysou <[email protected]>
2026-11-20 19:21:41 +08:00
faysouтаfaysou 9c523bba36 fix(markdown): keep Mermaid math labels inside nodes (#4786)
WebKit painted relatively positioned native MathML wrappers in Mermaid labels at the SVG origin, leaving nodes empty. Native MathML KaTeX labels inside foreignObject are now statically positioned so each formula paints inside its node.

Co-authored-by: faysou <[email protected]>
2026-11-20 19:21:34 +08:00
l0ng-ai 8f3e20cdf8 fix(debugger): show and copy the whole value of a long string (#4795)
The value popup showed the adapter's truncated, escaped value in a modal only its close button dismissed. It now re-evaluates the variable in the clipboard context for the full value, shows strings unescaped with real line breaks, and closes on an outside click; Copy Value of a string gets the full value too.
2026-11-20 19:08:31 +08:00
l0ng-ai affee5452d fix(settings): flag a Maven thread count Maven would not accept (#4793)
Settings › Maven › Thread count drops any value Maven would not accept as -T (a count or a core multiplier) so it cannot break builds, but said nothing, leaving builds serial. The field now marks such a value invalid and explains the accepted forms, using the same rule as the backend's thread_count().
2026-11-20 19:01:43 +08:00
l0ng-ai 4149c1b5d7 fix(http): follow system proxy changes in Auto proxy mode (#4791)
In Auto-detect proxy mode the shared HTTP client was cached per proxy setting and kept the system proxy it saw when first built, so a proxy app switching the system proxy on after launch left plugin downloads going direct until a restart (Check connection, a fresh client, worked). The cached client now remembers the system proxy it was built with, re-read at most every 3 seconds, and is rebuilt when it changes.
2026-11-20 18:53:44 +08:00
l0ng-ai 52010b95b1 Keep navigation bar child lists within the viewport (#4740)
The floating navigation bar keeps its path visible while a segment's child list is open: the list anchors to that segment and scrolls within the viewport. Both navigation bar placements share compact row spacing and font size, keep full names on hover, and open toward the editor.
2026-11-20 18:45:16 +08:00
l0ng-ai 9e530a9024 fix(debugger): enable Stop for the selected debug session only (#4785)
Stop in the Debug tool window was enabled whenever any session was live, so a finished session's tab showed an active Stop that did nothing. It now follows the selected tab like Rerun, Resume, Pause and the step buttons; with no tab selected it still acts on any live session.
2026-11-20 18:34:04 +08:00
eclix-del aebc7f7f99 fix(database): quote completions of custom JDBC sources by their URL's dialect (#4765)
A custom JDBC source has driver "jdbc", so completion quoted only names that aren't plain words. On Oracle (and other case-folding servers) a mixed-case table such as BAS_MeterUnit was inserted bare and folded to BAS_METERUNIT (ORA-00942).

Completion now takes the dialect from the source's URL scheme (jdbc:oracle:thin:@…, jdbc:postgresql://…), using the vendor scheme table Data Source from URL already uses, and quotes table, column and JOIN candidates the way that dialect needs. Unknown schemes keep the previous behaviour.

Co-authored-by: eclix-del <[email protected]>
2026-11-20 18:27:18 +08:00
eclix-del 1586738468 fix(database): complete only the schemas a data source selects (#4766)
JDBC completion read the columns of every schema on the server. The JDBC bridge runs one command at a time, so on a large Oracle instance (dozens of system schemas, minutes of metadata) the user's statements queued behind it.

Completion now reads only the schemas the data source's Schemas tab picks, matched the way the database tree matches them (exact names, `*` / `?` patterns); sources that show all schemas behave as before.

Co-authored-by: eclix-del <[email protected]>
2026-11-20 18:25:54 +08:00
akshathayadav378-boopтаakshathayadav378-boop 7ec5080047 fix(database): preserve table horizontal scroll position (#4779)
Database table tabs remember their horizontal scroll offset when the tab is mounted again (more than five kept table tabs, or the table opened in a split pane), alongside the page, sort and filter they already remembered.

The offset lives in a ref and is written straight into the remembered view state, so scrolling sideways doesn't re-render the editor; the grid restores it once on mount, retrying as the columns are measured.

Co-authored-by: akshathayadav378-boop <[email protected]>
2026-11-20 18:21:33 +08:00
akshathayadav378-boopтаakshathayadav378-boop 06d7487913 perf(events): coalesce diagnostics within a frame (#4767)
Diagnostics events are full replacements for one (path, source), but the desktop sink serialized and emitted each one immediately. Repeated diagnostics now collapse to the latest within a 16 ms window, any other event flushes pending diagnostics first so ordering is kept, and the buffer flushes at 4,096 keys instead of dropping. Installed on the global and per-window sinks; part of #3937.

Co-authored-by: akshathayadav378-boop <[email protected]>
2026-11-20 18:13:40 +08:00
zhzhsxтаzhzhsx e676138956 fix(editor): go to implementation falls back to the declaration (#4768)
Go to Implementation on a reference to a symbol with no implementations now navigates to the symbol's declaration instead of stopping on No implementations found, including servers that fail the request rather than answer empty (gopls). On the declaration itself it still reports nothing found.

Co-authored-by: zhzhsx <[email protected]>
2026-11-20 18:02:00 +08:00
Muuтаmuutot 1a1ea14b9c fix(vcs): allow Add to .gitignore for attached projects' repositories (#4751)
In a window with an attached project, Add to .gitignore / .git/info/exclude on an untracked file of the attached repository failed with Ignore selection is outside the project: the guard checked the project folder only. It now also accepts any path in one of the window's repositories, the set the Changes view lists; paths inside the project folder stay accepted before that set is discovered.

Co-authored-by: muutot <[email protected]>
2026-11-20 17:59:44 +08:00
l0ng-ai 5c0917b849 feat(vcs): ⌘/Ctrl-click a repository in the log filter to see only it (#4774)
Cmd-click (macOS) or Ctrl-click on a repository in the Git Log's Repository filter now shows only that repository; a plain click still adds or removes it, and each row's tooltip says so. Menu items gain an optional modifier-click action and a row tooltip.
2026-11-20 17:55:52 +08:00
l0ng-ai 19f2c0ef5d feat(http-client): Reformat Code formats JSON request bodies (#4771)
Reformat Code in an .http file reported No language server available. The HTTP Client now contributes a formatter that re-indents each request's JSON body, keeping {{variables}} and number literals as written and leaving headers, response handlers, references and file inputs alone.
2026-11-20 17:50:24 +08:00
l0ng-ai 8c696b8fe7 test(e2e): follow the split panes of the Inspections and Plugins settings (#4769)
#4629 and #4636 moved the Inspections and Plugins settings into resizable split panels; the shared settings layout specs now select the details section and profile label through the new structure.
2026-11-20 17:44:36 +08:00
l0ng-ai deecdbbf4f test(e2e): fix the Python highlighting and Recent Locations specs (#4752)
pythonHighlight: the fixture's Darcula-based scheme doesn't name NOT_USED_ELEMENT_ATTRIBUTES, which since #4737 comes from Darcula (#72737A). recentNavigationLayout: the snippet height check allows a fractional pixel (89.94px vs 90px).
2026-11-20 17:29:09 +08:00
Muuтаmuutot 802400c324 fix(editor): keep long blame tooltips inside a scroll container (#4741)
Hovering the inline blame label of a commit with a long message spilled the tooltip over the workbench: it had only a max-width, and the shared editor theme never made the hover host a column flex container, so CodeMirror's height cap near the window edge did not clip it. The blame tooltip now caps its height and scrolls inside, and the base editor theme lets hover sections shrink inside the squeezed host (the rules LSP hovers already had).

Co-authored-by: muutot <[email protected]>
2026-11-20 17:24:40 +08:00
Ziop edc6a522ee fix(search): find a pasted Windows absolute path by its project-relative path (#4739)
On Windows, pasting a plain absolute path such as E:\work\project\pkg\Config.go into Search Everywhere found nothing: backslashes were converted only when the paste had no forward slash, the project-root prefix was compared case-sensitively although drive-letter paths are not, and a \\?\ prefix was kept. The query parser and the index now reduce an absolute path below the project root to its project-relative form (case-insensitively for drive-letter roots), with mixed separators and verbatim prefixes handled.

Co-authored-by: wangpi26 <[email protected]>
2026-11-20 17:14:43 +08:00
Vladislav Kuzmin 0c7a278ca6 fix(database): execute SQL from read-only editor files (#4608)
Running SQL with Cmd+Enter in a read-only SQL file left Results stuck on Executing: the file lock removes the SQL editor's run-state field, so setting up the progress marks threw before execution. The marks are now skipped when the field is absent, and a failure while setting them up still clears the running request.

Co-authored-by: principalwater <[email protected]>
2026-11-20 17:12:51 +08:00
l0ng-ai 8c93136063 feat(remote): Download to… in a remote project's Project view (#4748)
In an SSH project window, the Project view's context menu and the action Download to… copy the selection into a local folder over the window's SSH session (new desktop command remote_download_local), with a cancellable progress task and a failure report. The download loop of Remote Host › Download to… is shared, including its guard against writing outside the chosen folder.
2026-11-20 17:11:40 +08:00
l0ng-ai e20e7b04bc feat(run): Diagnose with Agent on a failed test (#4744)
A failed test's context menu in the test tree gets Diagnose with Agent while the agents feature is active. It appends the failure (test name, source location reference, expected/actual when the framework names them, first 60 output lines) to the agent message typed last and opens it for review.
2026-11-20 16:54:20 +08:00
l0ng-ai f325e8c9d6 Align Inspection Results panes and actions (#4734)
Inspection Results aligns its result tree, detail pane and action toolbar: the panes keep usable widths and the actions stay grouped and labelled for assistive technology.
2026-11-20 16:41:33 +08:00
persicaTaoтаpersicaTao 84edcc03a4 fix(run): pass the tool search path to script launches (#4732)
On Windows an auto-detected npm run start found npm.cmd on the login-shell and user PATH and started it by full path, but the script it ran only inherited the IDE process PATH, so 'node' was not recognized. A run now passes the same search path it used to resolve its program to the child, unless the configuration sets PATH itself or turns off the system environment.

Co-authored-by: persicaTao <[email protected]>
2026-11-20 16:40:37 +08:00
youngledoтаyoungledo 4146ca2041 fix(app): list open projects in the macOS Window menu (#4736)
On macOS the Window menu did not list open project windows: the submenu was registered as the application's windows menu while the menu was still being built, before set_menu attached it to NSApp, so muda skipped it. It is now registered after the menu bar is installed, and AppKit lists each window by its title (project or workspace name, plus the current file).

Co-authored-by: youngledo <[email protected]>
2026-11-20 16:39:02 +08:00
l0ng-ai 105c37360b fix(editor): give Darcula-based imported schemes Darcula's colours (#4737)
An exported IntelliJ scheme lists only what differs from its parent. One based on Darcula that left TEXT out got Islands Dark's editor background (#191a1c) instead of Darcula's #2b2b2b, and likewise for every attribute it left out. Attributes a Darcula-based scheme doesn't name now come from Darcula, in both Color Scheme import and IntelliJ theme plugin import; exports write an empty value for an attribute they have nothing for so the parent can't show through on re-import; and an imported scheme's gutter follows its editor background unless it sets its own.
2026-11-20 16:26:23 +08:00
TWINKLE 567b432468 fix(terminal): upgrade xterm to 6.1 for the IME anchor and viewport fixes (#4714)
xterm 6.0.0 anchors the IME candidate window and preedit to its helper textarea, which only follows the cursor while no composition runs. Agent TUIs park the cursor at the end of a chunked redraw, so a composition starting then appeared at the far edge. 6.0.0 also left the viewport at line 0 after ESC[3J trimmed the scrollback. Both are fixed upstream in 6.1 (xtermjs#5759, #6046), which is only available as a beta.

- Move @xterm/xterm, addon-fit and addon-search to the 6.1 betas, pinned to exact versions until 6.1 is stable.
- Adapt to overviewRuler -> scrollbar (option and DOM class names) and to the DOM renderer's new createRow blink arguments in the cached renderRows; the version guard refuses renderers without them.
- Re-check the IME patches against 6.1 and update their rationale.
- Stub a 2D canvas context in the test setup, which 6.1's renderer needs under jsdom.

Co-authored-by: H-TWINKLE <[email protected]>
2026-11-20 16:09:13 +08:00
l0ng-ai f13d2b46cd Align the Scopes settings list and editor (#4731)
Scopes settings place the scope list beside the Name and Pattern fields in wide windows and stack them in narrow ones. Scope names use the standard UI text size with the full name and pattern on hover, keyboard selection stays visible, and adding a scope selects its default name for editing.
2026-11-20 16:07:25 +08:00
l0ng-ai 266bd35a3d Keep Attach to Process columns readable in compact windows (#4726)
Attach to Process uses a resizable dialog with Executable, PID and Command line columns; the list scrolls under a fixed header while the filter and actions stay in view. Compact dialogs show the debug port beside the command line with the full endpoint on hover, and long executables and commands have tooltips.
2026-11-20 15:51:30 +08:00
l0ng-ai 330d45279b Align the Git Remotes table and edit form (#4724)
Git Remotes uses dedicated Name and URL columns with a fixed header; long values keep their own space and show in full on hover. The list scrolls inside a resizable dialog with the toolbar and footer in view, keyboard selection brings the row into view, and the edit form aligns both labels beside their fields.
2026-11-20 15:39:03 +08:00
shanyuea af0e9c9a55 feat(vcs): synchronous branch control for projects with several repositories (#4723)
In a project with several Git repositories, branch operations follow a new setting, Settings > Version Control > Git > Execute branch operations on all repositories (on by default). On: the branches popup lists branches common to all repositories and acts on all of them, also when they are on different branches (it says Branches have diverged, and checking out a common branch moves only the repositories not on it); common branches gain Rename and Checkout and Rebase onto Current; each multi-repository operation can be rolled back when one repository fails. Off: the popup acts on the selected repository only. The Git log's Branches pane lists each branch once with the repositories that have it, with Group by Repository to switch back.

Co-authored-by: shanyuea <[email protected]>
2026-11-20 15:37:18 +08:00
l0ng-ai 0e1a5e47d3 Keep keyboard-selected menu rows visible and align shortcuts (#4721)
The shared action menu scrolls the keyboard-focused row into view when the menu is taller than the window. Shortcuts share a right edge with a separate column for submenu arrows, long shortcuts truncate while leaving room for the label, and rows use the standard UI text size.
2026-11-20 15:30:36 +08:00
l0ng-ai 5226443670 Keep Extract Interface members readable in short windows (#4720)
The Extract Interface dialog keeps its member table readable in short windows: the table takes the remaining height with a Member header and scrolls, while the name and package fields stay in view.
2026-11-20 15:28:44 +08:00
l0ng-ai 07191394a5 Align the Environment Variables editor in run configurations (#4715)
The run configuration Environment Variables editor aligns its table, toolbar and options in a fixed-height dialog, with the focused row outlined, so long lists and values stay readable.
2026-11-20 15:27:46 +08:00
l0ng-ai 882a08c5a4 fix(java): honor the java-analyzer debug fallback (#4719)
When JDT LS is enabled but missing (e.g. on a WSL remote host), the editor falls back to java-analyzer, but Run and Debug still treated jdtls as serving the module and failed with 'jdtls is not installed'. Choosing the server for the classpath and debugger now skips a jdtls that gave up starting.
2026-11-20 15:26:35 +08:00
Muuтаmuutot 8b5a9f582f fix(sdk): resolve the effective Python interpreter off the main thread (#4713)
sdk_python_effective was a sync command, so Tauri ran it on the main thread, where merging a workspace member's settings from scratch could overflow the remaining stack inside a WebView2 IPC callback and crash on start-up. It now runs on the blocking pool like the other SDK probes, and a workspace file that fails to load falls back to the primary project's interpreter.

Co-authored-by: muutot <[email protected]>
2026-11-20 15:24:54 +08:00
akshathayadav378-boopтаakshathayadav378-boop 1a430e5fdb fix(settings): show inherited static symbol italics (#4722)
Static symbols render italic by default, but the color scheme settings reported the inherited value as not italic, so the Italic checkbox showed unchecked and unchecking it changed nothing. Static symbol, and PHP's Static field that inherits it, now declare the renderer's italic default, so the page shows the applied state and unchecking writes an explicit upright override.

Co-authored-by: akshathayadav378-boop <[email protected]>
2026-11-20 15:19:34 +08:00
C3B6 7b2ba44a8d feat(agents): show the Claude Code context window breakdown (#4710)
Clicking the agent status bar's context meter in a Claude Code session opens a breakdown of the context window read on demand from the CLI's get_context_usage control request (system prompt, tools, MCP, memory files, skills, messages, autocompact buffer, free space), with the auto-compact threshold and a Compact session button when the session offers /compact. Other providers keep the plain meter with its tooltip.

Co-authored-by: 0xC3B6 <[email protected]>
2026-11-20 14:46:35 +08:00
l0ng-ai e6905f288e fix(vcs): align the Git Conflicts dialog (#4709)
The Conflicts dialog puts the merge status and file count above a larger, resizable file list; the resolution actions sit beside the list and move below it in narrow windows, and file names keep their width before long directory paths are shortened.
2026-11-20 14:38:59 +08:00
l0ng-ai 1828601b2a fix(project): align the file Copy dialog (#4706)
The Copy dialog states what it copies (file, directory or item count) above aligned New name / To directory fields, with the directory hint under its field and the Open copy in editor option in the footer.
2026-11-20 14:30:52 +08:00
l0ng-ai 463b13b6b5 fix(project): align the file deletion confirmation (#4703)
Message dialogs gain a form presentation: a titled dialog with the message and checkbox stacked in the body instead of an icon layout with the checkbox in the footer. The project tree's Delete confirmation uses it when Safe delete is offered.
2026-11-20 14:29:27 +08:00
l0ng-ai 84cdfa2136 fix(settings): align Gutter Icons in a preview list (#4702)
Gutter Icons puts its five options in one bordered list under the master checkbox, each with a representative icon or color swatch, aligned checkboxes and labels at the standard settings font size, keeping search matches visible in a narrow pane.
2026-11-20 14:28:25 +08:00
l0ng-ai 2bb93366bb fix(editor): show encodings in one searchable picker (#4697)
The status-bar encoding item opens a searchable Change File Encoding popup (checked current encoding, BOM toggle, link to File Encodings settings). Picking an encoding asks whether to reload the file in it or convert the current text on save.
2026-11-20 14:27:01 +08:00
l0ng-ai 7ee0a99853 fix(settings): keep Directory Mappings readable while scrolling (#4695)
Directory Mappings is a table with Directory and VCS columns that stays readable while scrolling, with add and remove in its toolbar.
2026-11-20 14:22:43 +08:00
l0ng-ai 7f21fdbe4d test(settings): expect the New tab choice in Open project in (#4708)
The Settings dialog test still expected exactly three Open project in choices after New tab in current window was added.
2026-11-20 14:21:49 +08:00
l0ng-ai d47e9688cb fix(editor): align the line and column dialog (#4693)
Go to Line puts its label and coordinate field on one row in the workbench UI font, and opening it selects the current coordinates so they can be typed over.
2026-11-20 14:17:45 +08:00
l0ng-ai 94e318e740 fix(templates): align the new file name and kind picker (#4690)
The new-file naming popup opens centered with an inset name field, template icon and divider above the kind list; the kind list uses standard selection rows, scrolls in short windows, and arrow keys keep the selected kind in view while the name field keeps focus.
2026-11-20 14:15:56 +08:00
l0ng-ai 6303cd5aef feat(editor): load or keep a file that changed on disk with unsaved edits (#4707)
A file changed on disk while its buffer had unsaved changes was reported with a fixed English notification and no way to take the disk version. The backend now emits DocDiskConflict and the editor shows a localized prompt with Load Changes from Disk (new doc_reload_from_disk: drops the buffer's changes and reads the file again) and Keep Editor Changes.
2026-11-20 14:12:14 +08:00
l0ng-ai 748f567abc fix(run): detect Spring Boot applications from Spring Boot on the classpath (#4705)
A @SpringBootApplication main class only became a Spring Boot configuration when its module or a parent POM applied spring-boot-maven-plugin, so modules that get Spring Boot as a dependency (directly, from spring-boot-starter-parent, or through the BOM) stayed plain Java applications. A module now counts when its build or a parent build in the project references Spring Boot outside <pluginManagement>; Gradle modules also count with an org.springframework.boot dependency.
2026-11-20 13:58:56 +08:00
l0ng-ai 9fe1dd8d7b feat(run): expand multi-line run configuration fields into a larger editor (#4704)
VM options and the other multi-line run configuration fields get an Expand button (Shift+Enter) opening a resizable editor where each line stays on one visual line and scrolls sideways, so a long JVM argument isn't wrapped into what looks like several. OK applies; Cancel or OK without edits leaves the field unchanged.
2026-11-20 13:49:43 +08:00
langxpтаkradme c0b243f020 feat(maven): add POM artifact and managed-version navigation (#4699)
Go to Declaration on a dependency, plugin or <parent> in a POM opens the artifact's own POM (a workspace module with matching coordinates first, then the local repository), and unversioned dependencies and plugins get a gutter icon that opens the management entry supplying their version, through active profiles (including JDK-activated ones), parent POMs, imported BOMs and plugin management. Maven element values are underlined whole, and contributed definition/hover providers that decline a position let the next one answer. Review fix: a BOM import without a version no longer ends the management search.

Co-authored-by: kradme <[email protected]>
2026-11-20 13:45:47 +08:00
l0ng-ai 96f3818bf2 feat(vcs): setting to hide the Generate Commit Message with Agent button (#4701)
Version Control > Commit > Commit Message Generation gets "Show the Generate Commit Message with Agent button" (on by default). Off hides the button above the commit message in the Commit tool window and dialog; the action stays available from Find Action and its shortcut.
2026-11-20 13:29:32 +08:00
l0ng-ai adf17d030e feat(workbench): open projects in a new tab of the current window by default (#4700)
"Open project in" gets "New tab in current window", and Don't ask again in the Open Project dialog now remembers New Tab too, so opening further projects adds project tabs to the current window without asking. A window without its own project, or a remote project, falls back to a new window. Attach stays a one-off choice.
2026-11-20 13:26:06 +08:00
l0ng-ai 815bebf4ec fix(editor): keep in-file Find responsive in large files (#4698)
CodeMirror compares a plain-text query one character at a time; a pass over a 50 MB log took ~850 ms and each find-bar keystroke runs several, freezing the editor for seconds. Plain-text queries now run as an escaped regular expression (~35 ms per pass) with a literal replacement. Find Previous no longer uses CodeMirror's quadratic backward regex search; one forward pass finds the previous match.
2026-11-20 13:19:51 +08:00
l0ng-ai 2b75b79ea0 fix(run): import a Maven module by its artifactId before a same-named folder (#4696)
IDEA names a Maven module after its artifactId. The JetBrains run-configuration importer accepted a folder name or an artifactId in one breadth-first search, so a project folder named like a child module's artifactId resolved to the root module. Search artifactIds first, then folder names, then the Gradle source-set fallback.
2026-11-20 13:07:13 +08:00
l0ng-ai 2c6329012a fix(vcs): keep each repository's branch submenu expansion separate (#4694)
In multi-repository projects every repository's branch submenu read and wrote the same expansion state, so expanding Remote or a folder in one (e.g. to check out a remote branch) expanded it in all others. Each repository's submenu now keeps its own expansion (keys scoped by repository root); the single-repository popup keeps its saved state.
2026-11-20 12:57:30 +08:00
l0ng-ai f40bcd747f fix(database): complete columns of custom JDBC data sources (#4692)
SQL completion for custom JDBC data sources knew tables but no columns: the JDBC completion model left every table's columns empty (no alias. members, no WHERE columns, no SELECT * expansion). The bridge returns a namespace's columns in one DatabaseMetaData.getColumns call (schemaColumns) and the model fills each table; a driver refusing it still completes tables.
2026-11-20 12:27:41 +08:00
l0ng-ai c752f007be fix(run): show the compile errors when Update Application's build fails (#4691)
A failed Spring Boot / Tomcat update build only said "Application update build failed" and the Run tool window returned to the app's tab, hiding the reason. The notification now lists the compiler errors: from the Java language server's build, and from the Maven/Gradle update build's output (Maven, javac and Kotlin error lines, ANSI-stripped, de-duplicated, first ten). Notification bodies keep their line breaks.
2026-11-20 12:23:04 +08:00
l0ng-ai bcdff6886f fix(settings): organize editor appearance controls (#4687)
Editor > General > Appearance gets four titled sections (caret behavior, code structure, presentation, code assistance): line numbers and indent guides sit together, whitespace controls stay indented under their toggle, using the existing Settings section typography and spacing.
2026-11-20 12:21:02 +08:00
Deng Liuтаdengliu b7e9276b0f feat(agents): open model settings from the picker and composer (#4689)
The model picker showed settings only for the active model. Clicking the effort/context summary beside the model name now edits the current model directly, and each model row has an arrow that opens that model's settings without selecting it; changing a setting there selects the model and keeps the panel open, Back/Escape without an edit leaves the selection alone. Works in New Task and existing chats without sending the draft.

Co-authored-by: dengliu <[email protected]>
2026-11-20 12:19:53 +08:00
Muuтаmuutot 6023e391bc fix(editor): keep line-end annotations clear of a folded chip (#4688)
A header-line fold's chip is drawn at the same position as the zero-width anchors of line-end annotations, so the Code Vision hint, plugin line-end messages and inline blame painted over the chip and took its clicks. A shared foldChipWidth helper measures a chip drawn after an anchor and all three consumers step past it (Code Vision gains the MutationObserver the others already had).

Co-authored-by: muutot <[email protected]>
2026-11-20 12:15:57 +08:00
l0ng-ai 3d80e661b7 fix(search): keep Find results usable in narrow docks (#4681)
The pinned Find tool window moves its result actions to a vertical toolbar and the replacement controls to a wrapping footer. Wide docks show results beside the source preview, narrow docks stack them and remember the divider per layout; result rows use the editor code size and truncate long paths before file names and match counts.
2026-11-20 11:52:49 +08:00
zhzhsxтаzhzhsx b66439ceda fix(editor): keep the hover documentation from moving as it opens (#4682)
The hover documentation was placed twice: create() returned a popup holding only its toolbar, CodeMirror measured and placed it, and it moved once the text arrived. The body is now built in a layout effect and rendered before create() returns (flushSync), so the tooltip is measured once at its final size; the F1 popup and Documentation tool window share DocView and lose their empty first frame too.

Co-authored-by: zhzhsx <[email protected]>
2026-11-20 11:50:04 +08:00
l0ng-ai 899fe888b7 fix(docker): show container logs, processes and image layers without the docker CLI (#4686)
Engine API connections (SSH tunnel, socket, TCP) still ran docker logs / top / image history, failing on machines without the docker CLI. These now use the Engine API when the CLI is missing: logs stream and follow over their own connection (chunked encoding and per-stream frames, or a TTY's raw stream, cancellable); processes and image layers come from /top and /history. Refs #4648.
2026-11-20 11:46:36 +08:00
l0ng-ai e7de2aaf6d fix(docker): disable a container's actions while one runs on it (#4685)
Container actions gave no feedback while a slow (remote) daemon worked, inviting repeated or conflicting clicks. A container is now held busy from the request until the following snapshot: its actions are disabled in the dashboard, Services toolbar and context menu, the running one shows a spinner, and a second request is ignored. Compose actions are disabled while a Docker task runs. Refs #4648.
2026-11-20 11:46:30 +08:00
l0ng-ai 9293b13737 feat(vcs): show the Rollback Changes files as a checkable tree (#4684)
Rollback Changes listed the files flat. It now uses the checkable change tree of the Shelve and Create Patch dialogs: files grouped by directory under the repository, with tri-state boxes on repository and directory rows; the summary follows the selection.
2026-11-20 11:45:27 +08:00
l0ng-ai d1f79d05b3 fix(project-tree): add Manage Remotes and Clone to the Project view's Git menu (#4680)
The Project view's Git submenu stopped at Stash / Unstash; it now ends with Manage Remotes… and Clone…, like the editor's Git submenu and IDEA's Git context menu. Covered by a new e2e test in editorGitMenu.spec.ts.
2026-11-20 11:39:28 +08:00
l0ng-ai 176c43c908 fix(editor): make the paste history preview resizable (#4677)
Paste from History gives the preview more room by default and remembers the divider position (a resizable split). Delete moves beside the filter as a toolbar button; the snippets and preview use the active editor's font and zoom, and the preview drops line numbers to use its full width.
2026-11-20 11:33:27 +08:00
Nc 20b6b0aed5 fix(maven): sort sidebar profiles by ID (#4679)
The Maven sidebar listed profiles in model order. Profiles within each project group now sort by ID ignoring case, as IntelliJ's Maven tool window does; the -P argument keeps the model order.

Co-authored-by: qiany-sui <[email protected]>
2026-11-20 11:30:31 +08:00
l0ng-ai 101a0862e4 fix(database): reconnect a custom JDBC data source whose session was lost (#4675)
When a proxy or tunnel dropped an idle custom JDBC connection, every later statement failed and the source still showed Connected: the cached pool was only marked closed when the IDE closed it. After a failed statement the bridge now checks Connection.isValid (new valid op); an invalid or orphaned session closes the pool so the next statement or Connect reconnects. Keep-alive for JDBC uses the same check (and its option shows in the dialog); failures log at info.
2026-11-20 11:29:35 +08:00
Bin b48f0b6071 fix(vcs): enlarge deleted line marker hit area (#4669)
The deleted-lines marker is drawn above its gutter row, but clicks were resolved from the pointer's row, so clicking the triangle near the line boundary could miss the deletion. The marker gets a 12x12 transparent hit area (same triangle) with a pointer cursor, and clicks on it resolve to the deletion's row. Verified with vcs hunks and editor cm vitest, typecheck, and in the app (clicking the marker's upper half opens the Deleted lines popup).

Co-authored-by: ffgenius <[email protected]>
2026-11-20 11:23:37 +08:00
l0ng-ai a9b16c3e06 fix(debugger): keep call stack locations visible in narrow docks (#4671)
Call stack locations stay visible in narrow debug docks. Verified with e2e debugStackLayout, debugger vitest and typecheck.
2026-11-20 11:13:32 +08:00
l0ng-ai abd55f88b5 fix(search): make the editor switcher fit the workbench (#4660)
The editor switcher fits the workbench. Verified with e2e switcherLayout, search vitest and typecheck.
2026-11-20 11:13:20 +08:00
l0ng-ai dac4db0994 fix(settings): separate file type associations from ignore rules (#4657)
File Types settings separate file type associations from ignore rules. Verified with e2e fileTypesLayout, settings/locales vitest and typecheck.
2026-11-20 11:13:08 +08:00
Deng Liuтаdengliu b0d0ea868b feat(agents): configure GitHub Copilot authentication account (#4663)
Copilot launched with whichever GitHub CLI account was active outside the IDE. GitHub Copilot's settings get a GitHub account field: at launch the IDE asks gh for that account's token and passes it as COPILOT_GITHUB_TOKEN, without storing it; the account (not a credential) is kept with the agent's settings and scopes the catalog cache. Also adds the field's text to the en/zh catalog. Verified with cargo test -p ide-agent, clippy, agents and locale vitest, typecheck, and the field in Settings › Agents › Coding Agents.

Co-authored-by: dengliu <[email protected]>
2026-11-20 11:11:05 +08:00
Deng Liuтаdengliu d86ff872af fix(agents): recover model controls for fallback sessions (#4662)
A session whose agent fell back to a configuration without a model option kept a stale model label and offered no way to pick another model. The composer rebuilds the model control from the provider's catalog and set_config accepts a model from that catalog, switching through the same path as other discovered models. Verified with cargo test -p ide-agent, clippy, agents vitest and typecheck.

Co-authored-by: dengliu <[email protected]>
2026-11-20 11:07:37 +08:00
Deng Liuтаdengliu dbef3cdc96 fix(agents): support Auto-only Copilot catalogs (#4661)
Copilot can return an enabled Auto tier with an empty direct-model list; the catalog parser treated that as an empty catalog and forced the fallback transport. An enabled Auto tier now yields the auto model. Verified with cargo test -p ide-agent copilot and clippy.

Co-authored-by: dengliu <[email protected]>
2026-11-20 11:06:32 +08:00
C3B6 c483c3b76f perf(http-client): limit cached response details to four (#4659)
The HTTP Client kept every exchange's full request and response in memory for the whole session, even after its row left the backend's 100-entry history. The history list is capped at 100 like the backend, and only the four most recently viewed exchanges keep their details; older rows reload theirs from the saved history (which stores the full exchange) when selected. Verified with http-client vitest and typecheck.

Co-authored-by: 0xC3B6 <[email protected]>
2026-11-20 11:05:24 +08:00
HEOJUNFO da79a73def fix(http-client): keep the whole value of a Spring params/headers condition (#4666)
Spring params/headers conditions were split with split("=", 2), which drops everything after a second '='; only the first '=' divides name and value now, as in Spring. Verified with http-client vitest.

Co-authored-by: HEOJUNFO <[email protected]>
2026-11-20 11:04:44 +08:00
akshathayadav378-boopтаakshathayadav378-boop 2cc54b35f6 test(markdown): allow large render test to finish (#4664)
The large Markdown re-render test renders plugins/README.md repeatedly and can exceed Vitest's default 5 s timeout under full-suite load; it gets a 20 s timeout like other heavy tests.

Co-authored-by: akshathayadav378-boop <[email protected]>
2026-11-20 11:04:36 +08:00
zhzhsxтаzhzhsx 097221c1b3 fix(editor): colour Go's default like the other keywords (#4654)
@lezer/go tags every keyword except default, and gopls sends no keyword semantic tokens, so default in a Go switch/select rendered as plain text. Go now gets an extra style tag for default. Verified with editor cm vitest and typecheck.

Co-authored-by: zhzhsx <[email protected]>
2026-11-20 10:25:05 +08:00
l0ng-ai 1bb4ffe6b2 Keep the color scheme preview visible while editing (#4653)
The color scheme preview stays visible while editing scheme options. Verified with e2e colorSchemeLayout/editorFontLayout, settings and platform vitest and typecheck; main merged in (locale conflict resolved).
2026-11-20 10:22:05 +08:00
l0ng-ai 51e525336b Keep Welcome project search and actions in one row (#4652)
Welcome project search and actions stay in one row. Verified with e2e welcomeProjectsLayout, full vitest and typecheck.
2026-11-20 10:21:06 +08:00
l0ng-ai 1b47bc2c14 Keep the editor font preview visible while changing settings (#4649)
The editor font preview stays visible while changing font settings. Verified with e2e editorFontLayout, full vitest and typecheck.
2026-11-20 10:20:59 +08:00
l0ng-ai aa1326496b Show both commit ranges in Git branch comparisons (#4642)
Git branch comparison shows both commit ranges side by side in resizable panes. Verified with e2e branchCompareLayout, full vitest and typecheck.
2026-11-20 10:20:51 +08:00
leenтаleen2175 7850429174 fix(vcs): open existing worktrees over SSH (#4465)
Opening a linked worktree from an SSH or WSL project treated the remote directory as a local path. The Worktrees toolbar, row double-click and the checkout prompt's Open now go through openWorktree, which reuses the session's remote target and opens a remote window; local projects are unchanged. Verified with vcs and remote-dev vitest and typecheck on macOS (local path); the SSH flow was verified by the author in the native Linux app.

Co-authored-by: leen2175 <[email protected]>
2026-11-20 10:17:09 +08:00
Mansur Akhmadiтаmansur-akhmadi 3dd5c75fa0 feat(debugger): Remove All Watches in the Variables view's context menu (#4647)
A watch row's context menu in the Variables view gets Remove All Watches next to Remove Watch; it empties the project's stored watch list. Verified with debugger and locale vitest and typecheck; main merged in (locale conflict resolved).

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-20 10:15:56 +08:00
Mansur Akhmadiтаmansur-akhmadi 36ecb53159 feat(run): Fold Lines Like This in the Run console's context menu (#4635)
The Run console's context menu gets Fold Lines Like This: it opens Settings › Build, Execution, Deployment › Console with the selected single-line text, or the right-clicked line, added to the fold patterns. Verified with full vitest, typecheck, and in the app (pattern added, Cancel leaves settings unchanged).

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-20 10:15:00 +08:00
006405ca11 fix(remote): restore WSL projects onto a live connection (#4103)
* fix(remote): restore WSL projects onto a live connection

A reopened WSL window kept sending commands to a remote host it was no
longer connected to. Remember the remote location, and do not drop a
connection that a later open or a superseded attempt still needs.

Co-authored-by: Cursor <[email protected]>

* Use ? for the last remote location prefix (clippy::question_mark)

* fix(remote): save window session after connecting

---------

Co-authored-by: 胡长贵 <[email protected]>
Co-authored-by: Cursor <[email protected]>
Co-authored-by: l0ng-ai <[email protected]>
2026-11-20 10:12:35 +08:00
Mollo-i 40b95650cf fix(maven): custom project.* properties and bare built-in shorthands resolve to their definition (#4651)
Every project.* name was treated as a Maven built-in, so custom properties such as project.port never navigated, and the bare built-in shorthand (@artifactId@) did not either. Non-coordinate project.* names now fall through to the <properties> lookup along the parent chain, and the bare shorthand resolves to the pom's own coordinate unless a custom property of that name exists. Verified with cargo test -p ide-build (maven tests pass; the one failing Go workspace test is unrelated to this change and fails from the local go toolchain) and clippy.

Co-authored-by: Greenker <[email protected]>
2026-11-20 10:08:09 +08:00
zhzhsxтаzhzhsx 0a571c0b4d fix(libraries): keep a Go module inside the project editable (#4639)
go list -m reports a replace target's own folder as the module's Dir, so a local replacement inside the project was registered as a read-only library root. Modules whose source sits inside the opened project (outside vendor/) are no longer library roots. Also passes the project root in the zig_groups test added on main. Verified with cargo test -p ide-sdk (new go_modules test passes; three go command tests fail the same way without this change, from the local go shim) and clippy.

Co-authored-by: zhzhsx <[email protected]>
2026-11-20 10:06:44 +08:00
l0ng-ai b1f88bf79c Separate shelves from the files they contain (#4640)
Shelf tool window separates the list of shelves from the files of the selected shelf in resizable panes. Verified with e2e shelfLayout, full vitest and typecheck.
2026-11-20 09:21:25 +08:00
l0ng-ai 0a6b3d011f Keep plugin list and details visible in narrow settings (#4636)
Plugins settings keep the list and details visible in narrow settings with a resizable split. Verified with e2e pluginsLayout, plugins/settings/locales vitest and typecheck.
2026-11-20 09:17:56 +08:00
l0ng-ai fd9b20fa05 Give interactive rebase plans and messages separate panes (#4637)
Interactive rebase shows the plan and the commit message in separate resizable panes. Verified with e2e interactiveRebaseLayout, full vitest and typecheck.
2026-11-20 09:17:14 +08:00
l0ng-ai 4f5622d72c refactor(agents): remove playful words from the working status (#4555)
Removes Settings › Agents › Working Status and its playfulStatus / playfulAfterSeconds / playfulWords settings. The line under a working conversation keeps saying what the agent is doing (Reading…, Running a command…); stored values of the removed settings are ignored.
2026-11-20 09:13:57 +08:00
l0ng-ai f4a7a7bafb perf(ui): smoother editor scrolling, tab switching and first file open (#4633)
Removes selectors that restyled whole subtrees on every inserted editor line or focus change (CodeMirror via a pnpm patch; selectorCost.test.ts guards them), measures space width once per font, shares one tooltip host, builds tab menus lazily, caches parsed SVG icons, prewarms an off-screen editor at idle, stats project-tree entries in parallel, and keeps the Git tool window at its size during a live window resize. Verified with full vitest, typecheck, ide-vfs cargo test and clippy, gitLog e2e, and a window resize in the app.
2026-11-20 09:13:29 +08:00
l0ng-ai 737afc6a8d Keep keymap search and shortcuts readable in narrow settings (#4632)
Keymap settings group the scheme selector with its actions and move the search controls to a second line in narrow settings; long action names scroll inside the tree. Verified with e2e keymapLayout/compactSettingsControls, settings vitest and typecheck.
2026-11-20 09:11:52 +08:00
l0ng-ai 6bf75155b6 Keep hierarchy symbols and source context readable (#4630)
Hierarchy view keeps symbol names and source context readable in narrow panes. Verified with e2e hierarchyLayout, code-insight vitest and typecheck.
2026-11-20 08:26:29 +08:00
l0ng-ai bbedf7e1f6 Make Inspections panes fit narrow settings windows (#4629)
Inspections settings panes resize and fit narrow settings windows. Verified with e2e inspectionsLayout/settingsFormLayout, full vitest and typecheck.
2026-11-20 08:26:21 +08:00
l0ng-ai 42fd0fa8e0 Organize Code Style settings into tabs (#4627)
Code Style settings are organized into tabs. Verified with e2e codeStyleLayout, settings vitest and typecheck.
2026-11-20 08:22:50 +08:00
l0ng-ai 97a41ae983 Give line bookmark text room in the tool window (#4624)
Bookmarks tool window rows give line bookmark text room. Verified with e2e bookmarkTreeLayout, search vitest and typecheck.
2026-11-20 08:22:42 +08:00
l0ng-ai f29903b698 Give the Stash dialog room for branch names and messages (#4623)
Stash dialog gives branch names and the message field room. Verified with e2e stashDialogLayout, vcs vitest and typecheck.
2026-11-20 08:22:35 +08:00
l0ng-ai 610fe23f88 Make the Pull dialog fit long branch names (#4622)
Pull dialog wraps long branch names instead of overflowing. Verified with e2e pullDialogLayout, vcs vitest and typecheck.
2026-11-20 08:22:26 +08:00
l0ng-ai 59376b9718 Improve the Update Project dialog layout (#4621)
Update Project dialog options and actions lay out cleanly at any width. Verified with e2e updateProject, vcs vitest and typecheck.
2026-11-20 08:22:18 +08:00
l0ng-ai 170fd735dd fix(vcs): keep clone fields usable in narrow dialogs (#4618)
Clone dialog fields stay usable and inside the dialog in narrow windows. Verified with e2e cloneLayout, vcs vitest and typecheck.
2026-11-20 08:22:11 +08:00
l0ng-ai e0ae9e764c fix(app): fit the New Project wizard in narrow windows (#4617)
The New Project wizard's template form fits narrow windows and keeps edits when resized. Verified with e2e newProjectLayout, app vitest and typecheck.
2026-11-20 08:07:19 +08:00
l0ng-ai 19c1b72650 fix(settings): fit SDK details within Project Structure (#4616)
Project Structure SDK details now wrap and stay inside the pane in narrow windows; the Home Path row reuses the shared path field. Verified with e2e projectSdkLayout/sdkFieldLayout, settings vitest and typecheck.
2026-11-20 07:53:11 +08:00
lleviathe 06ff2e51c3 fix(editor): even out the spacing of editor tabs (#4606)
Editor tabs sit 4px apart and keep an 18px close slot at one edge: before the icon when the close button is on the left, after the label when it is on the right, so switching sides no longer resizes tabs. The drag ghost keeps the strip's classes so it renders with the same layout. Verified with e2e editorTabClose/editor, src/ui vitest, typecheck, and both close positions in the app.

Co-authored-by: lleviathe <[email protected]>
2026-11-20 07:52:02 +08:00
l0ng-ai 6ae31b8148 test(keymap): list Shelve/Unshelve Silently in the VS Code and Eclipse presets (#4628)
#4620 added vcs.shelveSilently and vcs.unshelveSilently to the IntelliJ keymaps only, so the check that the VS Code preset covers every IntelliJ action id failed on main. Both the VS Code (macOS) and Eclipse (Windows) presets now list them unbound, like the other changelist actions.
2026-11-20 07:42:36 +08:00
Mansur Akhmadiтаmansur-akhmadi 3783b601b5 feat(vcs): copy a path from its repository's root in Copy Path/Reference… (#4626)
Copy Path/Reference... gains Path From Repository Root, as in IDEA: each selected path relative to the root of the Git repository holding it (innermost for nested repositories, a repository root as '.'), one per line, through the same copyPath menu group the hosting link uses. Paths outside every repository are left out, and the item is hidden when none is inside one.

Closes #4625

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-20 07:38:35 +08:00
l0ng-ai 37044dcd89 fix(vcs): give Local History diffs room in narrow panes (#4613)
Local History gave its revision list a fixed share of the pane, so in narrow panes the diff had little room and long labels were clipped. The list and diff are now a resizable split with sensible minimums, revision rows truncate with full text in tooltips, and the diff keeps room in narrow panes.
2026-11-20 07:37:21 +08:00
l0ng-ai 1a2adab237 fix(editor): align Reformat Code dialog groups and controls (#4611)
The Reformat Code dialog's option groups and controls were laid out ad hoc, so labels and checkboxes misaligned and the scope group wrapped awkwardly. The dialog now uses shared dialog fieldsets with aligned groups and controls, the same as the other analysis dialogs.
2026-11-20 07:12:25 +08:00
l0ng-ai 9ed87d77a7 fix(project-tree): make the Move dialog readable in narrow windows (#4609)
The Move dialog's title, target field and validation were laid out for a wide window, so in narrow ones the path and Browse button were clipped. The dialog now names what it moves (file, directory or N items), the target row wraps with its Browse button, and invalid targets (a folder into itself, the same directory) are explained inline.
2026-11-20 06:55:23 +08:00
Mansur Akhmadiтаmansur-akhmadi 9f4731189d feat(vcs): Shelve Silently and Unshelve Silently (#4620)
Shelving and unshelving always opened a dialog. As in IDEA, Shelve Silently (Changes toolbar, Ctrl+Shift+H / Shift+Cmd+H) shelves the Commit selection, or the active changelist, without a dialog, one shelf per changelist named as the Shelve dialog would suggest; Unshelve Silently (Ctrl+Alt+U / Opt+Cmd+U in the Shelf) applies the selected shelf or file into the matching changelist and honours Remove applied files from the shelf. The Shelve and Unshelve dialogs share the same helpers, and both actions are in the IntelliJ keymaps and IDEA_ACTIONS.

Closes #4619

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-20 06:39:35 +08:00
l0ng-ai 92ccfac192 fix(debugger): keep breakpoint details usable in narrow windows (#4605)
The Breakpoints dialog had a fixed list width beside the details, so in narrow windows locations were clipped and the details' controls ran off the dialog. The list and details are now a resizable split that stacks vertically below 560px (each layout remembered), the dialog itself can be resized, and locations show the file name and line with the full path in the tooltip.
2026-11-20 06:38:09 +08:00
l0ng-ai 60d335eec0 fix(refactor): keep the Change Signature parameter table readable (#4602)
The Change Signature dialog's parameter table had fixed column widths and a one-line preview, so in narrow windows types and names were clipped and long signatures ran off the preview. The table columns now share the width with truncation, the preview puts each parameter on its own line as IDEA's does, and the dialog's sections keep their controls visible.
2026-11-20 06:05:24 +08:00
Hafiz Faizan ul hassanтаfaizanalhassan a679e8086f feat(database): pick data source, then database and schema in the query console (#4614)
The query console's Data source dropdown mixed databases into the source list, and SQL Server's second dropdown listed databases. As in DataGrip, the dropdown now lists data sources only, and a database.schema switcher next to it opens a searchable database -> schema tree that loads a database's schemas on expand and moves the console to the picked database; one-level drivers keep a flat schema list and SQLite has none. SQL Server's console schema is now a real schema (SCHEMA_NAME()) that scopes resolution and completion, since a session's default schema can't be changed, while the pooled connection still returns to its database. Tree speed search also opens with Cmd/Ctrl+F, as in IDEA.

Closes #4577

Co-authored-by: faizanalhassan <[email protected]>
2026-11-20 06:04:34 +08:00
Mr0Bread 4c20aa5c8d test(editor): cover missing-file and malformed session restore (#4615)
Adds regression tests for editor session recovery: a deleted selected file is dropped quietly and the remaining tab restores with its caret, a permission-denied tab stays open with its error inline, and truncated session JSON loads as null without writing storage until a valid session replaces it. No production changes.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-20 06:00:56 +08:00
l0ng-ai d19d74120b fix(debugger): keep values visible in narrow variables panes (#4600)
In narrow Variables panes the name and type kept their full width, so values were cut to nothing and the Show button could be pushed out. Names and types now truncate within caps, the value and its Show button share a group that keeps a minimum width, overflow is measured against that group, and full names and types are in tooltips.
2026-11-20 06:00:12 +08:00
Mr0Bread 4e1cec5233 refactor(ipc): enforce typed error-kind comparisons (#4612)
IPC error kinds were compared as untyped strings (`(e as { kind?: string }).kind === "notFound"`), so a misspelt kind compiled and silently never matched. A typed `isErrorKind(error, kind)` helper, taking a kind from the generated `IdeError["kind"]`, now handles wrapped and raw IPC errors in document sync, editor session restore, Spring service identity, plugin commands and recent projects.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-20 05:41:29 +08:00
l0ng-ai 150eacc3de fix(editor): keep parameter info readable in narrow panes (#4599)
Parameter Info had a fixed 640px cap and a 12-signature window, so in narrow panes it overflowed the editor and long signatures were clipped. The popup now fits the editor's tooltip bounds and height, uses the editor's current font size, wraps long signatures with a hanging indent, scrolls when needed and keeps the current parameter in view.
2026-11-20 05:40:20 +08:00
l0ng-ai d1cc3cf68a fix(vcs): make merge panes resizable and keep actions visible (#4597)
The merge editor's three panes had fixed widths with decorative dividers, so in narrow windows they could not be resized and the toolbar actions overflowed. The panes are now a SplitGroup whose two handles carry the connector bands, each pane has its own title (branch and side), and the toolbar status is announced.
2026-11-20 05:25:12 +08:00
Mr0Bread 7c00ce4fa1 test(e2e): enforce TypeScript contract checking (#4610)
The e2e TypeScript project was never type checked: its tsconfig didn't inherit the app's settings, so @/ imports didn't resolve and hundreds of diagnostics went unnoticed. e2e/tsconfig.json now extends the root config (plus Node/Vite types and ES2024), pnpm typecheck runs tsrs -p e2e, and the remaining real type errors in the specs and fixtures are fixed; the code-style docs list the new project.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-20 05:19:07 +08:00
l0ng-ai 6539a95cb8 fix(vcs): keep push review readable in narrow windows (#4594)
The Push dialog's commits, changed files and diff panes had pixel minimums and fixed options rows, so narrow or short windows clipped the review and the target controls. The commits and changes now stack vertically below 640px with their own remembered split, the changed files come before the commit details, panes use relative minimums, and the target bar, options and tag options wrap.
2026-11-20 05:07:24 +08:00
l0ng-ai 08613ca800 fix(debugger): keep evaluation results readable in short dialogs (#4592)
The Evaluate dialog's result had a 220px minimum height, so in short windows the dialog overflowed and the result and buttons were cut off. The dialog now caps its height to the window, the expression field scrolls within half of it, imports wrap, and the result takes the remaining space; the expression uses the editor font and its label is tied to the field.
2026-11-20 04:49:29 +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
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
839 змінених файлів з 35180 додано та 7681 видалено

No files matched your search

Створено
+19
Переглянути файл
@@ -4156,6 +4156,8 @@ dependencies = [
"ide-vcs",
"ide-vfs",
"parking_lot",
"rustix",
"semver",
"serde",
"serde_json",
"specta",
@@ -4357,6 +4359,20 @@ dependencies = [
"which",
]
[[package]]
name = "ide-drag-out"
version = "0.1.49"
dependencies = [
"gtk",
"objc2 0.6.5",
"objc2-app-kit 0.3.2",
"objc2-foundation 0.3.2",
"raw-window-handle",
"tempfile",
"windows",
"windows-core",
]
[[package]]
name = "ide-extension"
version = "0.1.49"
@@ -4511,6 +4527,7 @@ dependencies = [
name = "ide-http"
version = "0.1.49"
dependencies = [
"hyper-util",
"ide-core",
"ide-vfs",
"parking_lot",
@@ -5017,6 +5034,7 @@ dependencies = [
"ignore",
"notify",
"parking_lot",
"rayon",
"rustix",
"serde",
"serde_json",
@@ -6696,6 +6714,7 @@ dependencies = [
"ide-dap",
"ide-db",
"ide-docker",
"ide-drag-out",
"ide-extension",
"ide-fonts",
"ide-github",
+1
Переглянути файл
@@ -38,6 +38,7 @@ ide-web = { path = "crates/ide-web" }
ide-spell = { path = "crates/ide-spell" }
ide-agent = { path = "crates/ide-agent" }
ide-clipboard = { path = "crates/ide-clipboard" }
ide-drag-out = { path = "crates/ide-drag-out" }
ide-fonts = { path = "crates/ide-fonts" }
ide-ssh = { path = "crates/ide-ssh" }
ide-remote = { path = "crates/ide-remote" }
+4
Переглянути файл
@@ -25,6 +25,10 @@ dunce.workspace = true
uuid.workspace = true
tempfile.workspace = true
which = "8"
semver = "1"
[target.'cfg(unix)'.dependencies]
rustix = { version = "1", features = ["fs"] }
[dev-dependencies]
tokio = { workspace = true, features = ["test-util"] }
+1 -1
Переглянути файл
@@ -51,7 +51,7 @@ async fn run_once(
move || launch.resolve_for_launch_with_copilot_env(&root, strip_ambient)
})
.await
.map_err(|e| e.to_string())?;
.map_err(|e| e.to_string())??;
let cwd = dunce::canonicalize(&root).unwrap_or(root);
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), ..Default::default() });
let client = Dialect::wrap(updates.clone());
+395
Переглянути файл
@@ -0,0 +1,395 @@
//! Checks and updates only the global npm installation selected by the agent launcher.
use crate::{AgentManager, AgentSource, provider};
use ide_core::{CancellationToken, IdeError, IdeResult, error::ErrorKind};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use specta::Type;
use std::{
fs, io,
path::{Path, PathBuf},
process::Command,
};
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
pub struct AgentCliOffer {
pub current: String,
pub latest: String,
pub prefix: PathBuf,
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "status", rename_all = "camelCase")]
pub enum AgentCliUpdateResult {
Available(AgentCliOffer),
Permission(AgentCliOffer),
Current { current: String },
Channel { current: String },
Updated { current: String },
Unmanaged,
Error { code: String },
}
pub(crate) fn package(id: &str) -> Option<&'static str> {
Some(match id {
"claude" => "@anthropic-ai/claude-code",
"codex" => "@openai/codex",
"gemini" => "@google/gemini-cli",
"opencode" => "opencode-ai",
"copilot" => "@github/copilot",
"qwen" => "@qwen-code/qwen-code",
"auggie" => "@augmentcode/auggie",
"qoder" => "@qoder-ai/qodercli",
"omp" => "@oh-my-pi/pi-coding-agent",
_ => return None,
})
}
impl AgentManager {
pub fn cli_update(
&self,
id: &str,
offer: Option<&AgentCliOffer>,
cancel: &CancellationToken,
) -> IdeResult<AgentCliUpdateResult> {
let spec = self.shared.spec(id).ok_or_else(|| IdeError::invalid(format!("unknown agent {id}")))?;
let (Some(pkg), Some(builtin)) = (package(id), provider::builtin_spec(id)) else {
return Ok(AgentCliUpdateResult::Unmanaged);
};
if spec.source != AgentSource::Builtin {
return Ok(AgentCliUpdateResult::Unmanaged);
}
let Ok(npm) = which::which("npm") else { return Ok(AgentCliUpdateResult::Unmanaged) };
let program = spec.resolve_for_launch(&self.shared.paths.project_root).command;
match maintain(&npm, Path::new(&program), &builtin.command, pkg, offer, cancel) {
Err(e) if e.kind == ErrorKind::Unavailable => Ok(AgentCliUpdateResult::Error { code: e.message }),
result => result,
}
}
}
struct Installation {
modules: PathBuf,
folder: PathBuf,
link: PathBuf,
}
impl Installation {
fn at(prefix: &Path, pkg: &str, bin: &str) -> Self {
let modules = prefix.join(if cfg!(windows) { "node_modules" } else { "lib/node_modules" });
let link = if cfg!(windows) { prefix.join(format!("{bin}.cmd")) } else { prefix.join("bin").join(bin) };
Self { folder: modules.join(pkg), modules, link }
}
fn version(&self, program: &Path, pkg: &str, bin: &str) -> IdeResult<Option<String>> {
if !program.is_absolute() || !self.folder.try_exists()? || !self.link.try_exists()? || !program.try_exists()? {
return Ok(None);
}
let folder = dunce::canonicalize(&self.folder)?;
if fs::symlink_metadata(&self.folder)?.is_symlink()
|| dunce::canonicalize(program)? != dunce::canonicalize(&self.link)?
{
return Ok(None);
}
let manifest = self.folder.join("package.json");
if !manifest.try_exists()? {
return Ok(None);
}
let manifest: Value = serde_json::from_slice(&fs::read(manifest)?)
.map_err(|_| IdeError::invalid("Invalid npm package manifest"))?;
let entry = manifest["bin"].as_str().or_else(|| manifest["bin"][bin].as_str());
let Some(entry) = entry.filter(|_| manifest["name"] == pkg) else { return Ok(None) };
let Some(version) = manifest["version"].as_str() else {
return Err(IdeError::invalid("Missing npm package version"));
};
let entry = folder.join(entry);
if !entry.try_exists()? {
return Ok(None);
}
let entry = dunce::canonicalize(entry)?;
if !entry.starts_with(&folder) {
return Ok(None);
}
#[cfg(unix)]
let owns = fs::symlink_metadata(&self.link)?.is_symlink() && dunce::canonicalize(&self.link)? == entry;
#[cfg(windows)]
let owns = {
let prefix = dunce::canonicalize(self.link.parent().unwrap())?;
let Ok(target) = entry.strip_prefix(prefix) else { return Ok(None) };
let needle = format!("%dp0%\\{}\"", target.display()).to_lowercase();
fs::read_to_string(&self.link)?.replace('/', "\\").to_lowercase().contains(&needle)
};
Ok(owns.then(|| version.to_owned()))
}
fn writable(&self) -> io::Result<bool> {
for dir in [&*self.folder, self.folder.parent().unwrap(), &self.modules, self.link.parent().unwrap()] {
#[cfg(unix)]
let access: io::Result<()> =
rustix::fs::accessat(rustix::fs::CWD, dir, rustix::fs::Access::WRITE_OK, rustix::fs::AtFlags::empty())
.map_err(Into::into);
#[cfg(windows)]
let access = tempfile::tempfile_in(dir).map(drop);
match access {
Err(e) if matches!(e.kind(), io::ErrorKind::PermissionDenied | io::ErrorKind::ReadOnlyFilesystem) => {
return Ok(false);
}
other => other?,
}
}
Ok(true)
}
}
fn stable(version: &str) -> Option<semver::Version> {
semver::Version::parse(version).ok().filter(|v| v.pre.is_empty() && v.build.is_empty())
}
fn maintain(
npm: &Path,
program: &Path,
bin: &str,
pkg: &str,
approved: Option<&AgentCliOffer>,
cancel: &CancellationToken,
) -> IdeResult<AgentCliUpdateResult> {
use AgentCliUpdateResult::*;
let run = |args: &[&str]| {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let mut cmd = Command::new(npm);
cmd.args(args)
.current_dir(npm.parent().unwrap())
.env("NPM_CONFIG_UPDATE_NOTIFIER", "false")
.env("NPM_CONFIG_LOGLEVEL", "error");
ide_tools::run_streamed(cmd, cancel, &|_| {}).map_err(|e| {
if e.kind == ErrorKind::Cancelled {
return e;
}
// npm diagnostics can contain private registry URLs; expose only known codes.
let code = e
.message
.split(|c: char| !c.is_ascii_alphanumeric() && c != '_')
.find(|w| {
matches!(
*w,
"EACCES"
| "EPERM"
| "EROFS"
| "ENOTFOUND"
| "EAI_AGAIN"
| "ETIMEDOUT"
| "E404"
| "E401"
| "E403"
)
})
.unwrap_or("npm");
IdeError::unavailable(code)
})
};
let output = run(&["prefix", "-g"])?;
let prefix = Path::new(output.trim_end());
if !prefix.is_absolute() {
return Err(IdeError::invalid("Invalid npm global prefix"));
}
let installation = Installation::at(prefix, pkg, bin);
let Some(current) = installation.version(program, pkg, bin)? else { return Ok(Unmanaged) };
let latest: String = serde_json::from_str(&run(&["view", &format!("{pkg}@latest"), "version", "--json"])?)
.map_err(|_| IdeError::invalid("Invalid npm version response"))?;
let (Some(before), Some(after)) = (stable(&current), stable(&latest)) else {
return Ok(Channel { current });
};
if before >= after {
return Ok(Current { current });
}
let offer = AgentCliOffer { current, latest, prefix: prefix.to_owned() };
if !installation.writable()? {
return Ok(Permission(offer));
}
if approved != Some(&offer) {
return Ok(Available(offer));
}
run(&[
"install",
"-g",
"--prefix",
prefix.to_str().unwrap(),
"--no-audit",
"--no-fund",
&format!("{pkg}@{}", offer.latest),
])?;
if installation.version(program, pkg, bin)?.as_ref() != Some(&offer.latest) {
return Err(IdeError::invalid("npm installation verification failed"));
}
Ok(Updated { current: offer.latest })
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
use tempfile::TempDir;
const PKG: &str = "@anthropic-ai/claude-code";
struct Fixture {
root: TempDir,
install: Installation,
}
impl Fixture {
fn new() -> Self {
let root = tempfile::Builder::new().prefix("全局 prefix ").tempdir().unwrap();
let install = Installation::at(root.path(), PKG, "claude");
fs::create_dir_all(&install.folder).unwrap();
fs::create_dir_all(install.link.parent().unwrap()).unwrap();
fs::write(install.folder.join("entry.js"), "").unwrap();
#[cfg(unix)]
std::os::unix::fs::symlink(install.folder.join("entry.js"), &install.link).unwrap();
#[cfg(windows)]
fs::write(&install.link, r#"@"%dp0%\node_modules\@anthropic-ai\claude-code\entry.js""#).unwrap();
let fixture = Self { root, install };
fixture.manifest(PKG, "2.1.9");
fixture
}
fn manifest(&self, name: &str, version: &str) {
fs::write(
self.install.folder.join("package.json"),
json!({"name":name,"version":version,"bin":{"claude":"entry.js"}}).to_string(),
)
.unwrap();
}
fn version(&self) -> Option<String> {
self.install.version(&self.install.link, PKG, "claude").unwrap()
}
#[cfg(unix)]
fn npm(&self, script: &str) -> PathBuf {
use std::os::unix::fs::PermissionsExt;
let path = self.root.path().join("npm");
fs::write(&path, format!("#!/bin/sh\nset -eu\n{script}\n")).unwrap();
fs::set_permissions(&path, fs::Permissions::from_mode(0o755)).unwrap();
path
}
}
#[test]
fn requires_the_selected_install_and_its_exact_package_entry() {
let f = Fixture::new();
assert_eq!(f.version().as_deref(), Some("2.1.9"));
let other = f.root.path().join("other");
fs::write(&other, "").unwrap();
assert_eq!(f.install.version(&other, PKG, "claude").unwrap(), None);
f.manifest("other-package", "2.1.9");
assert_eq!(f.version(), None);
f.manifest(PKG, "2.1.9");
fs::remove_file(&f.install.link).unwrap();
#[cfg(unix)]
std::os::unix::fs::symlink(&other, &f.install.link).unwrap();
#[cfg(windows)]
fs::write(&f.install.link, r#"@"%dp0%\other""#).unwrap();
assert_eq!(f.version(), None);
}
#[cfg(unix)]
const NPM: &str = r#"case "$1" in
prefix) pwd -P ;;
view) cat latest ;;
install)
test "$2" = "-g" && test "$3" = "--prefix" && test "$4" = "$(pwd -P)"
test "$7" = "@anthropic-ai/[email protected]"
cp updated.json "$4/lib/node_modules/@anthropic-ai/claude-code/package.json"
touch installed ;;
*) exit 2 ;;
esac"#;
#[cfg(unix)]
#[test]
fn installs_only_the_confirmed_offer_and_rechecks_ownership() {
use AgentCliUpdateResult::*;
let f = Fixture::new();
let npm = f.npm(NPM);
let cancel = CancellationToken::new();
let run =
|offer: Option<&AgentCliOffer>| maintain(&npm, &f.install.link, "claude", PKG, offer, &cancel).unwrap();
let latest = f.root.path().join("latest");
fs::write(&latest, r#""2.1.12""#).unwrap();
let Available(offer) = run(None) else { panic!("expected an offer") };
for different in [
AgentCliOffer { prefix: PathBuf::from("/other"), ..offer.clone() },
AgentCliOffer { current: "2.0.0".into(), ..offer.clone() },
] {
assert_eq!(run(Some(&different)), Available(offer.clone()));
}
fs::write(&latest, r#""2.2.0""#).unwrap();
assert!(matches!(run(Some(&offer)), Available(new) if new.latest == "2.2.0"));
fs::write(&latest, r#""2.0.0""#).unwrap();
assert!(matches!(run(Some(&offer)), Current { .. }));
fs::write(&latest, r#""2.2.0-beta.1""#).unwrap();
assert!(matches!(run(Some(&offer)), Channel { .. }));
fs::write(&latest, r#""2.1.12""#).unwrap();
f.manifest("other-package", "2.1.9");
assert_eq!(run(Some(&offer)), Unmanaged);
assert!(!f.root.path().join("installed").exists());
f.manifest(PKG, "2.1.12");
fs::copy(f.install.folder.join("package.json"), f.root.path().join("updated.json")).unwrap();
f.manifest(PKG, "2.1.9");
assert_eq!(run(Some(&offer)), Updated { current: "2.1.12".into() });
assert!(f.root.path().join("installed").exists());
assert_eq!(run(None), Current { current: "2.1.12".into() });
}
#[cfg(unix)]
#[test]
fn permission_failure_never_starts_an_install() {
use std::os::unix::fs::PermissionsExt;
let f = Fixture::new();
let npm = f.npm(NPM);
fs::write(f.root.path().join("latest"), r#""2.1.12""#).unwrap();
let run = |offer: Option<&AgentCliOffer>| {
maintain(&npm, &f.install.link, "claude", PKG, offer, &CancellationToken::new()).unwrap()
};
let AgentCliUpdateResult::Available(offer) = run(None) else { panic!("expected an offer") };
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o555)).unwrap();
// root can write even when no mode bit grants write permission.
if tempfile::tempfile_in(&f.install.folder).is_err() {
assert_eq!(run(Some(&offer)), AgentCliUpdateResult::Permission(offer));
}
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o755)).unwrap();
assert!(!f.root.path().join("installed").exists());
}
#[cfg(unix)]
#[test]
fn cancellation_stops_a_running_npm_process() {
use std::time::{Duration, Instant};
let f = Fixture::new();
let npm = f.npm(
r#"case "$1" in
prefix) pwd -P ;;
view) echo '"2.1.12"' ;;
install) touch started; exec sleep 30 ;;
esac"#,
);
let cancel = CancellationToken::new();
let AgentCliUpdateResult::Available(offer) =
maintain(&npm, &f.install.link, "claude", PKG, None, &cancel).unwrap()
else {
panic!("expected an offer")
};
let started = f.root.path().join("started");
std::thread::scope(|s| {
let op = s.spawn(|| maintain(&npm, &f.install.link, "claude", PKG, Some(&offer), &cancel));
let deadline = Instant::now() + Duration::from_secs(5);
while !started.exists() && Instant::now() < deadline {
std::thread::sleep(Duration::from_millis(10));
}
cancel.cancel();
assert!(started.exists());
assert_eq!(op.join().unwrap().unwrap_err().kind, ErrorKind::Cancelled);
});
assert_eq!(f.version().as_deref(), Some("2.1.9"));
}
}
+22 -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};
@@ -272,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();
@@ -368,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"));
}
}
+96 -22
Переглянути файл
@@ -10,10 +10,12 @@
mod acp;
mod async_questions;
mod catalogs;
mod cli_update;
mod config;
mod conversation;
mod elicitation;
mod external;
pub mod hermes;
pub mod mcp;
mod model;
mod native;
@@ -26,6 +28,7 @@ mod timeline;
mod worktree;
pub use catalogs::AgentCatalogs;
pub use cli_update::{AgentCliOffer, AgentCliUpdateResult};
pub use external::ExternalSession;
pub use model::*;
@@ -131,6 +134,7 @@ pub type McpExecutableFn = dyn Fn() -> Option<PathBuf> + Send + Sync;
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
struct CopilotBinaryKey {
command: String,
github_account: Option<String>,
modified: Option<std::time::SystemTime>,
len: Option<u64>,
}
@@ -139,7 +143,7 @@ struct Shared {
paths: AgentPaths,
runtime: tokio::runtime::Handle,
connector: Connector,
sink: RwLock<Option<AgentSink>>,
sinks: RwLock<HashMap<String, AgentSink>>,
security: RwLock<Option<SecurityHook>>,
new_task_approvals: RwLock<Option<NewTaskApprovalsHook>>,
known: Arc<Mutex<HashMap<String, Known>>>,
@@ -192,6 +196,7 @@ impl Shared {
let metadata = std::fs::metadata(&executable).ok();
CopilotBinaryKey {
command: executable.to_string_lossy().into_owned(),
github_account: provider::copilot_github_account(&spec.env),
modified: metadata.as_ref().and_then(|m| m.modified().ok()),
len: metadata.as_ref().map(std::fs::Metadata::len),
}
@@ -210,10 +215,12 @@ impl Shared {
}
fn emit(&self, event: AgentEvent) {
let sink = self.sink.read().clone();
if let Some(sink) = sink {
sink(event);
let mut sinks: Vec<_> = self.sinks.read().values().cloned().collect();
let Some(last) = sinks.pop() else { return };
for sink in sinks {
sink(event.clone());
}
last(event);
}
/// The MCP servers passed to a session, and the names of the ones off for it.
@@ -558,7 +565,7 @@ impl AgentManager {
paths,
runtime,
connector,
sink: RwLock::new(None),
sinks: RwLock::new(HashMap::new()),
security: RwLock::new(None),
new_task_approvals: RwLock::new(None),
known,
@@ -601,12 +608,22 @@ impl AgentManager {
/// Routes events to `sink` (replacing the previous subscriber); returns every task.
pub fn subscribe(&self, sink: AgentSink) -> Vec<AgentTask> {
*self.shared.sink.write() = Some(sink);
self.subscribe_as("", sink)
}
/// Routes events to `sink` too, replacing only the sink `subscriber` (a view of the project) had.
pub fn subscribe_as(&self, subscriber: &str, sink: AgentSink) -> Vec<AgentTask> {
self.shared.sinks.write().insert(subscriber.to_owned(), sink);
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().snapshot()).collect();
tasks.sort_by(|a, b| b.updated_ms.total_cmp(&a.updated_ms));
tasks
}
/// A closed view releases its sink, never the task or its agent process.
pub fn unsubscribe(&self, subscriber: &str) {
self.shared.sinks.write().remove(subscriber);
}
/// Sets the callback used to read the active command execution security policy.
pub fn set_security_hook(&self, hook: SecurityHook) {
*self.shared.security.write() = Some(hook);
@@ -709,7 +726,8 @@ impl AgentManager {
/// The slash commands to complete for `provider`, in `task`'s directory or (without one)
/// in the project: what the agent offered last time there, unadvertised builtins,
/// and, for Claude Code, skills and custom commands on disk it has not listed.
/// and, for Claude Code, skills and custom commands on disk it has not listed (for Hermes,
/// its profile's skills).
pub async fn commands(&self, provider: &str, task: Option<&str>) -> IdeResult<Vec<AgentCommand>> {
let (provider, offered, cwd) = match task {
Some(id) => {
@@ -743,10 +761,18 @@ impl AgentManager {
offered.push(command);
}
}
let home = self.shared.paths.home_dir.clone();
if provider == "hermes" || provider.starts_with("hermes-") {
let found = blocking(move || {
let profile = hermes::root(home.as_deref()).and_then(|root| hermes::profile_home(&root, &provider));
Ok(profile.map(|p| skills::hermes(&p)).unwrap_or_default())
})
.await?;
return Ok(skills::merge(offered, found));
}
if provider != "claude" && provider != "claude-acp" {
return Ok(offered);
}
let home = self.shared.paths.home_dir.clone();
let found = blocking(move || Ok(skills::discover(&cwd, home.as_deref()))).await?;
Ok(skills::merge(offered, found))
}
@@ -832,6 +858,7 @@ impl AgentManager {
retry: None,
background: Box::default(),
mcp_overrides: BTreeMap::new(),
stats: Box::default(),
};
let file = TaskFile {
task: task.clone(),
@@ -949,6 +976,7 @@ impl AgentManager {
retry: None,
background: Box::default(),
mcp_overrides: req.mcp_overrides,
stats: Box::default(),
};
let file = TaskFile {
task: task.clone(),
@@ -1114,6 +1142,16 @@ impl AgentManager {
/// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts.
pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> {
let task = self.task(id)?;
let provider = task.state.lock().task.provider.clone();
let discovered = self
.shared
.paths
.catalogs
.cached(&self.shared, &provider)
.config
.iter()
.find(|o| o.id == option && o.category.as_deref() == Some("model"))
.cloned();
let (target, change) = {
let mut s = task.state.lock();
let busy = s.busy;
@@ -1134,17 +1172,19 @@ impl AgentManager {
task.emit_task();
return Ok(());
}
let target = s
.task
.config
.iter()
.find(|o| o.id == option)
.ok_or_else(|| IdeError::not_found("no such setting"))?
.clone();
let session_target = s.task.config.iter().find(|o| o.id == option).cloned();
let recovered_model = session_target.is_none();
let target = match session_target {
Some(target) => target,
None if discovered.is_some() => discovered.unwrap(),
None => return Err(IdeError::not_found("no such setting")),
};
if s.pending_model.is_some() && config::is_per_model_option(&target) {
return Err(IdeError::invalid("This setting is not available on the selected model"));
}
if !target.values.iter().any(|v| v.value == value) {
if recovered_model {
(target, None)
} else if !target.values.iter().any(|v| v.value == value) {
if target.category.as_deref() != Some("model") {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
}
@@ -1316,6 +1356,7 @@ impl AgentManager {
resets_ms: None,
retry: None,
background: Box::default(),
stats: Box::default(),
..s.task.clone()
};
TaskFile {
@@ -1530,6 +1571,18 @@ impl AgentManager {
Ok(())
}
pub async fn context_usage(&self, id: &str) -> IdeResult<AgentContextUsage> {
let task = self.task(id)?;
let live = task.live.lock().clone().ok_or_else(|| IdeError::unavailable("the agent session is offline"))?;
if !live.capabilities.context_usage {
return Err(IdeError::unavailable("this agent does not report context details"));
}
live.peer
.request("_openidea/context_usage", json!({ "sessionId": live.session }), None)
.await
.map_err(|error| IdeError::internal(task.describe(error)))
}
/// Stops background task `background` of task `id`.
pub async fn stop_background(&self, id: &str, background: &str) -> IdeResult<()> {
let task = self.task(id)?;
@@ -1961,7 +2014,7 @@ impl AgentManager {
// What arrived after the last save (a subagent's late updates).
task.persist();
}
*self.shared.sink.write() = None;
self.shared.sinks.write().clear();
}
}
@@ -2653,7 +2706,13 @@ impl Task {
.await;
}
match result {
Ok(v) => Ok(v.get("stopReason").and_then(Value::as_str).unwrap_or("end_turn").to_owned()),
Ok(v) => {
if let Some(tokens) = config::tokens_of(&v) {
self.state.lock().task.stats.tokens = Some(tokens);
self.emit_task();
}
Ok(v.get("stopReason").and_then(Value::as_str).unwrap_or("end_turn").to_owned())
}
Err(e) => Err(self.failure(e)),
}
}
@@ -2780,9 +2839,12 @@ impl Task {
pending_model: Option<&PendingModel>,
) -> Result<Live, SessionOpenError> {
let launch_cwd = cwd.to_path_buf();
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
.await
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?;
let mut spec = tokio::task::spawn_blocking(move || {
spec.resolve_for_launch_with_copilot_env(&launch_cwd, provider::prefer_stored_copilot_auth())
})
.await
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?
.map_err(|e| SessionOpenError { message: e, allow_acp_fallback: false })?;
if spec.driver == provider::Driver::Acp && provider::is_copilot_provider(provider_id) {
let mcp_overrides = self.state.lock().task.mcp_overrides.clone();
for name in self.shared.mcp_servers_off_for_session(provider_id, &mcp_overrides) {
@@ -3187,6 +3249,17 @@ impl Task {
return;
}
if kind == "session_info_update" {
let depth = update.pointer("/_meta/hermes/sessionProvenance/compressionDepth").and_then(Value::as_u64);
if let Some(depth) = depth.and_then(|d| u32::try_from(d).ok()) {
let changed = {
let mut s = self.state.lock();
std::mem::replace(&mut s.task.stats.compressions, depth) != depth
};
if changed {
self.persist();
self.emit_task();
}
}
// The agent's own title for the session replaces the first line of the prompt,
// unless the user named the task.
let title = update.get("title").and_then(Value::as_str).map(str::trim).filter(|t| !t.is_empty());
@@ -3820,6 +3893,7 @@ fn capabilities_of(init: &acp::Negotiated) -> (AgentCapabilities, bool) {
rollback: meta("/openidea/rollback"),
steer: steer_method(init).is_some(),
background_tasks: meta("/openidea/backgroundTasks"),
context_usage: meta("/openidea/contextUsage"),
};
(capabilities, init.prompt("embeddedContext"))
}
@@ -4038,7 +4112,7 @@ fn entry_event(
entry: &AgentEntry,
) -> AgentEvent {
let text = match entry {
AgentEntry::Agent { text } | AgentEntry::Thought { text } => Some(text),
AgentEntry::Agent { text } | AgentEntry::Thought { text, .. } => Some(text),
_ => None,
};
let Some(text) = text else {
+54
Переглянути файл
@@ -45,6 +45,8 @@ pub struct AgentCapabilities {
pub steer: bool,
/// It reports its background tasks and stops them one by one.
pub background_tasks: bool,
/// The connected agent can report a breakdown of its context window.
pub context_usage: bool,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
@@ -108,6 +110,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.
@@ -252,6 +277,24 @@ pub struct AgentUsage {
pub cost: Option<Box<AgentCost>>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentContextUsage {
pub categories: Vec<AgentContextCategory>,
pub total_tokens: u32,
pub max_tokens: u32,
pub model: String,
pub is_auto_compact_enabled: Option<bool>,
pub auto_compact_threshold: Option<u32>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
pub struct AgentContextCategory {
pub name: String,
pub tokens: u32,
pub kind: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentCost {
@@ -479,6 +522,9 @@ pub enum AgentEntry {
},
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,
@@ -490,6 +536,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>,
@@ -563,6 +614,9 @@ pub struct AgentProvider {
pub command_read_only_reason: Option<AgentCommandReadOnlyReason>,
/// Whether the command was found (on `PATH`).
pub installed: bool,
/// The built-in command can be owned by a global npm package.
#[serde(default)]
pub can_check_cli_update: bool,
/// Environment variables it starts with (from its agent file).
pub env: BTreeMap<String, String>,
/// Settings (models, modes…) the agent offered last time it ran; empty before its first session.
+6 -1
Переглянути файл
@@ -407,7 +407,7 @@ impl Shim {
"promptCapabilities": { "image": true, "embeddedContext": true },
"sessionCapabilities": { "fork": {} },
"mcpCapabilities": { "stdio": true, "http": true, "sse": true },
"_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true } },
"_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true, "contextUsage": true } },
},
"agentInfo": { "name": "claude", "title": "Claude Code", "version": self.version() },
"authMethods": [],
@@ -492,6 +492,11 @@ impl Shim {
session.steer(params.get("prompt").cloned().unwrap_or_default()).map_err(invalid)?;
Ok(json!({}))
}
"_openidea/context_usage" => {
let session = self.session(&params)?;
let proc = session.st.lock().proc.clone().ok_or_else(|| internal("Claude Code is not running"))?;
rt.block_on(proc.control(json!({ "subtype": "get_context_usage" }))).map_err(internal)
}
"_openidea/stop_task" => {
let session = self.session(&params)?;
let task = params.get("taskId").and_then(Value::as_str).ok_or_else(|| invalid("no taskId"))?;
+2 -1
Переглянути файл
@@ -144,7 +144,8 @@ async fn discover_once(spec: ProviderSpec, cwd: PathBuf, strip_ambient: bool) ->
move || spec.resolve_for_launch_with_copilot_env(&cwd, strip_ambient)
})
.await
.map_err(|e| DiscoverError { message: e.to_string(), allow_acp_fallback: false })?;
.map_err(|e| DiscoverError { message: e.to_string(), allow_acp_fallback: false })?
.map_err(|e| DiscoverError { message: e, allow_acp_fallback: false })?;
let cwd = dunce::canonicalize(&cwd).unwrap_or(cwd);
let args = headless_args(&launch.args);
let peer = Peer::spawn_framed(
+14 -2
Переглянути файл
@@ -312,7 +312,7 @@ impl Settings {
}
/// Parses `models.list` + optional `models.listTokenPriceUnits` into catalog entries,
/// prepending `"auto"` when not already in the list.
/// prepending `"auto"` when direct models are present or Copilot advertises an enabled Auto tier.
pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<ModelEntry> {
let units = parse_price_units(price_units);
let raw = list
@@ -322,7 +322,7 @@ pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<Mo
.map(Vec::as_slice)
.unwrap_or_default();
let mut out = Vec::new();
if !raw.iter().any(|m| str_of(m, "id") == Some("auto")) && !raw.is_empty() {
if !raw.iter().any(|m| str_of(m, "id") == Some("auto")) && (!raw.is_empty() || auto_model_available(list)) {
out.push(ModelEntry {
id: "auto".into(),
name: "Auto".into(),
@@ -344,6 +344,18 @@ pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<Mo
out
}
fn auto_model_available(list: &Value) -> bool {
let Some(auto) = list.get("auto") else { return false };
if auto.get("enabled").or_else(|| auto.pointer("/status/enabled")).and_then(Value::as_bool) == Some(false) {
return false;
}
let Some(tiers) = auto.get("tiers").and_then(Value::as_array) else { return auto.is_object() };
tiers.is_empty()
|| tiers.iter().any(|tier| {
tier.get("enabled").or_else(|| tier.pointer("/status/enabled")).and_then(Value::as_bool) != Some(false)
})
}
fn parse_model(m: &Value, units: &HashMap<String, PriceUnit>) -> Option<ModelEntry> {
let id = str_of(m, "id")?.to_owned();
if m.get("model_picker_enabled").and_then(Value::as_bool) == Some(false)
+66
Переглянути файл
@@ -110,6 +110,72 @@ fn sample_price_units() -> Value {
})
}
#[test]
fn parses_an_enabled_auto_only_catalog() {
let list = json!({
"models": [],
"auto": {
"defaultTier": "balance",
"tiers": [
{
"id": "balance",
"displayName": "Standard",
"type": "auto",
"fusionTier": "standard",
"status": { "enabled": true, "pickerVisible": true }
},
{
"id": "hydrafusion",
"displayName": "High",
"type": "fusion",
"fusionTier": "high",
"status": {
"enabled": false,
"pickerVisible": true,
"reason": "user_not_eligible"
}
},
{
"id": "fast",
"displayName": "Fast",
"type": "auto",
"status": { "enabled": true, "pickerVisible": false }
}
],
"providerId": "copilot"
},
"imageModels": []
});
let catalog = models::parse_catalog(&list, None);
assert_eq!(catalog.iter().map(|m| m.id.as_str()).collect::<Vec<_>>(), ["auto"]);
assert_eq!(Settings::new(&catalog, &UserDefaults::default()).model, "auto");
let options =
config::parse_options(&models::config_options(&catalog, &Settings::new(&catalog, &UserDefaults::default())));
let model = options.iter().find(|option| option.id == MODEL).unwrap();
assert_eq!(model.current.as_deref(), Some("auto"));
assert_eq!(model.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(), ["auto"]);
}
#[test]
fn rejects_an_auto_only_catalog_when_every_tier_is_disabled() {
let list = json!({
"models": [],
"auto": {
"defaultTier": "balance",
"tiers": [
{
"id": "balance",
"status": { "enabled": false, "pickerVisible": true }
}
]
}
});
assert!(models::parse_catalog(&list, None).is_empty());
}
#[test]
fn parses_tiered_context_windows_pricing_and_uses_copilots_own_defaults() {
let catalog = models::parse_catalog(&sample_models_list(), Some(&sample_price_units()));
+141 -3
Переглянути файл
@@ -9,6 +9,8 @@ use serde_json::Value;
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
pub(crate) const COPILOT_GITHUB_ACCOUNT_ENV: &str = "OPENIDEA_COPILOT_GITHUB_ACCOUNT";
/// The protocol an agent speaks. Native ones run behind an in-process ACP endpoint
/// (`native`), so tasks see every agent as ACP and read features from its capabilities.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
@@ -82,6 +84,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> {
@@ -137,15 +140,31 @@ impl ProviderSpec {
/// Resolve once before connecting, so authentication guidance names that same install.
pub(crate) fn resolve_for_launch(self, cwd: &Path) -> Self {
let strip = prefer_stored_copilot_auth();
self.resolve_for_launch_with_copilot_env(cwd, strip)
self.resolve_for_launch_base(cwd, strip)
}
pub(crate) fn resolve_for_launch_with_copilot_env(mut self, cwd: &Path, strip_ambient_tokens: bool) -> Self {
pub(crate) fn resolve_for_launch_with_copilot_env(
self,
cwd: &Path,
strip_ambient_tokens: bool,
) -> Result<Self, String> {
let account = is_copilot_provider(&self.id).then(|| copilot_github_account(&self.env)).flatten();
let mut resolved = self.resolve_for_launch_base(cwd, strip_ambient_tokens || account.is_some());
if let Some(account) = account {
let token = github_token_for_account(&account)?;
resolved.env.retain(|(name, _)| !AMBIENT_COPILOT_AUTH_VARS.contains(&name.as_str()));
resolved.env.push(("COPILOT_GITHUB_TOKEN".into(), token));
}
Ok(resolved)
}
fn resolve_for_launch_base(mut self, cwd: &Path, strip_ambient_tokens: bool) -> Self {
if self.driver != Driver::Acp {
self.command = crate::native::newest_install(&self.command);
}
if is_copilot_provider(&self.id) {
self.env = sanitized_copilot_env(&self.env, strip_ambient_tokens);
self.env.retain(|(name, _)| name != COPILOT_GITHUB_ACCOUNT_ENV);
}
let program = ide_jsonrpc::resolve_spawn_program(&self.command, &self.env);
self.command =
@@ -163,6 +182,50 @@ pub(crate) fn is_copilot_provider(id: &str) -> bool {
id == "copilot" || id.starts_with("copilot-")
}
pub(crate) fn copilot_github_account(env: &[(String, String)]) -> Option<String> {
env.iter()
.rev()
.find(|(name, _)| name == COPILOT_GITHUB_ACCOUNT_ENV)
.map(|(_, value)| value.trim())
.filter(|value| !value.is_empty())
.map(str::to_owned)
}
fn github_token_for_account(account: &str) -> Result<String, String> {
let path = ide_core::process::shell_env()
.find(|(name, _)| name == "PATH")
.map(|(_, value)| value)
.or_else(|| ide_core::process::host_var_os("PATH"));
let program = path
.as_deref()
.and_then(|path| ide_core::process::find_executable("gh", path))
.ok_or_else(|| "GitHub CLI (`gh`) is required to select a Copilot GitHub account".to_owned())?;
let mut command = std::process::Command::new(program);
command.args(["auth", "token", "--hostname", "github.com", "--user", account]).envs(ide_core::process::shell_env());
for name in AMBIENT_COPILOT_AUTH_VARS {
command.env_remove(name);
}
let output = command
.output()
.map_err(|error| format!("Couldn't read GitHub authentication for account {account}: {error}"))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
let detail = stderr.trim();
return Err(if detail.is_empty() {
format!("GitHub CLI has no authenticated account named {account}")
} else {
format!("Couldn't use GitHub account {account}: {detail}")
});
}
let token = String::from_utf8(output.stdout)
.map_err(|_| format!("GitHub CLI returned a non-text token for account {account}"))?;
let token = token.trim();
if token.is_empty() {
return Err(format!("GitHub CLI returned no token for account {account}"));
}
Ok(token.to_owned())
}
pub(crate) fn prefer_stored_copilot_auth() -> bool {
PREFER_STORED_COPILOT_AUTH.load(std::sync::atomic::Ordering::Acquire)
}
@@ -310,6 +373,7 @@ pub(crate) fn describe(spec: &ProviderSpec) -> AgentProvider {
command_editable: reason.is_none(),
command_read_only_reason: reason,
installed: installed(&spec.command),
can_check_cli_update: spec.source == AgentSource::Builtin && crate::cli_update::package(&spec.id).is_some(),
env: spec.env.iter().cloned().collect(),
config: vec![],
thought_levels: BTreeMap::new(),
@@ -338,6 +402,31 @@ pub(crate) fn set_builtin_env(
id: &str,
env: BTreeMap<String, String>,
) -> IdeResult<()> {
if id == "copilot" {
let file = custom_dir.join("copilot.toml");
if file.try_exists()?
&& let mut agent = CustomAgent::read_with(&file, id, secrets).map_err(IdeError::invalid)?
&& agent.registry.is_some()
{
let existing = agent.env.clone();
let mut existing_launch_env = existing.clone();
let mut next_launch_env = env.clone();
existing_launch_env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
next_launch_env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
if existing_launch_env != next_launch_env {
return Err(IdeError::invalid(format!("{id} is installed from the ACP Registry")));
}
match env.get(COPILOT_GITHUB_ACCOUNT_ENV).filter(|value| !value.trim().is_empty()) {
Some(account) => {
agent.env.insert(COPILOT_GITHUB_ACCOUNT_ENV.into(), account.trim().into());
}
None => {
agent.env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
}
}
return agent.write(&file).map_err(Into::into);
}
}
update_builtin(custom_dir, secrets, id, |agent, _| agent.env = env)
}
@@ -503,7 +592,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 +805,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());
@@ -945,6 +1043,46 @@ mod tests {
set_builtin_env(dir.path(), None, "not-a-builtin", env).unwrap_err();
}
#[test]
fn registry_copilot_allows_only_the_github_account_override() {
let dir = tempfile::tempdir().unwrap();
let file = dir.path().join("copilot.toml");
CustomAgent {
name: Some("GitHub Copilot".into()),
driver: Driver::Acp,
command: "/tools/copilot".into(),
args: vec!["--acp".into()],
env: BTreeMap::from([("REGISTRY_SETTING".into(), "kept".into())]),
registry: Some(RegistryRef { id: "copilot".into(), version: "1.0.0".into() }),
}
.write(&file)
.unwrap();
set_builtin_env(
dir.path(),
None,
"copilot",
BTreeMap::from([
("REGISTRY_SETTING".into(), "kept".into()),
(COPILOT_GITHUB_ACCOUNT_ENV.into(), "dengliu_microsoft".into()),
]),
)
.unwrap();
let spec = load(Some(dir.path()), None).into_iter().find(|spec| spec.id == "copilot").unwrap();
assert_eq!(copilot_github_account(&spec.env).as_deref(), Some("dengliu_microsoft"));
set_builtin_env(dir.path(), None, "copilot", BTreeMap::from([("REGISTRY_SETTING".into(), "changed".into())]))
.unwrap_err();
}
#[test]
fn launch_metadata_never_passes_the_github_account_control_to_copilot() {
let mut spec = builtin_spec("copilot").unwrap();
spec.env.push((COPILOT_GITHUB_ACCOUNT_ENV.into(), "dengliu_microsoft".into()));
let resolved = spec.resolve_for_launch(Path::new("."));
assert!(resolved.env.iter().all(|(name, _)| name != COPILOT_GITHUB_ACCOUNT_ENV));
}
#[test]
fn acp_adapters_of_native_agents_are_unlisted_until_customized() {
let dir = tempfile::tempdir().unwrap();
+8
Переглянути файл
@@ -537,6 +537,14 @@ fn install_entry_with(
return Err(e);
}
};
let github_account = (entry.id == "copilot")
.then(|| CustomAgent::read(&file).ok())
.flatten()
.and_then(|agent| agent.env.get(provider::COPILOT_GITHUB_ACCOUNT_ENV).cloned());
let mut env = env;
if let Some(account) = github_account {
env.insert(provider::COPILOT_GITHUB_ACCOUNT_ENV.into(), account);
}
let agent = CustomAgent {
name: Some(entry.name.clone()),
driver: Driver::Acp,
+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();
+130 -2
Переглянути файл
@@ -452,6 +452,35 @@ fn manager(dir: &Path, agent: Arc<FakeAgent>) -> AgentManager {
manager_at(dir, &dir.join("models.json"), agent)
}
#[tokio::test]
async fn subscribers_do_not_replace_or_close_each_other() {
let tmp = tempfile::tempdir().unwrap();
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
let main = Arc::new(Mutex::new(Vec::new()));
let child = Arc::new(Mutex::new(Vec::new()));
let subscribe = |window: &str, events: &Arc<Mutex<Vec<AgentEvent>>>| {
let events = events.clone();
mgr.subscribe_as(window, Arc::new(move |event| events.lock().push(event)));
};
subscribe("main", &main);
subscribe("editor-main-1", &child);
mgr.shared.emit(AgentEvent::Providers);
assert_eq!(main.lock().len(), 1);
assert_eq!(child.lock().len(), 1);
// A reloaded webview replaces only its own old channel.
let reloaded = Arc::new(Mutex::new(Vec::new()));
subscribe("editor-main-1", &reloaded);
mgr.shared.emit(AgentEvent::Providers);
assert_eq!(main.lock().len(), 2);
assert_eq!(child.lock().len(), 1);
assert_eq!(reloaded.lock().len(), 1);
mgr.unsubscribe("editor-main-1");
mgr.shared.emit(AgentEvent::Providers);
assert_eq!(main.lock().len(), 3);
assert_eq!(reloaded.lock().len(), 1);
mgr.shutdown();
}
fn manager_at(dir: &Path, models_file: &Path, agent: Arc<FakeAgent>) -> AgentManager {
// These tests speak to FakeAgent, never an installed CLI, including after a provider reload.
let agents = dir.join("agents");
@@ -909,6 +938,27 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
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();
@@ -1877,6 +1927,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();
@@ -2286,6 +2362,56 @@ async fn idle_model_switches_discover_controls_and_no_control_models_without_ano
restored.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn session_without_a_model_option_can_select_from_a_recovered_catalog() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
*agent.model_options.lock() = HashMap::from([
("big".into(), effort_options(&["low", "high"], "high")),
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
]);
let mgr = manager(tmp.path(), agent);
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude-acp".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let spec = mgr.shared.spec("claude-acp").unwrap();
let (_, flight) = mgr.shared.paths.catalogs.request(&mgr.shared, spec, true, None);
if let Some(mut ready) = flight {
tokio::time::timeout(Duration::from_secs(5), async {
while !*ready.borrow_and_update() {
ready.changed().await.unwrap();
}
})
.await
.unwrap();
}
{
let task = mgr.task(&task.id).unwrap();
let mut state = task.state.lock();
state.task.config.retain(|option| option.category.as_deref() != Some("model"));
state.task.model = Some("stale-model".into());
}
mgr.set_config(&task.id, "model", "small".into()).await.unwrap();
let task = mgr.task(&task.id).unwrap();
{
let state = task.state.lock();
assert_eq!(state.task.model.as_deref(), Some("small"));
let model = state.task.config.iter().find(|option| option.category.as_deref() == Some("model")).unwrap();
assert_eq!(model.current.as_deref(), Some("small"));
assert!(model.values.iter().any(|value| value.value == "small"));
}
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn idle_model_discovery_failure_restores_the_previous_choice_without_claiming_no_controls() {
let tmp = tempfile::tempdir().unwrap();
@@ -3531,11 +3657,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);
+41 -4
Переглянути файл
@@ -85,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) => {
@@ -134,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;
};
@@ -156,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"));
@@ -183,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() {
@@ -432,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() },
]
);
@@ -528,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));
+3 -4
Переглянути файл
@@ -236,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() {
+13 -1
Переглянути файл
@@ -82,11 +82,23 @@ pub fn load_linked(
maven_repo: Option<PathBuf>,
settings: &ide_core::settings::MavenSettings,
gradle_settings: &ide_core::settings::GradleSettings,
) -> BuildModel {
load_linked_with_jdk(root, cache_dir, maven_repo, settings, gradle_settings, None)
}
/// [`load_linked`] with the JDK Maven runs on, for JDK-activated Maven profiles.
pub fn load_linked_with_jdk(
root: &Path,
cache_dir: &Path,
maven_repo: Option<PathBuf>,
settings: &ide_core::settings::MavenSettings,
gradle_settings: &ide_core::settings::GradleSettings,
maven_jdk_version: Option<u32>,
) -> BuildModel {
let maven = maven::has_projects(root, settings).then(|| {
let profiles = settings.profiles(&sync::maven_profiles(cache_dir));
let repo = maven_repo.or_else(maven::default_local_repo);
let mut m = maven::load_with_linked(root, repo, &profiles, &settings.linked_projects);
let mut m = maven::load_with_linked_jdk(root, repo, &profiles, maven_jdk_version, &settings.linked_projects);
maven::UnlinkedProjects::from_model(&m, settings).filter(&mut m);
// The user settings' profiles can be chosen too (`-P` applies to them as well).
for p in maven::user_settings_file(root, settings).map(|f| maven::settings_profiles(&f)).unwrap_or_default() {
File diff suppressed because it is too large. Load diff
+37 -1
Переглянути файл
@@ -197,6 +197,7 @@ pub enum ImportsOnPaste {
#[serde(default, rename_all = "camelCase")]
pub struct FoldingSettings {
pub show_outline: bool,
pub outline_visibility: FoldingOutlineVisibility,
pub file_header: bool,
pub imports: bool,
pub doc_comments: bool,
@@ -204,10 +205,24 @@ pub struct FoldingSettings {
impl Default for FoldingSettings {
fn default() -> Self {
Self { show_outline: true, file_header: true, imports: true, doc_comments: false }
Self {
show_outline: true,
outline_visibility: FoldingOutlineVisibility::Hover,
file_header: true,
imports: true,
doc_comments: false,
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum FoldingOutlineVisibility {
#[default]
Hover,
Always,
}
/// Editor › General › Editor Tabs.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
@@ -543,3 +558,24 @@ mod auto_import_tests {
}
}
}
#[cfg(test)]
mod folding_tests {
use super::{FoldingOutlineVisibility, FoldingSettings};
#[test]
fn folding_outline_defaults_to_hover_for_existing_settings() {
let settings: FoldingSettings = serde_json::from_str(r#"{"showOutline":false}"#).unwrap();
assert!(!settings.show_outline);
assert_eq!(settings.outline_visibility, FoldingOutlineVisibility::Hover);
}
#[test]
fn folding_outline_visibility_round_trips() {
for mode in ["hover", "always"] {
let json = serde_json::json!({ "outlineVisibility": mode });
let settings: FoldingSettings = serde_json::from_value(json).unwrap();
assert_eq!(serde_json::to_value(settings).unwrap()["outlineVisibility"], mode);
}
}
}
+8
Переглянути файл
@@ -89,6 +89,14 @@ pub enum IdeEvent {
DocDirty {
doc: DocId,
dirty: bool,
/// Text version when this transition occurred, including when it was saved.
version: u32,
},
/// An open document's file changed on disk while the buffer had unsaved changes. The buffer
/// keeps them (autosave leaves the file alone); the UI offers to load the disk version.
DocDiskConflict {
doc: DocId,
path: String,
},
/// A complete workspace edit can be undone as one operation.
WorkspaceEditApplied {
+1
Переглянути файл
@@ -15,6 +15,7 @@ pub mod inspection_settings;
pub mod ipc_path;
pub mod java_runtime;
pub mod jsonc;
pub mod memory;
pub mod output_encoding;
pub mod platform;
pub mod process;
+20
Переглянути файл
@@ -0,0 +1,20 @@
//! Returning freed heap pages to the OS.
/// Hands pages the allocator has freed but kept back to the OS. Call after a burst of
/// short-lived allocations (a full index scan); until then they still count towards the
/// process's memory footprint.
pub fn release_free_pages() {
#[cfg(target_os = "macos")]
{
unsafe extern "C" {
fn malloc_zone_pressure_relief(zone: *mut std::ffi::c_void, goal: usize) -> usize;
}
// SAFETY: a null zone covers every zone; a zero goal releases as much as possible.
unsafe { malloc_zone_pressure_relief(std::ptr::null_mut(), 0) };
}
#[cfg(all(target_os = "linux", target_env = "gnu"))]
// SAFETY: malloc_trim only returns free memory to the OS.
unsafe {
libc::malloc_trim(0);
}
}
-13
Переглянути файл
@@ -100,16 +100,6 @@ pub struct AgentSettings {
pub smooth_text: bool,
/// Conversations and the composer expand to the full width of the pane instead of staying in a centred column.
pub fit_window_width: bool,
/// While the agent works, playful words fill the pauses in what it reports.
pub playful_status: bool,
/// Seconds the agent reports nothing new before the playful words take over; 0 shows them
/// from the start.
pub playful_after_seconds: u32,
/// The user's playful words by activity (`working`, `thinking`, `reading`, …), replacing
/// the built-in ones of that activity; an empty list keeps its status factual.
#[serde(deserialize_with = "or_default")]
#[specta(type = BTreeMap<String, Vec<String>>)]
pub playful_words: BTreeMap<String, Vec<String>>,
#[serde(deserialize_with = "or_default")]
#[specta(type = ThinkingDisplay)]
pub thinking: ThinkingDisplay,
@@ -152,9 +142,6 @@ impl Default for AgentSettings {
fold_turns: true,
smooth_text: true,
fit_window_width: false,
playful_status: false,
playful_after_seconds: 0,
playful_words: BTreeMap::new(),
thinking: ThinkingDisplay::Auto,
tool_calls: ToolCallDisplay::Grouped,
expand_tool_output: false,
+22
Переглянути файл
@@ -11,6 +11,8 @@ use std::collections::BTreeMap;
pub struct VcsSettings {
/// Colour folders that contain changed files (project tree, tabs).
pub show_dirty_directories: bool,
/// Diffs the user opens show in an editor tab; off, in a separate window.
pub diff_as_editor_tab: bool,
/// Stop file history (Show History) after `history_limit` commits.
pub limit_history: bool,
pub history_limit: u32,
@@ -55,6 +57,7 @@ impl Default for VcsSettings {
Self {
// IDEA's VcsConfiguration.SHOW_DIRTY_RECURSIVELY is off by default.
show_dirty_directories: false,
diff_as_editor_tab: true,
limit_history: true,
history_limit: 1000,
git: GitSettings::default(),
@@ -76,6 +79,8 @@ pub struct GitSettings {
/// label is plain text and a click on it places the caret as past the line end.
pub inline_blame_clickable: bool,
pub show_branch_in_project_view: bool,
/// Branch operations from the branches popup act on every repository of the project.
pub sync_branch_operations: bool,
/// Path to the git executable; empty = auto-detect.
pub executable: String,
/// Default of Update Project: `merge` | `rebase`.
@@ -117,6 +122,7 @@ impl Default for GitSettings {
inline_blame: false,
inline_blame_clickable: true,
show_branch_in_project_view: false,
sync_branch_operations: true,
executable: String::new(),
update_method: "merge".into(),
auto_update_on_push_rejected: false,
@@ -176,6 +182,8 @@ pub struct CommitSettings {
pub agent_model: String,
/// That model's thinking level for commit messages; empty keeps the agent's.
pub agent_effort: String,
/// Show the Generate Commit Message with Agent button above the commit message.
pub agent_button: bool,
}
impl Default for CommitSettings {
@@ -201,6 +209,7 @@ impl Default for CommitSettings {
agent: String::new(),
agent_model: String::new(),
agent_effort: String::new(),
agent_button: true,
}
}
}
@@ -606,3 +615,16 @@ impl Default for AgentSecuritySettings {
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn git_settings_without_sync_key_execute_on_all_repositories() {
let missing: GitSettings = serde_json::from_str("{}").unwrap();
assert!(missing.sync_branch_operations);
let off: GitSettings = serde_json::from_str(r#"{"syncBranchOperations":false}"#).unwrap();
assert!(!off.sync_branch_operations);
}
}
+148 -72
Переглянути файл
@@ -145,30 +145,38 @@ impl ClickhousePool {
let cancel = CancellationToken::new();
let initialize = async {
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
if !rejects_driver_setting(&error) {
let Some(setting) = rejected_driver_setting(&error) else {
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);
if setting == "readonly" {
return Err(error);
}
if !source.read_only {
return Err(IdeError::new(
error.kind,
format!(
"{}; enable Read-only for independent queries on a strict read-only server",
error.message
),
));
}
// Every request still sends readonly=1, regardless of which node answers.
pool.0.session.lock().await.strict_read_only = true;
pool.execute("SELECT 1", 1, &cancel).await?;
} else {
// Only rely on the server's write protection after proving strict read-only
// in this same named session.
{
let mut session = pool.0.session.lock().await;
// The rejected probe may have opened a session on a different node.
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
@@ -236,7 +244,7 @@ impl ClickhousePool {
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
request = request.query(&[("database", &self.0.database)]);
}
if self.0.read_only && !session.strict_read_only {
if self.0.read_only && (session.id.is_none() || !session.strict_read_only) {
request = request.query(&[("readonly", "1")]);
}
request
@@ -324,7 +332,7 @@ impl ClickhousePool {
result
}
None => {
let killed = self.kill(&client, &query_id).await;
let killed = self.kill(&client, &query_id, &session).await;
match killed {
Ok(()) => Err(IdeError::cancelled()),
Err(error) => Err(IdeError::new(
@@ -336,15 +344,16 @@ impl ClickhousePool {
}
}
async fn kill(&self, client: &Client, query_id: &str) -> IdeResult<()> {
let response = client
async fn kill(&self, client: &Client, query_id: &str, session: &Session) -> IdeResult<()> {
let mut request = client
.post(self.0.endpoint.clone())
.basic_auth(&self.0.user, Some(&self.0.password))
.timeout(Duration::from_secs(3))
.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC"))
.send()
.await
.map_err(http_error)?;
.timeout(Duration::from_secs(3));
if self.0.read_only && session.id.is_none() {
request = request.query(&[("readonly", "1")]);
}
let response =
request.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")).send().await.map_err(http_error)?;
let status = response.status();
let code = response
.headers()
@@ -551,13 +560,14 @@ 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 {
fn rejected_driver_setting(error: &IdeError) -> Option<&str> {
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, _)| {
.map(|(name, _)| name)
.filter(|&name| {
matches!(
name,
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
@@ -953,19 +963,77 @@ mod tests {
}
#[tokio::test]
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
for read_only in [false, true] {
let (port, requests) = server(vec![(
async fn strict_stateless_connections_keep_readonly_on_every_request() {
let denied = "Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)";
let (port, requests) = server(vec![
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", denied),
("200 OK", "", ONE),
(
"500 Internal Server Error",
"X-ClickHouse-Exception-Code: 164\r\n",
"Code: 164. DB::Exception: Cannot execute query in readonly mode. (READONLY)",
),
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[0]\n[1]\n[2]\n"),
])
.await;
let source = DataSource {
database: "fixture_database".into(),
read_only: true,
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
..source(port)
};
let pool = Pool::connect(&source, None, None).await.unwrap();
let cancel = CancellationToken::new();
let write = "CREATE TABLE fixture_table (n UInt8) ENGINE=Memory";
assert!(pool.execute(write, 1, &cancel).await.unwrap_err().message.contains("Code: 164"));
let sql = "SELECT number AS n FROM numbers(3) LIMIT 3";
let result = pool.execute(sql, 1, &cancel).await.unwrap();
assert_eq!(result.rows, vec![vec![Some("0".into())]]);
assert!(result.has_more);
let requests = requests.await.unwrap();
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[1].ends_with("SELECT 1"));
assert!(requests[2].ends_with(write));
assert!(requests[3].ends_with(sql));
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}");
}
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
assert_eq!(query_value(&url, "database").as_deref(), Some("fixture_database"));
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
assert_eq!(query_value(&url, "max_result_rows").as_deref(), (index == 0).then_some("2"));
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), (index == 0).then_some("break"));
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), (index == 0).then_some("1"));
}
}
#[tokio::test]
async fn stateless_connections_require_readonly_and_only_relax_driver_result_settings() {
for (read_only, detail, body) in [
(
false,
"enable Read-only",
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
)])
.await;
),
(
true,
"Cannot modify 'readonly'",
"Code: 164. DB::Exception: Cannot modify 'readonly' setting in readonly mode. (READONLY)",
),
(
true,
"Cannot modify 'max_threads'",
"Code: 164. DB::Exception: Cannot modify 'max_threads' setting in readonly mode. (READONLY)",
),
] {
let (port, requests) =
server(vec![("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", body)]).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"));
assert!(error.message.contains(detail), "{}", error.message);
let requests = requests.await.unwrap();
assert_eq!(requests.len(), 1);
assert!(requests[0].ends_with("SELECT 1"));
@@ -1041,7 +1109,7 @@ mod tests {
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}");
assert_eq!(rejected_driver_setting(&error).is_some(), expected, "{setting}");
}
}
@@ -1084,37 +1152,45 @@ mod tests {
#[tokio::test]
async fn cancellation_sends_kill_outside_the_busy_session() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (started, received) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let (mut health, _) = listener.accept().await.unwrap();
read_request(&mut health).await;
reply(&mut health, "200 OK", "", ONE).await;
drop(health);
let (mut query, _) = listener.accept().await.unwrap();
let request = read_request(&mut query).await;
started.send(()).unwrap();
let (mut kill, _) = tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
let kill_request = read_request(&mut kill).await;
reply(&mut kill, "200 OK", "", "").await;
(request, kill_request)
});
let pool = Pool::connect(&source(port), None, None).await.unwrap();
let cancel = CancellationToken::new();
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
let cancelled = async {
received.await.unwrap();
cancel.cancel();
};
let (result, ()) = tokio::join!(query, cancelled);
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
let (query, kill) = server.await.unwrap();
let target = query.lines().next().unwrap().split_whitespace().nth(1).unwrap();
let url = Url::parse(&format!("http://localhost{target}")).unwrap();
let query_id = url.query_pairs().find(|(k, _)| k == "query_id").unwrap().1.into_owned();
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
assert!(!kill.contains("session_id="));
for stateless in [false, true] {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (started, received) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let (mut health, _) = listener.accept().await.unwrap();
read_request(&mut health).await;
reply(&mut health, "200 OK", "", ONE).await;
drop(health);
let (mut query, _) = listener.accept().await.unwrap();
let request = read_request(&mut query).await;
started.send(()).unwrap();
let (mut kill, _) =
tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
let kill_request = read_request(&mut kill).await;
reply(&mut kill, "200 OK", "", "").await;
(request, kill_request)
});
let source = DataSource {
read_only: true,
properties: vec![property("use_http_session", if stateless { "false" } else { "true" })],
..source(port)
};
let pool = Pool::connect(&source, None, None).await.unwrap();
let cancel = CancellationToken::new();
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
let cancelled = async {
received.await.unwrap();
cancel.cancel();
};
let (result, ()) = tokio::join!(query, cancelled);
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
let (query, kill) = server.await.unwrap();
let query_id = query_value(&request_url(&query), "query_id").unwrap();
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
let url = request_url(&kill);
assert_eq!(query_value(&url, "session_id"), None);
assert_eq!(query_value(&url, "readonly").as_deref(), stateless.then_some("1"));
}
}
#[tokio::test]
+10 -1
Переглянути файл
@@ -217,7 +217,8 @@ impl ManageConnection for MssqlConnectionManager {
let row = client.simple_query("SELECT DB_NAME()").await?.into_row().await?;
let default = row
.and_then(|r| r.get::<&str, _>(0).map(str::to_owned))
.and_then(|db| crate::sql::use_schema(DbDriver::SqlServer, &db));
// Statements that `USE` another database must not move the pooled connection for good.
.map(|db| format!("USE {}", crate::sql::quote_ident(DbDriver::SqlServer, &db)));
Ok(MssqlConnection(Some(client), Context::new(default)))
}
@@ -748,6 +749,14 @@ impl Pool {
}
/// The keep-alive ping (Oracle needs a FROM clause).
/// Keep-alive: one cheap round trip on the session.
pub async fn ping(&self) -> IdeResult<()> {
match self {
Pool::Jdbc(p) => p.ping().await,
_ => self.rows(self.ping_sql(), 1).await.map(|_| ()),
}
}
pub fn ping_sql(&self) -> &'static str {
match self {
Pool::Oracle(_) => "SELECT 1 FROM DUAL",
+101 -3
Переглянути файл
@@ -5,6 +5,7 @@ use crate::{DataSource, DbManager, QueryResult, ResultColumn};
use ide_core::{CancellationToken, IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::HashMap;
use std::io::{Cursor, Read};
use std::path::{Path, PathBuf};
use std::process::Stdio;
@@ -302,7 +303,9 @@ async fn read_frame(output: &mut (impl AsyncRead + Unpin)) -> IdeResult<Vec<u8>>
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.")
IdeError::invalid(
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect.",
)
}
async fn exchange(
@@ -458,6 +461,44 @@ impl JdbcPool {
}
async fn request(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
let result = self.exchange_once(fields, sql, cancel).await;
if let Err(e) = &result
&& fields.first() != Some(&"open")
&& e.kind != ide_core::error::ErrorKind::Cancelled
&& !self.is_closed()
&& !self.session_valid().await
{
// The session is gone (a proxy or tunnel dropped the idle TCP connection): close the
// pool so the next statement or Connect starts a new one instead of failing forever.
self.close().await;
}
result
}
/// Keep-alive: checks the session (any SQL would be dialect-specific) and closes a dead one.
pub(crate) async fn ping(&self) -> IdeResult<()> {
if self.session_valid().await {
return Ok(());
}
self.close().await;
Err(IdeError::new(ide_core::error::ErrorKind::Io, "JDBC connection was lost"))
}
/// Whether the JDBC session still works, asked after a failed statement.
async fn session_valid(&self) -> bool {
if self.bridge.lock().await.is_none() {
return false;
}
let cancel = CancellationToken::new();
match tokio::time::timeout(Duration::from_secs(10), self.exchange_once(&["valid"], "", &cancel)).await {
Ok(Ok(result)) => {
result.rows.first().and_then(|row| row.first()).cloned().flatten().as_deref() != Some("false")
}
Ok(Err(_)) | Err(_) => false,
}
}
async fn exchange_once(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
let mut slot = tokio::select! {
biased;
() = cancel.cancelled() => return Err(IdeError::cancelled()),
@@ -562,14 +603,32 @@ fn decode(data: &[u8], sql: &str, elapsed_ms: f64) -> IdeResult<QueryResult> {
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?;
let mut column_count = 0;
// Read the schemas the source's Schemas tab picks, like the database tree does. It also
// keeps large instances usable: an Oracle server exposes dozens of system schemas, and
// dumping the columns of all of them takes minutes, during which the bridge (a single
// Java process that runs one command at a time) executes none of the user's statements.
let introspection = self.source(id)?.introspection;
let schemas: Vec<String> =
self.schemas(id).await?.into_iter().filter(|s| introspection.shows_schema(s)).collect();
for schema in &schemas {
// Columns of the whole namespace in one call; a driver that refuses it still completes tables.
let mut columns = if column_count < crate::MAX_META_ROWS {
pool.metadata(&["schemaColumns", schema]).await.map(schema_columns).unwrap_or_else(|e| {
tracing::warn!("JDBC columns of {schema}: {}", e.message);
HashMap::new()
})
} else {
HashMap::new()
};
for table in self.tables(id, schema).await? {
let columns = columns.remove(&table.name).unwrap_or_default();
column_count += columns.len();
tables.push(crate::CompletionTable {
schema: schema.clone(),
name: table.name,
kind: table.kind,
columns: vec![],
columns,
});
if tables.len() >= crate::MAX_META_ROWS {
break;
@@ -594,10 +653,49 @@ impl DbManager {
}
}
/// The bridge's `schemaColumns` rows (table, name, type, nullable, default) by table.
fn schema_columns(rows: Vec<Vec<Option<String>>>) -> HashMap<String, Vec<crate::CompletionColumn>> {
let mut by_table: HashMap<String, Vec<crate::CompletionColumn>> = HashMap::new();
for row in rows {
let mut it = row.into_iter();
let (Some(Some(table)), Some(Some(name))) = (it.next(), it.next()) else { continue };
let data_type = it.next().flatten().unwrap_or_default();
let nullable = it.next().flatten().as_deref() != Some("0");
let has_default = it.next().flatten().is_some();
by_table.entry(table).or_default().push(crate::CompletionColumn {
name,
data_type,
nullable,
primary_key: false,
has_default,
});
}
by_table
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn schema_columns_group_by_table() {
let row = |t: &str, n: &str, null: &str, def: Option<&str>| {
vec![Some(t.into()), Some(n.into()), Some("INT".into()), Some(null.into()), def.map(Into::into)]
};
let by_table = schema_columns(vec![
row("orders", "id", "0", None),
row("orders", "note", "1", Some("'none'")),
row("items", "sku", "1", None),
vec![None, Some("orphan".into())],
]);
let orders = &by_table["orders"];
assert_eq!(orders.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["id", "note"]);
assert_eq!((orders[0].nullable, orders[0].has_default), (false, false));
assert_eq!((orders[1].nullable, orders[1].has_default), (true, true));
assert_eq!(by_table["items"].len(), 1);
assert_eq!(by_table.len(), 2);
}
#[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']);
+12 -7
Переглянути файл
@@ -379,8 +379,8 @@ pub(crate) fn keep_alive(pool: &Arc<Pool>, every: Duration) {
loop {
tick.tick().await;
let Some(p) = pool.upgrade().filter(|p| !p.is_closed()) else { break };
if let Err(e) = p.rows(p.ping_sql(), 1).await {
tracing::debug!("keep-alive: {}", e.message);
if let Err(e) = p.ping().await {
tracing::info!("keep-alive: {}", e.message);
}
}
});
@@ -847,12 +847,12 @@ impl DbManager {
}
pub fn is_connected(&self, id: &str) -> bool {
self.pools.lock().contains_key(id)
self.pools.lock().get(id).is_some_and(|p| !p.is_closed())
}
/// Connected targets (data source ids, `<id>:<database>`).
pub fn connected(&self) -> Vec<String> {
self.pools.lock().keys().cloned().collect()
self.pools.lock().iter().filter(|(_, p)| !p.is_closed()).map(|(id, _)| id.clone()).collect()
}
/// The pool of target `id`, connecting first if needed.
@@ -862,8 +862,13 @@ impl DbManager {
if self.tunnels.lock().get(source_id).is_some_and(|t| t.is_closed()) {
self.disconnect_source(source_id).await;
}
if let Some(p) = self.pools.lock().get(id) {
return Ok(p.clone());
let cached = self.pools.lock().get(id).cloned();
if let Some(p) = cached {
if !p.is_closed() {
return Ok(p);
}
// The connection broke (a custom JDBC session whose TCP connection was dropped): reconnect.
self.disconnect(id).await;
}
let source = self.source(id)?;
let password = self.password(&source).await;
@@ -917,7 +922,7 @@ impl DbManager {
/// Disconnects every database of data source `id`.
pub async fn disconnect_source(&self, id: &str) {
let targets: Vec<String> = self.connected().into_iter().filter(|t| split_target(t).0 == id).collect();
let targets: Vec<String> = self.pools.lock().keys().filter(|t| split_target(t).0 == id).cloned().collect();
for t in targets {
self.disconnect(&t).await;
}
+59
Переглянути файл
@@ -124,6 +124,45 @@ impl Default for DbIntrospection {
}
}
impl DbIntrospection {
/// Whether the tree shows this schema: every one with `all_schemas`, otherwise it has to
/// match one of the `schemas` patterns. The completion model uses the same test, so it
/// offers exactly the tables the tree lists (and does not read the ones it never shows).
pub fn shows_schema(&self, name: &str) -> bool {
self.all_schemas
|| self.schemas.iter().map(|p| p.trim()).filter(|p| !p.is_empty()).any(|p| schema_matches(p, name))
}
}
/// `*` matches any run of characters, `?` a single one; a pattern without wildcards matches the
/// name as typed (the dialog fills names from the list the server returned, so case is settled).
fn schema_matches(pattern: &str, name: &str) -> bool {
if !pattern.contains('*') && !pattern.contains('?') {
return pattern == name;
}
let p: Vec<char> = pattern.chars().collect();
let n: Vec<char> = name.chars().collect();
let (mut pi, mut ni) = (0, 0);
// Position of the last `*` and how much of the name it has already swallowed.
let mut star: Option<(usize, usize)> = None;
while ni < n.len() {
if pi < p.len() && (p[pi] == '?' || p[pi] == n[ni]) {
pi += 1;
ni += 1;
} else if pi < p.len() && p[pi] == '*' {
star = Some((pi, ni));
pi += 1;
} else if let Some((at, taken)) = star {
pi = at + 1;
ni = taken + 1;
star = Some((at, taken + 1));
} else {
return false;
}
}
p[pi..].iter().all(|&c| c == '*')
}
/// Advanced tab: a driver property. PostgreSQL: run-time parameters (and
/// `application_name`); MySQL: session variables (and `charset`, `collation`);
/// SQLite: pragmas. See [`crate::conn`].
@@ -765,4 +804,24 @@ mod tests {
assert_eq!(r.snowflake().auth, DbSnowflakeAuth::Browser);
assert_eq!(scheme_driver("snowflake"), Some(DbDriver::Snowflake));
}
#[test]
fn introspection_shows_only_the_picked_schemas() {
let mut i = DbIntrospection::default();
assert!(i.shows_schema("SYS"), "the default reads every schema");
i.all_schemas = false;
assert!(!i.shows_schema("SYS"), "nothing picked: the tree lists nothing either");
i.schemas = vec!["XMCB".into(), " APP_* ".into()];
assert!(i.shows_schema("XMCB"));
assert!(i.shows_schema("APP_INFO"));
assert!(!i.shows_schema("APP"), "`*` needs the text that follows it");
assert!(!i.shows_schema("SYS"));
assert!(!i.shows_schema("xmcb"), "patterns match the names the server returned");
i.schemas = vec!["?".into()];
assert!(i.shows_schema("A"));
assert!(!i.shows_schema("AB"));
}
}
+8 -6
Переглянути файл
@@ -442,7 +442,8 @@ pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
DbDriver::Sqlite | DbDriver::Jdbc => None,
DbDriver::Postgres => Some("SELECT current_schema()"),
DbDriver::Mysql => Some("SELECT DATABASE()"),
DbDriver::SqlServer => Some("SELECT DB_NAME()"),
// The login's default schema; the database is the console's target (IDEA's `database.schema`).
DbDriver::SqlServer => Some("SELECT SCHEMA_NAME()"),
DbDriver::Oracle => Some("SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') FROM DUAL"),
DbDriver::Snowflake => Some("SELECT CURRENT_SCHEMA()"),
}
@@ -450,12 +451,13 @@ pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
/// The statement that makes unqualified names resolve in `schema` on the
/// connection that runs it (a query console's active schema; `None`: the driver
/// has no schema to switch — SQLite's `main`, ClickHouse's `USE` differs).
/// has no schema to switch — SQLite's `main`, ClickHouse's `USE` differs, and SQL Server
/// cannot change a session's default schema, so its console schema only scopes resolution).
pub fn use_schema(driver: DbDriver, schema: &str) -> Option<String> {
match driver {
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc => None,
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc | DbDriver::SqlServer => 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::Mysql => Some(format!("USE {}", quote_ident(driver, schema))),
DbDriver::Oracle => Some(format!("ALTER SESSION SET CURRENT_SCHEMA = {}", quote_ident(driver, schema))),
DbDriver::Snowflake => Some(format!("USE SCHEMA {}", quote_ident(driver, schema))),
}
@@ -1030,7 +1032,7 @@ mod tests {
assert_eq!(quote_ident(DbDriver::SqlServer, "a]b"), "[a]]b]");
assert_eq!(qualified(DbDriver::SqlServer, "dbo", "t"), "[dbo].[t]");
assert_eq!(qualified(DbDriver::SqlServer, "", "t"), "[t]");
assert_eq!(current_schema(DbDriver::SqlServer), Some("SELECT DB_NAME()"));
assert_eq!(current_schema(DbDriver::SqlServer), Some("SELECT SCHEMA_NAME()"));
assert_eq!(crate::conn::begin_statement(DbDriver::SqlServer), "BEGIN TRAN");
assert_eq!(
schemas(DbDriver::SqlServer, true),
@@ -1149,7 +1151,7 @@ mod tests {
fn schema_switch_statement_per_dialect() {
assert_eq!(use_schema(DbDriver::Postgres, "app data"), Some("SET search_path TO \"app data\"".into()));
assert_eq!(use_schema(DbDriver::Mysql, "a`b"), Some("USE `a``b`".into()));
assert_eq!(use_schema(DbDriver::SqlServer, "app] data"), Some("USE [app]] data]".into()));
assert_eq!(use_schema(DbDriver::SqlServer, "dbo"), None);
assert_eq!(use_schema(DbDriver::Postgres, "a\"b"), Some("SET search_path TO \"a\"\"b\"".into()));
assert_eq!(use_schema(DbDriver::Oracle, "a\"b"), Some("ALTER SESSION SET CURRENT_SCHEMA = \"a\"\"b\"".into()));
assert!(sqlserver_databases().contains("state = 0 AND HAS_DBACCESS(name) = 1"));
+43 -3
Переглянути файл
@@ -90,7 +90,10 @@ async fn duckdb_custom_driver_through_database_manager() -> IdeResult<()> {
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");
let completion = db.completion("test").await?;
assert_eq!(completion.default_schema, "main");
let items = completion.tables.iter().find(|t| t.schema == "main" && t.name == "items").expect("items");
assert_eq!(items.columns.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["id", "label"]);
db.execute("test", "create temporary table session_marker as select 42 as id", 1, &c).await?;
let stop = CancellationToken::new();
let (cancelled, ()) =
@@ -207,9 +210,46 @@ async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
})
.await
.expect("driver cancellation must be bounded");
assert!(result.unwrap_err().message.contains("Reconnect"));
assert_eq!(
result.unwrap_err().message,
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect."
);
assert!(db.connected().is_empty());
assert_eq!(db.execute("test", "after cancellation", 1, &normal).await?.affected, Some(1.0));
assert_eq!(db.connected(), ["test"]);
db.disconnect("test").await;
assert_eq!(db.execute("test", "after reconnect", 1, &normal).await?.affected, Some(1.0));
Ok(())
}
#[tokio::test]
#[ignore = "requires JDBC_FIXTURE_JAR (java/jdbc-bridge/build.py --test --out fixture.jar) and Java 17+"]
async fn a_lost_session_reconnects_on_the_next_statement() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let db = manager(tmp.path());
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,
jdbc_driver: "fixture".into(),
url: "jdbc:fixture:".into(),
..Default::default()
};
db.save_sources(vec![source]).await?;
let cancel = CancellationToken::new();
db.execute("test", "first", 1, &cancel).await?;
// The fixture's session reports itself invalid after "drop", like a connection a proxy reset.
assert!(db.execute("test", "drop", 1, &cancel).await.unwrap_err().message.contains("connection reset"));
assert!(!db.is_connected("test"), "a lost session is no longer listed as connected");
assert_eq!(db.execute("test", "after reconnect", 1, &cancel).await?.affected, Some(1.0));
assert!(db.is_connected("test"));
db.disconnect("test").await;
Ok(())
}
+382 -9
Переглянути файл
@@ -7,9 +7,10 @@
use crate::{
COMPOSE_DIR, COMPOSE_FILES, COMPOSE_PROJECT, COMPOSE_SERVICE, ContainerOp, DockerAvailability, DockerContainer,
DockerEndpoint, DockerImage, DockerNetwork, DockerObject, DockerSnapshot, DockerVolume, split_csv,
DockerEndpoint, DockerImage, DockerImageLayer, DockerLogLine, DockerNetwork, DockerObject, DockerProcessList,
DockerSnapshot, DockerVolume, split_csv,
};
use ide_core::{IdeError, IdeResult};
use ide_core::{CancellationToken, IdeError, IdeResult};
use serde::Deserialize;
use std::collections::BTreeMap;
use std::io::{Read, Write};
@@ -193,9 +194,15 @@ fn request(addr: &Address, method: &str, path: &str, timeout: Duration) -> IdeRe
read_response(&mut conn)
}
/// Reads an HTTP/1.1 response: head until `\r\n\r\n`, then the body per its
/// framing (chunked, `Content-Length`, or until the connection closes).
fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
/// A response's status line and body framing.
struct Head {
status: u16,
chunked: bool,
length: Option<usize>,
}
/// Reads an HTTP/1.1 response head until `\r\n\r\n`.
fn read_head(stream: &mut impl Read) -> IdeResult<Head> {
let mut head: Vec<u8> = Vec::new();
let mut byte = [0u8; 1];
loop {
@@ -228,16 +235,27 @@ fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
length = value.parse().ok();
}
}
let body = if chunked {
Ok(Head { status, chunked, length })
}
/// Reads an HTTP/1.1 response: its head, then the body per its framing
/// (chunked, `Content-Length`, or until the connection closes).
fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
let head = read_head(stream)?;
let body = read_body(stream, &head)?;
Ok(Response { status: head.status, body })
}
fn read_body(stream: &mut impl Read, head: &Head) -> IdeResult<Vec<u8>> {
Ok(if head.chunked {
read_chunked(stream)?
} else if let Some(n) = length {
} else if let Some(n) = head.length {
read_exact_n(stream, n)?
} else {
let mut body = Vec::new();
stream.read_to_end(&mut body)?;
body
};
Ok(Response { status, body })
})
}
/// Reads one `\n`-terminated line (returned without it).
@@ -482,6 +500,292 @@ pub(crate) fn inspect(
})())
}
/// The processes running in a container (`docker top`).
pub(crate) fn container_top(ep: &DockerEndpoint, id: &str, timeout: Duration) -> Option<IdeResult<DockerProcessList>> {
let addr = address(ep)?;
Some((|| {
let body = check(request(&addr, "GET", &format!("/containers/{}/top", path_segment(id)), timeout)?)?;
serde_json::from_str::<ApiTop>(&body)
.map(|t| DockerProcessList { titles: t.titles, processes: t.processes })
.map_err(|e| IdeError::internal(format!("the Docker daemon's process list is not JSON: {e}")))
})())
}
#[derive(Deserialize, Default)]
#[serde(rename_all = "PascalCase", default)]
struct ApiTop {
titles: Vec<String>,
processes: Vec<Vec<String>>,
}
/// An image's layers, newest first (`docker image history`).
pub(crate) fn image_history(
ep: &DockerEndpoint,
id: &str,
timeout: Duration,
) -> Option<IdeResult<Vec<DockerImageLayer>>> {
let addr = address(ep)?;
Some((|| {
let body = check(request(&addr, "GET", &format!("/images/{}/history", path_segment(id)), timeout)?)?;
let layers = serde_json::from_str::<Vec<ApiLayer>>(&body)
.map_err(|e| IdeError::internal(format!("the Docker daemon's image history is not JSON: {e}")))?;
Ok(map_layers(layers, unix_now()))
})())
}
#[derive(Deserialize, Default)]
#[serde(rename_all = "PascalCase", default)]
struct ApiLayer {
id: String,
created: i64,
created_by: String,
size: i64,
comment: String,
}
fn map_layers(layers: Vec<ApiLayer>, now: i64) -> Vec<DockerImageLayer> {
layers
.into_iter()
.map(|l| DockerImageLayer {
id: l.id,
created_by: l.created_by,
size: human_size(l.size),
created_since: human_duration((now - l.created).max(0)),
created_at: unix_utc(l.created),
comment: l.comment,
})
.collect()
}
fn unix_now() -> i64 {
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs() as i64).unwrap_or(0)
}
/// How often a log stream that has nothing to read checks for cancellation.
const LOG_POLL: Duration = Duration::from_millis(200);
#[derive(Deserialize, Default)]
#[serde(rename_all = "PascalCase", default)]
struct ApiContainerInspect {
config: ApiContainerConfig,
}
#[derive(Deserialize, Default)]
#[serde(rename_all = "PascalCase", default)]
struct ApiContainerConfig {
tty: bool,
}
/// Streams a container's logs (`tail` last lines, then follows while `follow`)
/// from `ep`'s daemon until they end or `cancel` fires.
#[allow(clippy::too_many_arguments)]
pub(crate) fn logs(
ep: &DockerEndpoint,
id: &str,
tail: u32,
follow: bool,
timestamps: bool,
timeout: Duration,
cancel: &CancellationToken,
on_line: &dyn Fn(DockerLogLine),
) -> Option<IdeResult<()>> {
let addr = address(ep)?;
Some((|| {
// A TTY container's log is one raw stream; otherwise it is framed per stream.
let body = check(request(&addr, "GET", &format!("/containers/{}/json", path_segment(id)), timeout)?)?;
let tty = serde_json::from_str::<ApiContainerInspect>(&body).map(|c| c.config.tty).unwrap_or(false);
let path = format!(
"/containers/{}/logs?stdout=1&stderr=1&tail={tail}&follow={}&timestamps={}",
path_segment(id),
u8::from(follow),
u8::from(timestamps),
);
let mut conn = Conn::connect(&addr, timeout)?;
conn.write_all(
format!("GET {path} HTTP/1.1\r\nHost: docker\r\nUser-Agent: openidea\r\nConnection: close\r\n\r\n")
.as_bytes(),
)?;
let head = read_head(&mut conn)?;
if !(200..300).contains(&head.status) {
let body = read_body(&mut conn, &head)?;
check(Response { status: head.status, body })?;
}
conn.set_timeouts(LOG_POLL);
let mut decoder = LogDecoder::new(&head, tty);
let mut buf = [0u8; 8192];
while !decoder.done() {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
match conn.read(&mut buf) {
Ok(0) => break,
Ok(n) => decoder.feed(&buf[..n], &mut |line| on_line(line))?,
Err(e)
if matches!(
e.kind(),
std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut | std::io::ErrorKind::Interrupted
) => {}
Err(e) => return Err(e.into()),
}
}
decoder.finish(&mut |line| on_line(line));
Ok(())
})())
}
/// Turns a log response body, as it arrives, into lines: undoes the chunked
/// transfer encoding, then the per-stream frames (8-byte header: stream, 3 zero
/// bytes, big-endian length) unless the container has a TTY.
struct LogDecoder {
body: BodyFraming,
tty: bool,
header: Vec<u8>,
frame_left: usize,
frame_stderr: bool,
/// Partial lines of stdout and stderr.
partial: [Vec<u8>; 2],
}
enum BodyFraming {
Chunked { state: ChunkState, line: Vec<u8> },
Length(usize),
Close,
}
#[derive(Clone, Copy, PartialEq)]
enum ChunkState {
Size,
Data(usize),
DataEnd,
Trailer,
Done,
}
impl LogDecoder {
fn new(head: &Head, tty: bool) -> Self {
let body = if head.chunked {
BodyFraming::Chunked { state: ChunkState::Size, line: Vec::new() }
} else if let Some(n) = head.length {
BodyFraming::Length(n)
} else {
BodyFraming::Close
};
Self { body, tty, header: Vec::new(), frame_left: 0, frame_stderr: false, partial: [Vec::new(), Vec::new()] }
}
fn done(&self) -> bool {
matches!(self.body, BodyFraming::Chunked { state: ChunkState::Done, .. } | BodyFraming::Length(0))
}
fn feed(&mut self, mut bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) -> IdeResult<()> {
let mut payload = Vec::new();
match &mut self.body {
BodyFraming::Close => payload.extend_from_slice(bytes),
BodyFraming::Length(left) => {
let take = (*left).min(bytes.len());
payload.extend_from_slice(&bytes[..take]);
*left -= take;
}
BodyFraming::Chunked { state, line } => {
while !bytes.is_empty() {
match *state {
ChunkState::Done => break,
ChunkState::Data(n) => {
let take = n.min(bytes.len());
payload.extend_from_slice(&bytes[..take]);
bytes = &bytes[take..];
*state = if take == n { ChunkState::DataEnd } else { ChunkState::Data(n - take) };
}
_ => {
let b = bytes[0];
bytes = &bytes[1..];
if b != b'\n' {
if b != b'\r' {
line.push(b);
}
continue;
}
let text = String::from_utf8_lossy(line).into_owned();
line.clear();
*state = match *state {
ChunkState::Size => {
let size = text.split(';').next().unwrap_or_default().trim();
match usize::from_str_radix(size, 16) {
Ok(0) => ChunkState::Trailer,
Ok(n) => ChunkState::Data(n),
Err(_) => {
return Err(IdeError::internal(
"the Docker daemon answered with a malformed chunked response",
));
}
}
}
ChunkState::DataEnd => ChunkState::Size,
_ if text.is_empty() => ChunkState::Done,
other => other,
};
}
}
}
}
}
self.frames(&payload, emit);
Ok(())
}
fn frames(&mut self, mut bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) {
if self.tty {
self.lines(false, bytes, emit);
return;
}
while !bytes.is_empty() {
if self.frame_left == 0 {
let take = (8 - self.header.len()).min(bytes.len());
self.header.extend_from_slice(&bytes[..take]);
bytes = &bytes[take..];
if self.header.len() == 8 {
self.frame_stderr = self.header[0] == 2;
self.frame_left =
u32::from_be_bytes([self.header[4], self.header[5], self.header[6], self.header[7]]) as usize;
self.header.clear();
}
continue;
}
let take = self.frame_left.min(bytes.len());
self.lines(self.frame_stderr, &bytes[..take], emit);
self.frame_left -= take;
bytes = &bytes[take..];
}
}
fn lines(&mut self, stderr: bool, bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) {
let partial = &mut self.partial[usize::from(stderr)];
for &b in bytes {
if b == b'\n' {
emit(DockerLogLine { stderr, text: line_text(partial) });
partial.clear();
} else {
partial.push(b);
}
}
}
/// Emits the last lines that ended without a newline.
fn finish(&mut self, emit: &mut dyn FnMut(DockerLogLine)) {
for stderr in [false, true] {
let partial = &mut self.partial[usize::from(stderr)];
if !partial.is_empty() {
emit(DockerLogLine { stderr, text: line_text(partial) });
partial.clear();
}
}
}
}
fn line_text(bytes: &[u8]) -> String {
String::from_utf8_lossy(bytes.strip_suffix(b"\r").unwrap_or(bytes)).into_owned()
}
/// One URL path segment, percent-encoded so an id cannot change the path.
fn path_segment(id: &str) -> String {
let mut out = String::with_capacity(id.len());
@@ -817,6 +1121,75 @@ mod tests {
assert!(read_response(&mut &garbage[..]).is_err());
}
/// Feeds `body` one byte at a time, as a slow connection delivers it.
fn decode(head: Head, tty: bool, body: &[u8]) -> (Vec<(bool, String)>, bool) {
let mut lines = Vec::new();
let mut decoder = LogDecoder::new(&head, tty);
for b in body {
decoder.feed(std::slice::from_ref(b), &mut |l| lines.push((l.stderr, l.text))).unwrap();
}
let done = decoder.done();
decoder.finish(&mut |l| lines.push((l.stderr, l.text)));
(lines, done)
}
fn frame(stream: u8, text: &str) -> Vec<u8> {
let mut f = vec![stream, 0, 0, 0];
f.extend((text.len() as u32).to_be_bytes());
f.extend(text.as_bytes());
f
}
#[test]
fn engine_image_history_reads_like_the_cli() {
let layers: Vec<ApiLayer> = serde_json::from_str(
r#"[{"Id":"sha256:abc","Created":1000,"CreatedBy":"CMD [\"python3\"]","Size":20500,"Comment":"buildkit","Tags":["py:3"]},
{"Id":"<missing>","Created":940,"CreatedBy":"RUN x","Size":0,"Comment":""}]"#,
)
.unwrap();
let rows = map_layers(layers, 1000 + 2 * 7 * 86_400);
assert_eq!(
rows.iter().map(|l| (l.id.as_str(), l.size.as_str(), l.created_since.as_str())).collect::<Vec<_>>(),
[("sha256:abc", "20.5kB", "2 weeks ago"), ("<missing>", "0B", "2 weeks ago")]
);
assert_eq!(rows[0].created_by, "CMD [\"python3\"]");
let top: ApiTop = serde_json::from_str(r#"{"Titles":["PID","CMD"],"Processes":[["1","sh"]]}"#).unwrap();
assert_eq!(
(top.titles, top.processes),
(vec!["PID".to_owned(), "CMD".to_owned()], vec![vec!["1".to_owned(), "sh".to_owned()]])
);
}
#[test]
fn container_logs_split_into_stream_lines_across_chunks_and_frames() {
// Frames split mid-line, a CRLF line, and a stderr line between stdout parts.
let mut framed = frame(1, "tick 1\r\ntick");
framed.extend(frame(2, "oops\n"));
framed.extend(frame(1, " 2\nlast"));
let mut chunked = Vec::new();
for part in framed.chunks(7) {
chunked.extend(format!("{:x}\r\n", part.len()).as_bytes());
chunked.extend(part);
chunked.extend(b"\r\n");
}
chunked.extend(b"0\r\n\r\n");
let (lines, done) = decode(Head { status: 200, chunked: true, length: None }, false, &chunked);
assert!(done);
let expected = [(false, "tick 1"), (true, "oops"), (false, "tick 2"), (false, "last")];
assert_eq!(lines, expected.map(|(e, t)| (e, t.to_owned())));
// A TTY container's log is one raw stream; the body may end with the connection.
let (lines, done) = decode(Head { status: 200, chunked: false, length: None }, true, b"a\r\nb\n");
assert!(!done);
assert_eq!(lines, [(false, "a".to_owned()), (false, "b".to_owned())]);
// A Content-Length body ends after its length.
let body = frame(1, "one\n");
let (lines, done) = decode(Head { status: 200, chunked: false, length: Some(body.len()) }, false, &body);
assert!(done);
assert_eq!(lines, [(false, "one".to_owned())]);
}
#[test]
fn daemon_errors_carry_their_message() {
let resp = Response { status: 404, body: br#"{"message":"No such container: missing"}"#.to_vec() };
+15
Переглянути файл
@@ -287,6 +287,11 @@ fn check_id(id: &str) -> IdeResult<&str> {
/// `docker image history --no-trunc --format '{{json .}}'` of one image.
pub fn image_history(ep: &DockerEndpoint, id: &str) -> IdeResult<Vec<DockerImageLayer>> {
let id = check_id(id)?;
if docker_executable().is_none()
&& let Some(layers) = engine::image_history(ep, id, QUICK)
{
return layers;
}
let out = run(ep, &["image", "history", "--no-trunc", "--format", "{{json .}}", id], QUICK)?;
Ok(parse_image_history(&out))
}
@@ -294,6 +299,11 @@ pub fn image_history(ep: &DockerEndpoint, id: &str) -> IdeResult<Vec<DockerImage
/// `docker top <id>` of a running container.
pub fn container_top(ep: &DockerEndpoint, id: &str) -> IdeResult<DockerProcessList> {
let id = check_id(id)?;
if docker_executable().is_none()
&& let Some(processes) = engine::container_top(ep, id, QUICK)
{
return processes;
}
let out = run(ep, &["top", id], QUICK)?;
Ok(parse_container_top(&out))
}
@@ -316,6 +326,11 @@ pub fn logs(
cancel: &CancellationToken,
on_line: &dyn Fn(DockerLogLine),
) -> IdeResult<()> {
if docker_executable().is_none()
&& let Some(streamed) = engine::logs(ep, id, tail, follow, timestamps, QUICK, cancel, on_line)
{
return streamed;
}
let tail = tail.to_string();
let mut args = vec!["logs", "--tail", &tail];
if follow {
+54
Переглянути файл
@@ -0,0 +1,54 @@
[package]
name = "ide-drag-out"
description = "OS file drags out of an app window, so file managers and transfer clients copy the files: GTK on Linux, OLE on Windows, AppKit on macOS"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
[target.'cfg(target_os = "linux")'.dependencies]
gtk = "0.18"
[target.'cfg(any(windows, target_os = "macos"))'.dependencies]
raw-window-handle = "0.6"
[target.'cfg(windows)'.dependencies]
windows = { version = "0.62", features = [
"Win32_Foundation",
"Win32_Graphics_Gdi",
"Win32_System_Com",
"Win32_System_Com_StructuredStorage",
"Win32_System_Memory",
"Win32_System_Ole",
"Win32_System_SystemServices",
"Win32_UI_Shell",
"Win32_UI_Shell_Common",
] }
# `#[implement]` expands to paths into `windows_core`.
windows-core = "0.62"
[target.'cfg(target_os = "macos")'.dependencies]
objc2 = { version = "0.6", default-features = false, features = ["std"] }
objc2-foundation = { version = "0.3", default-features = false, features = ["std", "NSArray", "NSGeometry", "NSObject", "NSString", "NSURL"] }
objc2-app-kit = { version = "0.3", default-features = false, features = [
"std",
"objc2-core-foundation",
"NSApplication",
"NSDragging",
"NSDraggingItem",
"NSDraggingSession",
"NSEvent",
"NSGraphics",
"NSGraphicsContext",
"NSImage",
"NSPasteboard",
"NSPasteboardItem",
"NSResponder",
"NSView",
"NSWindow",
"NSWorkspace",
] }
[dev-dependencies]
tempfile.workspace = true
+122
Переглянути файл
@@ -0,0 +1,122 @@
//! macOS: an AppKit dragging session with one pasteboard item per path, each a file URL.
use super::Outcome;
use objc2::rc::Retained;
use objc2::runtime::ProtocolObject;
use objc2::{AnyThread, DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
use objc2_app_kit::{
NSApplication, NSDragOperation, NSDraggingContext, NSDraggingItem, NSDraggingSession, NSDraggingSource, NSEvent,
NSEventModifierFlags, NSEventType, NSPasteboardItem, NSPasteboardTypeFileURL, NSView, NSWorkspace,
};
use objc2_foundation::{NSArray, NSObject, NSObjectProtocol, NSPoint, NSRect, NSSize, NSString, NSURL};
use raw_window_handle::{HasWindowHandle, RawWindowHandle};
use std::cell::Cell;
use std::io;
use std::path::PathBuf;
/// The size of each file's icon under the pointer, in points.
const ICON_SIZE: f64 = 32.0;
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`, each shown with its
/// Finder icon; `done` runs on the main thread when the drag ends.
pub fn start<W: HasWindowHandle>(
window: &W,
paths: Vec<PathBuf>,
done: impl FnOnce(Outcome) + 'static,
) -> io::Result<()> {
let mtm = MainThreadMarker::new().ok_or_else(|| io::Error::other("a drag starts on the main thread"))?;
let RawWindowHandle::AppKit(handle) =
window.window_handle().map_err(|error| io::Error::other(error.to_string()))?.as_raw()
else {
return Err(io::Error::other("not an AppKit window"));
};
// SAFETY: the handle names this window's view, alive while `window` is borrowed.
let view = unsafe { handle.ns_view.cast::<NSView>().as_ref() };
let window = view.window().ok_or_else(|| io::Error::other("the view has no window"))?;
let content = window.contentView().ok_or_else(|| io::Error::other("the window has no content view"))?;
// In window coordinates, which are the content view's.
let pointer = window.mouseLocationOutsideOfEventStream();
let frame = NSRect::new(
NSPoint::new(pointer.x - ICON_SIZE / 2.0, pointer.y - ICON_SIZE / 2.0),
NSSize::new(ICON_SIZE, ICON_SIZE),
);
let workspace = NSWorkspace::sharedWorkspace();
let mut items = Vec::with_capacity(paths.len());
for path in &paths {
let path = NSString::from_str(&path.to_string_lossy());
let url = NSURL::fileURLWithPath(&path)
.absoluteString()
.ok_or_else(|| io::Error::other(format!("not a file URL: {path}")))?;
let item = NSPasteboardItem::new();
if !item.setString_forType(&url, unsafe { NSPasteboardTypeFileURL }) {
return Err(io::Error::other(format!("cannot put {path} on the pasteboard")));
}
let drag_item =
NSDraggingItem::initWithPasteboardWriter(NSDraggingItem::alloc(), ProtocolObject::from_ref(&*item));
let icon = workspace.iconForFile(&path);
unsafe { drag_item.setDraggingFrame_contents(frame, Some(&icon)) };
items.push(drag_item);
}
// The session starts from a drag event at the pointer: the web view's own mouse events
// went to WebKit, and the current event may be a later one.
let timestamp = NSApplication::sharedApplication(mtm).currentEvent().map_or(0.0, |event| event.timestamp());
let event = NSEvent::mouseEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_clickCount_pressure(
NSEventType::LeftMouseDragged,
pointer,
NSEventModifierFlags::empty(),
timestamp,
window.windowNumber(),
None,
0,
1,
1.0,
)
.ok_or_else(|| io::Error::other("cannot make the drag event"))?;
let source = DragSource::new(Box::new(done), mtm);
content.beginDraggingSessionWithItems_event_source(
&NSArray::from_retained_slice(&items),
&event,
ProtocolObject::from_ref(&*source),
);
Ok(())
}
type Done = Box<dyn FnOnce(Outcome)>;
struct Ivars {
done: Cell<Option<Done>>,
}
define_class!(
#[unsafe(super(NSObject))]
#[thread_kind = MainThreadOnly]
#[name = "OpenIdeaDragOutSource"]
#[ivars = Ivars]
struct DragSource;
unsafe impl NSObjectProtocol for DragSource {}
unsafe impl NSDraggingSource for DragSource {
#[unsafe(method(draggingSession:sourceOperationMaskForDraggingContext:))]
fn operation_mask(&self, session: &NSDraggingSession, _context: NSDraggingContext) -> NSDragOperation {
session.setAnimatesToStartingPositionsOnCancelOrFail(true);
NSDragOperation::Copy
}
#[unsafe(method(draggingSession:endedAtPoint:operation:))]
fn ended(&self, _session: &NSDraggingSession, _point: NSPoint, operation: NSDragOperation) {
if let Some(done) = self.ivars().done.take() {
done(if operation == NSDragOperation::None { Outcome::Cancelled } else { Outcome::Dropped });
}
}
}
);
impl DragSource {
fn new(done: Done, mtm: MainThreadMarker) -> Retained<Self> {
let this = Self::alloc(mtm).set_ivars(Ivars { done: Cell::new(Some(done)) });
unsafe { msg_send![super(this), init] }
}
}
+190
Переглянути файл
@@ -0,0 +1,190 @@
//! OS file drags out of an app window: the app the files are dropped on (Explorer,
//! Finder, a file manager, an SFTP client such as Xftp) copies them, as when they are
//! dragged from IDEA's Project view (#2867).
//!
//! Linux starts a GTK drag offering `text/uri-list`, Windows an OLE `DoDragDrop` of a
//! `CF_HDROP` data object, macOS an AppKit dragging session of file URLs. A drag is
//! always a copy, never a move, so no target can take project files away.
//!
//! [`start`] runs on the UI thread while the primary button is still held. It returns
//! once the drag has begun (Linux, macOS) or ended (Windows); `done` gets the outcome
//! when it ends, or is dropped without being called when the backend lost track of it.
use std::io;
use std::path::PathBuf;
/// How a drag ended.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Outcome {
/// A target accepted the drop.
Dropped,
/// Released where nothing accepted it, or cancelled with Escape.
Cancelled,
}
/// The paths a drag may carry: at least one, each an absolute path to a file or folder
/// on this machine. A remote project's paths name files on its server and fail here.
/// Windows also refuses paths of `MAX_PATH` or more: Explorer can't copy from them.
/// Network shares (`\\server\share\…`) are local paths here and drag like any other.
pub fn local_paths<S: Into<PathBuf>>(paths: impl IntoIterator<Item = S>) -> io::Result<Vec<PathBuf>> {
let paths: Vec<PathBuf> = paths.into_iter().map(Into::into).collect();
if paths.is_empty() {
return Err(io::Error::new(io::ErrorKind::InvalidInput, "no files to drag"));
}
for path in &paths {
if !path.is_absolute() || std::fs::symlink_metadata(path).is_err() {
return Err(io::Error::new(io::ErrorKind::NotFound, format!("not a local file: {}", path.display())));
}
if cfg!(windows) && !fits_max_path(path) {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
format!("path too long to drag: {}", path.display()),
));
}
}
Ok(paths)
}
/// Whether `path` is shorter than Windows' `MAX_PATH` (260 UTF-16 units with the NUL).
fn fits_max_path(path: &std::path::Path) -> bool {
path.as_os_str().to_string_lossy().encode_utf16().count() < 260
}
#[cfg(target_os = "linux")]
pub use gtk_impl::start;
#[cfg(target_os = "linux")]
mod gtk_impl {
use super::Outcome;
use gtk::glib::{self, SignalHandlerId};
use gtk::prelude::*;
use gtk::{TargetList, gdk};
use std::cell::{Cell, RefCell};
use std::io;
use std::path::PathBuf;
use std::rc::Rc;
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`; `done` runs on
/// the UI thread when the drag ends.
pub fn start(
window: &gtk::ApplicationWindow,
paths: Vec<PathBuf>,
done: impl FnOnce(Outcome) + 'static,
) -> io::Result<()> {
// `file://` URIs with every reserved or non-ASCII byte escaped.
let uris = paths
.iter()
.map(|path| glib::filename_to_uri(path, None).map(|uri| uri.to_string()))
.collect::<Result<Vec<_>, _>>()
.map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error.to_string()))?;
let targets = TargetList::new(&[]);
targets.add_uri_targets(0);
// The button that started the drag (1), not its mask: GTK ends the drag on that
// button's release.
let context = window
.drag_begin_with_coordinates(&targets, gdk::DragAction::COPY, 1, None, -1, -1)
.ok_or_else(|| io::Error::other("the window system refused to start a drag"))?;
let outcome = Rc::new(Cell::new(Outcome::Cancelled));
context.connect_drop_performed({
let outcome = outcome.clone();
move |_, _| outcome.set(Outcome::Dropped)
});
let handlers: Rc<RefCell<Vec<SignalHandlerId>>> = Rc::default();
let data = window.connect_drag_data_get({
let context = context.clone();
move |_, ctx, selection, _, _| {
if *ctx == context {
let uris: Vec<&str> = uris.iter().map(String::as_str).collect();
selection.set_uris(&uris);
}
}
});
// The target asks for the data after the drop (XDND is asynchronous), so the data
// handler stays connected until `drag-end`, which GTK emits last.
let done = Cell::new(Some(done));
let end = window.connect_drag_end({
let handlers = handlers.clone();
move |window, ctx| {
if *ctx != context {
return;
}
for handler in handlers.borrow_mut().drain(..) {
window.disconnect(handler);
}
if let Some(done) = done.take() {
done(outcome.get());
}
}
});
handlers.borrow_mut().extend([data, end]);
Ok(())
}
}
#[cfg(windows)]
mod ole;
#[cfg(windows)]
pub use ole::start;
#[cfg(target_os = "macos")]
mod appkit;
#[cfg(target_os = "macos")]
pub use appkit::start;
/// The `CF_HDROP` file list: each path in UTF-16 with `/` as `\\`, NUL-terminated, and a
/// second NUL after the last.
#[cfg(any(windows, test))]
fn hdrop_file_list<P: IntoIterator<Item = u16>>(paths: impl IntoIterator<Item = P>) -> Vec<u16> {
let mut list = Vec::new();
for path in paths {
list.extend(path.into_iter().map(|unit| if unit == u16::from(b'/') { u16::from(b'\\') } else { unit }));
list.push(0);
}
list.push(0);
list
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn accepts_existing_absolute_files_and_folders() {
let dir = tempfile::tempdir().unwrap();
let file = dir.path().join("a b ü.txt");
std::fs::write(&file, "x").unwrap();
let paths = local_paths([file.clone(), dir.path().to_path_buf()]).unwrap();
assert_eq!(paths, vec![file, dir.path().to_path_buf()]);
}
#[test]
fn measures_max_path_in_utf16_units() {
let path = |len: usize| PathBuf::from(format!("C:/{}", "中".repeat(len - 3)));
assert!(fits_max_path(&path(259)));
assert!(!fits_max_path(&path(260)));
}
#[test]
fn lists_hdrop_files_double_nul_terminated() {
let list = hdrop_file_list(["C:/a b/ü.txt", r"\\nas\share\中"].map(str::encode_utf16));
let expected: Vec<u16> = "C:\\a b\\ü.txt\0\\\\nas\\share\\中\0\0".encode_utf16().collect();
assert_eq!(list, expected);
}
#[test]
fn refuses_an_empty_drag() {
assert_eq!(local_paths(Vec::<PathBuf>::new()).unwrap_err().kind(), io::ErrorKind::InvalidInput);
}
#[test]
fn refuses_relative_and_missing_paths() {
let dir = tempfile::tempdir().unwrap();
let file = dir.path().join("a.txt");
std::fs::write(&file, "x").unwrap();
// One path that is not local fails the whole drag: none of it is half-copied.
for bad in [PathBuf::from("a.txt"), dir.path().join("missing.txt")] {
assert_eq!(local_paths([file.clone(), bad]).unwrap_err().kind(), io::ErrorKind::NotFound);
}
}
}
+171
Переглянути файл
@@ -0,0 +1,171 @@
//! Windows: OLE `DoDragDrop` of a data object that serves the paths as `CF_HDROP`.
use super::{Outcome, hdrop_file_list};
use raw_window_handle::HasWindowHandle;
use std::io;
use std::os::windows::ffi::OsStrExt;
use std::path::PathBuf;
use windows::Win32::Foundation::{
DRAGDROP_S_CANCEL, DRAGDROP_S_DROP, DRAGDROP_S_USEDEFAULTCURSORS, DV_E_FORMATETC, E_NOTIMPL, GlobalFree, HGLOBAL,
OLE_E_ADVISENOTSUPPORTED, S_OK,
};
use windows::Win32::System::Com::{
DATADIR_GET, DVASPECT_CONTENT, FORMATETC, IAdviseSink, IDataObject, IDataObject_Impl, IEnumFORMATETC,
IEnumSTATDATA, STGMEDIUM, STGMEDIUM_0, TYMED_HGLOBAL,
};
use windows::Win32::System::Memory::{GHND, GlobalAlloc, GlobalLock, GlobalUnlock};
use windows::Win32::System::Ole::{
CF_HDROP, DROPEFFECT, DROPEFFECT_COPY, DROPEFFECT_NONE, DoDragDrop, IDropSource, IDropSource_Impl, OleInitialize,
OleUninitialize,
};
use windows::Win32::System::SystemServices::{MK_LBUTTON, MODIFIERKEYS_FLAGS};
use windows::Win32::UI::Shell::{DROPFILES, SHCreateDataObject, SHCreateStdEnumFmtEtc};
use windows::core::{BOOL, Error, HRESULT, Ref, Result, implement};
/// Drags `paths` (see [`super::local_paths`]) until the button is released, then calls
/// `done` and returns. `DoDragDrop` runs its own message loop, so the window keeps painting.
pub fn start<W: HasWindowHandle>(
_window: &W,
paths: Vec<PathBuf>,
done: impl FnOnce(Outcome) + 'static,
) -> io::Result<()> {
let files = hdrop_file_list(paths.iter().map(|path| path.as_os_str().encode_wide()));
// The window's event loop has initialised OLE on this thread already; this takes a
// reference that `OleUninitialize` gives back.
unsafe { OleInitialize(None) }.map_err(io::Error::other)?;
let outcome = drag(files);
unsafe { OleUninitialize() };
done(outcome.map_err(io::Error::other)?);
Ok(())
}
fn drag(files: Vec<u16>) -> Result<Outcome> {
// Formats other than `CF_HDROP` (the drag image, drop descriptions the shell sets on
// the source's data object) are kept by a plain shell data object.
let inner: IDataObject = unsafe { SHCreateDataObject(None, None, None::<&IDataObject>) }?;
let data: IDataObject = DataObject { files, inner }.into();
let source: IDropSource = DropSource.into();
let mut effect = DROPEFFECT_NONE;
match unsafe { DoDragDrop(&data, &source, DROPEFFECT_COPY, &mut effect) } {
DRAGDROP_S_DROP if effect != DROPEFFECT_NONE => Ok(Outcome::Dropped),
DRAGDROP_S_DROP | DRAGDROP_S_CANCEL => Ok(Outcome::Cancelled),
error => Err(Error::from_hresult(error)),
}
}
#[implement(IDropSource)]
struct DropSource;
impl IDropSource_Impl for DropSource_Impl {
fn QueryContinueDrag(&self, escape_pressed: BOOL, keys: MODIFIERKEYS_FLAGS) -> HRESULT {
if escape_pressed.as_bool() {
DRAGDROP_S_CANCEL
} else if keys & MK_LBUTTON == MODIFIERKEYS_FLAGS(0) {
DRAGDROP_S_DROP
} else {
S_OK
}
}
fn GiveFeedback(&self, _effect: DROPEFFECT) -> HRESULT {
DRAGDROP_S_USEDEFAULTCURSORS
}
}
#[implement(IDataObject)]
struct DataObject {
/// The `DROPFILES` file list ([`hdrop_file_list`]).
files: Vec<u16>,
inner: IDataObject,
}
const HDROP: FORMATETC = FORMATETC {
cfFormat: CF_HDROP.0,
ptd: std::ptr::null_mut(),
dwAspect: DVASPECT_CONTENT.0,
lindex: -1,
tymed: TYMED_HGLOBAL.0 as u32,
};
fn is_hdrop(format: *const FORMATETC) -> bool {
unsafe { format.as_ref() }.is_some_and(|format| {
format.cfFormat == HDROP.cfFormat && format.dwAspect == HDROP.dwAspect && format.tymed & HDROP.tymed != 0
})
}
impl DataObject {
/// A new `DROPFILES` block; the receiver frees it.
fn hdrop(&self) -> Result<HGLOBAL> {
let header = size_of::<DROPFILES>();
let size = header + std::mem::size_of_val(self.files.as_slice());
unsafe {
let handle = GlobalAlloc(GHND, size)?;
let block = GlobalLock(handle).cast::<u8>();
if block.is_null() {
let error = Error::from_thread();
let _ = GlobalFree(Some(handle));
return Err(error);
}
block.cast::<DROPFILES>().write_unaligned(DROPFILES {
pFiles: header as u32,
fWide: true.into(),
..Default::default()
});
std::ptr::copy_nonoverlapping(self.files.as_ptr().cast::<u8>(), block.add(header), size - header);
// Fails with no error once the lock count is back to zero, which it is.
let _ = GlobalUnlock(handle);
Ok(handle)
}
}
}
impl IDataObject_Impl for DataObject_Impl {
fn GetData(&self, format: *const FORMATETC) -> Result<STGMEDIUM> {
if !is_hdrop(format) {
return unsafe { self.inner.GetData(format) };
}
Ok(STGMEDIUM {
tymed: TYMED_HGLOBAL.0 as u32,
u: STGMEDIUM_0 { hGlobal: self.hdrop()? },
pUnkForRelease: std::mem::ManuallyDrop::new(None),
})
}
fn GetDataHere(&self, format: *const FORMATETC, medium: *mut STGMEDIUM) -> Result<()> {
if is_hdrop(format) {
return Err(DV_E_FORMATETC.into());
}
unsafe { self.inner.GetDataHere(format, medium) }
}
fn QueryGetData(&self, format: *const FORMATETC) -> HRESULT {
if is_hdrop(format) { S_OK } else { unsafe { self.inner.QueryGetData(format) } }
}
fn GetCanonicalFormatEtc(&self, format: *const FORMATETC, canonical: *mut FORMATETC) -> HRESULT {
unsafe { self.inner.GetCanonicalFormatEtc(format, canonical) }
}
fn SetData(&self, format: *const FORMATETC, medium: *const STGMEDIUM, release: BOOL) -> Result<()> {
unsafe { self.inner.SetData(format, medium, release.as_bool()) }
}
fn EnumFormatEtc(&self, direction: u32) -> Result<IEnumFORMATETC> {
if direction != DATADIR_GET.0 as u32 {
return Err(E_NOTIMPL.into());
}
unsafe { SHCreateStdEnumFmtEtc(&[HDROP]) }
}
fn DAdvise(&self, _format: *const FORMATETC, _advf: u32, _sink: Ref<IAdviseSink>) -> Result<u32> {
Err(OLE_E_ADVISENOTSUPPORTED.into())
}
fn DUnadvise(&self, _connection: u32) -> Result<()> {
Err(OLE_E_ADVISENOTSUPPORTED.into())
}
fn EnumDAdvise(&self) -> Result<IEnumSTATDATA> {
Err(OLE_E_ADVISENOTSUPPORTED.into())
}
}
+91 -9
Переглянути файл
@@ -5,10 +5,10 @@ use crate::Host;
use crate::agent_secrets::{AgentSecrets, Kept};
use ide_agent::registry::{AgentRegistry, RegistryPaths};
use ide_agent::{
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentEntry,
AgentEvent, AgentModelCatalog, AgentProbe, AgentPrompt, AgentProvider, AgentQueued, AgentTask, CustomAgentInput,
ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput,
McpTransport, NewAgentTask,
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCliOffer,
AgentCliUpdateResult, AgentCommand, AgentContextUsage, AgentEntry, AgentEvent, AgentModelCatalog, AgentProbe,
AgentPrompt, AgentProvider, AgentQueued, AgentTask, CustomAgentInput, ExternalSession, McpExternalSource,
McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput, McpTransport, NewAgentTask,
};
use ide_command::command;
use ide_core::error::ErrorKind;
@@ -17,12 +17,28 @@ use ide_tools::InstallEvent;
use std::collections::HashSet;
use std::sync::{LazyLock, Mutex};
/// Streams the project's agent events to this window; returns every task.
/// Streams the project's agent events to `subscriber`, one of the project's windows (a remote
/// host sees them all as one `window`); returns every task.
#[command(trust = always)]
pub fn agent_subscribe(host: &Host, window: &str, on_event: Channel<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
Ok(host.project(window)?.agents.subscribe(std::sync::Arc::new(move |e| {
let _ = on_event.send(e);
})))
pub fn agent_subscribe(
host: &Host,
window: &str,
on_event: Channel<AgentEvent>,
subscriber: String,
) -> IdeResult<Vec<AgentTask>> {
Ok(host.project(window)?.agents.subscribe_as(
&subscriber,
std::sync::Arc::new(move |e| {
let _ = on_event.send(e);
}),
))
}
/// Stops the events of a window that closed.
#[command(trust = always)]
pub fn agent_unsubscribe(host: &Host, window: &str, subscriber: String) -> IdeResult<()> {
host.project(window)?.agents.unsubscribe(&subscriber);
Ok(())
}
#[command(trust = trusted)]
@@ -33,6 +49,16 @@ pub fn agent_providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider
Ok(providers)
}
/// Hermes Agent profiles on this machine (`default` first); empty without Hermes.
#[command(trust = trusted)]
pub async fn agent_hermes_profiles(host: &Host, window: &str) -> IdeResult<Vec<ide_agent::hermes::HermesProfile>> {
host.require_trust(window)?;
let root = ide_agent::hermes::root(dirs::home_dir().as_deref());
tokio::task::spawn_blocking(move || root.map(|r| ide_agent::hermes::labeled_profiles(&r)).unwrap_or_default())
.await
.map_err(join_err)
}
/// Refreshes the model catalog; force bypasses freshness, not the cooldown.
#[command(trust = trusted)]
pub fn agent_refresh_models(
@@ -333,6 +359,50 @@ pub async fn agent_rollback(host: &Host, window: &str, task: String, turns: u32)
host.project(window)?.agents.rollback(&task, turns).await
}
/// Checks the selected installation without modifying it.
#[command(trust = trusted)]
pub async fn agent_cli_update_check(
host: &Host,
window: &str,
provider: String,
request: RequestId,
) -> IdeResult<AgentCliUpdateResult> {
cli_update(host, window, provider, None, request).await
}
/// Installs the exact version offered if the selected installation still matches.
#[command(trust = trusted)]
pub async fn agent_cli_update(
host: &Host,
window: &str,
provider: String,
offer: AgentCliOffer,
request: RequestId,
) -> IdeResult<AgentCliUpdateResult> {
cli_update(host, window, provider, Some(offer), request).await
}
async fn cli_update(
host: &Host,
window: &str,
provider: String,
offer: Option<AgentCliOffer>,
request: RequestId,
) -> IdeResult<AgentCliUpdateResult> {
host.require_trust(window)?;
let project = host.project(window)?;
let installing = offer.as_ref().map(|_| Installing::begin(&provider)).transpose()?;
let cancel = host.begin_project_request(window, request);
let result = tokio::task::spawn_blocking(move || {
let _installing = installing;
project.agents.cli_update(&provider, offer.as_ref(), &cancel)
})
.await
.map_err(join_err);
host.end_request(request);
result?
}
/// What the agent reports about itself when it starts (no session: no MCP servers, hooks
/// or sign-in run). Remembered until `refresh`.
#[command(trust = trusted)]
@@ -341,6 +411,13 @@ pub async fn agent_probe(host: &Host, window: &str, provider: String, refresh: b
host.project(window)?.agents.probe(&provider, refresh).await
}
/// Reads the running session's context categories without sending a prompt.
#[command(trust = trusted)]
pub async fn agent_context_usage(host: &Host, window: &str, task: String) -> IdeResult<AgentContextUsage> {
host.require_trust(window)?;
host.project(window)?.agents.context_usage(&task).await
}
/// Stops the task's current turn, or with `subagent` only that subagent's work.
#[command(trust = always)]
pub fn agent_cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
@@ -1067,7 +1144,10 @@ ide_command::domain!(
agent_archive,
agent_base_text,
agent_cancel,
agent_context_usage,
agent_changes,
agent_cli_update,
agent_cli_update_check,
agent_commands,
agent_create,
agent_delete,
@@ -1075,6 +1155,7 @@ ide_command::domain!(
agent_external_sessions,
agent_fork,
agent_grouped_changes,
agent_hermes_profiles,
agent_import_session,
agent_mcp_discover_sources,
agent_mcp_import,
@@ -1106,4 +1187,5 @@ ide_command::domain!(
agent_subscribe,
agent_unarchive,
agent_unqueue,
agent_unsubscribe,
);
+25 -4
Переглянути файл
@@ -1,6 +1,7 @@
//! Cucumber sources: the project's `.feature` files and the JavaScript / TypeScript files
//! (`@cucumber/cucumber`, `playwright-bdd`) and Java / Kotlin files (cucumber-jvm's
//! `@Given("…")` annotations and Java 8 lambdas) that could define steps, with their text. The UI
//! `@Given("…")` annotations and Java 8 lambdas) and Python files (behave and pytest-bdd's
//! `@given('…')` decorators) that could define steps, with their text. The UI
//! owns the Gherkin and step-expression parsing and the index it feeds (as for `routes`),
//! so this side stays a cheap scan.
@@ -21,6 +22,8 @@ const MAX_FILE_BYTES: u64 = 2 << 20;
/// What a step definition call starts with (`Given('…'`, `defineStep(/…/`).
const STEP_CALLS: [&str; 5] = ["Given(", "When(", "Then(", "Step(", "defineStep("];
/** What a Python step decorator starts with (behave also takes the capitalized names). */
const PYTHON_STEP_CALLS: [&str; 8] = ["@given(", "@when(", "@then(", "@step(", "@Given(", "@When(", "@Then(", "@Step("];
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -38,10 +41,14 @@ fn is_feature(path: &Path) -> bool {
fn is_script(path: &Path) -> bool {
matches!(
path.extension().and_then(|e| e.to_str()),
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt")
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt" | "py")
)
}
fn is_python(path: &Path) -> bool {
path.extension().and_then(|e| e.to_str()) == Some("py")
}
/// The feature files and step definition files under `root`.
pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
let found: Mutex<Vec<StepSource>> = Mutex::new(Vec::new());
@@ -55,7 +62,8 @@ pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
return;
}
let Ok(text) = std::fs::read_to_string(path) else { return };
if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) {
let calls: &[&str] = if is_python(path) { &PYTHON_STEP_CALLS } else { &STEP_CALLS };
if !feature && !calls.iter().any(|call| text.contains(call)) {
return;
}
let Ok(mut found) = found.lock() else { return };
@@ -76,6 +84,7 @@ pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>>
let mut excludes = project.search_excludes();
// Cucumber's own sources (and every other package's) are not the project's steps.
excludes.push("node_modules".to_owned());
excludes.push("site-packages".to_owned());
let mut out = Vec::new();
for root in std::iter::once(project.root.clone()).chain(project.content_roots()) {
out.extend(sources_in(&root, &excludes));
@@ -104,11 +113,23 @@ mod tests {
std::fs::write(root.join("src/CartSteps.java"), "@Given(\"an empty cart\")\npublic void empty() {}").unwrap();
std::fs::write(root.join("src/App.java"), "class App {}").unwrap();
std::fs::write(root.join("src/notes.md"), "Given('x')").unwrap();
std::fs::write(root.join("steps/cart_steps.py"), "@given('an empty cart')\ndef step_impl(context): pass")
.unwrap();
std::fs::write(root.join("src/util.py"), "def given(x): return x\nWhen = given('x')").unwrap();
std::fs::write(root.join("node_modules/@cucumber/cucumber/lib/index.js"), "Given('x')").unwrap();
let files = sources_in(root, &["node_modules".to_owned()]);
let names: Vec<String> =
files.iter().map(|f| f.path.0.strip_prefix(root).unwrap().to_string_lossy().replace('\\', "/")).collect();
assert_eq!(names, ["features/cart.feature", "src/CartSteps.java", "steps/bdd.mjs", "steps/cart.steps.ts"]);
assert_eq!(
names,
[
"features/cart.feature",
"src/CartSteps.java",
"steps/bdd.mjs",
"steps/cart.steps.ts",
"steps/cart_steps.py"
]
);
assert!(files[0].feature && !files[1].feature);
assert!(files[3].text.contains("an empty cart"));
}
+118 -21
Переглянути файл
@@ -8,30 +8,79 @@ use crate::{Host, Project};
use ide_command::command;
use ide_build::compile::{self, BuildEvent, BuildKind, BuildResult};
use ide_build::maven::PomGoto;
use ide_build::maven::completion::{PomCompletion, PomCompletionOption};
use ide_build::maven::{PomGoto, PomManagedDeclaration, PomNavigationOptions};
use ide_build::pom_edit::{ArtifactKey, Exclusion};
use ide_build::{BuildModel, BuildTool, SyncOptions, SyncProgress};
use ide_core::settings::Settings;
use ide_core::{DocId, FileEdit, IdeError, IdeEvent, IdeResult, Location, Pos, Range, RequestId, WorkspaceEdit};
use std::collections::HashMap;
use std::path::Path;
use std::sync::Arc;
use std::sync::{Arc, Mutex, OnceLock};
use std::time::{Duration, Instant};
fn join_err(e: tokio::task::JoinError) -> IdeError {
IdeError::internal(e.to_string())
}
/// POM gutters in several editors refresh together. A very short cache lets those
/// requests share one reactor scan without serving a stale module list after edits settle.
const MAVEN_MODULE_CACHE_TTL: Duration = Duration::from_millis(250);
type MavenModuleCache = HashMap<String, (Instant, Vec<ide_build::maven::ModulePom>)>;
static MAVEN_MODULES: OnceLock<Mutex<MavenModuleCache>> = OnceLock::new();
fn maven_modules(
project: &Project,
settings: &Settings,
options: &PomNavigationOptions,
) -> Vec<ide_build::maven::ModulePom> {
let key = format!(
"{}\0{:?}\0{:?}\0{:?}\0{:?}",
project.root.display(),
project.build_cache_dir(),
settings.languages.java.maven.linked_projects,
options.profiles,
options.jdk_version
);
let cache = MAVEN_MODULES.get_or_init(|| Mutex::new(HashMap::new()));
if let Some((_at, modules)) = cache.lock().ok().and_then(|mut cache| {
let fresh = cache.get(&key).filter(|(at, _)| at.elapsed() < MAVEN_MODULE_CACHE_TTL).cloned();
if fresh.is_none() {
cache.remove(&key);
}
fresh
}) {
return modules;
}
let model = load(&project.root, &project.build_cache_dir(), settings).maven.unwrap_or_default();
let modules = model
.projects
.into_iter()
.map(|p| ide_build::maven::ModulePom {
group_id: p.group_id,
artifact_id: p.artifact_id,
version: p.version,
pom: project.root.join(&p.pom),
})
.collect::<Vec<_>>();
if let Ok(mut cache) = cache.lock() {
cache.insert(key, (Instant::now(), modules.clone()));
}
modules
}
/// The build model with the launch settings applied: the JDK (`JAVA_HOME`), and
/// the Maven home and options from Settings › Maven.
pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
let mut model = ide_build::load_linked(
let jdk = ide_sdk::apply::project_jdk(root, settings);
let mut model = ide_build::load_linked_with_jdk(
root,
cache,
ide_sdk::apply::maven_local_repository(root, settings),
&settings.languages.java.maven,
&settings.languages.java.gradle,
ide_sdk::apply::maven_jdk(root, settings, None).map(|jdk| jdk.major),
);
let jdk = ide_sdk::apply::project_jdk(root, settings);
if let Some(m) = &mut model.maven {
let mvn = ide_sdk::apply::maven_command(root, settings);
let options = ide_sdk::apply::maven_options(root, settings);
@@ -77,6 +126,23 @@ pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
model
}
/// POM navigation follows the same profile choices as the last Maven sync and
/// resolves JDK-activated profiles with the project's selected Maven runtime.
fn pom_navigation_options(project: &Project, settings: &Settings) -> PomNavigationOptions {
let mut profiles = settings.languages.java.maven.profiles(&[]);
for profile in ide_build::maven_profiles(&project.build_cache_dir()) {
if !profiles.contains(&profile) {
profiles.push(profile);
}
}
PomNavigationOptions {
local_repo: ide_sdk::apply::maven_local_repository(&project.root, settings)
.or_else(ide_build::maven::default_local_repo),
profiles,
jdk_version: ide_sdk::apply::maven_jdk(&project.root, settings, None).map(|jdk| jdk.major),
}
}
/// Build and Run use the same selected toolchain and module-local runtime discovery.
fn prepare_plan(mut plan: compile::BuildPlan, root: &Path, settings: &Settings) -> compile::BuildPlan {
let kind = match plan.system {
@@ -547,8 +613,9 @@ pub async fn maven_dependency_declaration(
}
/// The go-to-declaration target at `pos` of a Maven POM: the definition of the
/// `${property}` at the caret, or the `<dependencyManagement>` / `<pluginManagement>`
/// entry providing the dependency's / plugin's version, along the parent chain.
/// `${property}` at the caret, the parent POM, or the dependency / plugin's own POM
/// (a project module first, then the local repository). A dependency without a
/// resolvable artifact POM falls back to its management entry.
#[command(trust = trusted)]
pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos: Pos) -> IdeResult<Option<PomGoto>> {
// `pom` is project-relative, or absolute for a parent POM opened from the local repository.
@@ -561,26 +628,55 @@ pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos:
let path = if given.is_absolute() { given.to_path_buf() } else { project.root.join(given) };
let text = project.text_of(&path)?;
let settings = project.settings.effective();
let repo = ide_sdk::apply::maven_local_repository(&project.root, &settings)
.or_else(ide_build::maven::default_local_repo);
let modules = || {
let model = load(&project.root, &project.build_cache_dir(), &settings).maven.unwrap_or_default();
model
.projects
.into_iter()
.map(|p| ide_build::maven::ModulePom {
group_id: p.group_id,
artifact_id: p.artifact_id,
pom: project.root.join(&p.pom),
})
.collect()
};
Ok(ide_build::maven::goto_declaration_in(&text, &path, pos, repo, modules))
let options = pom_navigation_options(&project, &settings);
let module_options = options.clone();
let modules = || maven_modules(&project, &settings, &module_options);
Ok(ide_build::maven::goto_declaration_with(&text, &path, pos, options, modules))
})
.await
.map_err(join_err)?
}
/// Gutter targets of the unversioned dependencies and plugins in a Maven POM:
/// the management declarations that actually supply their versions, including
/// parent POMs and imported BOMs. Cancel with `cancel_request(request)`.
#[command(trust = trusted)]
pub async fn maven_managed_declarations(
host: &Host,
window: &str,
pom: String,
request: RequestId,
) -> IdeResult<Vec<PomManagedDeclaration>> {
let project = host.project(window)?;
let cancel = host.begin_project_read_request(window, request);
let result = tokio::task::spawn_blocking(move || {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let given = Path::new(&pom);
let path = if given.is_absolute() { given.to_path_buf() } else { project.root.join(given) };
let text = project.text_of(&path)?;
let settings = project.settings.effective();
let options = pom_navigation_options(&project, &settings);
let cancelled = cancel.clone();
let module_options = options.clone();
let modules = || {
if cancelled.is_cancelled() {
return Vec::new();
}
maven_modules(&project, &settings, &module_options)
};
let declarations = ide_build::maven::managed_declarations_with(&text, &path, options, modules);
if cancel.is_cancelled() { Err(IdeError::cancelled()) } else { Ok(declarations) }
})
.await;
host.end_request(request);
match result {
Ok(result) => result,
Err(error) => Err(join_err(error)),
}
}
/// How long completion waits for Maven Central before answering from the local repository.
const CENTRAL_WAIT: std::time::Duration = std::time::Duration::from_secs(1);
@@ -1333,4 +1429,5 @@ ide_command::domain!(
maven_dependency_declaration,
maven_exclude_dependency,
maven_goto_declaration,
maven_managed_declarations,
);
+8
Переглянути файл
@@ -70,6 +70,13 @@ pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
}
/// Load Changes from Disk: discards the buffer's unsaved changes and reads its file again.
#[command(trust = always)]
pub async fn doc_reload_from_disk(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
let project = host.project(window)?;
host.blocking(move || project.documents.discard_and_reload(doc)).await
}
/// An automatic save: `false` (nothing written) when the file changed on disk after the
/// buffer was edited, which only an explicit save overwrites.
#[command(trust = always)]
@@ -120,6 +127,7 @@ ide_command::domain!(
doc_edit,
doc_open,
doc_open_untitled,
doc_reload_from_disk,
doc_save,
doc_autosave,
doc_save_all,
+5 -3
Переглянути файл
@@ -1,6 +1,6 @@
use super::*;
use crate::{HostConfig, Project};
use ide_core::{IdeEvent, TextChange, event::NotifyLevel};
use ide_core::{IdeEvent, TextChange};
use parking_lot::Mutex;
use std::{path::Path, sync::Arc};
@@ -57,7 +57,9 @@ impl Fixture {
self.events
.lock()
.iter()
.filter(|e| matches!(e, IdeEvent::DocPatched { .. } | IdeEvent::DocDirty { .. } | IdeEvent::Notify { .. }))
.filter(|e| {
matches!(e, IdeEvent::DocPatched { .. } | IdeEvent::DocDirty { .. } | IdeEvent::DocDiskConflict { .. })
})
.cloned()
.collect()
}
@@ -110,7 +112,7 @@ async fn dirty_document_keeps_edits_and_warns_once() {
let loaded = f.project.documents.snapshot(original.id).unwrap();
assert_eq!(loaded.text, "local original\n");
assert!(loaded.dirty);
assert!(matches!(f.document_events().as_slice(), [IdeEvent::Notify { level: NotifyLevel::Warning, .. }]));
assert!(matches!(f.document_events().as_slice(), [IdeEvent::DocDiskConflict { .. }]));
f.events.lock().clear();
f.sync().await;
assert!(f.document_events().is_empty());
+31 -21
Переглянути файл
@@ -122,28 +122,38 @@ pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) ->
/// The interpreter the project uses: the configured one, else its virtualenv.
#[command(trust = trusted)]
pub fn sdk_python_effective(host: &Host, window: &str, near: Option<PathBuf>) -> IdeResult<Option<ide_core::IpcPath>> {
pub async fn sdk_python_effective(
host: &Host,
window: &str,
near: Option<PathBuf>,
) -> IdeResult<Option<ide_core::IpcPath>> {
host.require_trust(window)?;
let project = host.project(window)?;
let member = ide_workspace::workspace::Workspace::load(&project.root)?.and_then(|w| {
let near = near.as_deref()?;
w.projects.into_iter().filter(|root| near.starts_with(root)).max_by_key(|root| root.components().count())
});
let (root, settings) = match member {
Some(root) => {
let settings = ide_workspace::SettingsStore::load(&host.config_dir, Some(&root)).effective();
(root, settings)
}
None => (project.root.clone(), project.settings.effective()),
};
// A member with no Python of its own falls back to the primary project's
// (the same chain run configurations use), so every answer names one interpreter.
let interpreter = ide_sdk::apply::python_interpreter_near(&root, near.as_deref(), &settings).or_else(|| {
(root != project.root)
.then(|| ide_sdk::apply::python_interpreter(&project.root, &project.settings.effective()))
.flatten()
});
Ok(interpreter.map(Into::into))
let (config_dir, project_root) = (host.config_dir.clone(), project.root.clone());
// Loading a member's settings needs more stack than a sync command's main thread has left.
tokio::task::spawn_blocking(move || {
let member = ide_workspace::workspace::Workspace::load(&project_root).ok().flatten().and_then(|w| {
let near = near.as_deref()?;
w.projects.into_iter().filter(|root| near.starts_with(root)).max_by_key(|root| root.components().count())
});
let (root, settings) = match member {
Some(root) => {
let settings = ide_workspace::SettingsStore::load(&config_dir, Some(&root)).effective();
(root, settings)
}
None => (project_root.clone(), project.settings.effective()),
};
// A member with no Python of its own falls back to the primary project's
// (the same chain run configurations use), so every answer names one interpreter.
let interpreter = ide_sdk::apply::python_interpreter_near(&root, near.as_deref(), &settings).or_else(|| {
(root != project_root)
.then(|| ide_sdk::apply::python_interpreter(&project_root, &project.settings.effective()))
.flatten()
});
Ok(interpreter.map(Into::into))
})
.await
.map_err(join_err)?
}
/// The PHP interpreter chosen in Settings › Languages & Frameworks › PHP; `None`: the `php` on `PATH`.
@@ -461,7 +471,7 @@ mod tests {
host.open_project("main", &root).unwrap();
let detected = sdk_detect(&host, "main", SdkKind::Python).await.unwrap();
assert!(detected.iter().any(|s| s.path == sdk.path && s.name == sdk.name));
assert_eq!(sdk_python_effective(&host, "main", None).unwrap(), Some(sdk.path));
assert_eq!(sdk_python_effective(&host, "main", None).await.unwrap(), Some(sdk.path));
assert!(sdk_python_interpreter(&host, "main", root.join("README.md")).await.unwrap().is_none());
host.close_project("main");
}
+7 -1
Переглянути файл
@@ -633,8 +633,14 @@ pub async fn vcs_add_to_ignore(
host.require_trust(window)?;
let project = host.project(window)?;
blocking(move || {
// The Changes view lists every repository of the window (the project's and the
// attached ones'): a path inside the project folder, or in any of those repositories.
// The folder check stays so a request right after opening, before the repositories
// are discovered, still works.
let repos = project.repos();
for path in &paths {
if path == &project.root || !path.starts_with(&project.root) {
let in_project = path != &project.root && path.starts_with(&project.root);
if !in_project && repos.for_path(path).is_none() {
return Err(ide_core::IdeError::invalid("Ignore selection is outside the project"));
}
}
+28 -6
Переглянути файл
@@ -406,15 +406,16 @@ impl Proc {
}
}
/// What it printed since the last call, each stream at most `max` bytes.
/// What it printed since the last call, each stream at most `max` bytes. The status
/// comes with the last chunk only: once it ended, its pipes reached the end and
/// nothing is left to read, so a caller can stop at the first chunk that has one.
fn chunk(&self, max: usize) -> ProcessChunk {
let mut state = self.state.lock();
let eof = state.readers == 0;
ProcessChunk {
stdout: take_text(&mut state.stdout, max, eof),
stderr: take_text(&mut state.stderr, max, eof),
status: state.status,
}
let stdout = take_text(&mut state.stdout, max, eof);
let stderr = take_text(&mut state.stderr, max, eof);
let drained = eof && state.stdout.is_empty() && state.stderr.is_empty();
ProcessChunk { stdout, stderr, status: state.status.filter(|_| drained) }
}
}
@@ -4126,6 +4127,27 @@ mod tests {
api.release_process(id);
}
#[cfg(unix)]
#[test]
fn the_status_comes_with_the_last_of_the_output() {
let tmp = tempfile::tempdir().unwrap();
let api = shell_api(tmp.path());
let token = CancellationToken::new();
let id = api.start_process(shell("printf 'abcdefghij'; printf 'xyz' >&2"), None, None).unwrap();
let first = api.wait_process(id, 4, Duration::from_secs(5), &token).unwrap();
assert_eq!((first.stdout.as_str(), first.stderr.as_str(), first.status), ("abcd", "xyz", None));
let mut stdout = first.stdout;
let status = loop {
let chunk = api.poll_process(id, 4).unwrap();
stdout.push_str(&chunk.stdout);
if let Some(status) = chunk.status {
break status;
}
};
assert_eq!((stdout.as_str(), status), ("abcdefghij", 0));
api.release_process(id);
}
#[test]
fn programs_run_only_as_approved() {
let tmp = tempfile::tempdir().unwrap();
+1
Переглянути файл
@@ -191,6 +191,7 @@ pub fn client_accepts(event: &IdeEvent, trusted: bool) -> bool {
| IdeEvent::ExcludedDirsChanged { .. }
| IdeEvent::DocPatched { .. }
| IdeEvent::DocDirty { .. }
| IdeEvent::DocDiskConflict { .. }
| IdeEvent::WorkspaceEditApplied { .. }
| IdeEvent::DocLanguage { .. }
| IdeEvent::Diagnostics { .. }
+1 -1
Переглянути файл
@@ -161,7 +161,7 @@ async fn light_notebooks_open_without_interpreter_detection_or_execution() {
assert!(ops::notebook::notebook_save(&host, "main", notebook.id.clone()).await.is_ok());
let error = ops::sdk::sdk_detect(&host, "main", ide_sdk::SdkKind::Python).await.unwrap_err();
assert!(error.message.contains("Restricted Mode"));
assert!(ops::sdk::sdk_python_effective(&host, "main", None).is_err());
assert!(ops::sdk::sdk_python_effective(&host, "main", None).await.is_err());
assert!(ops::sdk::sdk_locate_tools(&host, "main", vec!["prettier".into()], Some(root)).await.is_err());
let error = ops::notebook::notebook_restart(&host, "main", notebook.id.clone()).await.unwrap_err();
assert!(error.message.contains("Restricted Mode"));
+1 -1
Переглянути файл
@@ -351,7 +351,7 @@ async fn python_venv() {
// The project's virtualenv: listed first, and the interpreter the project uses.
let found = ops::sdk::sdk_detect(&p.host, WINDOW, ide_sdk::SdkKind::Python).await.unwrap();
assert_eq!(found.first().map(|s| s.source.as_str()), Some("venv"), "{found:?}");
let effective = ops::sdk::sdk_python_effective(&p.host, WINDOW, None).unwrap().expect("an interpreter");
let effective = ops::sdk::sdk_python_effective(&p.host, WINDOW, None).await.unwrap().expect("an interpreter");
assert!(effective.starts_with(p.root.join(".venv")), "{effective:?}");
}
+73
Переглянути файл
@@ -21,6 +21,7 @@ async fn patches_read_and_write_the_requested_repository() {
git(root, &["init", "-b", "main"]);
git(root, &["config", "user.name", "Test"]);
git(root, &["config", "user.email", "[email protected]"]);
git(root, &["config", "core.autocrlf", "false"]);
std::fs::write(root.join("same.txt"), format!("root {i}\n")).unwrap();
git(root, &["add", "."]);
git(root, &["commit", "-m", "initial"]);
@@ -65,3 +66,75 @@ async fn patches_read_and_write_the_requested_repository() {
assert!(vcs::vcs_apply_patch(&host, "main", Some(base.join("outside")), String::new()).await.is_err());
host.close_project("main");
}
/// The Changes view also lists attached projects' repositories, and their untracked files
/// offer Add to .gitignore / .git/info/exclude: the guard must follow the window's
/// repository set, not the project folder alone.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn add_to_ignore_accepts_the_repositories_of_attached_projects() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let project_root = base.join("project");
let attached_root = base.join("attached");
for root in [&project_root, &attached_root] {
std::fs::create_dir_all(root).unwrap();
git(root, &["init", "-b", "main"]);
git(root, &["config", "user.name", "Test"]);
git(root, &["config", "user.email", "[email protected]"]);
git(root, &["config", "core.autocrlf", "false"]);
std::fs::write(root.join("tracked.txt"), "x\n").unwrap();
git(root, &["add", "."]);
git(root, &["commit", "-m", "initial"]);
}
// Untracked files, one per repository; the attached one is what failed.
let own = project_root.join("own.ignore-me");
let attached = attached_root.join("attached.ignore-me");
std::fs::write(&own, "x").unwrap();
std::fs::write(&attached, "x").unwrap();
let host = Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("data"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(NullSink)),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
host.trust.decide(&project_root, true, false).unwrap();
host.trust.decide(&attached_root, true, false).unwrap();
let project = host.open_project("main", &project_root).unwrap();
ide_host::ops::project::attach_workspace(&host, "main", &attached_root).unwrap();
for _ in 0..500 {
if project.repos().all().len() == 2 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
assert_eq!(project.repos().all().len(), 2);
vcs::vcs_add_to_ignore(&host, "main", vec![attached.clone()], ide_vcs::IgnoreDestination::Gitignore).await.unwrap();
assert!(
std::fs::read_to_string(attached_root.join(".gitignore")).unwrap().contains("/attached.ignore-me"),
"the attached repository's .gitignore did not receive the rule"
);
vcs::vcs_add_to_ignore(&host, "main", vec![own.clone()], ide_vcs::IgnoreDestination::LocalExclude).await.unwrap();
assert!(
std::fs::read_to_string(project_root.join(".git/info/exclude")).unwrap().contains("/own.ignore-me"),
"the project repository's exclude did not receive the rule"
);
// A repository of an unattached sibling folder stays outside.
let sibling_root = base.join("sibling");
std::fs::create_dir_all(&sibling_root).unwrap();
git(&sibling_root, &["init", "-b", "main"]);
let sibling = sibling_root.join("sibling.ignore-me");
std::fs::write(&sibling, "x").unwrap();
let error =
vcs::vcs_add_to_ignore(&host, "main", vec![sibling], ide_vcs::IgnoreDestination::Gitignore).await.unwrap_err();
assert!(error.message.contains("outside the project"), "{error:?}");
assert!(!sibling_root.join(".gitignore").exists());
host.close_project("main");
}
+10 -1
Переглянути файл
@@ -199,7 +199,9 @@ async fn python_effective_interpreter_falls_back_to_the_primary_project() {
host.trust.decide(&member, true, false).unwrap();
host.open_project("main", &primary).unwrap();
let python = |near: Option<&std::path::Path>| {
ops::sdk::sdk_python_effective(&host, "main", near.map(|p| p.to_path_buf())).unwrap().map(|p| p.into_path_buf())
futures::executor::block_on(ops::sdk::sdk_python_effective(&host, "main", near.map(|p| p.to_path_buf())))
.unwrap()
.map(|p| p.into_path_buf())
};
// The primary project's own virtualenv, and the bare member inheriting it.
assert_eq!(python(Some(&primary)), Some(venv_python.clone()));
@@ -217,6 +219,13 @@ async fn python_effective_interpreter_falls_back_to_the_primary_project() {
)
.unwrap();
assert_eq!(python(Some(&member.join("src"))), Some(configured));
// A workspace file that fails to load (a corrupt one, say) falls back to the
// primary project's interpreter instead of failing the whole command.
let workspace_file = primary.join(ide_workspace::workspace::FILE);
let valid = std::fs::read(&workspace_file).unwrap();
std::fs::write(&workspace_file, b"{not json").unwrap();
assert_eq!(python(Some(&member.join("src"))), Some(venv_python.clone()));
std::fs::write(&workspace_file, valid).unwrap();
host.close_project("main");
}
+2
Переглянути файл
@@ -15,6 +15,8 @@ tokio.workspace = true
tracing.workspace = true
parking_lot.workspace = true
reqwest.workspace = true
# The system proxy reqwest reads, to notice when it changes (see `client::shared`).
hyper-util = { version = "0.1", default-features = false, features = ["client-proxy", "client-proxy-system"] }
rustls.workspace = true
rustls-platform-verifier.workspace = true
uuid.workspace = true
+81 -8
Переглянути файл
@@ -5,7 +5,7 @@ use ide_core::proxy_settings::{ProxyMode, ProxyRoute, ProxySettings};
use ide_core::{CancellationToken, IdeError, IdeResult};
use parking_lot::Mutex;
use std::sync::Arc;
use std::time::Duration;
use std::time::{Duration, Instant};
/// `builder` routed as `proxy` says: direct, the environment's proxy (reqwest's
/// default), or the manual proxy except for the "No proxy for" hosts.
@@ -62,18 +62,61 @@ pub fn build_with_redirect(proxy: &ProxySettings, redirect: reqwest::redirect::P
with_proxy(builder, proxy).build().map_err(|e| fail(e.to_string()))
}
/// A client built for these proxy settings and, in Auto mode, this system proxy.
struct Cached {
settings: Arc<ProxySettings>,
system: Option<String>,
client: reqwest::Client,
}
/// The client for the current proxy settings, rebuilt when they change.
pub fn shared() -> IdeResult<reqwest::Client> {
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
let proxy = ide_core::proxy_settings::proxy();
let mut cached = CLIENT.lock();
if let Some((settings, client)) = cached.as_ref()
&& **settings == *proxy
static CLIENT: Mutex<Option<Cached>> = Mutex::new(None);
cached_client(&CLIENT, build, system_proxy)
}
/// The client the HTTP Client executes requests with: redirects off, `exec`
/// follows them by hand — that is what lets a `POST` stay a `POST` on a
/// 301/302 and puts the redirect chain into the response.
pub fn shared_without_redirects() -> IdeResult<reqwest::Client> {
static CLIENT: Mutex<Option<Cached>> = Mutex::new(None);
cached_client(&CLIENT, |proxy| build_with_redirect(proxy, reqwest::redirect::Policy::none()), system_proxy)
}
/// The system proxy (the environment's, then macOS / Windows settings) as reqwest reads
/// it when a client is built, re-read at most every few seconds. A client in Auto mode
/// keeps the proxy it was built with, so a proxy app that switches the system proxy on
/// after launch would otherwise leave downloads going direct until a restart.
fn system_proxy() -> String {
static LAST: Mutex<Option<(Instant, String)>> = Mutex::new(None);
let mut last = LAST.lock();
if let Some((at, seen)) = last.as_ref()
&& at.elapsed() < Duration::from_secs(3)
{
return Ok(client.clone());
return seen.clone();
}
// Credentials are left out of the matcher's `Debug`.
let seen = format!("{:?}", hyper_util::client::proxy::matcher::Matcher::from_system());
*last = Some((Instant::now(), seen.clone()));
seen
}
fn cached_client(
slot: &Mutex<Option<Cached>>,
build: impl Fn(&ProxySettings) -> IdeResult<reqwest::Client>,
system: fn() -> String,
) -> IdeResult<reqwest::Client> {
let proxy = ide_core::proxy_settings::proxy();
let system = (proxy.mode == ProxyMode::Auto).then(system);
let mut cached = slot.lock();
if let Some(c) = cached.as_ref()
&& *c.settings == *proxy
&& c.system == system
{
return Ok(c.client.clone());
}
let client = build(&proxy)?;
*cached = Some((proxy, client.clone()));
*cached = Some(Cached { settings: proxy, system, client: client.clone() });
Ok(client)
}
@@ -127,6 +170,36 @@ pub fn describe(e: &reqwest::Error) -> String {
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn auto_mode_rebuilds_the_shared_client_when_the_system_proxy_changes() {
static SYSTEM: Mutex<String> = Mutex::new(String::new());
static BUILDS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
fn system() -> String {
SYSTEM.lock().clone()
}
let slot = Mutex::new(None);
let get = || {
cached_client(
&slot,
|proxy| {
BUILDS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
build(proxy)
},
system,
)
.unwrap()
};
assert_eq!(ide_core::proxy_settings::proxy().mode, ProxyMode::Auto);
get();
get();
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 1);
// A proxy app switches the system proxy on after launch.
*SYSTEM.lock() = "Matcher { https: 127.0.0.1:7890 }".into();
get();
get();
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 2);
}
use ide_core::proxy_settings::ProxyKind;
use std::io::{BufRead, BufReader, Write};
use std::net::TcpListener;
+288 -15
Переглянути файл
@@ -13,6 +13,19 @@ use std::time::Instant;
/// Bodies above this are cut (the full size is still reported).
pub const MAX_BODY: usize = 16 * 1024 * 1024;
/// Redirects followed per request; beyond this the redirect response itself is
/// returned (IntelliJ's HTTP Client follows the same number).
pub const MAX_REDIRECTS: usize = 50;
/// Responses whose `Location` is followed: 301, 302, 303, 307 and 308, the set
/// IntelliJ's HTTP Client redirects on.
const REDIRECT_STATUSES: [u16; 5] = [301, 302, 303, 307, 308];
/// Request headers not re-sent to a redirect on another host. IntelliJ's HTTP
/// Client strips the same set and restores it when the redirect stays on the
/// original host.
const SENSITIVE_HEADERS: [&str; 5] = ["authorization", "cookie", "cookie2", "www-authenticate", "proxy-authorization"];
/// A request ready to send: variables substituted, includes read.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -24,6 +37,15 @@ pub struct PreparedRequest {
pub body: Option<String>,
}
/// One followed redirect: the response and the `Location` it pointed to.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RedirectHop {
pub status: u16,
pub status_text: String,
pub location: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct HttpResponse {
@@ -32,6 +54,9 @@ pub struct HttpResponse {
pub version: String,
pub headers: Vec<(String, String)>,
pub content_type: Option<String>,
/// Followed redirects, first hop first; empty when not redirected.
#[serde(default)]
pub redirects: Vec<RedirectHop>,
/// Body as text (lossy UTF-8); `None` for binary bodies.
pub body: Option<String>,
/// Size in bytes as received (after decompression).
@@ -128,25 +153,84 @@ fn looks_textual(content_type: Option<&str>, bytes: &[u8]) -> bool {
}
}
/// Sends `req`; cancelled when `cancel` fires.
/// The request for one hop: `req`'s headers and body against `url`, the
/// sensitive headers dropped when the redirect crosses to another host.
fn request_to(
client: &reqwest::Client,
method: &reqwest::Method,
req: &PreparedRequest,
body: Option<&str>,
original: &reqwest::Url,
url: &reqwest::Url,
) -> IdeResult<reqwest::Request> {
let same_host = url.host_str() == original.host_str();
let mut builder = client.request(method.clone(), url.clone());
for (k, v) in &req.headers {
if same_host || !SENSITIVE_HEADERS.iter().any(|s| k.eq_ignore_ascii_case(s)) {
builder = builder.header(k, v);
}
}
if let Some(body) = body {
builder = builder.body(body.to_owned());
}
builder.build().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))
}
/// Sends `request`; cancelled when `cancel` fires.
async fn send(
client: &reqwest::Client,
request: reqwest::Request,
cancel: &CancellationToken,
) -> IdeResult<reqwest::Response> {
let send = client.execute(request);
tokio::select! {
r = send => r.map_err(|e| IdeError::new(ide_core::error::ErrorKind::Io, describe(&e))),
() = cancel.cancelled() => Err(IdeError::cancelled()),
}
}
/// Sends `req`, following redirects the way IntelliJ's HTTP Client does:
/// 301, 302, 303, 307 and 308 up to [`MAX_REDIRECTS`] times, `303` continuing
/// as `GET` without the body, the other statuses keeping the method and body —
/// so a `POST` redirected to `https` on the same host is re-sent as a `POST`.
/// Sensitive headers (Authorization, cookies, proxy credentials) are not
/// re-sent across hosts. The followed hops are reported in the response.
/// Cancelled when `cancel` fires.
pub async fn execute(req: &PreparedRequest, cancel: &CancellationToken) -> IdeResult<HttpResponse> {
let client = crate::client::shared()?;
let client = crate::client::shared_without_redirects()?;
let method = reqwest::Method::from_bytes(req.method.as_bytes())
.map_err(|_| IdeError::invalid(format!("invalid method {}", req.method)))?;
let mut builder = client.request(method, &req.url);
for (k, v) in &req.headers {
builder = builder.header(k, v);
}
if let Some(body) = &req.body {
builder = builder.body(body.clone());
}
let request = builder.build().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))?;
let original = req.url.parse::<reqwest::Url>().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))?;
let mut url = original.clone();
let mut method = method;
let mut body = req.body.clone();
let mut redirects = Vec::new();
let started = Instant::now();
let send = client.execute(request);
let mut response = tokio::select! {
r = send => r.map_err(|e| IdeError::new(ide_core::error::ErrorKind::Io, describe(&e)))?,
() = cancel.cancelled() => return Err(IdeError::cancelled()),
};
let mut response;
loop {
let request = request_to(&client, &method, req, body.as_deref(), &original, &url)?;
response = send(&client, request, cancel).await?;
let status = response.status();
if redirects.len() >= MAX_REDIRECTS || !REDIRECT_STATUSES.contains(&status.as_u16()) {
break;
}
let next = response
.headers()
.get(reqwest::header::LOCATION)
.and_then(|v| v.to_str().ok())
.and_then(|location| url.join(location).ok());
let Some(next) = next else { break };
redirects.push(RedirectHop {
status: status.as_u16(),
status_text: status.canonical_reason().unwrap_or("").to_owned(),
location: next.to_string(),
});
if status == reqwest::StatusCode::SEE_OTHER {
method = reqwest::Method::GET;
body = None;
}
url = next;
}
let ttfb = started.elapsed();
let status = response.status();
let version = format!("{:?}", response.version());
@@ -179,6 +263,7 @@ pub async fn execute(req: &PreparedRequest, cancel: &CancellationToken) -> IdeRe
version,
headers,
content_type,
redirects,
body,
size: size as f64,
truncated: size > bytes.len(),
@@ -249,6 +334,47 @@ mod tests {
assert_eq!(url("GET https://api.test/cb?u=http://x\n"), "https://api.test/cb?u=http://x");
}
/// A loopback server answering each accepted connection with the next of
/// `responses`, returning every request as its head and body.
async fn scripted(responses: Vec<String>) -> (u16, tokio::task::JoinHandle<Vec<(String, String)>>) {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let handle = tokio::spawn(async move {
let mut seen = Vec::new();
for response in responses {
let (mut socket, _) = listener.accept().await.unwrap();
let mut request = Vec::new();
let (head, body) = loop {
let mut buffer = [0u8; 4096];
let read = socket.read(&mut buffer).await.unwrap();
assert!(read > 0, "request ended before its body");
request.extend_from_slice(&buffer[..read]);
let Some(end) = request.windows(4).position(|w| w == b"\r\n\r\n") else { continue };
let head = String::from_utf8_lossy(&request[..end]).into_owned();
let length: usize = head
.lines()
.find_map(|line| {
let (name, value) = line.split_once(':')?;
name.eq_ignore_ascii_case("content-length").then(|| value.trim().parse().unwrap())
})
.unwrap_or(0);
if request.len() >= end + 4 + length {
break (head, String::from_utf8_lossy(&request[end + 4..end + 4 + length]).into_owned());
}
};
seen.push((head, body));
socket.write_all(response.as_bytes()).await.unwrap();
}
seen
});
(port, handle)
}
fn response(status_line: &str, headers: &str, body: &str) -> String {
format!("HTTP/1.1 {status_line}\r\n{headers}Content-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len())
}
#[tokio::test]
async fn sends_exact_environment_numbers_to_a_local_server() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
@@ -341,6 +467,7 @@ mod tests {
assert_eq!(r.status_text, "Created");
assert_eq!(r.body.as_deref(), Some("{\"ok\":true}"));
assert!(r.headers.iter().any(|(k, v)| k == "x-a" && v == "b"));
assert!(r.redirects.is_empty());
assert!(r.total_ms >= r.ttfb_ms);
}
@@ -369,4 +496,150 @@ mod tests {
let err = execute(&req, &cancel).await.unwrap_err();
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
}
#[tokio::test]
async fn post_keeps_method_and_body_on_301_302_307_308() {
for status_line in ["301 Moved Permanently", "302 Found", "307 Temporary Redirect", "308 Permanent Redirect"] {
let status: u16 = status_line[..3].parse().unwrap();
let (port, server) =
scripted(vec![response(status_line, "Location: /landing\r\n", ""), response("200 OK", "", "ok")]).await;
let req = PreparedRequest {
name: None,
method: "POST".into(),
url: format!("http://127.0.0.1:{port}/submit"),
headers: vec![("Content-Type".into(), "application/json".into())],
body: Some("{\"a\":1}".into()),
};
let r = execute(&req, &CancellationToken::new()).await.unwrap();
let seen = server.await.unwrap();
let (head, body) = &seen[1];
assert_eq!(head.lines().next().unwrap(), "POST /landing HTTP/1.1", "{status_line}");
assert!(head.to_ascii_lowercase().contains("content-type: application/json"), "{head}");
assert_eq!(body, "{\"a\":1}", "{status_line}");
assert_eq!(r.status, 200, "{status_line}");
assert_eq!(r.body.as_deref(), Some("ok"), "{status_line}");
assert_eq!(
r.redirects,
vec![RedirectHop {
status,
status_text: status_line[4..].to_owned(),
location: format!("http://127.0.0.1:{port}/landing"),
}],
"{status_line}"
);
}
}
#[tokio::test]
async fn see_other_303_resends_as_get_without_the_body() {
let (port, server) =
scripted(vec![response("303 See Other", "Location: /after\r\n", ""), response("200 OK", "", "done")]).await;
let req = PreparedRequest {
name: None,
method: "POST".into(),
url: format!("http://127.0.0.1:{port}/submit"),
headers: vec![],
body: Some("{\"a\":1}".into()),
};
let r = execute(&req, &CancellationToken::new()).await.unwrap();
let seen = server.await.unwrap();
assert_eq!(seen[1].0.lines().next().unwrap(), "GET /after HTTP/1.1");
assert_eq!(seen[1].1, "");
assert_eq!(r.status, 200);
assert_eq!(r.body.as_deref(), Some("done"));
assert_eq!(r.redirects[0].status, 303);
}
#[tokio::test]
async fn same_host_redirect_keeps_authorization() {
let (port, server) = scripted(vec![
response("301 Moved Permanently", "Location: /landing\r\n", ""),
response("200 OK", "", "ok"),
])
.await;
let req = PreparedRequest {
name: None,
method: "GET".into(),
url: format!("http://127.0.0.1:{port}/start"),
headers: vec![("Authorization".into(), "Bearer secret".into())],
body: None,
};
execute(&req, &CancellationToken::new()).await.unwrap();
let seen = server.await.unwrap();
assert!(seen[1].0.to_ascii_lowercase().contains("authorization: bearer secret"), "{}", seen[1].0);
}
#[tokio::test]
async fn cross_host_redirect_keeps_the_method_but_drops_authorization() {
let (port_b, server_b) = scripted(vec![response("200 OK", "", "moved")]).await;
let (port_a, server_a) = scripted(vec![response(
"301 Moved Permanently",
&format!("Location: http://127.0.0.1:{port_b}/x\r\n"),
"",
)])
.await;
let req = PreparedRequest {
name: None,
method: "POST".into(),
url: format!("http://localhost:{port_a}/start"),
headers: vec![("Authorization".into(), "Bearer secret".into())],
body: Some("{\"a\":1}".into()),
};
let r = execute(&req, &CancellationToken::new()).await.unwrap();
let seen_a = server_a.await.unwrap();
let seen_b = server_b.await.unwrap();
assert!(seen_a[0].0.to_ascii_lowercase().contains("authorization: bearer secret"), "{}", seen_a[0].0);
assert_eq!(seen_b[0].0.lines().next().unwrap(), "POST /x HTTP/1.1");
assert!(!seen_b[0].0.to_ascii_lowercase().contains("authorization"), "{}", seen_b[0].0);
assert_eq!(seen_b[0].1, "{\"a\":1}");
assert_eq!(r.status, 200);
assert_eq!(r.body.as_deref(), Some("moved"));
assert_eq!(r.redirects.len(), 1);
}
#[tokio::test]
async fn redirects_beyond_the_limit_return_the_last_redirect_response() {
let responses = vec![response("301 Moved Permanently", "Location: /loop\r\n", ""); MAX_REDIRECTS + 1];
let (port, server) = scripted(responses).await;
let req = PreparedRequest {
name: None,
method: "GET".into(),
url: format!("http://127.0.0.1:{port}/start"),
headers: vec![],
body: None,
};
let r = execute(&req, &CancellationToken::new()).await.unwrap();
let seen = server.await.unwrap();
assert_eq!(r.status, 301);
assert_eq!(r.status_text, "Moved Permanently");
assert_eq!(r.redirects.len(), MAX_REDIRECTS);
assert_eq!(seen.len(), MAX_REDIRECTS + 1);
}
#[tokio::test]
async fn redirect_chain_is_recorded_across_hops() {
let (port, server) = scripted(vec![
response("302 Found", "Location: /b\r\n", ""),
response("302 Found", "Location: /c\r\n", ""),
response("200 OK", "", "end"),
])
.await;
let req = PreparedRequest {
name: None,
method: "GET".into(),
url: format!("http://127.0.0.1:{port}/a"),
headers: vec![],
body: None,
};
let r = execute(&req, &CancellationToken::new()).await.unwrap();
let seen = server.await.unwrap();
assert_eq!(r.status, 200);
assert_eq!(r.body.as_deref(), Some("end"));
assert_eq!(r.redirects.len(), 2);
assert_eq!(r.redirects[0].status, 302);
assert_eq!(r.redirects[0].location, format!("http://127.0.0.1:{port}/b"));
assert_eq!(r.redirects[1].status, 302);
assert_eq!(r.redirects[1].location, format!("http://127.0.0.1:{port}/c"));
assert_eq!(seen[2].0.lines().next().unwrap(), "GET /c HTTP/1.1");
}
}
+4 -4
Переглянути файл
@@ -265,7 +265,7 @@ impl ProjectIndex {
pub fn find_files(&self, query: &str, limit: usize) -> Vec<FileMatch> {
let recent = self.shared.recent.lock().clone();
let d = self.shared.data.read();
matching::find_files(&d, &matching::Recents::new(&recent), query, limit)
matching::find_files(&d, &matching::Recents::new(&recent), query, Some(&self.root), limit)
}
/// All indexed files with this exact basename, for resolving printed source locations.
@@ -301,7 +301,7 @@ impl ProjectIndex {
/// Fuzzy search for folders that hold indexed files; `rel_path` ends in `/`.
pub fn find_dirs(&self, query: &str, limit: usize) -> Vec<FileMatch> {
matching::find_dirs(&self.shared.data.read(), query, limit)
matching::find_dirs(&self.shared.data.read(), query, Some(&self.root), limit)
}
/// Fuzzy symbol search; CamelHump aware (`OCo` → `OrderController`).
@@ -574,11 +574,11 @@ pub mod bench_support {
}
pub fn find_files(&self, query: &str, limit: usize) -> Vec<FileMatch> {
matching::find_files(&self.data, &matching::Recents::new(&self.recent), query, limit)
matching::find_files(&self.data, &matching::Recents::new(&self.recent), query, None, limit)
}
pub fn find_dirs(&self, query: &str, limit: usize) -> Vec<FileMatch> {
matching::find_dirs(&self.data, query, limit)
matching::find_dirs(&self.data, query, None, limit)
}
pub fn find_symbols(&self, query: &str, filter: SymbolFilter, limit: usize) -> Vec<SymbolMatch> {
+56 -8
Переглянути файл
@@ -205,29 +205,67 @@ impl<'a> Recents<'a> {
}
}
/// `Foo.kt:12:3` -> `Foo.kt`; `\` -> `/`; strips leading `./` and `/`.
fn normalize_file_query(q: &str) -> String {
/// `Foo.kt:12:3` -> `Foo.kt`; `\` -> `/`; a pasted absolute path under `root` -> its project-relative
/// form; strips leading `./` and `/`.
fn normalize_file_query(q: &str, root: Option<&Path>) -> String {
let mut q = q.trim().replace('\\', "/");
// `\\?\C:\a` (verbatim) and `\\.\C:\a` name `C:/a`.
if let Some(rest) = verbatim_target(&q) {
q = rest.to_owned();
}
while let Some((head, tail)) = q.rsplit_once(':')
&& !tail.is_empty()
&& tail.bytes().all(|b| b.is_ascii_digit())
{
q = head.to_owned();
}
if let Some(root) = root
&& let Some(rel) = strip_root(&q, root)
{
q = rel;
}
let q = q.trim_start_matches("./").trim_start_matches('/');
q.chars().filter(|c| !c.is_whitespace()).collect()
}
/// Path a `\\?\` / `\\.\` verbatim prefix points at, for a `/`-separated path.
fn verbatim_target(q: &str) -> Option<&str> {
q.strip_prefix("//?/").or_else(|| q.strip_prefix("//./"))
}
/// `q` (already `/`-separated) below `root`, without the separating slash. A drive-letter root
/// compares like Windows, where case does not matter.
fn strip_root(q: &str, root: &Path) -> Option<String> {
let root = root.to_string_lossy().replace('\\', "/");
let root = verbatim_target(&root).unwrap_or(&root);
let root = root.trim_end_matches('/');
let windows = root.as_bytes().get(1) == Some(&b':');
let head = q.get(..root.len())?;
if head != root && !(windows && head.eq_ignore_ascii_case(root)) {
return None;
}
match q.get(root.len()..)? {
"" => Some(String::new()),
tail => tail.strip_prefix('/').map(str::to_owned),
}
}
enum FileQuery {
Name(Needle),
Path { dir: Needle, name: Needle },
}
pub(crate) fn find_files(data: &IndexData, recents: &Recents, query: &str, limit: usize) -> Vec<FileMatch> {
pub(crate) fn find_files(
data: &IndexData,
recents: &Recents,
query: &str,
root: Option<&Path>,
limit: usize,
) -> Vec<FileMatch> {
if limit == 0 {
return Vec::new();
}
let q = normalize_file_query(query);
let q = normalize_file_query(query, root);
if q.is_empty() {
return recents
.paths
@@ -306,8 +344,8 @@ pub(crate) fn find_files(data: &IndexData, recents: &Recents, query: &str, limit
/// Fuzzy folder search over the folders holding indexed files: folder-name matches beat
/// path matches; `/` in the query matches the whole path. `rel_path` ends in `/`.
pub(crate) fn find_dirs(data: &IndexData, query: &str, limit: usize) -> Vec<FileMatch> {
let q = normalize_file_query(query);
pub(crate) fn find_dirs(data: &IndexData, query: &str, root: Option<&Path>, limit: usize) -> Vec<FileMatch> {
let q = normalize_file_query(query, root);
if limit == 0 || q.is_empty() {
return Vec::new();
}
@@ -673,8 +711,18 @@ mod tests {
#[test]
fn normalizes_queries() {
assert_eq!(normalize_file_query(" ./src\\main.rs:12:4 "), "src/main.rs");
assert_eq!(normalize_file_query("/a b"), "ab");
let root = Path::new("E:/work/sample");
assert_eq!(normalize_file_query(" ./src\\main.rs:12:4 ", None), "src/main.rs");
assert_eq!(normalize_file_query("/a b", None), "ab");
// A pasted absolute path names an indexed file (#4079 follow-up).
assert_eq!(normalize_file_query(r"E:\work\sample\pkg\Config.go", Some(root)), "pkg/Config.go");
assert_eq!(normalize_file_query(r"e:/WORK/sample\pkg/Config.go", Some(root)), "pkg/Config.go");
assert_eq!(normalize_file_query(r"\\?\E:\work\sample\src\App.kt", Some(root)), "src/App.kt");
assert_eq!(normalize_file_query(r"E:\work\sample\pkg\Config.go:12:4", Some(root)), "pkg/Config.go");
// Outside the project, and a POSIX root, keep the path as given.
assert_eq!(normalize_file_query(r"E:\elsewhere\x.go", Some(root)), "E:/elsewhere/x.go");
assert_eq!(normalize_file_query("/home/me/Src/a.rs", Some(Path::new("/home/me/src"))), "home/me/Src/a.rs");
assert_eq!(normalize_file_query("/home/me/src/a.rs", Some(Path::new("/home/me/src"))), "a.rs");
assert_eq!(split_symbol_query("Order.save"), (Some("Order"), "save"));
assert_eq!(split_symbol_query("a::b::C::new"), (Some("C"), "new"));
assert_eq!(split_symbol_query("save"), (None, "save"));
+5 -2
Переглянути файл
@@ -13,6 +13,9 @@ const FILES: TableDefinition<&str, &[u8]> = TableDefinition::new("files");
const META: TableDefinition<&str, &[u8]> = TableDefinition::new("meta");
/// Bump when [`FileRecord`] or its encoding changes. 4: a symbol's base names.
const SCHEMA: &str = "openidea-index-4";
/// redb's page cache, which otherwise grows to 1 GiB. Queries run on the in-memory snapshot;
/// the database is read once at startup and written incrementally.
const DB_CACHE_BYTES: usize = 64 * 1024 * 1024;
/// The real Git directory for a checkout/worktree (`root/.git` may be a file
/// containing `gitdir: ...`).
@@ -389,7 +392,7 @@ impl Store {
fn open_db(&self) -> Result<Database> {
let file = self.snapshot.with_file_name("index.redb");
let db = match Database::create(&file) {
let db = match Database::builder().set_cache_size(DB_CACHE_BYTES).create(&file) {
Ok(db) => db,
Err(redb::DatabaseError::DatabaseAlreadyOpen) => {
return Err(format!("{} is in use", file.display()));
@@ -398,7 +401,7 @@ impl Store {
tracing::warn!("index cache {} unreadable ({e}); rebuilding", file.display());
let _ = std::fs::remove_file(&file);
let _ = std::fs::remove_file(&self.snapshot);
Database::create(&file).map_err(err)?
Database::builder().set_cache_size(DB_CACHE_BYTES).create(&file).map_err(err)?
}
};
let valid = {
+13
Переглянути файл
@@ -190,6 +190,19 @@ fn file_ranking_is_idea_like() {
assert_eq!(shown.to_lowercase(), "uibtn");
}
#[test]
fn a_pasted_absolute_path_finds_the_indexed_file() {
let fx = sample();
let idx = fx.open();
let abs = fx.root.join("src/ui/Button.tsx");
let abs = abs.to_string_lossy().into_owned();
assert_eq!(files(&idx, &abs)[0], "src/ui/Button.tsx");
// A trailing `:line:col`, and a path outside the project that names no file.
assert_eq!(files(&idx, &format!("{abs}:12:4"))[0], "src/ui/Button.tsx");
let outside = fx.root.parent().unwrap().join("elsewhere/Button.tsx");
assert!(files(&idx, &outside.to_string_lossy()).is_empty());
}
#[test]
fn find_dirs_ranks_folder_names() {
let f = sample();
+2
Переглянути файл
@@ -472,6 +472,8 @@ impl Shared {
fn full_scan(&self, found: Option<Vec<Found>>, guard: SystemTime) {
self.scan(None, found, guard);
// Parsing every file churns through far more memory than the index keeps.
ide_core::memory::release_free_pages();
}
fn scan(&self, dirs: Option<&[PathBuf]>, prewalked: Option<Vec<Found>>, guard: SystemTime) -> Option<ScanCounts> {
+22 -1
Переглянути файл
@@ -25,7 +25,7 @@ impl LspManager {
/// Whether jdtls serves the Java files of `path`. Without it, launches build with the
/// build tool and take the classpath from [`Self::java_server_classpath`] or the build model.
pub fn java_served_by_jdtls(&self, path: &Path) -> bool {
self.servers_for(&LanguageId::new("java"), path).iter().any(|s| s.name == JDTLS)
self.servers_for(&LanguageId::new("java"), path).iter().any(|s| s.name == JDTLS && !s.gave_up())
}
/// The java-analyzer executable among the Java servers of `path`, whatever the server is
@@ -107,6 +107,27 @@ fn is_java_analyzer(binary: &Path) -> bool {
#[cfg(test)]
mod tests {
use super::*;
use crate::server::Conn;
use ide_core::event::ServerStatus;
use ide_language::LanguageRegistry;
use std::sync::Arc;
#[test]
fn missing_jdtls_leaves_java_analyzer_to_serve_the_module() {
let project = tempfile::tempdir().unwrap();
let root = project.path();
let manager =
LspManager::new(root.to_path_buf(), Arc::new(LanguageRegistry::load(None).unwrap()), Arc::new(|_| {}));
assert!(manager.java_served_by_jdtls(root));
assert!(manager.java_analyzer_binary(root).is_none());
let jdtls = manager.servers_for(&LanguageId::new("java"), root).into_iter().find(|s| s.name == JDTLS).unwrap();
let generation = jdtls.begin_start().unwrap();
assert!(jdtls.fail_start(generation, Conn::Missing, manager.sink(), ServerStatus::Missing, None));
assert!(!manager.java_served_by_jdtls(root));
assert_eq!(manager.java_analyzer_binary(root).as_deref(), Some(Path::new("java-analyzer")));
}
#[test]
fn recognises_java_analyzer_by_its_executable() {
+8 -6
Переглянути файл
@@ -1049,12 +1049,14 @@ impl LspManager {
if let Err(e) = peer.notify("initialized", json!({})) {
tracing::warn!("{}: {e}", server.name);
}
// Servers that don't ask with `workspace/configuration` only learn settings this way.
let cfg = server.effective_config();
if cfg.settings.is_some()
&& let Err(e) =
peer.notify("workspace/didChangeConfiguration", json!({ "settings": handler::all_settings(&cfg) }))
{
// Sent even without settings: servers that don't ask with `workspace/configuration`
// only learn settings this way, and Pyright, given workspace folders, waits for it
// before asking and loading the workspace.
let mut settings = handler::all_settings(&server.effective_config());
if settings.is_null() {
settings = json!({});
}
if let Err(e) = peer.notify("workspace/didChangeConfiguration", json!({ "settings": settings })) {
tracing::debug!("{}: didChangeConfiguration: {e}", server.name);
}
+42 -3
Переглянути файл
@@ -1324,6 +1324,36 @@ async fn initialize_and_incremental_sync() {
assert_eq!(infos[0].status, ServerStatus::Ready);
}
/// Pyright, told the client has workspace folders, asks for its configuration and loads the
/// workspace only after a `workspace/didChangeConfiguration`: every server gets one at startup.
#[tokio::test(flavor = "multi_thread")]
async fn every_server_hears_its_configuration_once_initialized() {
let cases = [
(None, None, json!({})),
(Some(json!({ "flag": true })), None, json!({ "flag": true })),
(
None,
Some(json!({ "python": { "pythonPath": "/venv/bin/python" } })),
json!({ "python": { "pythonPath": "/venv/bin/python" } }),
),
(Some(json!({ "flag": true })), Some(json!({ "other": 2 })), json!({ "flag": true, "other": 2 })),
];
for (init, settings, expected) in cases {
let h = harness_configured("mock", "mk", &[("pyright", incremental_caps())], |cfg| {
cfg.initialization_options = init.clone().map(|v| toml::Value::try_from(v).unwrap());
cfg.settings = settings.clone();
});
h.open("a.mk", "x");
h.wait_status("pyright", ServerStatus::Ready).await;
let s = h.launcher.state("pyright");
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
assert_eq!(s.notified("workspace/didChangeConfiguration"), vec![json!({ "settings": expected })]);
let order: Vec<String> = s.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
let at = |m: &str| order.iter().position(|n| n == m).unwrap();
assert!(at("initialized") < at("workspace/didChangeConfiguration"));
}
}
#[tokio::test(flavor = "multi_thread")]
async fn full_sync_and_desync_recovery() {
let h = harness(&[("full", json!({ "textDocumentSync": 1 })), ("inc", json!({ "textDocumentSync": 2 }))]);
@@ -2650,7 +2680,16 @@ async fn configuration_answer_resyncs_open_documents_of_opted_in_servers() {
.await;
assert_eq!(s.notified("textDocument/didChange").len(), 2, "one re-sync per answer");
let methods: Vec<String> = extra.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
assert_eq!(methods, ["initialized", "textDocument/didOpen", "textDocument/didChange", "textDocument/didSave"]);
assert_eq!(
methods,
[
"initialized",
"workspace/didChangeConfiguration",
"textDocument/didOpen",
"textDocument/didChange",
"textDocument/didSave"
]
);
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
}
@@ -2706,9 +2745,9 @@ async fn settings_changes_reach_servers_without_restarts() {
let s = h.launcher.state("mock");
*settings.lock() = Some(json!({ "nested": { "other": 2 } }));
h.mgr.reconfigure().await;
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
eventually(|| s.notified("workspace/didChangeConfiguration").len() == 2).await;
assert_eq!(
s.notified("workspace/didChangeConfiguration")[0],
s.notified("workspace/didChangeConfiguration")[1],
json!({ "settings": { "flag": true, "nested": { "deep": 1, "other": 2 } } })
);
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
+26 -7
Переглянути файл
@@ -462,35 +462,54 @@ fn main() {
#[tokio::test(flavor = "multi_thread")]
#[ignore = "requires ty on PATH"]
async fn ty_python_end_to_end() {
python_server_end_to_end("ty").await;
}
/// Pyright loads the workspace only after `workspace/didChangeConfiguration`.
#[tokio::test(flavor = "multi_thread")]
#[ignore = "requires pyright-langserver on PATH"]
async fn pyright_python_end_to_end() {
python_server_end_to_end("pyright").await;
}
#[tokio::test(flavor = "multi_thread")]
#[ignore = "requires basedpyright on PATH"]
async fn basedpyright_python_end_to_end() {
python_server_end_to_end("basedpyright").await;
}
/// Definition and diagnostics from `name` alone, in a project without configuration.
async fn python_server_end_to_end(name: &str) {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().canonicalize().unwrap();
let path = root.join("example.py");
let source = "def greet(name: str) -> str:\n return name\n\nresult = greet('Ada')\nbad: int = 'wrong'\n";
std::fs::write(&path, source).unwrap();
let mut python = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("python")).unwrap();
python.language_servers.retain(|server| server.name == "ty");
python.language_servers.retain(|server| server.name == name);
assert_eq!(python.language_servers.len(), 1);
python.language_servers[0].fallback = false;
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![python]));
let doc = DocId::next();
mgr.did_open(doc, &path, &LanguageId::new("python"), 1, source);
retry("ty ready", Duration::from_secs(30), || {
let status = last_status(&events, "ty");
retry(&format!("{name} ready"), Duration::from_secs(30), || {
let status = last_status(&events, name);
if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, msg)) = &status {
panic!("ty failed: {msg:?}");
panic!("{name} failed: {msg:?}");
}
async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
})
.await;
let defs = retry("ty definition", Duration::from_secs(30), || {
let defs = retry(&format!("{name} definition"), Duration::from_secs(30), || {
let mgr = mgr.clone();
async move { mgr.goto(doc, Pos::new(3, 10), GotoKind::Definition).await.ok().filter(|d| !d.is_empty()) }
})
.await;
assert_eq!(defs[0].path, path);
assert_eq!(defs[0].range.start.line, 0);
retry("ty diagnostics", Duration::from_secs(30), || {
retry(&format!("{name} diagnostics"), Duration::from_secs(30), || {
let found = events.lock().iter().any(
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == "ty" && !items.is_empty()),
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == name && !items.is_empty()),
);
async move { found.then_some(()) }
})
+1 -1
Переглянути файл
@@ -1 +1 @@
9ec6fcb9763867a747206b0efaf8bbeac7934a4ec0d1915623557839cf2dba5e
b59392bcc1999048f0ab922ec659bc21d9e825c696fa41d9f0a40c85627a5b2c
+1 -1
Переглянути файл
@@ -1 +1 @@
2015380825fc406a6466f90658443f824ef06311894b82acae2ecc1446ff0813
034b99891313c03eb2a6b8c3cb2e4784129e1936965be803512f1d869b1768c2
+1 -1
Переглянути файл
@@ -1 +1 @@
7388e5ef7a5bff42f41ed613bfb75a8da835f93a63f8fb26358bb50b77b44c00
29ec0a96e2a0f6965915c7c25e35036743fc27a49037df588c217e8abfff93e3
+1 -1
Переглянути файл
@@ -1 +1 @@
aded25a93667f14a683b0bbb7547b35eed23e4971fdf2761496b09fd898b5034
87b367cfdd65c360920eff7be4d6a8d6b939721f6398aa6a01e39a289590699e
+1 -1
Переглянути файл
@@ -1 +1 @@
178bba6e74a51c0911502524f253cf7148854c46883c3f7f96d2c968e70522f5
7d034ee1a4b99615642d5bf033802f8e4662216d45b209c4c7a24eb8f1338f48
+1 -1
Переглянути файл
@@ -1 +1 @@
786e1abf853d615bf0eab7315280b3884e4c2ff6362c23a41a917d6af4c050e9
3fdf985273ec14ae623fa84602a9220cfbfb2e0e587ab192fc2bcb8d990ce9e3
+1 -1
Переглянути файл
@@ -1 +1 @@
77a825aa6adc3aa39ee390204e1fd35a12425d0a38552f116c74497dac446046
8434e9271e27a6778bb3d5922e8925f3fd9f1d35377e5dddf5b5eb5416bd09bb
+1 -1
Переглянути файл
@@ -1 +1 @@
352246ecdba1e3d43127c7b808a3b1cdf48cf0b4ae7d85d532ffaae734158e15
9fa7468ce385ff33c1f3b99c84711e0d11a84b10e8e4f95b358fcd2ccc96e255
+1 -1
Переглянути файл
@@ -1 +1 @@
da9abe9bd086f7808cc1520a592f47c843f26ecc0a5291110915467f57816dc4
5220a5bfb6ec0467a72e63e21d690e70b7d46b4f2eaff4116a8a79220a5eca8f
+1 -1
Переглянути файл
@@ -1 +1 @@
322b82aa432e072f8ae1d4345d321d227dbcb9376bd113c166b816254e7ddf13
a962127d1c6e37e85b81973a272a5d6b383cc2884b41bb2d82e8640ef5f8f943
+1 -1
Переглянути файл
@@ -1 +1 @@
e1ff50682e4aa18ca6bb96547cdd7b2815ad700e6ecaa3aede6d9f20205d4cdb
92ad3e43e7f343004dcf26a51e282e97ed694cc9bd7325ff75aa5b18f1a2eeb6
+1 -1
Переглянути файл
@@ -1 +1 @@
d3757cea9bcc8e33521c50c66b396d8ece2a90d830c2e57e651ebeb018536c62
2200ed0d44dbafb70ad864cb9569b0b2c37cf9eec1582b05efa903a9e8ec89ee
+1 -1
Переглянути файл
@@ -1 +1 @@
409e7017849fc68bd3241bfa5357366259e1eb634fb71ef69d4b857bec0aa821
644612ee4228010f141042ea0eab5431b8386370f863a70b63cd3315f69d963a
+1 -1
Переглянути файл
@@ -1 +1 @@
0b217ad8f0c8f802c1d670422d9621d07553985b9852f3efb724b17688cfa3b9
2af5d46516bfc1d38ad1f24d6cf3c57e2d6db6b0d3225748f55c4f13110430fb
+1 -1
Переглянути файл
@@ -1 +1 @@
8cc7d2ce4e21838f8f1b0f5bd56aea61257fe288f6b7189343ccf849a78de665
0ee0773cefd61b8144d0550718e1988a1e60438bee826c3867350e28886a56f7
+1 -1
Переглянути файл
@@ -1 +1 @@
19b8af5e283a0a6ae866538096d2fa95e51020a9fd423768224c2ae4cfcefa27
941cb9008aaab11464b193c37b91e2476d771ec526247713f291c6642caf5995
+1 -1
Переглянути файл
@@ -1 +1 @@
ccaa7d24825c05409dbcfe1491276b229ee6d712f2ba18556413a87d851c475c
06d70aae3152c88d1299a9b33f151b0baa4a77c3ca7145215c6f6e0aa40727b2
+1 -1
Переглянути файл
@@ -1 +1 @@
b0ae383f86a8059e0bc723ca1cd21dfa76a0faa68975a1b827b44ebe1ffad2f1
86eb87758e4f7c0242a18f12a113c31d418da64d7198041120f19401a5707bfb
+1 -1
Переглянути файл
@@ -1 +1 @@
38eadb34cc096538f2b529beb07d10860323356c554dd8171ccc7ca25ebfec8e
4442bb686fa18e8e8a52fd1cd8683b8767ec7908ffc1454dff476d9cb1711be9
+1 -1
Переглянути файл
@@ -1 +1 @@
1c5c9a19b4dc05219b3c144b21cad6e05a98fe5c01da7c67383cc39223b6e4d8
dd51f1b8634ff6305ba1a69c8457bd586996200a2b18e4a08d0cfa2fb60abaf6
+1 -1
Переглянути файл
@@ -1 +1 @@
d76fe0c659ef337ae7bb9c75ecfa5a9bcdff2eb92d487ca0df2aefa77bd21daf
4319f2655ee1e240b33f4b96c23fff59c61aa62d6ccc628715e5ff9fe38c2717
+1 -1
Переглянути файл
@@ -1 +1 @@
f671d361a8de5eead5c4ed801bfeacafb7b0aa82abefddbe2436c4d679a56d37
50c4fd7e08a4187afae0e00c775a61578b82bbad056807ad063ee47e79e2cef1
+1 -1
Переглянути файл
@@ -1 +1 @@
5cbb5a91f8676fbc0178535f58213eca341c52e210264ffe3da9eb2a47ef02af
220666302d814e6d8bde346954205c94c82320d5584d46f01672fd7d32400bf3
+1 -1
Переглянути файл
@@ -1 +1 @@
79d5d589c64b66fab58f6fc2cd2a10e91ad23e0dc34b356f6d6d51d7fdcca8b0
4ee484afaa1a1f71a9e544582d90db3260307fc89b8f514aaaff883df2761ba6
+1 -1
Переглянути файл
@@ -1 +1 @@
4eb1b77f62effb313bf67c1dfe34b8e0718bf5afaf84c8252d664b9a9888d040
3fba59ce802d88a2a1c026480a2cb8ce4d9539eb7b88f5a18bf6232f7adef147
+1 -1
Переглянути файл
@@ -1 +1 @@
a36c3f0d92237f226d47325dc4e33312f9179e0e05673154fc07d61f6e68f86e
73433da25d5304d0a3cb83d750d02feb5e270ee7e9f680c4ee9d923afa9aa066
+1 -1
Переглянути файл
@@ -1 +1 @@
2b48734dcf4a8cdf0db0ec80628754a836a0efb2f11dac9fd0fcf80572a23dfe
12df43f99eac93f4e1a070635780ad653932cf69a14595175d8ba6d4f0a4445c
+1 -1
Переглянути файл
@@ -1 +1 @@
fc1cb738668cee77a4d2a7b48d5543a29d568a8d2231921f5257de6a835be307
427b63c11188689262101cde971af0a92e54bd6c88a4e3cc8fdfa1a7c8c95fce
+1 -1
Переглянути файл
@@ -1 +1 @@
f609a501e4e752055d9c8f0ff20d1397b0085587f1435af2928e47fe8507f6ca
07ae58fe39746b779b1e466d7bbbb666ba550f427c7bf8de97d7ede647c00bc0
+1 -1
Переглянути файл
@@ -1 +1 @@
dcacc16856c9b9f11245e4b8c686b1ef6532a0f4090cdf531dafb76f0663a00a
f9912644c28512e37299834123cd4c94f6ed11f29bd38ddbc1c92df168447494
+1 -1
Переглянути файл
@@ -1 +1 @@
ca252d45f83c5e5b9378d6acec40319db2d6acc636d13bf7e79a5339869f7f09
ea0eec8c07d6469d3ab63c3bb08c85b01208be1757edffe5eabcb7be79ccf537
+1 -1
Переглянути файл
@@ -1 +1 @@
f54f4b5ac28e44b8d288104a6290557743e68d2b50af4583dc51a01aca7e7777
1ce55fabaa5ea1ddf770c8a1ad7f7b60a843c82c453d42289088c4b2fec61d84
+1 -1
Переглянути файл
@@ -1 +1 @@
cc98a2e2e74b14a84d3272b41211679a15d06abd4dd664bd87da5ece439e0c00
3356b4ec918c668c4c249f84afb9bafcd06c073ba86235b6ceea7ef6220cdaf5
+71 -57
Переглянути файл
@@ -349,64 +349,9 @@ impl RemoteService {
progress: &mut (dyn FnMut(&str, usize, usize) + Send),
) -> IdeResult<TransferReport> {
let fs = self.fs(connection).await?;
let mut report = TransferReport::default();
let mut folders = Vec::new();
let mut jobs = Vec::new();
for remote in remotes {
let Some(top) = download_target(dir, remote, remote) else {
report.skipped += 1;
continue;
};
match fs.stat(remote).await {
Ok(Some(e)) if e.is_dir => {
folders.push(top);
let mut entries = Vec::new();
if let Err(e) = remote_tree(&fs, remote, cancel, &mut entries).await {
report.fail(remote.clone(), e);
}
for entry in entries {
match download_target(dir, remote, &entry.path) {
Some(local) if entry.is_dir => folders.push(local),
Some(local) => jobs.push((entry.path, local)),
None => report.skipped += 1,
}
}
}
Ok(Some(_)) => jobs.push((remote.clone(), top)),
Ok(None) => report.fail(remote.clone(), IdeError::not_found(format!("{remote} does not exist"))),
Err(e) => report.fail(remote.clone(), e),
}
}
let root = tokio::fs::canonicalize(dir).await?;
for folder in &folders {
if !stays_inside(&root, folder).await {
report.fail(folder.display().to_string(), outside(folder));
} else if let Err(e) = tokio::fs::create_dir_all(folder).await {
report.fail(folder.display().to_string(), e.into());
}
}
for (i, (remote, local)) in jobs.iter().enumerate() {
if cancel.is_cancelled() {
break;
}
progress(remote, i, jobs.len());
if !stays_inside(&root, local).await {
report.fail(remote.clone(), outside(local));
continue;
}
if let Some(parent) = local.parent()
&& let Err(e) = tokio::fs::create_dir_all(parent).await
{
report.fail(remote.clone(), e.into());
continue;
}
match fs.download(remote, local).await {
Ok(()) => report.files += 1,
Err(e) => report.fail(remote.clone(), e),
}
}
let r = download_into(&fs, remotes, dir, cancel, progress).await;
fs.close().await;
Ok(report)
r
}
// --- save hook -----------------------------------------------------------------
@@ -656,6 +601,75 @@ fn cache_key(connection: &FsConnection) -> String {
}
/// Files and folders under remote folder `dir` (symlinked folders are not followed).
/// `remotes` (folders recursively) into the local folder `dir`, each under its own name, without
/// the remote path above it; existing files are replaced. Remote Host › Download to…, and the
/// project view's Download to… in a remote project.
pub async fn download_into(
fs: &RemoteFs,
remotes: &[String],
dir: &Path,
cancel: &CancellationToken,
progress: &mut (dyn FnMut(&str, usize, usize) + Send),
) -> IdeResult<TransferReport> {
let mut report = TransferReport::default();
let mut folders = Vec::new();
let mut jobs = Vec::new();
for remote in remotes {
let Some(top) = download_target(dir, remote, remote) else {
report.skipped += 1;
continue;
};
match fs.stat(remote).await {
Ok(Some(e)) if e.is_dir => {
folders.push(top);
let mut entries = Vec::new();
if let Err(e) = remote_tree(fs, remote, cancel, &mut entries).await {
report.fail(remote.clone(), e);
}
for entry in entries {
match download_target(dir, remote, &entry.path) {
Some(local) if entry.is_dir => folders.push(local),
Some(local) => jobs.push((entry.path, local)),
None => report.skipped += 1,
}
}
}
Ok(Some(_)) => jobs.push((remote.clone(), top)),
Ok(None) => report.fail(remote.clone(), IdeError::not_found(format!("{remote} does not exist"))),
Err(e) => report.fail(remote.clone(), e),
}
}
let root = tokio::fs::canonicalize(dir).await?;
for folder in &folders {
if !stays_inside(&root, folder).await {
report.fail(folder.display().to_string(), outside(folder));
} else if let Err(e) = tokio::fs::create_dir_all(folder).await {
report.fail(folder.display().to_string(), e.into());
}
}
for (i, (remote, local)) in jobs.iter().enumerate() {
if cancel.is_cancelled() {
break;
}
progress(remote, i, jobs.len());
if !stays_inside(&root, local).await {
report.fail(remote.clone(), outside(local));
continue;
}
if let Some(parent) = local.parent()
&& let Err(e) = tokio::fs::create_dir_all(parent).await
{
report.fail(remote.clone(), e.into());
continue;
}
match fs.download(remote, local).await {
Ok(()) => report.files += 1,
Err(e) => report.fail(remote.clone(), e),
}
}
Ok(report)
}
async fn remote_tree(
fs: &RemoteFs,
dir: &str,
+20 -6
Переглянути файл
@@ -631,9 +631,11 @@ fn spring_boot_apps(root: &Path, build: &Path, out: &mut Vec<RunConfig>) {
}
}
/// The module has main sources, and its build applies the Spring Boot plugin: its own build
/// file, or a build above it in `build` that applies it to its modules (a parent POM's
/// `<build><plugins>`, Gradle's `subprojects` / `allprojects`).
/// The module has main sources and Spring Boot on its classpath, as far as its build files
/// tell: its own build, or a build above it in `build` that hands Spring Boot to its modules,
/// references it (a dependency, the starter parent, the BOM or the plugin). A Maven module that
/// depends on Spring Boot through a parent or another module is a Spring Boot application even
/// without the packaging plugin; only `<pluginManagement>` alone doesn't count.
fn applies_spring_boot(build: &Path, module: &Path) -> bool {
if !["java", "kotlin"].iter().any(|l| module.join("src/main").join(l).is_dir()) {
return false;
@@ -642,15 +644,19 @@ fn applies_spring_boot(build: &Path, module: &Path) -> bool {
if pom.contains("<packaging>pom</packaging>") {
return false;
}
if pom.contains("spring-boot-maven-plugin") {
if references_spring_boot(&without_plugin_management(&pom)) {
return true;
}
} else if GRADLE_BUILDS.iter().filter_map(|n| read(&module.join(n))).any(|text| applies_boot_gradle_plugin(&text)) {
} else if GRADLE_BUILDS
.iter()
.filter_map(|n| read(&module.join(n)))
.any(|text| applies_boot_gradle_plugin(&text) || text.contains("org.springframework.boot:"))
{
return true;
}
module.ancestors().skip(1).take_while(|dir| dir.starts_with(build)).any(|dir| {
if let Some(pom) = read(&dir.join("pom.xml")) {
return without_plugin_management(&pom).contains("spring-boot-maven-plugin");
return references_spring_boot(&without_plugin_management(&pom));
}
GRADLE_BUILDS.iter().filter_map(|n| read(&dir.join(n))).any(|text| {
(text.contains("subprojects") || text.contains("allprojects")) && applies_boot_gradle_plugin(&text)
@@ -658,6 +664,14 @@ fn applies_spring_boot(build: &Path, module: &Path) -> bool {
})
}
/// A POM (without its `<pluginManagement>`) referencing Spring Boot: a dependency or the parent
/// (`org.springframework.boot`), a starter, the BOM import or the plugin.
fn references_spring_boot(pom: &str) -> bool {
["org.springframework.boot", "spring-boot-starter", "spring-boot-dependencies", "spring-boot-maven-plugin"]
.iter()
.any(|m| pom.contains(m))
}
/// A Gradle build applying the plugin (`id("org.springframework.boot")`, `apply plugin: '…'`),
/// not only depending on Spring Boot (`org.springframework.boot:…`).
fn applies_boot_gradle_plugin(text: &str) -> bool {
Loaded 100 of 839 files, more files were not shown because too many files have changed in this diff. Show more