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

...
Автор SHA1 Повідомлення Дата
l0ng-ai 98856fd5a1 Merge remote-tracking branch 'origin/main' into HEAD
# Conflicts:
#	e2e/debugVariablesLayout.spec.ts
2026-11-22 20:34:54 +08:00
l0ng-ai d3be99543d fix(run): anchor console fold controls in the gutter (#5198)
Expanded output has a collapse control beside its row in the Run console gutter. It stays at the left edge while long output scrolls horizontally. A fold at the start of the buffer keeps its control after expansion, and activating a focused fold control leaves process input alone.
2026-11-22 20:34:31 +08:00
l0ng-ai f0cc99a4c7 fix(vcs): give commit subjects room beside compact refs (#5191)
Give Git Log commit subjects room beside long reference labels. Compact References View keeps labels within about a third of the available text column, with the full reference on hover. References in the log use the small UI font and the layout works on either side of the subject.
2026-11-22 20:34:26 +08:00
l0ng-ai 8db16dea32 fix(editor): keep same-name tabs distinguishable (#5187)
Same-name editor tabs show the distinguishing directory before the filename. In a narrow split, the directory gives up space first and the filename stays intact when it fits. The Hidden Tabs picker uses the same path label.
2026-11-22 20:34:21 +08:00
l0ng-ai 6a7297519c fix(settings): keep the current page visible in breadcrumbs (#5196)
Keep the current page name visible as the Settings pane narrows. Parent labels shorten first, and the breadcrumb tooltip shows the full path.
2026-11-22 20:33:01 +08:00
l0ng-ai 08362db3ca fix(run): keep the test summary together and clarify its status (#5186)
Keep elapsed time beside the test counts in the Run window at the same text size. The summary keeps its Running label when the first test has started and no results have arrived yet. A thin line below the summary shows the current state alongside the icon and counts.
2026-11-22 20:32:57 +08:00
l0ng-ai b7f3df0472 fix(debugger): keep values readable beside long type labels (#5185)
Keep debugger values readable beside long runtime types. The row reserves space for a value preview based on its length, so short values leave more room for names. A truncated type can still be read on hover, and the full type appears when the pane has room.
2026-11-22 20:32:52 +08:00
l0ng-ai c5824771c1 fix(editor): make workspace refactoring previews easier to scan (#5183)
Separate the filename from its directory in workspace refactoring previews. This gives same-named files distinct locations and frees space for rename targets and occurrence counts. Hovering a file or a rename target shows its full path.
2026-11-22 20:32:47 +08:00
l0ng-ai 40e5f9b7b3 fix(usages): distinguish files with the same name in the popup (#5181)
Add a muted directory caption beside each filename that appears in more than one file in Show Usages. Identical filenames, line numbers and snippets can otherwise make two results indistinguishable until selected. The popup uses the same directory labels as editor tabs, including a longer suffix when directory names repeat at different depths.
2026-11-22 20:32:41 +08:00
l0ng-ai 8bc82d08c6 fix(vcs): give outgoing commit messages a clear subject (#5180)
Give the selected commit's subject a stronger weight and separate it from the body in the Push dialog. The preview uses the editor's font settings for the message and compact text for the revision, author and date, matching the message hierarchy in Git Log.
2026-11-22 20:32:23 +08:00
l0ng-ai b0473f17b5 fix(run): keep the configuration header visible while scrolling (#5175)
Keep the configuration name and project-file checkbox visible above the scrolling options in Run/Debug Configurations. Long forms previously scrolled these controls out of view, so editing the name or changing where a configuration is saved meant returning to the top.
2026-11-22 20:31:59 +08:00
l0ng-ai 21264641ba fix(search): clarify Recent Locations file captions (#5170)
Recent Locations now shows the filename once, with a symbol breadcrumb or its parent directory beside it. Directory captions distinguish entries with the same filename, and hovering over a caption reveals the full project-relative path.
2026-11-22 20:31:00 +08:00
l0ng-ai 3ce4578600 fix(editor): separate quick fixes in the intentions popup (#5167)
Separate quick fixes from other actions in the Intentions popup with a divider. The divider is skipped during keyboard navigation and disappears when filtering leaves a single group. The popup keeps the chosen action selected when more results arrive from the language server.
2026-11-22 20:30:36 +08:00
l0ng-ai e89b565a78 fix(diff): keep revision filenames readable in narrow panes (#5163)
Keep filenames visible in side-by-side revision headings. Long directories elide before the filename, and the title tooltip shows the complete path and revision. Revision paths use the standard 13 px UI text size.
2026-11-22 20:28:36 +08:00
l0ng-ai b2a1ee2204 fix(run): keep primary actions in view in side docks (#5159)
Keep Rerun and Stop together and give narrow Run docks more room for output. When the toolbar gets narrow, Scroll to End and Soft-Wrap move into More Actions and keep their checked states. The same menu opens the current run configuration, and a wider panel shows the console toggles on the toolbar.
2026-11-22 20:28:31 +08:00
l0ng-ai 828cb271d9 fix(search): keep file locations readable in Find in Files (#5145)
Give line numbers their own space at the right edge of Find in Files and Replace in Files results. Long file labels can still fit with an ellipsis, and hovering reveals the full relative path. Consecutive hits in the same file use quieter filename text so the line numbers are easier to scan.
2026-11-22 20:28:26 +08:00
l0ng-ai ed369c2a6d fix(debugger): group line breakpoint actions (#5141)
Group a line breakpoint's logging controls under Actions in the Breakpoints dialog and gutter popup. The dialog includes Remove once hit in the same group. The gutter popup uses the standard 13 px text size for the condition and hit count labels.
2026-11-22 20:28:20 +08:00
l0ng-ai 3103ec19f9 fix(vcs): Add to .gitignore and Show History act on the focused Project view (#5215)
Add to .gitignore, Add to .git/info/exclude and Show History for File took the active editor's file even when the shortcut was pressed in the Project view. Like Add to VCS they now take the Project view's selection while it has focus and the open file otherwise.
2026-11-22 20:07:24 +08:00
Aevion 026ef8794f fix(vcs): Add to VCS stages the Project view's selection (#5210)
Pressing Add to VCS (Option+Cmd+A) with a folder selected in the Project view reported "Nothing to add" instead of staging the unversioned files in it: the action resolved its targets from the active editor's file only. While the Project view has focus it now takes the Project view's selection; from the editor it still adds the open file.

Co-authored-by: aevioni <[email protected]>
2026-11-22 20:03:40 +08:00
l0ng-ai 7e77c270b7 fix(java): resolve compileOnly project dependencies in Gradle builds (#5213)
Gradle's Eclipse model, which jdtls imports a Gradle build through, leaves out project dependencies a source set only compiles against (compileOnly / testCompileOnly(project(":a"))), so their classes showed as unresolved although Gradle compiled them. jdtls's Gradle import now runs an init script that adds every project on the main and test compile classpaths, keeping test-only ones marked as test code.

On macOS, Buildship stores a build's arguments joined by spaces and splits them again, and jdtls passes its own init scripts from its configuration area under Application Support, so every import that set a Gradle JDK, user home or argument failed ("The specified initialization script '.../Application' does not exist"). A jdtls install under a path with spaces now gets a configuration area in the user's cache directory, and our init script goes to the first directory without spaces.

Fixes #5090
2026-11-22 19:56:38 +08:00
Emir 9abca932d1 feat(settings): pick a custom accent colour with the colour picker (#5204)
The custom swatch of Settings > Appearance > Accent color now opens the editor's colour picker (opaque: RGB and HEX fields, recent colours, eyedropper where available) instead of a native colour input and hex field. The new value is staged and saved with Settings Apply.

The picker moves from the color-preview feature to src/ui so both features use the same component.

Co-authored-by: laot7490 <[email protected]>
2026-11-22 19:33:55 +08:00
Muuтаmuutot ce6c61aa5e feat(settings): preview Diff & Merge colours in a real merge view (#5098)
Settings > Editor > Color Scheme > Diff & Merge now previews the colours in a three-pane merge view (left / result / right) painted with the same CodeMirror diff decorations as a real merge, including a folded unchanged fragment with the wave separator. Clicking a coloured line selects its attribute.

The preview is a mergeSchemePreview editor kind registered from the VCS settings pages, so it also works in the standalone Settings window, which never activates the workbench diff viewer, and the settings feature does not import the VCS feature.

Co-authored-by: muutot <[email protected]>
2026-11-22 19:27:01 +08:00
LU XIANGRUIтаwildcatDownstairs 9e8722feb6 feat(lsp): lint and format with Biome (#5200)
Adds Biome as a language server (lint diagnostics and code actions) and as a formatter for CSS, GraphQL, JavaScript, TypeScript (and JSX), JSON and JSONC, with a Languages & Frameworks > Biome settings page (path, provider, run on save, enabled languages).

Biome formats instead of Prettier and oxfmt below a biome.json / biome.jsonc or a Biome installation, unless the nearest configuration sets formatter.enabled to false, in which case Prettier keeps formatting. Resolved conflicts with the Tailwind CSS language server: both servers are listed in the language definitions, registry tests and docs.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 19:18:37 +08:00
faysou f2950defcf perf(markdown): render preview math as SVG (#5048)
Typeset equations with MathJax before painting the Markdown preview.
Load MathJax on demand, preserve accessible MathML, and fall back
to KaTeX for unsupported equations.
2026-11-22 19:06:38 +08:00
LU XIANGRUIтаwildcatDownstairs 0130847bc0 feat(languages): start the Tailwind CSS language server in Tailwind projects (#5199)
Runs @tailwindcss/language-server next to the language's own servers for HTML, CSS, JS/JSX, TS/TSX, Vue, Svelte and Astro, only below a tailwind.config.* (v3) or a package.json listing tailwindcss in dependencies or devDependencies (v4), with one-click install like the ESLint and Angular servers. JSON root markers (package.json#…) now match a key with any non-null value, not only objects. Adds fixtures/tailwind-app and an ignored real-server test.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 18:55:05 +08:00
LU XIANGRUIтаwildcatDownstairs b9f9e2668a fix(debugger): adopt child sessions whose ids an earlier backend used (#5197)
A window whose project moves to another backend process (a remote reconnect, or a new openidea-server in the smoke tests) sees session ids numbered from 1 again. ownSession checked the ids of forgotten sessions before looking for a known parent, so a new child's started event reusing such an id was dropped, along with every later event of that child: the Debug tool window never showed the pause. started is a session's first event and can't be a late event of a forgotten session, so it no longer stops there; a child is still adopted only under a session of this window, and other late events of forgotten ids stay ignored.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 18:51:58 +08:00
LU XIANGRUIтаwildcatDownstairs 1f39eb8e63 fix(run): keep Jest and Vitest gutter runs as they were (#5194)
#5173 gave every JS file in test/ gutter targets and #5169 made all kind-node test configurations bases for gutter runs, so Jest/Vitest projects gained run icons in test/ helpers and imported npx jest configurations started running gutter targets. test/ now counts only in projects with a Mocha or node --test configuration, and only Playwright's node configurations are gutter bases.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 18:50:42 +08:00
l0ng-ai a4db4a9e3f fix(vcs): commit a new file's edits made after Add to Git (#5202)
Add to Git stages a new file as it was created, usually empty; edits afterwards leave it partially staged, and Commit included partially staged files with only their staged part, so the first commit held the empty file and the content needed a second commit. A partially staged file whose staged side is an addition is now included whole by default (also when committing selected files) and loses the partial badge; other partially staged files keep committing their staged part.

Fixes #5189
2026-11-22 18:48:23 +08:00
l0ng-ai ca05825d7c fix(debugger): stabilize the inline variable editor 2026-11-22 17:50:58 +08:00
l0ng-ai c209e189e0 docs(plugins): format the run-targets process tables (#5193)
Re-aligns the Running programs tables in docs/{en,zh}/plugins/guides/run-targets.mdx so pnpm format:check passes on main again. Whitespace only.
2026-11-22 17:44:20 +08:00
Muuтаmuutot 0b83b3ffbc style(ui): compact metrics for combo boxes and editor tabs (#5188)
Compact mode now also steps the combo box label padding (9/6 → 6/6, ComboBox.padding.compact) and radius (4px → 2px, ComboBox.arc.compact), and the editor tab pill's inline padding (8px → 6px, EditorTabs.tabInsets.compact), through new --combo-pad-start/end, --radius-combo and --tab-pad-x tokens. Toolbar and tool window stripe button radii stay at 6px → 4px (MainToolbar.Button.arc and Button.ToolWindow.arc 12 → 8).

Co-authored-by: muutot <[email protected]>
2026-11-22 16:55:22 +08:00
l0ng-ai 7caec95fee fix(java): stop reusing launch snapshots after Build › Rebuild (#5190)
Launch snapshots are reused while a module's sources keep their fingerprint. Build › Rebuild Project cleaned and recompiled target/classes but left the launch records untouched, so the next run kept loading a snapshot that could hold classes the clean removed (a class compiled under its old package), and Spring found two beans with the same name.

A Rebuild now clears the fingerprint of every launch record in the project, so the next launch copies the rebuilt outputs; the records stay, so those modules keep delegating to Maven.

Fixes #5179
2026-11-22 16:46:53 +08:00
Deng Liuтаdengliu 3d56af936d feat(dev): add dogfood:remote task to build and stage openidea-server (#5139)
Adds `pnpm dogfood:remote <remote_name> [--restart | --no-restart] [--clean] [--install-rust]` (also `mise run dogfood:remote`) for dogfooding backend changes in Remote Development without cross-compiling locally. It reads the host from Settings › Tools › SSH Configurations, checks SSH reachability and the minimum Rust version, syncs the backend workspace to `~/.cache/openidea-dogfood/workspace`, builds `openidea-server` there, installs it at the `~/.openidea/server/<version>/<build_id>` path `ensure_server` expects (so connecting doesn't upload another binary), stages the matching binary locally (`--clean` restores the release one), and asks before restarting a running server. The `build_id` hash uses `blake3` from the new `@noble/hashes` devDependency. Rust is installed on the host only with `--install-rust`.

Closes #5135

Co-authored-by: dengliu <[email protected]>
2026-11-22 15:35:33 +08:00
Deng Liuтаdengliu 0a3eac8652 feat(agents): parse context:fork and paths/globs skill metadata and show badges (#5162)
Skills now parse `context: fork` and `paths` / `globs` frontmatter (inline, bracketed or YAML list). Settings › Agents › Skills shows `context: fork` and `paths (n)` badges, with the patterns in the inspector, and the session Skills picker shows fork / paths pills. `SKILL.md` is still staged untouched, so CLIs that support these fields natively apply them. Frontmatter key lookup is case-insensitive.

Part of #5113

Co-authored-by: dengliu <[email protected]>
2026-11-22 15:33:47 +08:00
LU XIANGRUIтаwildcatDownstairs 70702934d1 feat(run): run Mocha tests with a test tree and Rerun Failed Tests (#5173)
Mocha runs showed no test tree, and single tests ran with Jest's `-t`. A `package.json` script that runs `mocha` is now a test configuration with `testRunner: "mocha"`. Test runs import the IDE's hook (`mochaHook.js`, a `data:` URL in `NODE_OPTIONS`), which prints a record per finished test (file, suite chain, status, duration, declaration line, error) next to the run's own reporter; the records become the tree and are hidden from the console. Gutter icons, Rerun Failed Tests and running selected tests use Mocha's own `--grep`. New fixture `fixtures/mocha-app`, run by `smoke/run.test.ts` in the TypeScript job.

Closes #5153

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 15:24:38 +08:00
LU XIANGRUIтаwildcatDownstairs 8e541d5b45 feat(run): run node:test tests with a test tree and Rerun Failed Tests (#5172)
`node --test` runs showed no test tree, and single tests ran with Jest's `-t`.

- Detection: a `package.json` script whose Node options include `--test` (also `tsx --test`) is a test configuration with `testRunner: "node-test"`; a script that picks its own `--test-reporter` runs as written.
- Test tree: test runs add the IDE's reporter (`nodeTestReporter.js`, passed as a `data:` URL) next to `spec` through `NODE_OPTIONS`, which works through `npm run`, Node's per-file child processes and remote run targets. It prints a record per test (file, describe chain, status, duration, declaration line, error); the records become the tree and are hidden from the console, which keeps `spec`'s output.
- Gutter, Rerun Failed Tests, run selected tests: select by full name with `--test-name-pattern` in `NODE_OPTIONS`, plus the files.

New fixture `fixtures/node-test-app`, run by `smoke/run.test.ts` in the TypeScript job.

Closes #5152

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 15:19:57 +08:00
LU XIANGRUIтаwildcatDownstairs 87c4659547 fix(i18n): insert tx template values as written (#5177)
In the Chinese UI, Rename on a folder named `tasks` read 将目录“任务”及其用法重命名为:. The `tx` template tag translated every interpolated string that had a catalog entry of its own, so a file, branch, script or container name that matched a UI word (`tasks`, `Retry`) was shown translated. Values are now inserted as written. Call sites that interpolate the app's own UI words (kind labels, option titles, "Source"/"Target") mark them with the new `txPart(...)`, which is also translated again after a language change; the text catalog guard checks `txPart` literals too. `txTemplate` still translates captured parts.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 15:14:54 +08:00
l0ng-ai 3475dbd688 fix: restore frontend tests after the skill installer and Python Console (#5182)
Three frontend tests failed on main after #5157 and #5164: SkillsPage.module.css read an undeclared --r-sm (now --radius-small); the SKILL.md catalog entry is a file name kept as written in Chinese, so it joins the same-as-English list; and the VS Code presets lacked python.console.executeSelection, which stays unbound there because Shift+Enter would shadow typing in Python files.
2026-11-22 15:14:02 +08:00
Deng Liuтаdengliu 0800e8445f feat(agents): native GitHub skill browser, preview, static scan, and installer (#5157)
Settings › Agents › Skills gets Install Skill…: enter a GitHub source in the forms `npx skills add` accepts (`owner/repo`, `owner/repo@skill`, `owner/repo#ref`, `owner/repo/path[@ref]`, GitHub tree URLs, pasted skills.sh links), pick one of the skills found, preview its `SKILL.md` and file list, and install it into `~/.agents/skills` (default) or the workspace `.agents/skills` (trusted projects only). Sources resolve through GitHub's Git Trees and Blobs APIs over the existing `ide-tools` HTTP client, with no curated repository list and no Node or git dependency, retrying unauthenticated when an ambient GitHub token gets HTTP 401 on a public repository. Only the selected skill's subtree is downloaded (capped at 2 MiB / 256 files) and installed atomically through a staging folder. A static scan flags hidden or bidirectional Unicode, out-of-root symlinks (omitted on disk), executable scripts and `allowed-tools` shell grants; the user must confirm the warnings, and the backend checks that confirmation again before writing.

Part of #5115

Co-authored-by: dengliu <[email protected]>
2026-11-22 15:09:01 +08:00
Deng Liuтаdengliu b7ac5f1bbb feat(plugins): declarative [[contributes.skills]] in plugin.toml (API 1.15) (#5144)
Plugins can now bundle `SKILL.md` folders with a manifest-only `[[contributes.skills]]` extension point (API 1.15, no WIT change). They appear under Plugins in Settings › Agents › Skills and the Composer Skills picker while the plugin is enabled, and are staged into each CLI's per-session skill folder from the plugin's package directory; disabling or uninstalling the plugin removes them right away. Load-time validation keeps `path` inside the package (no `..` or escaping symlinks), requires `<dir>/SKILL.md` with the usual folder-name and frontmatter rules, and caps a skill folder at 2 MiB / 256 files; an invalid entry becomes a plugin load warning without failing the rest of the plugin. Every file of a valid skill folder is part of the package files, so versioned installs and remote sync copy supporting scripts and references. Workspace and user skills win on a name clash. Includes a declarative fixture plugin and docs.

Closes #5114

Co-authored-by: dengliu <[email protected]>
2026-11-22 15:02:11 +08:00
l0ng-ai f473cd9927 fix(agents): give Codex skill paths one separator on Windows (#5158)
Skill roots are joined as `.agents/skills`, so a SKILL.md path that could not be canonicalized kept a forward slash on Windows and failed hub_staging_hands_each_cli_its_own_tree. Rebuild the path from its components before handing it to Codex.
2026-11-22 14:44:44 +08:00
LU XIANGRUIтаwildcatDownstairs 9a3b97a5fa feat(python): flag requirements the interpreter does not satisfy and offer to install them (#5168)
`requirements*.txt` and `pyproject.toml` (`[project]` dependencies, optional dependencies, `[dependency-groups]`) now mark each requirement the project's interpreter doesn't have installed, or whose installed version misses the specifier. A banner offers Install requirements, and the quick fixes are Install requirement and Install all missing requirements; installs use the same pip/uv path as the interpreter settings page, run as a background task, report failures in one notification and re-check the file. The interpreter judges the requirements itself (with `packaging` or pip's vendored copy), so PEP 440 specifiers, PEP 503 names and markers behave as pip does; Rust only parses the files for spans, skipping `-r`, `-e`, options, URLs and paths. Nothing is checked without a local interpreter, for a container interpreter, or in Restricted Mode. It is a new inspection, "Unsatisfied package requirements", and the Cargo version check now shares the same editor plugin (`manifestCheck.ts`).

Closes #5147

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 14:43:09 +08:00
LU XIANGRUIтаwildcatDownstairs c632dfa01c feat(python): add a Python Console tool window (#5164)
Adds a Python Console tool window: an interactive interpreter of the project's Python (the one Settings and the status bar show; in a workspace, the member the active file is in), started in the project root with the source roots on `PYTHONPATH`. It uses IPython when the interpreter has it and plain Python otherwise, in its own `__main__`. Enter runs the input, Shift+Enter adds a line, Up/Down recall earlier inputs, and while code runs a typed line answers its `input()`. A Variables pane lists the console's globals after each run. Execute Selection in Python Console (`python.console.executeSelection`, Alt+Shift+E, also in the editor context menu of Python files) sends the selection or the current line, starting the console if needed; a selection inside an indented block is dedented. The console is a small driver script run on the existing Run process host, so there are no backend changes.

Closes #5148

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 14:34:50 +08:00
LU XIANGRUIтаwildcatDownstairs 88f494ca50 feat(debugger): view pandas and numpy values as a table (#5166)
In a Python debug session, a DataFrame, Series or ndarray variable or watch only showed a one-line repr. It now has View as Table in its context menu: a resizable window with column headers (with dtypes for a DataFrame), the index, the shape, and pagers for rows (100 per page) and columns (30 per page). Each page is one `evaluate` in the paused frame: a small helper slices the object in the debuggee and returns only that page as JSON, so the whole object never goes over DAP. The expression can be edited (e.g. `a[0]` for a 3-D array), and the window stays open across steps, refreshing after each step or frame change.

Closes #5165

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 14:31:17 +08:00
LU XIANGRUIтаwildcatDownstairs 9b4ee2a6ff feat(run): run Playwright tests with a test tree and Rerun Failed Tests (#5169)
A Playwright project had no test tree and no Rerun Failed Tests: its output went through the Jest / Vitest parser, single tests ran with Jest's `-t`, and projects without a `test` script weren't detected at all.

- Detection: a `package.json` script that runs `playwright test` is a test configuration and records `testRunner: "playwright"` (new optional `RunExtras.test_runner`, `test-runner` in `run.toml`); a package with a `playwright.config.*` that no script runs gets `npx playwright test`.
- Test tree: test runs add `--reporter=list` unless a reporter is named, parsed into file › [project] › describe chain › test with status, duration, location and failure details.
- Gutter: `test.describe` blocks and `fixme` / `fail` / `serial` tests get run / debug icons and run by declaration line (`file:line`); in a project with Playwright and another runner, specs run on Playwright's configuration and other tests on the other runner's.
- Rerun Failed Tests / run selected tests: the files plus `--grep` on the describe chain and title, with `--project` when the run named projects.

New fixture `fixtures/playwright-app`; `smoke/run.test.ts` runs it after `ts-app`.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 14:30:06 +08:00
LU XIANGRUIтаwildcatDownstairs e75d438f70 feat(python): update imports when a module or package is renamed or moved (#5171)
Renaming or moving a Python module or package left every import of it broken: basedpyright has no `workspace/willRenameFiles`, so no reference updates reached the move preview. `refactor_file_move_edits` now maps the moved paths to dotted module names from the project's Python roots (`src/` layout or the project root, `tests/`), and `Syntax::python_import_edits` rewrites the import statements of each project `.py`/`.pyi` file from its tree-sitter tree. It covers `import a.b` (with qualified uses `a.b.X`), `import a.b as c`, `from a.b import X`, `from a import b`, relative imports (kept relative, also in the moved files themselves) and package moves; when a rename changes the name an import binds, the import keeps it with an alias. The edits join the existing move preview and undo. A Python server that answers `willRenameFiles` still wins. The Python language smoke now checks file moves.

Closes #5146

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 14:26:50 +08:00
LU XIANGRUIтаwildcatDownstairs a67b27c33a feat(editor): highlight CSS, GraphQL, SQL and HTML in template literals (#5160)
In JavaScript and TypeScript files, embedded code in template literals showed as one string. The body of a tagged template literal is now parsed in the language its tag names: CSS for styled-components / emotion / Lit (`styled.div`, `styled(Comp)`, `.attrs(…)`, `css`, `createGlobalStyle`, `keyframes`, `injectGlobal`, parsed as declarations plus nested rules), GraphQL for `gql` / `graphql` (also the `graphql(`…`)` call form), SQL for `sql` and HTML for `html`; a `/* GraphQL */`-style comment before a plain literal works too. Substitutions stay JavaScript. CSS, SQL and HTML use the same modes as files in those languages; GraphQL gets a small stream mode used only inside literals (`.graphql` files keep tree-sitter highlighting). The embedded mode loads lazily, comment toggling and bracket matching follow it, and Angular TypeScript files and Markdown `ts` fences get the same injection.

Closes #5150

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 14:24:24 +08:00
Akbar Husain 62028362d6 feat(remote): forward ports of a WSL project (#5140)
The Ports tool window existed only for SSH hosts and dev containers; a WSL project refused to forward. A WSL distribution shares this machine's loopback (as `forward_web_url` already assumes), so a port it listens on is reachable here on the same port without a tunnel. The route decision is now a pure `forward_route(target, host)` (SSH channel tunnel, container exec tunnel, or WSL's shared loopback; another host stays reachable from a dev container only), and `Forward::Wsl` reports the port unchanged and owns no resource. The Ports tool window registers for WSL sessions, remembered ports are scoped per distribution and folder (`wsl:<distro>:<root>`), the refusal and its string are gone, and the remote docs describe it.

Co-authored-by: akbar1214 <[email protected]>
2026-11-22 14:23:05 +08:00
LU XIANGRUIтаwildcatDownstairs c57af26f9d feat(python): offer to install pylsp-rope when a refactoring needs it (#5161)
On Python files, Extract Method, Inline, Introduce Parameter and module-level Introduce Constant come from pylsp-rope, a companion server the missing-server prompt skipped, so without it these refactorings only said "Cannot perform refactoring". Now, when one of them finds nothing and pylsp-rope isn't installed, the usual missing-tool notification offers to install it (Install restarts the server, so the refactoring works right away). `promptInstall` takes a purpose (code insight, formatter or a refactoring) instead of a formatter flag; a refactoring purpose lets a companion server through, even when another server already serves the files. Opening a project stays quiet.

Closes #5149

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 14:21:33 +08:00
Ainul YaqinтаAkin01 ed6f264875 fix(plugins): provide lossless bounded streaming and configurable capture for processes (#4812)
Plugins running compilers, linters or large diffs lost output: `start` kept only a 1 MiB tail and `run`/`run-command` truncated stderr. API 1.15 adds `process-options` (`max-output-bytes` up to 128 MiB, `buffer-bytes` up to 4 MiB), `run-captured`, which fails explicitly when either stream overflows, and `start-stream`, which streams losslessly with pipe backpressure: readers pause at the buffer limit, resume as `poll`/`chunk` consume, and `wait` drains up to the total limit so fast producers don't deadlock. Overflow stops the process tree and records its exit status before reaping it. `run`, `run-command` and `start` behave as before, and 1.14 components still load.

Closes #4763

Co-authored-by: Akin01 <[email protected]>
2026-11-22 14:11:13 +08:00
HEOJUNFO 369f52d39e fix(http-client): use http when server.ssl.enabled is false (#5143)
A request generated from a Spring mapping got an `https://` host when `server.ssl.enabled=false` and a key store was also configured (typically a base file with the key store and a profile that turns TLS off for local runs). `hostFromConfig` picked https when TLS was enabled or a key store was set, so the key store won over an explicit `false`. In Spring Boot the property defaults to true and SSL is configured only when it is, so an explicit `false` now wins; the other cases are unchanged.

Co-authored-by: HEOJUNFO <[email protected]>
2026-11-22 14:06:03 +08:00
HEOJUNFO 305ff382e7 fix(run): carry a duration's rounded seconds into its minutes (#5142)
A run or test lasting between 1 m 59.5 s and 2 m showed as `1 m 60 s` (and likewise at every minute) in the test tree, the exported test report and the run tab's "Finished in …" tooltip. `formatDuration` split off whole minutes first and rounded the remainder afterwards; it now rounds to whole seconds first and splits after.

Co-authored-by: HEOJUNFO <[email protected]>
2026-11-22 14:04:54 +08:00
l0ng-ai 92dbf0baa5 fix(terminal): separate session choices from window actions (#5138)
Open the predefined session chooser directly on the installed shells and SSH. The plus button opens the default shell. Split commands live in the terminal tool window's Options menu, with Settings at the bottom of the session chooser. On the Windows fixture the chooser went from nine actions to six and from 267 px to 153 px in height.
2026-11-22 14:03:13 +08:00
l0ng-ai b02f212d3e fix(completion): keep suggestion names readable in narrow lookups (#5133)
Keep suggestion names readable when long signatures compete for space. The name keeps its natural width when it fits, the return type gets space next, and parameters use the rest. Exceptionally long names can still truncate within the editor.
2026-11-22 13:36:07 +08:00
l0ng-ai ca7f26f484 fix(editor): give a completed foreach its body (#5123)
⌘⇧↵ after `foreach ($xs as $x)` in PHP produced `foreach ($xs as $x);` with the caret on the next line: a semicolon that terminates an empty loop. `foreach` was missing from the block-head keywords, so the line was treated as a plain statement.

`foreach` (PHP, C#) and PHP's `elseif` are now block heads: the line gets `{` / caret / `}`, and a bare `foreach` gets `(|)` like `for`.
2026-11-22 13:21:34 +08:00
l0ng-ai bf4fff8fcf fix(editor): end completed C and C++ type definitions with }; (#5122)
⌘⇧↵ after `struct S` (C) or `class A` (C++) produced `struct S {` / `|` / `}`: a type definition without its terminating `;`, which does not compile.

`completeStatementSpec` now closes the body with `};` in C, C++, Objective-C and Objective-C++ when the header is a type definition: `struct` / `class` / `union` / `enum` / `enum class`, optionally with `typedef`, `template <…>`, `final` and base classes. `typedef struct Node`, `union U` and `template <typename T> class Box` are now recognised as block heads too. Namespaces and control flow keep a plain `}`.
2026-11-22 13:20:15 +08:00
l0ng-ai 3cbe327a6a fix(editor): line up C++ access specifiers with their class (#5128)
Typing `public:` on a member line of a C++ class left it at member indentation (`    public:`) instead of lining it up with the class, as CLion's default code style does. The Lezer C++ indentation has no rule for access specifiers, and its `indentOnInput` only reindents `case`, `default:` and braces.

For C++ (`EXTRA_SUPPORT` in `languages.ts`), an indent service puts a `public:` / `protected:` / `private:` line at the indentation of the line opening its class body (`FieldDeclarationList`), and an `indentOnInput` pattern reindents the line when the colon is typed. Members after it keep the member indentation; `std::` is unaffected.
2026-11-22 13:18:09 +08:00
l0ng-ai 0311297886 fix(editor): indent the body after a case label in C, C++ and PHP (#5124)
Enter after an 8-space `case 1:` (or `default:`) in C, C++ or PHP put the caret at 8 spaces, aligned with the label, instead of 12 for the branch body: the Lezer C++ and PHP grammars indent a `case` body from the switch body, not from the label.

`caseBodyIndent`, an indent service added for C, C++ and PHP in `EXTRA_SUPPORT`, puts the new line one level deeper than a `case …:` / `default:` line when nothing follows the caret. Other lines, including a C++ `std::`, are unchanged.
2026-11-22 13:16:56 +08:00
l0ng-ai a711c991b6 fix(navigation): compact navigation bar child lists (#5132)
Use compact rows and content-based widths in navigation bar child lists. The default row height is 18 px and the text stays at 13 px. The wide desktop fixture shows 20 complete rows, up from 14. The two-folder list in the narrow fixture uses 95 px of width, down from 199 px.
2026-11-22 13:15:32 +08:00
Gabriel Gondim 698cad2b3f fix(ci): run language smoke when editor navigation providers change (#5101)
src/editor/api.ts re-exports navigationProviders and relatedProviders, which the frontend smoke loads. Add both files to the Language smoke workflow paths and to the Changes step's smoke pattern, so scripts/smoke-paths.test.ts passes again and a change to either file runs every language.

Closes #5073
2026-11-22 12:57:44 +08:00
l0ng-ai 581c64f544 fix(vcs): surface the Git Log affected changes filter (#5130)
Show the affected-changes toggle on the changed-files toolbar when Git Log has a path filter. This makes it possible to narrow the selected commit's file list in one click. Group the Diff preview toggle and its location under Layout in View Options. Let the toolbar wrap when the pane is narrow.
2026-11-22 12:52:57 +08:00
l0ng-ai 77d6d81f8a fix(editor): complete /** doc stubs in PHP files and list C/C++ tags (#5127)
Two problems with the `/**` + Enter stub:

- **PHP**: `/**` + Enter right after `<?php` gave `/**` / caret, with no `*/`, so the function below ended up inside an open comment. With an unclosed `/**` directly after `<?php`, Lezer PHP parses the text as the surrounding HTML: `languageDataAt("commentTokens")` there returns only `<!-- -->` (checked with the real PHP language), and `enterInDocComment` stood back. In PHP documents it no longer requires `/* */` tokens at the caret, so the stub is closed and lists `@param` / `@return` as elsewhere in PHP.
- **C / C++**: the stub had no tags. New `cDocTags` lists `@param` per named parameter (defaults and array suffixes dropped, `void` / `...` skipped) and `@return` unless the function returns `void` or is a constructor or destructor. It handles specifiers, pointers and references, `template <…>`, qualified names (`Box<T>::take`), trailing `const` / `noexcept` / `override` and initializer lists; types, calls and statements get no tags.
2026-11-22 12:45:26 +08:00
l0ng-ai ea62941bc6 fix(editor): pair include and template angle brackets in C and C++ (#5126)
With bracket pairing on, `<` after `#include ` (C, C++) and after `std::vector` (C++) stayed single: `smartAngleBrackets` had no rule for C or C++.

- C and Objective-C: `#include <` (and `#include_next`, `#import`) pairs.
- C++ and Objective-C++: the same, plus `template <`, a standard template or cast written against its `<` (`std::vector<`, `std::make_unique<`, `static_cast<`…) and a capitalized name (`Box<`).
- Lowercase values (`a <`, `i<`), `std::cout <`, all-caps macros (`MAX<`) and `operator<` stay single.

`inLiteral` treated any node whose name contains "template" as a template literal, which made Lezer C++'s `TemplateFunction` (`std::make_unique`) look like a string; C++ template nodes are now excluded.
2026-11-22 12:42:18 +08:00
l0ng-ai 00e044b66b fix(project): group tool window options in submenus (#5118)
Project's Options menu groups its settings under Behavior, Appearance, and Sort By. Sort By includes the folder ordering toggle alongside the sort choices. The first level now has seven items, so the window controls stay visible in a short window.
2026-11-22 12:39:34 +08:00
l0ng-ai 1db368d2b4 fix(refactor): find clangd's extractions from the refactoring shortcuts (#5121)
⌥⌘V on `value * value` in C or C++ said "Selected block should represent an expression", while ⌥↵ on the same selection offered **Extract subexpression to variable** and it worked. clangd gives every tweak the kind `refactor`, and `refactor` is not contained in `refactor.extract`, so the shortcut's request returned nothing. Checked with a small LSP script against the installed clangd: `only: ["refactor"]` → `Extract subexpression to variable` (`refactor`); `only: ["refactor.extract"]` → none.

`requestKind` now asks for `refactor` in C, C++, Objective-C and Objective-C++ too (as it already does for typescript-language-server); `classifyAction` already maps a generic `refactor` action by its title.
2026-11-22 12:36:03 +08:00
l0ng-ai db50b5df5b fix(editor): keep inline find controls together (#5120)
Keep the Close button next to More in the editor's Find and Replace toolbar. The two fields share a column that scales with the editor pane. In narrow panes, the controls wrap below the query and the fields use the space freed by moving Close.
2026-11-22 12:32:52 +08:00
Deng Liu 17fe162f6c chore(dev): add dogfood build and install tasks (#5125)
Add `pnpm dogfood:build` / `pnpm dogfood:install` (and matching mise tasks) to build a fast local release app named openidea_dogfood with a grey icon. It keeps the release identifier, so it shares settings and data with the installed app.

The dogfood config clears the updater endpoints so a release never replaces the dogfood bundle, the bundle is read from Cargo's target directory, and the install output and setup docs note that the two apps share one instance and settings and that the dogfood app never updates itself.
2026-11-22 12:26:36 +08:00
Dan Zhengтаclevertension 0fc462350b feat(editor): copy absolute path with line number (#5136)
Copy Path/Reference… gets "Absolute Path with line number" right below "Absolute Path": the absolute file path with the caret line, or the selected line range (`/abs/path/File.java:12`, `/abs/path/File.java:12-18`), like the existing relative "Path with line number". It is also an action (`editor.copyAbsolutePathWithLineNumber`) reachable from Find Action. Like the relative variant, the chooser copies the value it previewed, even if the caret moved after it opened.

Co-authored-by: clevertension <[email protected]>
2026-11-22 12:07:33 +08:00
l0ng-ai ff80b4351a fix(editor): pair Kotlin template braces and generic factory calls (#5108)
Two pairing gaps in Kotlin:

- **`"${`** stayed `"${|"`: `closeBrackets()` pairs `{` only before whitespace or a closer, and here the auto-inserted closing quote follows. `templateBrace` pairs a `{` typed right after `$` inside an open string into `${|}`, in Kotlin, Groovy, Dart, Scala, JavaScript and TypeScript (template literals). Outside a string nothing changes.
- **`mutableListOf<`** got no `>`: the Kotlin rule only treats capitalized names as types. A generic factory call written directly against its `<` — `…Of` (`listOf`, `mutableMapOf`, `setOf`…), `empty…`, `arrayOfNulls`, `enumValues`, `enumValueOf`, `typeOf` — now pairs. Other lowercase names, and any name followed by a space, stay comparisons.
2026-11-22 11:55:51 +08:00
l0ng-ai af2be518ec fix(editor): move selected text by dragging it (#5137)
The desktop window keeps native drag and drop on for files dropped onto it, so HTML5 drop events never reach the page and CodeMirror's built-in text drag never landed: dragged text stayed where it was.

Text drag now runs on mouse events. Dragging the selection shows a drop caret, scrolls the editor near its edges, and drops the text at the caret on release, into the same or another editor. Option (macOS) or Ctrl held at release copies instead of moving; Escape cancels; a click on the selection without dragging places the caret. "Enable drag-and-drop functionality in editor" still turns it off.

Closes #5117
2026-11-22 11:53:25 +08:00
l0ng-ai 9f60e9b209 fix(search): integrate the Search Everywhere query field (#5116)
The Search Everywhere query field now sits directly on the popup surface. A single inset divider shows focus for the query and its history button. The shorter query row gives results more room in short windows.
2026-11-22 11:45:46 +08:00
Deng Liuтаdengliu 1838919f47 fix(agents): close Phase 1 skills hub discovery, staging, and override gaps (#5129)
Fixes the remaining Phase 1 gaps of the Agent Skills hub:

- `/` completion drops skills that are off or `user-invocable: false`, de-duplicates Codex's prefixed names, keeps `argument-hint`, defaults `disable-model-invocation: true` skills to slash-only, and refreshes when session or draft overrides change.
- Discovery scans workspace member folders, monorepo packages up to two levels down, `<category>/<skill>/SKILL.md` folders and Copilot CLI's two-level `installed-plugins` layout (skipping disabled plugins). Codex disable rules point at `<skill>/SKILL.md`, and roots each CLI already scans are treated as native so skills aren't staged twice.
- A skill that is off globally or for the workspace can be turned on for one session; untrusted workspace skills stay locked. Settings › Agents › Skills shows the other folders a symlinked skill is linked from.

Closes #3897

Co-authored-by: dengliu <[email protected]>
2026-11-22 11:45:20 +08:00
l0ng-ai 256d77c3f6 fix(editor): move Go switch cases and Kotlin when branches as a whole (#5112)
Move Statement (⌘⇧↓/↑) on a branch header:

- **Go** `case 1:`: `structural_ranges` climbed past the branch to the whole `switch` (a `case` keyword's ancestors are not direct children of a block until the switch). With no sibling, the line-based fallback ran and moved `println("one")` above every label, breaking the switch.
- **Kotlin** `1 -> …` in a `when`: the statement was the whole `when`, so nothing moved.

`LangKinds` gains `clauses` (Go `expression_case`, `default_case`, `type_case`, `communication_case`; Kotlin `when_entry`). In `structural_ranges`, a branch reached from its header is the statement, and its neighbours are only other branches (never the switch subject `x`). Statements inside a branch are unchanged. On the frontend, `planMoveStatement` trims the line breaks a node may end with: Go branch ranges run to the next line's start, which made `ownsLines` reject them and fall back again.
2026-11-22 11:31:54 +08:00
Ernstjan FreriksтаEjaYF 7ec2b18b63 fix(tools): name the .NET SDK a dotnet tool needs instead of dotnet's generic error (#5076)
Installing a .NET tool (csharp-ls, FsAutoComplete) on a machine whose newest SDK is older than the one the tool targets failed with dotnet's generic "NuGet feed cannot be accessed" hint.

Before installing, the IDE reads the newest SDK from `dotnet --list-sdks` and the target framework of the package's releases from the nuget.org catalog. If the latest release needs a newer SDK, it installs the newest stable release that runs on the installed one and logs why; if none of the 20 newest does, it fails naming the SDK version required. When nuget.org can't be reached it installs as before, and a failed install now quotes dotnet's `error NUxxxx` lines.

Co-authored-by: EjaYF <[email protected]>
2026-11-22 11:30:34 +08:00
l0ng-ai f8ec222a0d fix(run): integrate the Run Anything command field into the popup (#5111)
The Run Anything command field now sits directly on the popup surface. A single inset divider shows keyboard focus. The command row is 14 px shorter, giving the scrollable results the extra space in short windows.
2026-11-22 11:29:49 +08:00
l0ng-ai aad0573fb9 fix(refactor): introduce a Go variable where gopls offers only a constant (#5110)
⌥⌘V on `1 + 2` in `println(1 + 2)` (Go) answered "Selected block should represent an expression". gopls 0.24 offers only **Extract constant** (`refactor.extract.constant`) for a constant expression — checked with a small LSP script against the installed gopls: both `only: ["refactor"]` and `["refactor.extract"]` return just that action. No action mapped to Introduce Variable, and the syntax-based fallback deliberately stands back when a running server answers nothing (`reason: "empty"`).

When the server's answer contains another introduce-kind extraction for the selection, the server evidently takes it for an expression, so `runRefactoring` now calls the fallback with a new reason `otherKind`, which builds the variable from the syntax tree (`value := 1 + 2`, as GoLand does). An empty answer otherwise still means no fallback.
2026-11-22 11:28:17 +08:00
l0ng-ai 8ea0052a7f fix(editor): continuation indent after a Kotlin when arrow or assignment (#5109)
In Kotlin, Enter after `1 ->` in a `when` (with the body still to come) or after `val answer =` kept the line's indentation (8 and 4 spaces) instead of continuing one level deeper (12 and 8), as IDEA does. Kotlin uses CodeMirror's legacy C-like mode, whose indentation does not know either construct.

An indent service for the Kotlin mode (`EXTRA_SUPPORT` in `languages.ts`) adds one level after a line ending in `->` or in an assignment `=` (not `==`, `!=`, `<=`, `>=`), with nothing after the caret and no bracket left open.
2026-11-22 11:25:27 +08:00
l0ng-ai b20e0b0902 fix(editor): continue Rust /// documentation comments on Enter (#5107)
Enter after `/// Summary` above a Rust function gave a blank line: `enterInLineComment` only splits a comment when text follows the caret, so at the end of the line nothing continued the documentation. RustRover (and Rider for C#) continue documentation line comments.

`enterAfterDocLineComment` handles Enter at the end of a `///` line (Rust, C#, Dart, Swift, F#) or a Rust `//!` line: the next line gets the same indentation and prefix, caret after `/// `. Plain `//` comments and `////` banners are unchanged, as is Enter in the middle of a comment (still split by `enterInLineComment`).
2026-11-22 11:21:28 +08:00
l0ng-ai e3fca1bb6f fix(editor): keep the caret where the comment commands put it (#5106)
Two caret problems with the comment commands, seen in Go, Rust and Kotlin:

- **⌘/, Undo, Redo**: the comment came back but the caret went to the line above (L2 instead of L3). As with Delete Line and Move Statement, CodeMirror's history maps the pre-command caret through the change on Redo unless a selection was recorded after it; `commentLine` now records its resulting caret (and keeps its repeated-⌘/ detection on the state after that).
- **⌥⌘/ on a blank line without a selection** inserted `/*  */` with the caret before it. It now inserts the language's empty block comment with the caret between the delimiters (`/* | */`); lines with code keep the existing behaviour.
2026-11-22 11:18:58 +08:00
l0ng-ai bfea07a30e fix(editor): keep a Rust lifetime's apostrophe single (#5105)
With quote pairing on, typing `'a` between `<>` in `fn borrow<>() {}` gave `fn borrow<'a'>() {}`, and `&'a` got a stray quote too: `closeBrackets()` pairs `'` wherever no word character precedes it, and Rust's apostrophe also starts lifetimes.

`rustLifetimeQuote` (an input handler for Rust, under the Insert pair quote option) inserts a single `'` where a lifetime goes: after `<`, `&` or `+`, and after `,` or `:` inside angle brackets (`<'a, 'b>`, `<T: 'static>`). Lifetimes earlier on the line are ignored when counting brackets. A char literal (`let c = '`, `f('a', '`) still pairs.
2026-11-22 11:17:13 +08:00
l0ng-ai 4d5648c38d fix(editor): add the parameter list when completing a bare function header (#5104)
Complete Current Statement (⌘⇧↵) after `func f` (Go), `fn f` (Rust) or `fun f` (Kotlin) produced `func f {` / `|` / `}`: a body without a parameter list, which does not compile. A header that names a function (after any modifiers such as `pub async`, `private suspend`, and optional type parameters) but has no `(` yet now gets `()` before the body; the caret goes into the body as before. `pub async fn …` is now recognised as a block head too.
2026-11-22 11:15:17 +08:00
l0ng-ai fbcbfb648c fix(vcs): align Git Log commit message typography (#5103)
Git Log now uses the editor's configured font, size, and weights for commit subjects and descriptions. Authors, dates, branches, and signatures use smaller UI text and tighter spacing. Long metadata can wrap inside the details pane.
2026-11-22 11:14:45 +08:00
Charlie.Weiтаcharli117 bf2478934e feat(plugins): deliver caret-moved events (API 1.15) (#5119)
Plugin API 1.15 adds a caret-moved event through the existing events.other channel (no WIT interface or signature change): {path, line, col, settled} with 0-based UTF-16 positions for the focused editor. The frontend batches caret moves after 120 ms (only the latest position per file) and sends one settled event 600 ms after the caret rests; queued and delayed events are dropped when the editor, document, path or project changes. editor-focused now carries the focused editor (path, language, selections) through an optional argument on plugin_set_active_file, which the remote adapter forwards. Requires the events capability; components and fixtures are rebuilt for 1.15.

Co-authored-by: charli117 <[email protected]>
2026-11-22 10:43:27 +08:00
l0ng-ai 8f252398fe fix(debugger): adapt frames and variables to side docks (#5102)
The Debug tool window puts the call stack above Variables when docked on either side, giving both panes the full dock width; in the bottom dock the panes sit side by side. Each orientation remembers its divider position.
2026-11-22 10:35:18 +08:00
l0ng-ai 54c7cbc3b0 fix(problems): adapt the preview to the dock position (#5099)
In a side dock, Problems puts the severity and navigation toolbar above the list and the source preview below it, both at the full dock width; in the bottom dock the list and preview sit side by side. Each orientation remembers its divider position.
2026-11-22 10:08:12 +08:00
l0ng-ai 1fd9246ccc fix(structure): put tree controls in the tool window header (#5097)
The docked Structure tree starts directly below the tool window header, gaining 32 px of vertical space. The header's View Options menu groups sorting and member filters, and the existing Options menu holds Expand All, Collapse All and the two source-following commands.
2026-11-22 09:45:38 +08:00
l0ng-ai 7b6ac0d5a8 fix(run): keep session tab controls visible in narrow panels (#5096)
Run session tabs fit the available space in the tool window header. Long names shorten to keep the close or pin button visible, and hovering shows the full name and, for completed runs, the duration and exit code.
2026-11-22 09:24:47 +08:00
l0ng-ai d764f9cae1 fix(search): keep distinguishing folders visible in search results (#5095)
Search Everywhere shortens long directory paths before the last folder in Files and Classes, so same-named results stay distinguishable; hovering shows the full directory. File names keep their extensions visible when the name fits on the row.
2026-11-22 08:59:37 +08:00
Muuтаmuutot 3908b70b61 fix(ui): match JetBrains compact Tree.border insets (#5100)
Compact Mode reduced tree row height and the island gap, but the tree's horizontal inset stayed at 6px, leaving compact trees 2px wider on each side than JetBrains' compact Tree.border (2,8,2,8). The --tree-inset token now steps 6px → 4px in Compact Mode, so island gap plus inset is 12px normally and 8px compact.

Co-authored-by: muutot <[email protected]>
2026-11-22 08:50:19 +08:00
l0ng-ai c1f0a85718 fix(diff): keep status and viewer tools together (#5094)
The single-file diff toolbar keeps the comparison status beside Settings and the other viewer tools, in a group that can wrap to a second row so longer comparison messages stay readable. At toolbar widths of 520 px and below, the viewer layout, collapse and synchronized scrolling commands are available from Settings.
2026-11-22 08:37:37 +08:00
l0ng-ai acdd88f0f7 fix(debugger): group variable and watch context menu actions (#5093)
The debugger variable menu groups Set Value with Copy Value and Copy Name, and watch creation and field watchpoints get their own group when available. The watch menu puts Remove Watch and Remove All Watches first, above value and source commands.
2026-11-22 08:15:54 +08:00
l0ng-ai 1f8c869293 fix(vcs): group Commit changes menu actions by workflow (#5092)
The Commit changes menu leads with Commit, Rollback and Move to Another Changelist in the change-list workflow, and with Stage and Unstage in staging mode. Diff, source and path-copy commands are grouped together, and the two patch commands sit next to each other.
2026-11-22 07:53:31 +08:00
l0ng-ai f3928b3553 fix(terminal): organize the output context menu (#5091)
The terminal output menu puts Find and session commands first, then groups Copy, Paste and Select All above Clear Buffer and the split commands. Find opens the search bar with the selected text as the query.
2026-11-22 07:31:15 +08:00
l0ng-ai 5161d266ab fix(console): give the search field more room in narrow panes (#5088)
The console search field no longer shares a row with its matching options in a narrow dock: below 224 px the clear and matching controls move below the query. The match count uses the small UI font with tabular digits and sits beside the previous and next buttons.
2026-11-22 07:11:38 +08:00
l0ng-ai b30b30311f fix(workbench): keep toolbar controls readable in narrow windows (#5087)
The main toolbar shares the available text width between labels, so long project and run configuration names give up space before short branch names. At the minimum window width, dropdowns with leading icons show just those icons with their tooltips, while Run, Debug and the window buttons keep their hit targets.
2026-11-22 06:47:40 +08:00
l0ng-ai c9c6d87a14 fix(vcs): group Git Log commit context menu actions (#5086)
The Git Log commit menu puts revision copying and patch creation at the top, then separates comparison from operations that change the repository. Cherry-pick sits with the other commit operations, parent and child navigation sit together, and both bookmark actions share a group.
2026-11-22 06:17:56 +08:00
l0ng-ai 97ffd9aae9 fix(project): group Project view context menu actions (#5084)
The Project view puts Rename beside Refactor and Delete, with a separate group for Reformat Code and Optimize Imports. Jump to Source follows the clipboard actions; Local History, Git and Reload from Disk share a group, and comparison is separated from directory roles and file colors.
2026-11-22 05:58:37 +08:00
l0ng-ai 5e39650886 fix(editor): organize the editor tab context menu (#5081)
The editor tab context menu puts Close All Tabs beside Close Other Tabs, followed by the more specific close commands. Copy Path/Reference gets its own group above the splits, each split sits beside its split-and-move action, and pinning, opening a new window and configuring tabs share a group.
2026-11-22 05:42:00 +08:00
l0ng-ai 444c315d57 fix(platform): paste the primary selection only over editable content on Linux (#5089)
WebKitGTK pastes the primary selection on a middle-button release into the focused editable, wherever the release lands, so closing a tab with a middle click pasted into the active editor (and a middle click on a tree, tool window or the terminal did the same). Middle-button releases outside editable content now cancel that paste; a middle click in the editor or a text field still pastes.

Fixes #5079
2026-11-22 05:23:22 +08:00
l0ng-ai a4bea25ae3 fix(editor): group clipboard, search and open actions in the context menu (#5080)
The editor context menu keeps Cut, Copy, Paste and Copy / Paste Special together, with clipboard shortcut labels that follow the host platform. With a selection, Find in Files sits with the other search and navigation actions, and Split Right sits next to Open In, above Local History and Git.
2026-11-22 05:23:10 +08:00
Emir 84b1770da4 feat(i18n): detect the system language on first launch (#5082)
When the global settings.toml is missing, OpenIDEA now saves the OS's preferred UI language (NSLocale on macOS, GetUserPreferredUILanguages on Windows, LC_ALL/LC_MESSAGES/LANG elsewhere) as appearance.locale, mapped to one of the shipped UI languages with English as the fallback, and loads that catalog before the workbench renders. An existing settings file keeps its saved language. The mapping lives in ide-workspace next to the settings store, and a test keeps its locale list in step with the frontend's.

Co-authored-by: laot7490 <[email protected]>
2026-11-22 05:23:06 +08:00
arookieofc-ai 88295ecca8 fix(e2e): track tightened status bar height in compactMode sizes (#5083)
#5037 tightened the standard status bar to 30 px; the Compact Mode e2e still expected 34 px for the normal density.
2026-11-22 05:17:47 +08:00
l0ng-ai e87aee5969 fix(editor): make the Expressions chooser compact and readable (#5077)
The Expressions chooser uses one compact column for both the refactoring action and the syntax fallback. Multiline candidates show their first source line followed by an ellipsis, while selecting a row still highlights and uses the full expression; the highlight clears when filtering leaves no active row.
2026-11-22 05:02:33 +08:00
l0ng-ai 84d8be1181 fix(window): show minimize and maximize on Linux without a desktop session (#5085)
With no desktop session (WSLg, a bare compositor) GTK reports its built-in decoration layout, close only, so the frameless title bar had no way to minimize or maximize the window. The desktop's gtk-decoration-layout is now used only when a desktop session is running (XDG_CURRENT_DESKTOP, XDG_SESSION_DESKTOP or DESKTOP_SESSION); otherwise the title bar shows minimize, maximize and close.

Fixes #4421
2026-11-22 04:42:35 +08:00
l0ng-ai 27cbdb1ba6 fix(editor): preview changes in the Unwrap or Remove chooser (#5075)
The Unwrap/Remove chooser uses a compact list of action names. The selected action previews the kept and removed code in the editor; switching rows leaves the caret and scroll position in place, and Escape dismisses the chooser and clears the preview.
2026-11-22 04:42:22 +08:00
l0ng-ai 1005dc1363 fix(editor): lay out inline refactoring names as a lookup list (#5072)
Inline refactoring name suggestions align with the identifier being edited. Rows follow the editor font and zoom, with a separate footer for the shortcut; the list fits inside the editor and scrolls to keep the active suggestion visible.
2026-11-22 04:25:59 +08:00
l0ng-ai 3f3cdeba0d fix(editor): make the Generate chooser compact and scannable (#5069)
Generate now uses the compact, caret-anchored action chooser. Constructors, accessors, overrides and tests get distinct icons at the standard action-list size, and the chooser keeps its width while typing to filter.
2026-11-22 04:03:48 +08:00
l0ng-ai 9b8c88e1ee fix(editor): show the opening line of offscreen scopes (#5068)
When the caret reaches a closing delimiter whose opener is above the viewport, the opening line of that scope (with the declaration above a brace on its own line) is shown at the top of the editor after a short pause, in the editor's font, line numbers and colours. Caret and scroll stay put; it follows the brace highlighting setting, closes on Escape, and stays hidden when Sticky Lines already shows the opener.
2026-11-22 03:42:22 +08:00
l0ng-ai 392574fe2a fix(ui): don't show a scrollbar over content that fits after a resize (#5016)
A scroll range of one pixel or less is WebKit rounding after a resize (a splitter drag leaves scrollHeight 319 over clientHeight 318), not content: the overlay scrollbar and the editor scrollbar thumb no longer show for it.
2026-11-22 03:40:25 +08:00
l0ng-ai 41829e74db fix(editor): keep inline hints aligned with source text (#5066)
Inline hints use a size one pixel under the editor font, sit on the text baseline with even padding, and stay a single label when lines wrap, so they no longer shift or split around the source text.
2026-11-22 03:16:31 +08:00
l0ng-ai aee21233fb test(lsp): pass a lazy action's resolve data as a string (#5078)
CodeAction.data is serialized JSON on the IPC boundary; the test added in #5074 gave it an object, which pnpm typecheck rejects.
2026-11-22 03:04:29 +08:00
l0ng-ai 17f5889037 fix(diff): make collapsed unchanged lines easier to find and expand (#5065)
Collapsed unchanged lines in the diff viewer are now a full-width button: a chevron, the line count in UI type and a hatched rule in the separator colour, with hover and focus states. Clicking it or pressing Enter expands the range in both panes and returns focus to the editor.
2026-11-22 02:57:36 +08:00
l0ng-ai ff6c6eb13f fix(editor): restore the caret of Move Statement on Redo (#5063)
Redo of Move Statement Up / Down left the caret where the move started: CodeMirror's history maps the selection from before the edit through it unless the command records the selection after. Both the structural and the line-based move now record the caret they set, so Undo / Redo put it back.
2026-11-22 02:50:09 +08:00
l0ng-ai ac015847a3 fix(editor): remove unused imports in Optimize Imports for TypeScript (#5062)
Optimize Imports in JavaScript / TypeScript now removes unused imports first: typescript-language-server's organize imports only sorts and merges them, and removing the unused ones is its own source.removeUnusedImports action. Optimize-imports-on-save does the same.
2026-11-22 02:46:43 +08:00
l0ng-ai 4c774d2e8e fix(refactor): find TypeScript extractions for Introduce Variable and Extract Method (#5061)
typescript-language-server answers code actions with refactorings only when `only` contains a kind that contains `refactor`; asked for `refactor.extract` it returned nothing, so Introduce Variable and Extract Method refused the selection. JavaScript / TypeScript now ask for `refactor`; the actions are still mapped by their own kind, and other servers keep the narrow kind.
2026-11-22 02:43:04 +08:00
l0ng-ai 8adbbd1b05 fix(lsp): apply refactorings that resolve their edit lazily (#5074)
TypeScript Introduce Variable, Extract Constant and Extract Method did nothing with vtsls: its refactoring actions carry resolve data and a follow-up command but no edit, and an action was only resolved when it had no command either. The resolved edit then failed on a create of the edited file marked ignoreIfExists, which the conversion dropped.

- Resolve an action without an edit whenever it carries resolve data (interactive path and lsp_apply_code_action).
- Leave out create / rename operations their ignoreIfExists makes no-ops, and deletes their ignoreIfNotExists does.
2026-11-22 02:41:50 +08:00
l0ng-ai c207e57686 fix(editor): preview folded code on hover (#5060)
Hovering a folded region's placeholder shows the folded lines in a tooltip: highlighted as in the editor, with line numbers when the gutter shows them, up to 80 lines, aligned to the pane edge. It closes on Escape, scroll or a fold change. The sticky-lines renderer shares the line rendering.
2026-11-22 02:36:02 +08:00
l0ng-ai ac0a56d1ec fix(editor): show font size feedback when zooming (#5059)
Wheel or keyboard zoom now shows the current font size at the bottom of the editor pane that changed, with Reset Font Size and a link to Editor > General. It stays while hovered or focused and dismisses after five seconds; LightEdit gets the same reset.
2026-11-22 02:32:38 +08:00
l0ng-ai 07cbb560df fix(agents): give agents every root of a multi-project workspace (#5071)
A task's agent only learned its own directory, so in a workspace with attached projects it missed the other projects and left their part of a change undone.

- Sessions pass the workspace's other roots (the project and the trusted attached projects, minus the task's own directory and project) as ACP additionalDirectories to agents that advertise the capability.
- The Codex shim turns them into runtimeWorkspaceRoots on thread start, resume and fork, so workspace-write covers them and the model is told about them; the Claude Code shim passes each as --add-dir.
- New read-only MCP tool get_workspace_roots lists the roots, and the server instructions point to it for workspace questions and changes that span projects.

Fixes #5058
2026-11-22 02:17:09 +08:00
l0ng-ai 88936106ab feat(editor): documentation stub tags for TypeScript and Python docstrings (#5057)
Insert documentation comment stub filled tags in for PHP only.

- **JavaScript / TypeScript**: `/**` + Enter above a function declaration, method, constructor or arrow function assigned to a `const` now lists `@param name` for each parameter (parameter properties, rest and defaulted parameters included) and `@returns` when a non-void result type is declared. Calls and statements get no tags.
- **Python**: Enter between the quotes of a `"""` (or `'''`) opened on the first line under a `def` expands it into a docstring, as PyCharm does with its default reStructuredText format: the summary line, `:param name:` per parameter (`self` / `cls` skipped, `*args` / `**kw` by name) and `:return:` (not for `__init__` or `-> None`), then the closing quotes.

Both follow the existing Smart Keys › Insert documentation comment stub option.
2026-11-22 01:56:46 +08:00
l0ng-ai 78041f3745 fix(editor): complete arrow functions, open brackets and Python headers (#5056)
Complete Current Statement (⌘⇧↵) in TypeScript and Python (both use the text rules in `completeStatementSpec`):

- `const f = (x: number) =>` became `=>;`. An arrow function now gets a block body, followed by the brackets still open and a `;` where the statement needs one: `=> {` / `|` / `};`, `items.map((x) => {` / `|` / `});`.
- `const obj = { name: "Ada"` became `{ name: "Ada";`. Brackets the line opened and left open are now closed before the `;` (`{ name: "Ada" };`, `foo(a, bar(2));`); a line ending in `,` or `{` is left to continue.
- Python `async def …`, `with …`, `except …`, `case …`, `match …`, `async for …` got no `:`. Every compound statement header now gets one; `match = 5` and `case.x` stay statements.
2026-11-22 01:56:40 +08:00
l0ng-ai d0eeb5e8c3 fix(editor): type over a closing bracket that already closes a pair (#5054)
`closeBrackets()` steps over a closer only when it inserted that closer itself during the session. So with `value = (1 + 2|)` in a reopened file (or code pasted / written earlier), typing `)` gave `(1 + 2)|)`; same for `]` and `}`. IDEA types over a closing bracket that already closes a pair.

`skipClosingBracket` (an input handler next to `skipClosingQuote`, under the Insert pair bracket option) steps over the bracket at the caret when the syntax tree matches it to an opener and the line has no more openers than closers of that kind outside strings; otherwise the bracket is inserted (`f(g(x|)` still gets its missing `)`). Multi-line pairs (`foo(` … `)` on a later line) are stepped over too.
2026-11-22 01:52:21 +08:00
l0ng-ai 5a9783dbf0 fix(workbench): keep tool window header actions in view (#5053)
Tool window titles and tabs give up width before the header actions, so Options and Hide stay at the right edge of a narrow pane. A shortened title keeps its full text on hover. When the contributed controls need more room, their strip scrolls independently while Options and Hide stay in place.
2026-11-22 01:51:01 +08:00
l0ng-ai 74c2757a7a fix(editor): dedent after return and realign bare except: in Python (#5052)
Two Python indentation gaps against PyCharm:

- Enter after `return 1`, `pass`, `raise …`, `break` or `continue` kept the block's indentation. The dedent rule existed only in `fallbackIndent`, which steps aside when a language mode is loaded (Python has `@codemirror/lang-python`). An indent service for Python now applies it: one level out, unless a bracket is still open (`return foo(`) or text follows the caret.
- Typing a bare `except:` inside a `try` body left it indented: the stock `indentOnInput` pattern and `Body` rule only know `except ` with a space. `except:` now triggers reindentation and aligns with its `try:` (or a previous `except`).

Both are added through `EXTRA_SUPPORT` for the Python mode (`src/editor/core/cm/languages.ts`).
2026-11-22 01:50:44 +08:00
l0ng-ai ff6187ebf9 fix(editor): pair backticks, Python prefixed strings and triple quotes (#5051)
`prefsExtension` gives `closeBrackets()` its own pairing list (to honour the Insert pair bracket / quote options), and that list replaced the language's: only `( [ { ' "`. So:

- TypeScript / JavaScript: typing `\`` left the template literal open;
- Python: `f"`, `r'`, `b"`… left the string open (the language's `stringPrefixes` were dropped), and `"""` did not close.

The list now adds the backtick for JavaScript, TypeScript, Vue, Svelte, Astro and Go, and Python's `'''` / `"""` with its string prefixes; the two options still switch brackets and quotes off.
2026-11-22 01:48:28 +08:00
l0ng-ai 708ceac09a fix(editor): keep editor banner messages and actions readable (#5050)
Editor notification bars group their action links and let the message wrap at the width of the editor pane. Links stay on the same row when there is room and wrap below the message in narrower splits. The banner uses the UI text size and has smaller vertical insets in Compact Mode.
2026-11-22 01:47:53 +08:00
l0ng-ai 5ba43e93e5 fix(services): load container logs in batches and keep their colours (#5067)
Docker logs reached the webview one IPC message per line; WebView2 delivers each message on its own, so a 1000-line tail took 10-40 s on Windows. ide_docker::logs now collects lines for 30 ms and sends them together from a second thread, so a quiet log still flushes, and docker_logs streams Vec<DockerLogLine>. The log pane (container and plugin service logs) renders ANSI colours instead of stripping them, takes the Console log level colours like the Run console, and has Scroll to End.

Fixes #5049
2026-11-22 01:36:39 +08:00
l0ng-ai c552183924 fix(editor): restore the caret of Delete Line on Redo (#5047)
Delete Line (⌘⌫), Undo, Redo: the line was deleted again, but the caret ended at the end of the line above instead of where the deletion had put it (the next line, same column). CodeMirror's history restores, on Redo, the first selection recorded after the change, and otherwise maps the pre-change caret through it; Delete Line set its caret in the same transaction, so nothing was recorded and the old caret (inside the deleted line) mapped to the previous line end. `deleteLine` now dispatches its resulting selection once more, which the history records as the selection after the edit.
2026-11-22 01:16:55 +08:00
l0ng-ai f2adcccf2a feat(editor): fill the Java documentation stub with its tags (#5045) 2026-11-22 01:16:49 +08:00
l0ng-ai 158d11bd7f (#5044)
Copy Path/Reference opens at 500 px when space permits. Each row places the action and shortcut before the right-aligned path preview. Long paths keep the filename in view, and dragging the popup edge gives them more room.
2026-11-22 01:16:32 +08:00
l0ng-ai c6de070cba fix(editor): split a string literal on Enter instead of breaking it (#5043)
Enter inside a Java string (`String t = "hello|world";`) inserted a raw line break into the literal, leaving code that does not compile. A new Enter handler (`enterInStringLiteral`) splits a one-line string literal into two joined with `+`, the second on a continuation-indented line with the caret after its opening quote:

```java
String t = "hello" +
        "|world";
```

It applies in Java, C#, Kotlin, Groovy, JavaScript and TypeScript (the literal's own quote in JS/TS), with IDEA's default continuation indent (two levels for the JVM languages and C#, one for JS/TS). Text blocks, template literals, a caret inside an escape (`\\|n`), char literals, multi-line literals and other languages keep the plain newline.
2026-11-22 01:16:04 +08:00
l0ng-ai 42b9106ade fix(editor): undo Introduce Variable in one step (#5040)
After Introduce Variable (⌥⌘V) and Enter on a suggested name, one Undo only put the server's placeholder name back (`value` → `extracted`); the reformatting and the extraction each needed another Undo. The refactoring is made of several transactions (the server's workspace edit, `reformatGenerated`, the in-place rename) and each was its own history event.

A small history group (`src/editor/lsp/historyGroup.ts`) keeps the transactions in between out of the undo history and, when it closes, records the net change once. `applyIntroduceAction` opens it before applying the server action and closes it when the in-place rename ends (new `onEnd` on the session), or right away if no rename starts. One Undo now restores the original expression, and Redo brings the whole refactoring back.

Escape during the rename keeps the introduced variable with its current name, as the hint says and as IDEA does; that part of the report is not changed.
2026-11-22 01:04:48 +08:00
l0ng-ai 92a49f19af fix(editor): keep the keyboard in the editor after closing the focused tab (#5039)
Closing the focused editor tab with ⌘W (or its close button) showed the next tab, but `document.activeElement` became `<body>`: arrow keys and typing did nothing until the editor was clicked. `closeTab` removed the tab without giving the focus to the editor that took its place. It now does so when the closed editor had the focus (a tab closed while focus is elsewhere leaves focus alone).
2026-11-22 01:04:18 +08:00
l0ng-ai f58e6d1259 fix(editor): complete Java block heads and open strings with Complete Current Statement (#5038)
Complete Current Statement (⌘⇧↵) in Java added a `;` where a block was meant, because tree-sitter's error recovery reports a missing `;` after an unfinished head and the structural pass inserted it:

- `if (true)` → `if (true);` (the next statement then runs unconditionally)
- `public class App` / `public void run()` → `…;`
- `String m = "hello` → `"hello;` (the `;` inside the open string)
- `for` → `for { }` (the text rules only knew keyword-led heads)

Now a finished block head (balanced brackets, not followed by an Allman `{` line) and an open string skip the parser's `;` and go to the text rules, which:

- recognise type declarations behind modifiers/annotations and Java / C# method and constructor headers (`abstract` / `native` methods keep the `;`; `return` / `throw` / `new` lines and plain calls are statements);
- give a bare `if` / `for` / `while` / `switch` / `catch` its parentheses with the caret inside (`for (|) {` / `}`) in languages with parenthesised conditions;
- close an open string or char literal before the `;` (Rust's `'a` is a lifetime, not a quote).
2026-11-22 01:04:12 +08:00
l0ng-ai 13a2356fa1 fix(workbench): tighten status bar height and widget spacing (#5037)
The status bar uses one 30 px row in the standard density and a 24 px row in Compact Mode. Adjacent widgets use their existing insets for spacing, which gives the editor and its status controls a little more room.
2026-11-22 00:58:32 +08:00
Mr0Bread 002751e524 refactor(agents): remove CSS rules nothing reads (#5055)
Three CSS rules in the agents feature can never apply, so they only add to the files:

- `ReferenceChip.module.css` `.selected`: no `styles.selected` (or `chipStyles.selected`) anywhere in `src/`.
- `SkillsPage.module.css` `.link` and `.link:hover`: `SkillsPage.tsx` never reads `styles.link`.
- `Session.module.css`: the first `.questionChoices` block (`display`, `flex-direction`, `gap`) is overridden property-for-property by the second `.questionChoices` block later in the file (same selector, same specificity, no media query), so the computed style is unchanged.

22 lines removed, no behaviour change.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-22 00:52:31 +08:00
l0ng-ai ac87278ddd fix(welcome): separate project names, locations and branches in the switcher (#5035)
Project names now have a line of their own in the title bar project switcher, so a long Git branch can no longer crowd out the name. The path and branch use the smaller metadata type size. Remote projects show their host and folder on separate lines, with keyboard search highlighting each match in its corresponding line.
2026-11-22 00:52:24 +08:00
l0ng-ai a62d4d11c3 fix(editor): indent the line after Complete Current Statement like the statement (#5028)
Complete Current Statement (⌘⇧↵) on `String a = "123"` added the `;` but put the caret on a new line one continuation indent deeper (12 spaces instead of 8). `completeStatementSpec` asked for the new line's indentation before inserting the `;`, when the parser still saw an unfinished statement. The indentation is now computed on the line with the `;` in place.
2026-11-22 00:52:18 +08:00
l0ng-ai 0164e82e32 fix(run): group test navigation and display options (#5027)
The test results toolbar groups its filters together and moves Previous and Next Failed Test into More Actions, where the shortcuts are shown next to their labels. Test Runner Options can hide row durations to give long test names more room. The choice is remembered across sessions and the test summary and selected output remain visible.
2026-11-22 00:52:11 +08:00
l0ng-ai edb8f69024 fix(editor): finish Introduce Variable on a double-clicked name suggestion (#5026)
During Introduce Variable, the name suggestions listed under the new variable reacted only to a single press: a double click put the name in but left the refactoring open, so it looked like double click did nothing. A double click now puts the name in and finishes, as Enter does (a single click still only puts it in). The list and its hint used the hand cursor; they now show the arrow, as other editor popups do.
2026-11-22 00:52:05 +08:00
l0ng-ai ccfa4a1f22 fix(run): show why Profile or Run with Coverage did not start (#5025)
With the Run notification group set to not show balloons (Settings › Notifications, or Don't Show Again on a Run notification), clicking Profile '…' / Allocations / Live Objects or Run with Coverage looked like it did nothing: the reason the run could not start (async-profiler or the coverage tool is not installed, the configuration is not supported, preparing it failed) went only to the Notifications list. These notifications answer a command the user just ran, so they are now `userInitiated` and always show as a balloon, like a manual update check.
2026-11-22 00:51:58 +08:00
l0ng-ai 8eb332aba7 fix(new-project): flag a taken folder and remember the location (#5024)
New Project accepted the name of a folder that already exists and has files, and only reported "already exists and is not empty" in the progress view after Create. It now checks as the name or location changes: the name field and its hint turn red and Create is disabled. Until the user types a name, it follows the first free `untitled`, `untitled1`, … in the location.

The location always started at the home folder (unless Default Project Directory was set). It now starts where the last project was created; the Default Project Directory setting still comes first.

The check is the one `scaffold_create` already did, moved into `ide_scaffold::target_taken` and exposed with `free_name` as `scaffold_target_taken` / `scaffold_free_name`.
2026-11-22 00:51:52 +08:00
l0ng-ai 0798582173 feat(markdown): add a stacked editor and preview layout (#5023)
Markdown can display the editor above its live preview so both use the full width of a narrow editor group. Choose Side by side or Stacked under Preview layout in Markdown settings. Each layout remembers its own divider position, and existing side-by-side sizes are restored when switching back.
2026-11-22 00:51:45 +08:00
l0ng-ai 46883c413c feat(welcome): show Remote Development as a header button (#5021)
Remote Development was hidden in the welcome page's More Actions menu, with the same folder icon as Open; New File used the same plus as New Project. Remote Development is now a header button next to Clone Repository with a new server icon, and New File has a new page-with-plus icon (both icons apply wherever these actions appear). Header buttons no longer cap their width, which cut "Remote Development" to "Remote Develo…"; they collapse to icons below 740px.

The Remote Development dialog's rows ended at different edges because Configure… is wider than Browse. The form is now a two-column grid: fields share the first column and side buttons the second, and its horizontal padding matches the dialog footer, so fields, side buttons and Cancel / Open line up.
2026-11-22 00:51:38 +08:00
l0ng-ai 840dddb897 fix(editor): fit long single-row tabs inside narrow splits (#5020)
A long file name in a single-row editor split could push the selected tab's close button outside the visible strip. Single-row tabs now constrain the label to the available width and keep the close button beside the shortened name. The hidden tabs picker still opens tabs outside the visible strip.
2026-11-22 00:51:33 +08:00
l0ng-ai ae51e195a5 fix(vcs): reorder the annotation gutter context menu (#5019)
Right-clicking the annotation gutter showed Show Commit in Git Log first and Close Annotations last, below Options. The menu now starts with Close Annotations, then Show Diff and Copy Revision Number; after a separator come the revision actions (Annotate at Revision…, Annotate Previous Revision, Show Commit in Git Log, Ignore This Commit), and Options is last. On an uncommitted line the menu is Close Annotations, Options.
2026-11-22 00:51:26 +08:00
l0ng-ai 205be89d4e fix(terminal): keep the selected session tab visible in narrow panes (#5017)
A long terminal session name could take more space than its tab strip and push the close button out of view. Each tab now fits the available width, with an ellipsis for long labels and the full name on hover. New Tab and the terminal options sit next to the strip, and the tab picker handles sessions that overflow.
2026-11-22 00:51:20 +08:00
l0ng-ai ece9c7ef73 fix(project): keep file refactoring changes visible in the preview (#5013)
File refactoring previews give each file a distinct header with its directory and occurrence count. Each code excerpt starts near the changed text and can wrap in a narrow window. The reference count and confirmation buttons stay visible as the list scrolls, and excluded files have a struck-through file name.
2026-11-22 00:51:13 +08:00
Emir fe55a73e97 style(app): redesign welcome and plugins page (#4999)
The plugin details page groups version, downloads, author, categories and the ID / homepage / mail / signer fields so they are easier to scan, with translated labels. The Welcome sidebar uses a larger logo and full-width navigation rows; danger menu items tint their icons.

Co-authored-by: laot7490 <[email protected]>
2026-11-22 00:39:07 +08:00
Vladislav Kuzmin 65b0cc45f0 feat(database): choose tree visibility from row counts (#4824)
The count on a Database tree row opens a searchable chooser for what that row shows, without opening Data Source Properties: PostgreSQL source rows choose databases and database rows choose schemas (each database inherits the source rules until overridden, stored as schemasByDatabase); ClickHouse keeps a flat database list. A visibility-only save updates the rules against the latest saved file and keeps the connection and loaded metadata, while wildcard rules and names the server did not return are preserved.

Closes #4781

Co-authored-by: principalwater <[email protected]>
2026-11-22 00:38:27 +08:00
Vladislav Kuzmin aaab9a5dc6 feat(database): select a JDBC driver from a database preset (#4607)
The General tab of a named database preset lists its built-in driver and the local JDBC profiles associated with that preset, so a local driver no longer requires switching the type to Custom JDBC; the type and tree icon stay. Manage Drivers and Go to Driver open the profile manager scoped to that type. A connection refuses a profile associated with another preset, and a JDBC password is kept apart from a Snowflake key-pair passphrase when switching transports.

Closes #4564

Co-authored-by: principalwater <[email protected]>
2026-11-22 00:37:23 +08:00
Muuтаmuutot 4bc68d27cc feat(settings): Color Scheme › Diff & Merge support (#4994)
Adds a Diff & Merge page to Color Scheme with the four change types (Changed, Conflict, Deleted, Inserted: line background and error stripe mark) and the folded unchanged fragments wave. Each attribute edits the --diff-* tokens the diff viewer paints, with a live preview, and IntelliJ scheme import maps DIFF_* keys and DIFF_SEPARATOR_WAVE onto them. The theme template and token reference list the new wave token.

Co-authored-by: muutot <[email protected]>
2026-11-22 00:37:11 +08:00
Mr0Bread 50f0363669 refactor(agents): share the session MCP and skills picker chrome (#5029)
The MCP and Skills pickers in the composer share one SessionPicker for the trigger, popup header, filter, footer and row parts, and one CSS module; each picker supplies only its data and labels. The trigger's product name is passed as `brand` and shown as written, as before.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-22 00:37:06 +08:00
Mr0Bread 0ff51fdae4 refactor(agents): share the settings-page CSS between MCP servers and skills (#5030)
The rules the MCP Servers and Skills settings pages had in common move into SettingsPage.module.css; each page keeps only its own rules. No visual change.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-22 00:36:54 +08:00
Mr0Bread 7df0880dcc refactor(agents): table-drive classifyUrl and share tool-output ingestion (#5031)
GitHub and GitLab item URLs are matched through one route table, and tool output (JSON metadata and links) is ingested by one helper for both the gh-create and plain tool paths. Classification results are unchanged.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-22 00:36:50 +08:00
Mr0Bread 312559e121 refactor(editor): expose navigation providers, related providers and position helpers through editor/api (#4989)
Features import navigation/related provider registration and the offset/position helpers from `@/editor/api` instead of reaching into editor internals. No behaviour change.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-22 00:36:46 +08:00
LU XIANGRUIтаwildcatDownstairs db8f9a72b0 feat(vcs): edit the compared folders in Compare Directories (#4975)
The left and right paths of Compare Directories are editable fields with a folder chooser beside each, as in IDEA. Enter, leaving the field or picking a folder compares the new pair, opened as its own tab in place of the current one; a path that isn't a folder, or the same folder on both sides, is refused with a message. The layout e2e test follows the editable fields and per-row synchronisation.

Closes #3925

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 00:17:22 +08:00
LU XIANGRUIтаwildcatDownstairs 0a7a292d82 feat(vcs): synchronize compared directories with per-row operations (#4974)
Each Compare Directories row carries IDEA's synchronisation operation in the marker column: copy to the right, copy to the left, delete (one-sided entries) or do nothing; Space or a click cycles it. Synchronize Selected and Synchronize All run the operations as one batch after a single confirmation counting deletions and overwrites. The new fs_synchronize_directories command validates every path, runs the operations on the blocking pool through the existing copy/merge and delete paths (Local History, VCS delete hooks), continues past failures and returns them; cancelling stops before the next entry. The per-row operations replace the single-entry Copy to Left / Copy to Right / Delete buttons.

Refs #3925

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 00:16:19 +08:00
LU XIANGRUIтаwildcatDownstairs a78d1fdc27 feat(project-view): mark folders of attached projects as excluded (#4962)
A folder inside an attached project now has Mark Directory as › Excluded (and Cancel Exclusion), written to that project's own .openidea settings so it also applies when the project is opened alone. New commands project_workspace_members and project_workspace_member_set (projectStructure.* keys of attached projects only); the existing markFolder logic computes the change. Other roles stay out of the menu for attached projects until their source and test roots are applied.

Closes #4712

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 00:13:04 +08:00
LU XIANGRUIтаwildcatDownstairs 8681bfab0d feat(vcs): compare directories by content, text, size or timestamp (#4973)
Compare Directories gets IDEA's Compare by selector: Binary content (default), Text, Size, and Size and timestamp. Text decodes both files with the editor's encoding detection and ignores line separators (files over 5 MiB or binary ones fall back to bytes); Size and timestamp allows 2 s of skew. The choice is remembered.

Refs #3925

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 00:09:12 +08:00
LU XIANGRUIтаwildcatDownstairs 2e7aab9ec6 feat(run): build configurations started together in one Maven run (#4963)
With Delegate IDE build/run actions to Maven, starting several Java configurations together (a Compound, or several Services rows) ran one mvn -pl <module> -am compile plus one classpath probe per configuration, one after another, rebuilding shared upstream modules each time. A launch's Maven run now also builds the modules of the launches still waiting for theirs (same reactor, scope, incremental policy and delegation) as one -pl a,b,c -am run with one classpath probe; the waiting launches reuse the recorded snapshots and classpaths. A member with JDT errors makes it a clean compile; if the shared build fails, none start and each console shows the failure. A lone launch builds as before.

Refs #3971

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 00:09:07 +08:00
LU XIANGRUIтаwildcatDownstairs c08b9b8d4d feat(project): give attached projects their own excluded folders (#4960)
In a workspace with attached projects, the primary project's excluded folders were applied relative to every root (excluding gen in the primary also hid gen in each attached project), while an attached project's own exclusions were ignored. Each workspace project now keeps its own excluded folders, read from its Project Structure settings and build files, and one per-root lookup (exclude_globs_in / search_excludes_in / root_of) gives the index, file watchers, Find in Files, the Project view, the Cucumber/Spring scans and the MCP file tools that root's set. A workspace folder (container) still applies its excluded folders in every member.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 00:09:02 +08:00
LU XIANGRUIтаwildcatDownstairs 81b357cdce feat(color-scheme): add Kotlin extension call, package-level call and enum entry entries (#4979)
The Kotlin page gets Identifiers › Extension function call, Package-level function call and Classes › Enum entry, as IntelliJ's Kotlin page has. Calls on an explicit receiver to top-level functions are extension calls, without one package-level calls; enum entries no longer take Constant. Each falls back to its parent until set; .icls KOTLIN_* keys fill them.

Closes #4059

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 00:08:46 +08:00
LU XIANGRUIтаwildcatDownstairs 9eaa44e004 feat(color-scheme): split predefined types and functions and separate literal keywords (#4978)
Language Defaults and each language page get Identifiers › Predefined type and Predefined function next to Predefined symbol, and Literal keyword next to Keyword. The new entries show their parent until set, so existing overrides keep applying. true / false / null in the clike modes (Kotlin, Scala, Dart, Groovy, C#) are bool / null tokens taking Literal keyword instead of Constant.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 00:07:39 +08:00
LU XIANGRUIтаwildcatDownstairs a3dc3c99a6 feat(color-scheme): add a JavaScript and TypeScript page with decorator and global entries (#4977)
Settings › Editor › Color Scheme gets a JavaScript and TypeScript page as in WebStorm, with Decorator and Identifiers › Global variable / Global function. A decorator's whole name takes the Decorator colour (tsserver reports it as a class), from the syntax tree before the server answers; non-local variables and functions take the global entries, library symbols stay Predefined symbol. .icls TS.* / JS.* keys land on the new page.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-22 00:06:29 +08:00
SunZhiQiang 4c19b7d5b0 fix(agents): answer AskUserQuestion in the conversation (#5034)
The open AskUserQuestion card was pinned above the composer: with several options it covered the conversation (max 50vh, its own scroll), and in a short conversation it floated away from its messages. The card now renders in the conversation at the asking entry and scrolls with it; picking an option on a single-select question moves on to the next one. Permission forms and questions that outlive their turn still wait above the composer at the composer's width.

Closes #5033

Co-authored-by: panda-student <[email protected]>
2026-11-22 00:06:25 +08:00
faysouтаfaysou 85edcf0660 fix(markdown): hide code breadcrumbs in Preview Only (#5032)
Markdown Preview Only still showed the code breadcrumbs (the heading at the caret) under the rendered preview. A text editor wrapper can now report that it hides the source editor (useSourceHidden); the editor pane then drops that tab's code breadcrumbs. Markdown does so in Preview Only and keeps its heading breadcrumbs while the source is shown.

Co-authored-by: faysou <[email protected]>
2026-11-21 23:51:24 +08:00
faysouтаfaysou 49dd1bbef3 perf(markdown): cut layout reads while scrolling previews (#5036)
Each preview scroll frame read offsetTop of every block to find the line at the top. The preview now indexes its blocks when the HTML changes and binary-searches them, reading offsets lazily from the live layout so reflows (zoom, images, diagrams) still count.

Co-authored-by: faysou <[email protected]>
2026-11-21 23:51:17 +08:00
faysouтаfaysou aa73f4c2b9 feat(markdown): render linked footnotes in the preview (#4996)
The Markdown preview showed footnote references as raw text. A marked extension renders references as bracketed superscript links and collects (multi-line) definitions after the document body in citation order, each with return links to its citations; unresolved references and code spans stay literal.

Co-authored-by: faysou <[email protected]>
2026-11-21 23:51:12 +08:00
LU XIANGRUIтаwildcatDownstairs 5375099042 feat(editor): move a ; typed before ) to the end of the statement (#4943)
Typing ; while only closing parentheses follow the caret puts it after the last ), as IntelliJ IDEA's editor.move.semicolon.after.paren does (on by default). It applies in languages that end statements with ;, and not in strings, comments, control statement heads (for, if, try-with-resources, …), declarations, annotations, or when the statement continues on the next line. Settings › Editor › General › Smart Keys has an option to turn it off.

Closes #4936

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-21 23:51:07 +08:00
faysouтаfaysou 2c47bd58bb fix(vcs): group branches across linked worktrees (#5018)
Linked worktrees share one repository's branches, but the branch popup and the Git Log Branches pane listed each checkout as its own repository. vcs_roots now reports each root's branch_root (the main worktree of its common Git directory), and both views group checkouts by it while the Paths filter still scopes the log to the selected checkout. The branch menus also offer New Worktree from '<branch>'…, which preselects the branch, requires a new branch when it is already checked out, and opens the worktree in a new window.

Co-authored-by: faysou <[email protected]>
2026-11-21 23:51:03 +08:00
l0ng-ai d80aeb6e9e docs: describe ESLint, browser debugging, Bun debugging and Open In › GitHub (#5046)
The JavaScript page still said there was no ESLint integration, no browser debugging and no Bun debugging, and the GitHub page said files couldn't be opened on GitHub or linked. Document the ESLint server, the JavaScript Debug configuration, bun-dap, Open In / Copy Path/Reference… for GitHub, GitLab and Bitbucket remotes, and the TypeScript inlay hints, in English and Chinese.
2026-11-21 23:13:08 +08:00
l0ng-ai 55a5e79c9f fix(json): validate JSON files and map SchemaStore schemas for common config files (#5042)
vscode-json-language-server validates nothing unless json.validate.enable is set, so even a file's own $schema was ignored. JSON and JSONC now enable validation and map package.json, tsconfig/jsconfig, ESLint, Prettier, Babel, Lerna, Turborepo, SWC and Composer configs to their published schemas.
2026-11-21 23:09:01 +08:00
l0ng-ai df4210f529 fix(typescript): show inlay hints from vtsls and typescript-language-server (#5041)
Both servers produce no inlay hints unless their inlayHints settings ask for them, and no language config set any. TS, TSX, JS, JSX and Vue's vtsls now enable parameter names at literal arguments, inferred variable types and enum member values; Editor › Inlay Hints still decides which kinds are shown.
2026-11-21 23:08:56 +08:00
Deng Liuтаdengliu 09d8e92e2c chore(dev): add an optional mise contributor toolchain (#4948)
Add mise.toml pinning Rust (with rustfmt and clippy), Node.js and pnpm, plus six tasks (setup, dev, dev:app, build, test, check) that call the existing pnpm scripts and Cargo commands, so the worktree-aware launcher is unchanged and contributors can still work without mise. Document the optional workflow in both setup guides and AGENTS.md, and raise the documented Node minimum to 22.22.2, which the locked jsdom requires on the 22.x line.

Closes #4941

Co-authored-by: dengliu <[email protected]>
2026-11-21 22:22:19 +08:00
Mr0Bread 221b6c3098 fix(ci): validate language smoke dependency triggers (#4847)
Language smoke's path filters missed inputs the smoke actually loads (src/workbench, src/ui, src/bindings.ts, editor LSP modules, vite/tsconfig, pnpm-workspace, patches, build-tools) and the crates ide-host pulls in directly (ide-search, ide-streams), so changes there skipped the smoke. Add them to the workflow paths and the Changes step patterns, and add scripts/smoke-paths.ts with a test that derives the smoke's inputs from the frontend import closure and cargo metadata and fails when the workflow misses one. CI's frontend filter now also runs on crate manifest changes, which the test reads.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-21 22:21:17 +08:00
ntbang0901 d154dce4f7 fix(app): restrict base and form targets in the workbench CSP (#4874)
The workbench CSP had no base-uri or form-action, so injected markup could add a <base> element to retarget relative URLs or post a form to any origin. Add base-uri 'self' and form-action 'none'; the workbench never uses <base> and every form handles submit in script. The plugin view CSP already sets form-action 'none'.

Co-authored-by: ntbang0901 <[email protected]>
2026-11-21 22:19:42 +08:00
l0ng-ai 83364c5423 chore: v0.1.50 2026-11-21 21:03:57 +08:00
l0ng-ai fa33819afb fix(agents): keep the model name readable in a narrow chat composer (#5015)
In a narrow composer the toolbar's first item was capped at 110px, meant for the New Task agent picker. A chat's composer has no agent picker, so the cap fell on the model control and squeezed the model name to "G…" next to its settings chip while the row had room to spare. The agent picker already shows only its icon and doesn't grow, so the cap is removed.
2026-11-21 20:59:22 +08:00
l0ng-ai 5e6a59eae8 fix(agents): pick the model from the list and set its options from one chip (#5012)
The composer's model controls had three ways into the same settings: a "High" detail next to the model chip with a half divider and no chevron, a "Low ›" entry on model list rows leading to a settings page with a back arrow, and inside it a dropdown for Codex's six effort levels — two steps to change effort. While a model's settings loaded, a "Loading model settings…" text broke the row's alignment.

Now the model chip only picks (and pins) models, and the chip next to it opens every option of the current model — effort, context size, fast mode — in one popup, each a click away: on/off as a switch, up to five values as a segmented control, more listed. A model with a single option closes the popup on a choice. The chip has a chevron like the other composer chips, and a spinner takes its place while settings load. Configuring a model other than the current one from its list row is gone.
2026-11-21 20:46:14 +08:00
l0ng-ai a9971905dc fix(navigation): prioritize existing tests in the test chooser (#5011)
The Test and Test Subject choosers give file names their own space and align directories to the right, keeping the end of long directories visible. When there are several tests, the first match is selected and Create New Test appears below the results, with a divider before it.
2026-11-21 20:38:21 +08:00
l0ng-ai 7e6296f0c6 fix(navigation): separate target names from file locations (#5010)
Navigation target rows show the container next to the symbol at the same text size. File locations align to the right and keep the file name and line visible when a long path has to be shortened. The list scrolls inside the popup when space is limited.
2026-11-21 20:18:55 +08:00
l0ng-ai 31c169c889 fix(editor): give the indentation chooser a code style heading (#5008)
The indentation popup uses a Code Style heading for the active file's language. The current indentation stays checked even when the file uses a custom number of spaces. The heading and choices use the standard menu text size.
2026-11-21 20:05:32 +08:00
l0ng-ai 13103fd5af fix(plugins): update wasmtime to 49.0.7 for the WASI sandbox advisory (#5009)
RUSTSEC-2026-0587: on Windows a drive-prefixed path component let a WASI guest escape its preopened directory. 49.0.7 carries the fix; the rest of the wasmtime crates move with it. Lockfile-only.
2026-11-21 20:03:31 +08:00
l0ng-ai 50340219ac fix(editor): show usages on a declaration a server finds no definition for
Go to Declaration on a declaration's own name shows its usages only when the language server answers the declaration itself. kotlin-language-server answers nothing there, so ⌘B / ⌘-click on `fun lend` reported "Cannot find declaration to go to" while Find Usages listed four. When the server has no definition and the syntax tree puts the caret on a declaration's name, the usages show now, for every language.
2026-11-21 19:58:02 +08:00
l0ng-ai 71000e15f2 fix(editor): open library sources reached by navigation read-only
Go to Declaration into a library could open its source editable: only files under the External Libraries roots were read-only, and many language servers answer with sources they keep elsewhere (java-analyzer's source cache, the TypeScript lib files of the server's own typescript, Intelephense's stubs, the temporary copies kotlin-language-server writes). A file outside the project that code navigation opens (declarations, implementations, usages, hierarchy, documentation and inlay links) now opens read-only with the Library source notice. Files opened outside the project in other ways stay editable.
2026-11-21 19:58:02 +08:00
l0ng-ai 042008f681 fix(run): don't launch Java with a server JDK older than the module's release
Without jdtls, a Java run or debug used the JDK the Java language server reports (java-analyzer's own runtime) before matching the module's Java version, so a module compiled for release 21 started on JDK 17 and failed with UnsupportedClassVersionError. The server's JDK is now used only when it can run the module's release; otherwise the installed JDK matching it is picked.
2026-11-21 19:58:02 +08:00
l0ng-ai 942e6cb237 fix(windows): stop WebView2 browser shortcuts from taking unhandled IDE keys (#5007)
A key the keymap leaves alone reached WebView2's browser accelerators: Ctrl+F in a view without its own find opened the page's Find bar over the whole window, and F3, F12 or Alt+Left ran browser features. Turn the accelerators off for every webview; the page still gets every key.
2026-11-21 19:57:55 +08:00
l0ng-ai 674cdd3925 fix(diff): align headers in the combined changes view (#5006)
The combined changes view gives each file its own inset section, with a bold file name and a muted path. File actions sit before the name so they stay visible when a narrow editor pane truncates the text. Compact Mode reduces the space around file sections and headers.
2026-11-21 19:44:35 +08:00
l0ng-ai 04666f5980 fix(app): open middle-clicked links in the browser (#5005)
A middle click on a link (an agent reply, any rendered content) navigated the IDE window to it: link handlers listen to click, and the middle button fires auxclick, whose default action the webview carried out. A window-wide auxclick handler now cancels it for every link and opens a web link in the default browser, as a left click does; a link into the app itself does nothing.

Fixes #4992
2026-11-21 19:33:15 +08:00
l0ng-ai d335ba5fdd fix(project): align the New file type picker (#5004)
The keyboard New popup aligns the search icon and text with the options below it. The search divider has side margins, and the search field keeps its height in short windows while the list scrolls. The wider list and smaller shortcut text let the full Scratch File label fit alongside its Windows shortcut.
2026-11-21 19:23:09 +08:00
l0ng-ai 33d2f34e58 fix(vcs): list a nested repository's files once (#5003)
A folder the enclosing repository still tracks can become a repository of its own; both then reported its files, so the same path appeared twice in the Commit tool window's change tree and its rows went stale when a repository group was collapsed. Each file now belongs to its innermost repository: the enclosing repository's entries inside a nested one are dropped, in the full status and the scoped refresh.

Fixes #4990
2026-11-21 19:07:29 +08:00
l0ng-ai 7646bc4746 fix(workbench): align the empty editor shortcuts (#5001)
The empty editor presents its actions and shortcuts in a left-aligned block centered across the editor. The text uses a 16 px default size with more space between rows, and shortcuts use the foreground color. The Project action appears when the Project tool window is hidden. LightEdit uses the same layout for its file actions.
2026-11-21 19:04:42 +08:00
Emir 2c161812a0 fix(plugins): refresh marketplace after uninstall (#5000)
After uninstalling a plugin, the marketplace kept showing it as installed until it was refreshed, so it couldn't be installed again right away. Uninstall now refreshes the marketplace (from its cached index), as install already does.

Co-authored-by: laot7490 <[email protected]>
2026-11-21 18:51:06 +08:00
l0ng-ai 1778bf1ef3 fix(editor): keep inspection counts readable in split panes (#4998)
The editor inspection widget uses smaller tabular counts and groups the two diagnostic navigation buttons. A narrow pane shows the total beside the Problems icon, leaving more of the code visible. The summary tooltip and accessible label provide the count for each severity.
2026-11-21 18:39:36 +08:00
l0ng-ai 1e7fe7605b fix(editor): align Sticky Lines with the editor viewport (#4997)
Sticky Lines now shares the editor's typography, tab width, and line-number mode. Pinned text and line numbers align with their columns in the document. The panel follows the editor viewport and paints behind the overview lane, with header text clipped at the lane's edge.
2026-11-21 18:19:08 +08:00
l0ng-ai 67dcf5c978 fix(workbench): make background task details easier to read (#4995)
The Background Tasks popup has a fixed title bar and a scrollable task list. Long titles and progress details wrap, and the progress bars, percentages, and cancel buttons line up across rows. The popup remembers its size after it is resized.
2026-11-21 18:00:33 +08:00
l0ng-ai 20404d2f44 fix(workbench): give Notifications a readable timeline (#4993)
Notifications now has a Timeline heading and a Clear All button that stays visible while the history scrolls. Entries use the workbench UI text size and align their titles, timestamps, and actions. In a narrow pane the timestamp and dismiss button move below the title so longer titles can wrap at normal word boundaries. Multiline messages scroll with the history.
2026-11-21 17:38:38 +08:00
l0ng-ai b44e552628 fix(navigation): make the Bookmarks popup resizable (#4991)
The Bookmarks popup opens in the center and remembers its window size and the split between the bookmark list and source preview. The panes sit side by side in a wide window and stack in a narrow one so the preview has room for source lines. Bookmark rows use the workbench list density and align their line numbers on the right.
2026-11-21 17:18:32 +08:00
l0ng-ai bc4e8e9655 fix(editor): align Parameter Info typography and overload rows (#4988)
Parameter Info uses the workbench font and UI size for its signatures. A single signature emphasizes the current argument in bold. Overload lists use inset separators and a rounded highlight for the active signature, while keeping the current argument visible as the list wraps.
2026-11-21 16:55:56 +08:00
faysouтаfaysou c12799c973 test(debugger): select stack threads by their labels (#4987)
The narrow debug dock test timed out after the thread selector started including each thread's state in its option name (Order worker Running). It now finds the option by its visible thread label within the Thread listbox.

Co-authored-by: faysou <[email protected]>
2026-11-21 16:43:04 +08:00
l0ng-ai 0d4bd4a69a fix(editor): group Quick Documentation popup actions (#4986)
Quick Documentation now keeps Edit Source and More Actions in its lower-right corner. More Actions groups the commands for opening the Documentation tool window and moving back or forward through the current document history. The corner stays visible while the documentation scrolls.
2026-11-21 16:42:03 +08:00
l0ng-ai bf2f44d523 fix(debugger): align evaluation history with the expression editor (#4985)
Evaluate uses the configured editor font, size and line height for the expression field. Its history dropdown lines up with the full field and uses the same code typography. The Result label also names the results area for assistive technology.
2026-11-21 16:23:40 +08:00
LU XIANGRUIтаwildcatDownstairs 2b6fab3c1c fix(semantic): colour typescript-language-server's member tokens as methods (#4984)
typescript-language-server passes tsserver's own token type for methods, member (vtsls renames it method). The semantic token mapping only knew method and dropped member tokens, so with typescript-language-server method declarations took the field colour and calls none. member now maps like method.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-21 16:20:04 +08:00
LU XIANGRUIтаwildcatDownstairs 37df909358 fix(color-scheme): let derived tokens follow a scheme's overrides (#4983)
Under an imported or explicitly chosen non-default scheme, tokens that tokens.css derives with var() kept the parent scheme's colour: resolvedSchemeTokens resolved the parent's var() chains to hex first and applied the overrides afterwards. Overrides now take part in resolving, so a derived token follows its source unless it is overridden itself, in the editor stylesheet, the Settings preview and resolvedAttribute. The theme's own scheme is unchanged.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-21 16:15:03 +08:00
l0ng-ai b51054daca fix(navigation): group File Structure filters above the tree (#4980)
File Structure puts the member filters in a compact toolbar above the search field and symbol tree. The toolbar wraps complete labels on narrow windows, while the tree scrolls independently. Sorting and narrowing on typing are available from the View Options menu on the right.
2026-11-21 16:05:46 +08:00
l0ng-ai 57856f2d54 fix(search): keep filter controls visible while scrolling (#4976)
Search Everywhere now aligns the checkbox, type icon and label in each filter row. All, None and Invert sit below the scrolling list so they stay visible when the list is long or the window is short.
2026-11-21 15:50:40 +08:00
LU XIANGRUIтаwildcatDownstairs e06c16f547 fix(color-scheme): let Python method calls follow a Python function call colour (#4971)
A Python override of Function call coloured plain calls but not method calls: tokens.css declares --syn-python-method-call: var(--syn-function-call) on :root, so the fallback was resolved there and never saw the Python block's override. The Python block now re-declares the Python tokens whose default is a var() of a token it overrides (unless they have their own override), so Method call follows Function call and Nested function definition follows Function definition, as in PyCharm. The Settings page shows the same inherited colour.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-21 15:49:34 +08:00
Vladislav Kuzmin 7b893d2982 fix(database): show SQL batch progress as statements finish (#4799)
The SQL console got one response at the end of a batch, so progress, timings and results only appeared once every statement had finished. A new db_execute_stream command reports each statement's start and completion over a channel; the console shows the spinner and timer on the running statement and publishes each result grid as it completes. The batch still runs once, stops at the first error or on cancel, and an older remote server falls back to db_execute after rejecting the new command before execution.

Closes #4782

Co-authored-by: principalwater <[email protected]>
2026-11-21 15:45:35 +08:00
l0ng-ai 1cc8a361b8 fix(project-view): move speed search above the file rows (#4969)
- Place the Project tree's speed search above the file rows so the first item stays readable while typing.
- Use the standard field height, a 16 px search icon, and a visible caret. Long queries truncate within the sidebar. Keyboard focus stays in the tree.
2026-11-21 15:26:36 +08:00
l0ng-ai a28f6ce331 fix(editor): preview regex replacements at the match (#4967)
- Show the expanded replacement beneath the current match in file-level regex Replace when the result differs from the template. The preview uses the same replacement calculation as Replace Next.
- Use a compact monospace balloon that preserves line breaks and stays within the editor width. It follows the selected match and leaves focus in the toolbar.
2026-11-21 15:18:13 +08:00
l0ng-ai 5d27b4254b fix(editor): align the hidden tabs popup (#4966)
- List only the editor tabs clipped by the strip. A separator marks the split between tabs clipped before and after the visible stretch.
- Use compact rows with file icons, the tab label, and its close control. Keep the popup open while closing hidden tabs and bring the chosen tab into view when it is opened.
2026-11-21 14:52:59 +08:00
LU XIANGRUIтаwildcatDownstairs 45d85f5721 fix(plugins): keep web view panels transparent under a dark theme on Windows (#4964)
WebView2 paints an opaque backdrop behind an iframe whose color-scheme differs from the embedding page's. Plugin web view pages (web = "...") got data-theme from the frame bridge but no color-scheme (only html views get BASE_STYLE), so under a dark theme they turned white on Windows. The bridge now sets the frame root's color-scheme along with data-theme, as html views already have.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-21 14:48:21 +08:00
LU XIANGRUIтаwildcatDownstairs fa7fcd0d90 fix(color-scheme): import PyCharm's function call, class and f-string colours (#4965)
Importing a PyCharm color scheme skipped eight PyCharm Python keys (PY.FUNCTION_CALL, PY.CLASS_DEFINITION, PY.PARAMETER, PY.LOCAL_VARIABLE, PY.TYPE_PARAMETER, PY.INVALID_STRING_ESCAPE, PY.FSTRING_FRAGMENT_BRACES, PY.FSTRING_FORMAT_SPEC_NUMBER), so Python calls took the shared call colour. They now map to the existing Python attributes and export under PyCharm's keys; files exported earlier under OPENIDEA_ names still import.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-21 14:48:07 +08:00
l0ng-ai 6b2b4a96e7 fix(debugger): align the thread selector with the frames pane (#4961)
- Give the thread selector the width of the call stack header, with the standard workbench font and a fixed chevron at the trailing edge.
- Show a leading icon for running, suspended, and breakpoint threads in both the header and the menu. Keep the status text in the menu and make the selected thread's full name and status available in the header tooltip and accessible description.
2026-11-21 14:33:37 +08:00
l0ng-ai d507e67123 fix(debugger): anchor Smart Step Into to the paused line (#4959)
- Open the Smart Step Into target list by the paused source line. Center it when the paused source is outside the visible editor.
- Keep the list compact for short target lists. Scroll longer lists and show clipped method names in a tooltip.
2026-11-21 14:13:46 +08:00
l0ng-ai 5563345a8f fix(debugger): fit the full value viewer to its popup (#4958)
Size the debugger's full-value popup to the workbench and let the text fill the available space as the popup grows. Render the value with the configured editor font, line height and tab width. Keep the resized popup visible if the workbench shrinks.
2026-11-21 13:52:34 +08:00
Mollo-i bff0761c48 fix(vcs): honour the diff window setting in Show Diff (#4957)
Show Diff called openDiff directly and always opened an editor tab, ignoring Settings > Version Control > Confirmation > Open diff as editor tab. It now goes through openVcsDiff like the other change entry points, so with the option off the diff opens in the separate Diff window.

Co-authored-by: Greenker <[email protected]>
2026-11-21 13:42:14 +08:00
l0ng-ai 2811a438a0 fix(editor): skip project-wide background requests in library sources (#4933)
Go to Declaration in a library file could wait 10-20 s behind usage lenses, server code lenses and inheritor markers, which asked references / implementation for every visible library declaration and made the server analyse the whole project.

Usage lenses and server code lenses now skip library sources (library roots, node_modules, excluded folders, virtual documents, files outside the project). Gutter markers stay: in library files ↓ is asked for classes and interfaces only, and in-flight marker requests are cancelled while a navigation gesture runs and asked again afterwards.
2026-11-21 13:38:13 +08:00
Mollo-i d34252c80a fix(editor): keep Java annotations on their line's indentation after Enter (#4956)
Enter after a Java annotation added an indentation level, so stacked annotations above a class drifted right: the stock Java grammar parses an annotation (or an unfinished annotation type) as a Statement, which continues one level deeper. A Java-only indent service keeps the annotation line's indentation when the break follows the whole annotation; an open @Ann( and code blocks still indent.

Co-authored-by: Greenker <[email protected]>
2026-11-21 13:22:19 +08:00
l0ng-ai a60a36f052 fix(settings): align the Download JDK dialog (#4955)
Put Version first in Download JDK, followed by Vendor and Location. Use one aligned control column in the desktop dialog and put labels above their controls in narrow windows. The location field uses the regular UI font, and long help, progress, and error text can wrap within the dialog.
2026-11-21 13:20:21 +08:00
ntbang0901 939222cdfb feat(debugger): Java exception breakpoints for a chosen class (#4954)
The Breakpoints dialog gains Java Exception Breakpoints on a chosen class (subclasses included): Caught and/or Uncaught, optionally limited by class filters on the throwing code. java-debug's Caught/Uncaught filters stay as the Any exception row. java-debug has no per-class exception requests, so the jvm-inspect bundle (1.2.0) makes the JDI exception requests itself; ide-dap arms them before configurationDone (a throw on main's first line stops) and again after each setExceptionBreakpoints, which drops them. Condition and catch-class filters show disabled with the reason. The bundle jar was rebuilt from source and matches the checked-in one byte for byte.

Co-authored-by: ntbang0901 <[email protected]>
2026-11-21 13:19:21 +08:00
l0ng-ai ec0370ec23 fix(settings): fit Module Sources to the available width (#4953)
Put the folder tree and marked roots in a resizable split in Project Structure › Modules › Sources. The panels stack when the available width is too small for a side-by-side layout. The summary shows populated root groups and uses the 13 px workbench font for folder paths.
2026-11-21 12:58:16 +08:00
l0ng-ai 9243ff2eac feat(services): jump to the source of a run configuration (#4952)
Run configuration nodes in Services gain Jump to Source (F4, ⌘↓, context menu): JVM applications and Spring Boot open their main class at the declaration (the configuration's module first), npm/Bun the script in package.json, Python/Ruby/shell/pytest their file, Gradle/Maven the build file, Go the target or main.go, .NET the project file. Kinds without a file show it disabled. F4 on a run configuration no longer starts it; providers without Jump to Source keep activating.
2026-11-21 12:44:18 +08:00
l0ng-ai 143281d67e fix(settings): group Project Libraries attachments in a tree (#4951)
Project Libraries now shows class and source attachments in one expandable tree with a shared add and remove toolbar. Attachment rows use the 13 px workbench font. In narrow windows, the library list and details adapt to the available width, and long paths scroll inside the tree.
2026-11-21 12:35:29 +08:00
Zou e1f25d2747 feat(i18n): add Traditional Chinese (zh-TW) UI language (#4950)
Adds 繁體中文 to the UI languages. The catalogs are converted from the Simplified ones with OpenCC (s2twp) plus a Taiwan IT terminology pass keyed on the English source (column → 欄, undo → 復原). zh-TW, zh-HK, zh-MO and zh-Hant* resolve to it; other zh tags stay Simplified. The update source picks CNB for every zh* locale, matching the backend.

Co-authored-by: g4cj8498741 <[email protected]>
2026-11-21 12:25:12 +08:00
l0ng-ai 26fce11f94 fix(run): align the stack trace dialog (#4949)
Give the stack trace editor a 600 × 400 preferred area and use the configured editor typography, including tab width. Resizing the dialog grows the editor. At short window heights, the editor shrinks so the trace scrolls within the field and the footer stays visible.
2026-11-21 12:14:11 +08:00
Gabriel Gondim c5c2fb7c98 fix(ssh): use the agent from IdentityAgent or the login shell's SSH_AUTH_SOCK (#4939)
OpenSSH authentication asked the agent client for SSH_AUTH_SOCK from the process environment only. On macOS an app started from the Dock has launchd's socket there, so an agent exported in ~/.zshrc (Bitwarden's, in #4934) was never used. The default agent is now SSH_AUTH_SOCK as the login shell sets it (the app already reads that environment at startup), and IdentityAgent in ~/.ssh/config is honoured per host, jump hosts included (none, SSH_AUTH_SOCK, $VAR or a path with ~ and % tokens). On Windows a SSH_AUTH_SOCK that is not a pipe falls back to the OpenSSH pipe.

Co-authored-by: GGVidal <[email protected]>
2026-11-21 12:03:04 +08:00
l0ng-ai 31ca9daa61 fix(vcs): align the target changelist dialog (#4947)
Put existing and new target changelists in one editable **Name** field. Open the list to pick an existing target or enter a name to make a new one. The comment and active status sit in the same place for both choices. Undo Commit offers the commit subject as a suggested name.
2026-11-21 11:57:07 +08:00
l0ng-ai d89991168e fix(vcs): align the history commit message dialog (#4945)
Show the commit hash and author above the message editor when editing a commit. Use the same layout for the message of a squashed commit. The dialog resizes in both directions, and the text area follows the configured editor font, weight and line height.
2026-11-21 11:39:42 +08:00
l0ng-ai 16496f8001 fix(vcs): don't report the index a worktree diff refreshes as a repository change (#4946)
git diff against the working tree rewrites .git/index when it meets files with stale stat data, even with --no-optional-locks. The watcher reported that as a repository change, so the agent changes view, which re-reads on every repository change, re-ran its diffs and triggered itself again; on Windows, where git and gix disagree on stat data, it never settled and kept several git processes a second running (#4792). Every git diff that reads the working tree now records an index it rewrote as our own write, like status's write-back; this covers agent changes, compare with the working tree and the other worktree diffs.
2026-11-21 11:38:31 +08:00
l0ng-ai ce58c873da test: update two fixtures left stale by recent changes (#4944)
The commit settings default shape gained includeChangesByDefault (#4864), and New Task options now come from the project's saved catalog (#4901), so the approvals test seeds projectCatalogs instead of the removed provider-wide config. Fixes Rust checks on main for every platform.
2026-11-21 11:31:46 +08:00
l0ng-ai d069c3daff fix(vcs): align the revision comparison toolbar (#4942)
Move **Show Diff** from the desktop revision comparison footer to a compact toolbar above the changed files. The action is available when a file is selected. **Close** sits by itself at the bottom right.
2026-11-21 11:22:15 +08:00
l0ng-ai 95b71e1ffc fix(vcs): align the rebase dialog (#4940)
- Group the repository, command and target branch in one row. The row wraps when space is limited.
- Put the branch being rebased in the title. With `--onto` enabled, place the new base beside the command and label the old base on its own row.
- Move flags to **Modify options** and show active flags below the fields. Clear branch selections when switching repositories and wait for the new repository's branches.
2026-11-21 11:05:51 +08:00
l0ng-ai 732cfd6002 fix(vcs): align the unstash dialog (#4935)
- Align the repository, current branch, stash list, and branch input in two columns using the workbench form font. Put Show Changes and Drop Stash beside the list and group the restore options beneath it.
- Add a repository picker for multi-repository projects. Each repository loads its own stash list before the actions become available. After a drop, the list stays visible while the actions wait for the refreshed selection. The fields stack on narrow windows.
2026-11-21 10:48:32 +08:00
Akbar Husain 189879f0fa perf(vfs): coalesce the pre-debounce watcher queue per path (#4032)
Raw notify events were queued one by one until the debounce window closed, so an event storm grew the queue without bound. Events are now classified in the notify callback and coalesced per path, keeping each path's distinct transitions in order, so the batch sees the same result while memory is bounded by paths touched (100,000 writes over 1,000 paths: 100,000 entries before, 1,000 after). Coalesced VCS changes replay as creates so directory changes under .git are not dropped as lock-file touches.

Co-authored-by: akbar1214 <[email protected]>
2026-11-21 10:47:34 +08:00
l0ng-ai f0a412f3e2 fix(vcs): align the worktrees panel (#4937)
- Place the actions on the left of the Worktrees tree in both the dialog and the Git tool window.
- Show the checkout name above its branch and path, with the same UI font size for the checkout name and branch. Current, locked, and prunable worktrees have status icons. The tree supports searching by either checkout name or branch.
2026-11-21 10:40:52 +08:00
Gabriel Gondim 1a470e2a23 fix(window): host system buttons in the macOS fullscreen title bar (#4923)
In native full screen on macOS, the window buttons lived in the title bar strip AppKit slides down with the menu bar, which showed up as a dark band over the IDE's own title bar. Full screen now hosts system window buttons made by standardWindowButton:forStyleMask: in the slot the page keeps for them, and hides that strip. The strip is re-hidden from its own window notifications (no polling), matched by its exact class, and only for the window in full screen.

Fixes #4746

Co-authored-by: GGVidal <[email protected]>
2026-11-21 10:28:43 +08:00
l0ng-ai 793c720f7f fix(vcs): align the reset dialog (#4932)
- Align the Reset HEAD fields in two columns and use the workbench form font throughout. Show the current branch and the selected reset mode's effect, and stack the fields on narrow windows.
- Let the user choose the repository in a multi-repository project. A repository change resets the typed revision to HEAD.
- In Reset to Here, put the repository, branch, and fixed commit above the mode choices.
2026-11-21 09:53:24 +08:00
l0ng-ai 93c7f8b7fd fix(vcs): align the merge dialog (#4930)
- Put the repository and searchable branch picker on the same line as the Git command. The row wraps on narrow windows.
- Move the merge flags into the Modify options menu and show the selected flags below the command row. Choosing a custom commit message opens a multiline field.
2026-11-21 09:40:19 +08:00
l0ng-ai 3e37b60505 refactor(settings): remove the unused RadioRow control (#4931)
The settings pages that used RadioRow now lay out their radio groups themselves, so it had no callers left and knip failed on main. Removes it with its RadioChoice type.
2026-11-21 09:33:05 +08:00
weigramтаweigram a5c8fe17fd feat(services): drag a run type's group to reorder it (#4929)
The Services tree persists the order of its run type groups per project, but only configurations inside a group could be moved. Groups now reorder among each other by drag or with Move Up / Move Down, using the project's type list as their order, so the new position survives reopening.

Co-authored-by: weigram <[email protected]>
2026-11-21 09:32:07 +08:00
l0ng-ai 0684795334 fix(vcs): align the new branch dialog (#4924)
New Branch used a stacked prompt with a small label above the name field and the creation options at the left edge. The dialog now puts the label beside the field, uses the workbench UI font for both, and aligns validation and options with the field. On narrow windows the label stacks above the field and the checkboxes can wrap.
2026-11-21 09:31:00 +08:00
l0ng-ai 30cbb80f22 fix(history): align the recent changes chooser (#4917)
fix(history): align the recent changes chooser
2026-11-21 09:30:49 +08:00
weigramтаweigram 5cfb0d3311 feat(settings): reopen Settings on the page it was closed on (#4927)
Settings now records the page it shows (when it opens and on each navigation) and reopens there, in the separate Settings window and across restarts. The page is UI state and stays in localStorage; Settings for New Projects keeps its own pages out of it, and an id that no longer exists falls back to the first page.

Co-authored-by: weigram <[email protected]>
2026-11-21 09:22:16 +08:00
l0ng-ai bccf1bd7d6 fix(vcs): align the tag dialog (#4926)
- Align the Tag dialog's labels and controls in two columns, use the workbench font throughout, and stack the fields on narrow windows.
- Show the selected repository and its current branch above the tag fields. Keep the duplicate-name message and Force checkbox under the tag name.
2026-11-21 09:18:46 +08:00
l0ng-ai 3d79454be8 fix(vcs): align the changelist form (#4925)
The changelist form stacked small labels above each field and left room for only three lines of comments. The Name and Comment labels now sit beside a shared field column at the workbench UI size. The comment field starts at four lines, and the fields stack on narrow windows. The same form is available when creating, editing or moving changes to a new list.
2026-11-21 08:59:25 +08:00
l0ng-ai 46e4af2b32 fix(vfs): ignore Git metadata directory touches (#4922)
Git for Windows reports a parent directory modification when Git creates or removes a lock. The watcher treated these notifications as repository changes and refreshed Git status even when the index was identical. Refresh Git status on metadata file changes and directory creation or removal. Skip directory modifications caused by the changed entries.
2026-11-21 08:43:26 +08:00
l0ng-ai 067edb7d60 fix(vcs): align the Git annotation gutter (#4921)
Git annotations displayed only the first part of each author's name, and variable-width dates pushed the author column out of alignment. The gutter now uses the workbench UI font and sizes the columns from the file's annotations. Authors are shown by full name, with a width cap for long labels. When enabled, the revision column leads the row.
2026-11-21 08:25:00 +08:00
l0ng-ai 0a4abf1705 fix(vcs): align the file history layout (#4920)
File History inherited the repository log's sidebars, which left little room for the revision list or commit message. It now uses a full-width toolbar and revision list, with author and date before the subject by default. A resizable pane below puts the selected commit message beside the changed files and remembers its size independently. The repository log and directory history keep their current layout.
2026-11-21 08:06:50 +08:00
l0ng-ai d31699c86a fix(vcs): align the file revision chooser (#4919)
fix(vcs): align the file revision chooser
2026-11-21 07:59:59 +08:00
Gabriel Gondim 9467c4ea1b fix(plugins): install-dir reads and default editors over associated apps (#4918)
A plugin's fs.read-*, editor.open and views.open-location rejected absolute paths under its own install (package) directory, so a linked plugin could not open files bundled next to its component. The install directory is now readable like fs.plugin-dir() (writes still need an fs.write grant). Custom editors with priority "default" now open in the IDE ahead of the Files opened in associated applications list, so a PDF editor plugin is not bypassed by the built-in *.pdf association. The SDK carries the updated WIT docs and the plugin components are rebuilt.

Fixes #4167

Co-authored-by: GGVidal <[email protected]>
2026-11-21 07:58:50 +08:00
l0ng-ai 7c12c58874 fix(vcs): align the operations chooser (#4915)
fix(vcs): align the operations chooser
2026-11-21 07:29:12 +08:00
l0ng-ai 9f47ef0991 style(settings): format the Git settings imports (#4916)
Formats an import line that came out of a merge too long for oxfmt. No behaviour change.
2026-11-21 07:26:17 +08:00
l0ng-ai 3b614dda7a fix(diff): clarify clipboard comparison labels (#4911)
fix(diff): clarify clipboard comparison labels
2026-11-21 07:25:45 +08:00
l0ng-ai 5acd778340 fix(navigation): align the Select In chooser (#4909)
fix(navigation): align the Select In chooser
2026-11-21 07:25:17 +08:00
l0ng-ai 7c682a580f fix(editor): group the Refactor This actions (#4906)
Refactor This uses a compact action list with an Extract/Introduce section and dividers for the related action groups. Filtering keeps captions only for groups with matching actions. The number beside each action still selects that action directly.
2026-11-21 07:25:05 +08:00
l0ng-ai dc07691279 fix(run): align the run configuration chooser (#4904)
The run configuration chooser adapts its width to configuration names and leaves room for the row actions. At large zoom or in a short viewport, the configuration list scrolls while the search field and keyboard shortcuts stay visible.
2026-11-21 07:24:47 +08:00
l0ng-ai 2d04a3d9bc fix(editor): align the Quick Definition preview (#4903)
Quick Definition opens with a toolbar above a resizable code preview. The header shows the symbol and its source location, with previous and next controls when several results are available. The preview uses the source editor's font size, line height, and zoom.
2026-11-21 07:24:36 +08:00
l0ng-ai 8f9b9b1016 fix(workbench): group commands in the tool window layouts menu (#4902)
Window → Tool Window Layouts groups commands under each saved layout and marks the active layout. The default layout is at the top, with commands for the current arrangement below the saved layouts. Rename opens the name field for the selected layout directly.
2026-11-21 07:24:18 +08:00
l0ng-ai 096964c798 fix(workbench): align the toolbar customization dialog (#4898)
Move the add, remove, reorder, transfer, and restore controls into a compact toolbar above the lists. Keep the left and right groups side by side when there is room, and stack them in narrow windows so the labels have more space. The add picker opens directly below its command.
2026-11-21 07:24:08 +08:00
l0ng-ai f1bfd5db52 fix(workbench): center and label Quick Switch Scheme (#4897)
Quick Switch Scheme now opens in the center of the window and stays there when the window is resized. A title identifies the popup, and a numeric column shows shortcuts 1–4 for opening its categories. Theme previews and editor focus still restore when the popup closes.
2026-11-21 07:23:50 +08:00
l0ng-ai a17af582f3 fix(settings): align the Date Formats layout (#4894)
Place the date pattern help beside the input when there is room and let it wrap under the input in narrow windows. Put the live examples just below the time format control in smaller, secondary text. Pretty formatting remains a separate setting and still updates both examples.
2026-11-21 07:23:32 +08:00
l0ng-ai 47f018d8b5 fix(settings): align the External Tools form (#4893)
Pair Name and Group when the form has room and put Description on its own row. Tool Settings contains the command fields, while the execution checkboxes sit in a collapsible Advanced options section that opens for matching settings searches. The fields and macro buttons adapt to the available width.
2026-11-21 07:23:22 +08:00
l0ng-ai 94aa62430c fix(settings): align the System Settings layout (#4890)
Put exit confirmation before Project, then place file saving and synchronization in a Files section before Caches. In narrow windows, the project-opening choices use less vertical space, the directory field keeps its browse button beside it, and the idle timeout keeps its unit. The existing Autosave search term still finds the page.
2026-11-21 07:23:03 +08:00
l0ng-ai 4242c94bfc fix(settings): align the Updates settings layout (#4889)
Put Check Now and Last checked on the same row, below automatic checks and the update source. The last-checked timestamp uses secondary text and follows the button as the window narrows. The release notes preference sits below the manual check.
2026-11-21 07:22:44 +08:00
l0ng-ai 8864ff595d fix(settings): align the Maven settings layout (#4886)
Put the snapshot option and a compact thread count at the top. Group Maven home, user settings, the local repository, and toolchains under Environment. Put source downloads under Importing, with build delegation, JRE, and profiles together under Runner.

Environment and Runner put labels above their fields in narrow windows. Browse buttons stay beside their paths, and Maven Daemon controls are available below Runner.
2026-11-21 07:22:34 +08:00
l0ng-ai 0a08d9f4ce fix(settings): align the Gradle settings layout (#4885)
Place Gradle user home at the top of the page, with separate sections for Build and Run and the Gradle runtime. Keep the local installation path and Browse button beside Distribution when there is room. In narrow windows the path field moves below the selector and stays next to Browse. The Gradle JVM picker sits below the distribution controls.
2026-11-21 07:22:23 +08:00
l0ng-ai 7dbfe8852e fix(settings): align the Spelling settings layout (#4884)
Place custom dictionary files above the accepted words. Give both lists the available pane width, with monospaced paths and standard UI text for words. A tab selects the project or application dictionary within the accepted words section. Settings for New Projects shows the application dictionary directly.
2026-11-21 07:22:13 +08:00
l0ng-ai ae97d5f1c2 fix(settings): group the debugger Data Views controls (#4883)
Group inline values and value tooltips under Editor. Keep the hover delay beside its checkbox in wide windows and below it in narrow windows. Turning off hover dims the delay field and keeps its value for when hover is enabled again. Sort order and live watches sit at the top of the page.
2026-11-21 07:21:54 +08:00
l0ng-ai 4340a96c59 fix(settings): align the Terminal settings layout (#4882)
Group the primary font, fallback font, and sizing controls above Application Settings. Let the start directory and default tab name use the available width. Keep the shell path, installed-shell menu, and Browse button together. Narrow windows place text fields below their labels and show the application checkboxes in one column.
2026-11-21 07:21:17 +08:00
l0ng-ai 0af7bcc7cf fix(settings): align the VCS confirmation settings (#4878)
The file creation and deletion policies use aligned selectors in Version Control settings. They fit on separate rows at narrow widths. The patch creation and history controls follow the Changes group as separate settings.
2026-11-21 07:21:07 +08:00
l0ng-ai 4f52f5ebfa fix(vcs): align the directory comparison layout (#4875)
fix(vcs): align the directory comparison layout
2026-11-21 07:20:29 +08:00
l0ng-ai f284633162 fix(settings): align the Appearance controls (#4867)
fix(settings): align the Appearance controls
2026-11-21 07:20:18 +08:00
l0ng-ai 0ceda2c385 fix(settings): align the Git settings controls (#4865)
fix(settings): align the Git settings controls
2026-11-21 07:20:07 +08:00
l0ng-ai 8b3f55dfb4 fix(settings): align the HTTP Proxy form (#4863)
fix(settings): align the HTTP Proxy form
2026-11-21 07:19:48 +08:00
l0ng-ai c0e888dd2f fix(settings): align the Console settings layout (#4861)
fix(settings): align the Console settings layout
2026-11-21 07:19:37 +08:00
l0ng-ai 04bed01942 fix(vcs): align the Apply Patch preview (#4860)
fix(vcs): align the Apply Patch preview
2026-11-21 07:19:24 +08:00
weigramтаweigram dfafe6c767 fix(app): bring the window forward before the quit prompts ask (#4913)
Confirm Exit and the Terminate / Unsaved Changes prompts of a quit are drawn inside the window, but a quit can start outside it (the Dock, a logout, another window). A minimized or covered window asked with nothing on screen and the app looked hung. The window is now unminimized, shown and focused right before a quit prompt; a window with nothing to ask is left where it is.

Fixes #4912

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

Co-authored-by: weigram <[email protected]>
2026-11-21 07:06:44 +08:00
Vladislav Kuzmin 461c71a50b test(settings): measure notification labels in the group list (#4892)
#4810 replaced the notification group table with a listbox, and the compact settings test still waited for a table cell, so it timed out before measuring anything. It now measures the group labels inside the listbox.

Fixes #4891

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

Co-authored-by: principalwater <[email protected]>
2026-11-21 06:55:23 +08:00
l0ng-ai 82085a227e fix(agents): record a task's turns across nested repositories (#4910)
A local task in a project with nested git repositories recorded no turns, so the Changes pane's last-turn scope stayed empty there and the whole-task list no longer kept to the files the task touched. A turn now records each repository's HEAD as it starts; the files a turn changed, their text when it began and its rollback come from the repository holding each file, including commits made in a nested one.
2026-11-21 06:38:07 +08:00
Paweł SzymańskiтаPawelSzymanski89 c3f420374c fix(agents): list task changes per repository, including nested repos (#4543)
A local agent task in a project that holds nested git repositories (an own .git below the project root, not a submodule) only saw the changes of the repository at its root. Its changes are now read from every repository under the root, each against its own HEAD; the Changes pane groups them under a row per repository when there are several, and a rollback reads each file from its own repository.

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

Co-authored-by: PawelSzymanski89 <[email protected]>
2026-11-21 06:32:34 +08:00
faysouтаfaysou 6bf7bc8c2b fix(vcs): apply Directory Mappings changes to all selected roots (#4908)
Directory Mappings now supports multi-row selection with Cmd/Ctrl and Shift. Minus moves the selected Git roots to an Unregistered roots section instead of only removing manually added ones, and plus registers the selected unregistered roots again in one step. Applying a removal refreshes Git status and branches: removing the selected repository switches to the remaining one, and removing the last repository clears the previous Git state and decorations.

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

Co-authored-by: faysou <[email protected]>
2026-11-21 06:18:36 +08:00
faysouтаfaysou 34dfc166db fix(vcs): keep Git Log paths and branches in sync (#4907)
The Paths filter of the Git Log now holds the repository checkboxes, path entry, the file and folder tree and recent paths. Selecting paths replaces the repository selection, so a path in another repository no longer leaves the log empty, and the commit log and the Branches panel are scoped to the repositories the paths belong to.

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

Co-authored-by: faysou <[email protected]>
2026-11-21 06:15:44 +08:00
Chris Schofield 64632dc4d7 feat(editor): JSX/TSX tag editing — linked tag rename, prop values, Emmet (#4905)
JSX/TSX editing like the HTML modes: editing an opening or closing tag's name renames its partner (Simultaneous <tag></tag> editing), Enter between a tag pair puts the caret on an indented line with the closing tag below, and JSX tag pairs are matched. Typing = after a value-less prop inserts "" for string-typed props and {} otherwise (type from the server's hover, {} after 500 ms), following Pair quotes / Pair brackets. Emmet expands with Tab among an element's children and after return / => (className, self-closing void elements). Under TypeScript 7 the native server is asked for jsxAttributeCompletionStyle auto, so prop completion inserts the value delimiters as vtsls does.

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

Co-authored-by: ChildishForces <[email protected]>
2026-11-21 05:45:10 +08:00
Mr0Bread f484fd6802 fix(agents): let chats select any model their agent's catalog lists (#4901)
An existing agent chat listed models from the agent's catalog but refused to switch to them unless the catalog was under 15 minutes old and matched the launch fingerprint. A model the picker lists is now always selectable. The chat's picker offers the agent's current catalog plus the model the chat runs, and falls back to the session's own list when there is no catalog. The per-task copy of models and effort levels is removed, so the project catalog is the only source of available models and efforts.

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

Co-authored-by: Mr0Bread <[email protected]>
2026-11-21 04:50:52 +08:00
l0ng-ai 8121dc87f1 test(e2e): wait for the Run window to take focus before toggling it (#4900)
The tool-window shortcut hides a window only once it is active, and activation focuses it on the next frame; under load the test pressed Cmd+4 or Shift+Escape before that, so the window stayed open. The test now waits for focus inside the Run window first.
2026-11-21 04:27:03 +08:00
l0ng-ai 97f78908a1 fix(terminal): don't take focus that moved elsewhere while the view loaded (#4899)
A focus request made before xterm opened was applied whenever it opened, so a terminal still loading took the caret back from a view the user had clicked meanwhile. The deferred focus now applies only while focus is where it was when requested, on the page, or inside the terminal's own tool window.
2026-11-21 04:23:06 +08:00
faysouтаfaysou e7aec17d46 Match backtick runs in protected inline Markdown math (#4895)
Protected inline math ($`...`$) now matches the opening backtick run to the first closing run of the same length, as Markdown code spans do: ($``x` + y``$) renders as math, while ($`x` `y`$) keeps two code spans and literal dollars.

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

Co-authored-by: faysou <[email protected]>
2026-11-21 03:56:06 +08:00
l0ng-ai cb24f252c5 fix(vcs): keep focus on the commit message when the Commit window opens (#4896)
Activating a tool window focuses its first field or tree on the next frame unless its content marks a data-autofocus target. The Commit window's message wasn't marked, so after Cmd+K focused the message, activation could move focus to the Changes tree depending on timing. The message is now the window's preferred focus, also when the window is activated from its stripe button.
2026-11-21 03:55:28 +08:00
faysouтаfaysou 8557b8d21e feat(vcs): make default Commit inclusion configurable (#4864)
Settings > Version Control > Commit gets Include changes in the commit by default. It is on by default, which keeps the current behaviour (the active changelist's changes start checked). Turned off, the Commit view starts with every file unchecked, partially staged files included. Explicit selections still apply, and staging-area mode still follows the Git index.

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

Co-authored-by: faysou <[email protected]>
2026-11-21 03:32:16 +08:00
l0ng-ai 99a8f8feaa fix(completion): put the caret inside a Kotlin call that takes arguments (#4888)
Refs #3447

kotlin-lsp inserts a picked item itself, parentheses included, and the caret was moved after the whole edit (read()| for read(name: String)), so typed arguments went after the call. When the item's signature lists parameters and the server's edit ends with (), the caret now goes between the parentheses, as it does for items inserted on the client.
2026-11-21 02:50:55 +08:00
l0ng-ai 4b76566af4 fix(editor): write failed saves to the log with their stack (#4887)
Refs #3447

A failed save only showed its message in the Could not save notification, and a failed autosave of a closed tab went to the console. Both are now written to the log file with their stack, so a report's log shows where the save failed.
2026-11-21 02:49:14 +08:00
Emir 51bab9a25b feat(i18n): add Turkish localization (#4881)
Turkish joins the UI languages (Settings > Appearance > Language), with the key catalog and the source-text catalog; tr / tr-TR system locales resolve to it.

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

Co-authored-by: laot7490 <[email protected]>
2026-11-21 02:01:59 +08:00
Vadim LazukтаInf1mum 302c4068cf feat(agents): skills hub for every CLI, per-workspace modes, and per-session skills picker (#4879)
Fixes #3897 (phase 1)

Settings > Agents > Skills lists every skill found in the workspace (.agents/skills, .openidea/skills and each CLI's folder) and the user's folders (~/.agents/skills, ~/.claude/skills, ~/.copilot, ~/.codex, ~/.cursor), with symlinked copies collapsed and SKILL.md validated. Each skill can be auto, slash only or off, globally or per workspace ([agents.skills.<name>] in settings.toml). SKILL.md files are never edited. An untrusted workspace can only turn skills off. The composer gets a per-session Skills picker and /skills, and / completion offers active skills for every agent.

Sessions get their skills through a per-task folder that is rebuilt on each start: Claude Code via --add-dir and --settings skillOverrides, Copilot via skillDirectories/disabledSkills, Codex via skills/extraRoots/set and skills.config. Other ACP agents only get their / menu filtered.

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

Co-authored-by: Inf1mum <[email protected]>
2026-11-21 01:57:18 +08:00
l0ng-ai ff11932a65 fix(vcs): keep git status from rewriting the index (#4880)
Refs #4792

The dirty-scope status refresh (and the full one when gitoxide can't read the tree) ran git status, which writes refreshed stat data back to .git/index. The watcher can't tell that write from an external one, so it scheduled another refresh that could run git again. git status now runs with GIT_OPTIONAL_LOCKS=0 and leaves the index alone; our own gitoxide write-back is unchanged.
2026-11-21 01:45:09 +08:00
Ernstjan FreriksтаEjaYF 745038b4e2 fix(markdown): zoom preview images with ⌘/Ctrl+wheel like Mermaid diagrams (#4729)
Images in the Markdown preview get the pan/zoom Mermaid diagrams already have: Cmd/Ctrl+wheel zooms the image at the cursor, drag pans once zoomed, double-click resets; the image keeps its place and size in the page and font zoom still scales it.

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

Co-authored-by: EjaYF <[email protected]>
2026-11-21 01:41:13 +08:00
Vladislav Kuzmin 3c3b26b419 fix(settings): wrap radio labels in narrow System Settings (#4841)
In a narrow Settings window, System Settings clipped the Open project in radio labels because they could not wrap; the labels now wrap within the group.

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

Co-authored-by: principalwater <[email protected]>
2026-11-21 01:39:48 +08:00
ntbang0901 1189a71205 fix(search): match Words like IntelliJ when the text starts or ends with punctuation (#4873)
With Words on, Find and Replace in Files missed matches whose text starts or ends with punctuation (doWork( in doWork(arg), [] in string[]) because ripgrep's word rule wants non-word characters on both sides. The whole-word check now follows the editor's rule: an identifier-character edge must not touch another identifier character (escapes like \n excepted), any other edge only needs a different neighbour, and a rejected match is retried from its next character; it sits in the shared match iteration so search, Replace, match_ranges and replace_in_text agree. $ counts as an identifier character.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-21 01:38:57 +08:00
ntbang0901 f27dea2d8a fix(search): Replace All past the match limit keeps to the search context (#4872)
Replace All after the search hit its match limit ignored the Search Context (e.g. In Comments also rewrote code and string literals): past the limit the scope is searched again to find files, and the replace step had no comment/string filter. The filter now lives in SearchContext::keeps, used by both the search engine and replace_files_in_context, with comments and string literals from the same literals_of in ide-host.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-21 01:37:09 +08:00
ntbang0901 7b5ff4e4b5 fix(search): list and replace every match of a very long line (#4871)
Find in Files dropped every match outside the window kept around the first match of a line longer than 500 UTF-16 units, so long lines showed one match and Replace All replaced only that one. Such a line now yields one LineMatch per window, so each match is listed, counted, navigable and replaceable with its own context; result rows are keyed by line and column, and the MCP text search matches each long line once.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-21 01:33:56 +08:00
ntbang0901 e94dc1baae fix(refactor): keep editors on files a refactoring renames or moves (#4868)
Renaming or moving a class through a refactoring closed the editor of the old file and never opened the new one: workspace edits applied through Documents::apply_workspace_edit_as reported only the affected paths, so the editor saw just the watcher's removal. WorkspaceEditApplied now carries the edit's file moves, and WorkspaceHistory makes open editors follow them on apply, Undo and Redo using the Project view's helper (moved to src/editor/fileMoves.ts), which now waits for the old tab to close before reopening and settles the record before reopening on Undo/Redo.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-21 01:30:12 +08:00
l0ng-ai 3228da223e fix(build): align the Dependency Analyzer panes (#4856)
Dependency Analyzer keeps module selection, search, scope or configuration, and conflict filtering in the main toolbar; the pane headers align the resolved dependency list with the selected dependency's usages, with list and tree controls beside the list, and narrow editors stack both panes.
2026-11-21 01:28:47 +08:00
ntbang0901 332334fb4f fix(outline): show type aliases a language server reports as variables (#4869)
TypeScript type aliases showed as variables in the Structure view and breadcrumbs, and Rust type aliases / associated types had no usages lens, because LSP has no kind for type aliases and servers report Variable or TypeParameter. doc_outline now takes the syntax tree's type kind (merge_kinds) where the server reported one of those placeholder kinds for a declaration the syntax outline types at the same name and position.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-21 01:26:41 +08:00
ntbang0901 047ec9d6bc fix(navigation): name a target's container only from a type whose body holds it (#4870)
Navigation choosers and gutter marker names took a target's container from the nearest type declaration above it without checking that its body was still open, so targets after a closed type got that type's name. enclosingType now uses a declaration only when its body holds the target: brace bodies count braces up to the target column (ignoring string literals), others use indentation; Go methods still use their receiver.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-21 01:25:20 +08:00
ntbang0901 912c710096 fix(agents): open binary session artifacts through the checked backend command (#4866)
Clicking a binary artifact (Word, Excel...) in an agent session's Artifacts popup always opened it as text: SessionAssets called the opener plugin's openPath, which the app capability does not grant. It now goes through fs_open_with_system, the checked command Open in Associated Application uses (local window, trusted project, existing file inside the project or its content roots), and still falls back to the editor when the backend refuses.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-21 01:24:27 +08:00
ntbang0901 38f1c4810c fix(run): rerun a root Gradle test run's failed tests in their own subprojects (#4862)
After a run of a multi-project Gradle build's plain test task, Rerun Failed Tests and running a selection from the test tree put every --tests filter on that plain task, so the first subproject without a match failed the build. Each failed class is now resolved to its module (the source lookup Application configurations use, now classModules) and its filter goes on that subproject's own test task (:alpha:test --tests A :beta:test --tests B --continue); the command line is unchanged when a class is not found in exactly one module, all tests are the root project's, or the run already names a task.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-21 01:23:57 +08:00
l0ng-ai 7fe7ec0fea style(cucumber): format the Python step files (#4877)
Runs oxfmt on the Python step files from #4859, which were merged unformatted and failed pnpm format:check on main.
2026-11-21 01:22:37 +08:00
l0ng-ai 423bf2c733 fix(settings): align Code Completion case choices (#4852)
Settings > Editor > General > Code Completion shows both case-matching choices beside the Match case checkbox; the options wrap when space is limited and stay visible when disabled, so the saved choice is easy to see.
2026-11-21 01:11:23 +08:00
l0ng-ai 73d1470940 fix(settings): align Actions on Save in a table (#4848)
Settings > Tools > Actions on Save groups the three save preferences in a table: each row keeps its description with the checkbox and shows Save or Save All in the trigger column while enabled; the scope switch and the whitespace settings link stay below the table.
2026-11-21 00:57:56 +08:00
l0ng-ai c83b0b1442 fix(settings): pair postfix templates with a code preview (#4843)
Settings > Editor > General > Postfix Completion puts the template list beside a preview of the selected template, showing the typed expression and its expansion from the existing template body; in narrow panes the preview moves below the list.
2026-11-21 00:41:46 +08:00
l0ng-ai d16993e175 fix(lsp): end a cancelled server task the server never ends (#4842)
Cancelling a server-reported background task (window/workDoneProgress/cancel) left it on Cancelling for good when the server never sent end, e.g. Pyright stuck before loading its workspace. The server now gets five seconds to end the task; after that the IDE ends it and clears the server's busy state, ignoring later reports on that token.
2026-11-21 00:36:53 +08:00
l0ng-ai 5d4cdac3c7 fix(settings): align the File Colors rules table (#4839)
Settings > Editor > File Colors puts the placement switches together above the rules; a table keeps scope names aligned with their swatches and colour names, with the toolbar and headings sticky while the rules scroll. The selected rule's editor sits directly below the table, and the colour controls wrap in narrow panes so the full hex value stays visible.
2026-11-21 00:25:48 +08:00
l0ng-ai 9c414cc75c fix(settings): align Editor General controls (#4827)
Settings > Editor > General: the mouse-wheel zoom scope choices sit beneath their checkbox as radio buttons, the soft-wrap file patterns field sits beside its checkbox (wrapping underneath in a narrow pane), and Scrolling follows Virtual Space with each caret behaviour on its own line.
2026-11-21 00:10:18 +08:00
Vladislav Kuzmin 3bbc90d750 test(debugger): expect watch for explicit Quick Evaluate (#4837)
Explicit Quick Evaluate sends DAP context watch since #4801 so method calls can run; the layout e2e test now expects watch for both evaluations.

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

Co-authored-by: principalwater <[email protected]>
2026-11-21 00:03:02 +08:00
ntbang0901 6d157c8b71 fix(debugger): stop at an uncaught exception from a traced stream so its records stay (#4851)
When a traced stream's terminal operation threw something the program does not catch, the trace lost its records: ide-dap reads them in the stop after its stepOut, and an uncaught exception ends the thread without one. Before parking a trace whose terminal threw, the jvm-inspect bundle now adds an uncaught-only ExceptionRequest on the traced thread (unless an enabled java-debug request already stops there), so the program stops at that throw and the trace shows the records with the exception. Bundle 1.1.1; the jar was rebuilt from source and matches byte for byte.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:57:05 +08:00
l0ng-ai f2c0fcdc96 fix(settings): align Smart Keys backspace and paste controls (#4823)
Settings > Editor > General > Smart Keys places the Backspace and paste formatting controls directly below the Enter options; the two controls share a label column and the paste escaping option sits below the formatting control.
2026-11-20 23:54:10 +08:00
ntbang0901 a4574fdc92 fix(debugger): show toString() of Java values instead of a nameless child row (#4857)
Java values whose class overrides toString() showed without their text, and opening them showed one nameless row with the fields a level deeper. java-debug marks these values with DAP presentationHint.lazy and the IDE ignored it. Variables now carry lazy; debug_resolve_variable merges the adapter's single inner variable into the row; debugger configs can declare resolve-lazy-variables (on for java-debug) so variables/evaluate return resolved values; other adapters resolve a lazy row in place when it is opened or its (...) marker is clicked.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:53:34 +08:00
ntbang0901 4bc87f5d84 fix(debugger): stay suspended on a thread its breakpoint still holds after another resumes (#4858)
Java debugging suspends only the thread that hits a breakpoint, but the Debug window tracked one stopped thread: after resuming it, the window showed Running with Resume and Step disabled while another thread was still stopped. The session now tracks every thread stopped alone (stopped adds, continued removes) and moves to a remaining stopped thread when the shown one continues; steps report all_threads_continued false since they run only their thread.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:50:14 +08:00
ntbang0901 39671ff55b fix(vcs): merge and rebase branches by their short name (#4850)
Merging a branch from the Branches popup recorded "Merge branch 'refs/heads/feature'" (and the rebase reflog "checkout refs/heads/feature") because the popup passes the full ref to avoid tags of the same name. Merge and rebase now pass the short name when it resolves to that same branch, and keep the full ref when a tag shares the name.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:47:32 +08:00
ntbang0901 881812547d fix(vcs): open the Conflicts dialog when an unstash stops on conflicts (#4849)
Applying or popping a stash that conflicts with the working tree showed an error balloon instead of the conflict resolver. unstash() was the only operation that can stop on conflicts without the conflict handler; it now uses conflictsInstead like merge, rebase and unshelve, so the Conflicts dialog opens. Other unstash failures still report the error.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:46:47 +08:00
ntbang0901 9c145ea258 fix(run): run a Gradle subproject's tests with that subproject's test task (#4846)
In a Gradle multi-project build, gutter class/method runs, Run on a test file and JUnit configurations used the build's plain test task, so --tests filtered every subproject and the first one without a match failed the build before the subproject holding the test ran. They now share inGradleModule (the lookup directory runs already used) and run :<subproject>:test --tests ...; reruns and test-tree selections inherit that task.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:45:45 +08:00
ntbang0901 4f192a12bc fix(run): let Maven reactor modules without the selected tests pass in every test run (#4845)
In a Maven multi-module project, Rerun Failed Tests and Run on a test file failed before the selected tests ran: -Dtest reached the first module without a matching test and Surefire stopped the build, skipping the module with the test. Those two paths built -Dtest themselves without -Dsurefire.failIfNoSpecifiedTests=false; every Maven test selection now goes through withMavenTests, which replaces an earlier -Dtest and always adds the flag.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:44:02 +08:00
ntbang0901 1d857375dc fix(vcs): open a multi-line selection's lines on the Git remote from Open In (#4844)
Editor > Open In > GitHub / GitLab / Bitbucket opened only the caret line even with several lines selected. The editor menu passed the caret line only and vcs.openOnRemote dropped endLine; the menu now takes its lines from the helper Copy Path/Reference uses (moved to selectedLines.ts) and Open In keeps endLine.

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

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:43:20 +08:00
Vladislav Kuzmin 6543cdb36b test(debugger): expect unquoted strings in the value dialog (#4836)
The full-value dialog shows a string without its adapter quotes; the debugger layout e2e test now asserts the unquoted text there and keeps the quoted value in the Variables row.

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

Co-authored-by: principalwater <[email protected]>
2026-11-20 23:42:46 +08:00
Vladislav Kuzmin 684c92ce90 test(settings): target the exact font preview textbox (#4833)
The font-family e2e test matched both the editable preview and its resize handle through a substring label lookup; it now targets the textbox by its exact accessible name.

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

Co-authored-by: principalwater <[email protected]>
2026-11-20 23:42:38 +08:00
l0ng-ai 9a77a95180 feat(cucumber): behave and pytest-bdd step definitions in Python (#4859)
Python step definitions for Gherkin: behave decorators with its parse / cfparse / re matchers (use_step_matcher switches them), and pytest-bdd's exact strings and parsers.parse / cfparse / re. Covers navigation both ways, the Undefined step check and Create step definition (pending step_impl for behave, def _() for pytest-bdd, decorator added to the existing import). The backend scan reads .py files with a step decorator and skips site-packages.
2026-11-20 23:41:43 +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
1656 змінених файлів з 107180 додано та 15464 видалено

No files matched your search

+3 -2
Переглянути файл
@@ -65,8 +65,9 @@ jobs:
plugin_web='^plugins/official/[^/]+/web-src/'
# Paths the frontend checks never read...
backend='^(crates/|src-tauri/|sdk/|wit/|java/|fixtures/|Cargo\.(toml|lock)$|deny\.toml$|rustfmt\.toml$|rust-toolchain(\.toml)?$|\.cargo/)'
# ...except these, which frontend tests and e2e fixtures load.
read_by_web='^(fixtures/(folding|django-app)/|crates/ide-plugin/tests/fixtures/|crates/ide-db/(src|tests/fixtures)/snowflake/|src-tauri/(icons|capabilities)/|src-tauri/tauri\.conf\.json$)'
# ...except these, which frontend tests and e2e fixtures load (the crate manifests:
# scripts/smoke-paths.test.ts, through cargo metadata).
read_by_web='^(fixtures/(folding|django-app)/|(crates/[^/]+/)?Cargo\.toml$|crates/ide-plugin/tests/fixtures/|crates/ide-db/(src|tests/fixtures)/snowflake/|src-tauri/(icons|capabilities)/|src-tauri/tauri\.conf\.json$)'
# What the browser app and its e2e tests are built from.
app='^(src/|e2e/|public/|index\.html$|vite\.config\.ts$|tsconfig\.json$|playwright\.config\.ts$|package\.json$|pnpm-(lock|workspace)\.yaml$|crates/ide-plugin/tests/fixtures/|src-tauri/(icons|capabilities)/|src-tauri/tauri\.conf\.json$)'
# The plugin workspaces: the SDK, the plugins, their interface and the host's fixture plugins.
+30 -3
Переглянути файл
@@ -8,6 +8,9 @@ name: Language smoke
# (Run, Run tests, the test tree, Rerun Failed Tests): smoke/run.test.ts; and debugging its
# entry point with the debugger the IDE installs (breakpoint, frames, variables, evaluate,
# Step Over, Resume): smoke/debug.test.ts.
# The paths below and the Changes step's patterns must cover every file the smoke loads and
# every crate it runs: scripts/smoke-paths.test.ts checks them (`node scripts/smoke-paths.ts
# [file…]` lists what they miss, or the languages a change runs).
on:
push:
branches: [main]
@@ -20,10 +23,32 @@ on:
- "Cargo.lock"
- "src/features/run/**"
- "src/features/debugger/**"
- "src/features/build-tools/**"
- "src/platform/**"
- "src/workbench/**"
- "src/ui/**"
- "src/editor/api.ts"
- "src/editor/navigationProviders.ts"
- "src/editor/relatedProviders.ts"
- "src/editor/core/cm/cornerInset.ts"
- "src/editor/core/cm/iconArea.ts"
- "src/editor/lsp/availability.ts"
- "src/editor/lsp/diagnostics.ts"
- "src/editor/lsp/files.ts"
- "src/editor/lsp/hint.ts"
- "src/editor/lsp/lsp.ts"
- "src/editor/lsp/positions.ts"
- "src/bindings.ts"
- "src/styles/tokens.css"
- "src/test/setup.ts"
- "src-tauri/icons/128x128.png"
- "smoke/**"
- "vite.config.ts"
- "tsconfig.json"
- "package.json"
- "pnpm-lock.yaml"
- "pnpm-workspace.yaml"
- "patches/**"
- ".github/workflows/language-smoke.yml"
- ".github/tool-versions.env"
pull_request:
@@ -70,10 +95,12 @@ jobs:
--jq '.[] | .filename, (.previous_filename // empty)' > files.txt
cat files.txt
# Crates outside what the smoke runs (language servers, debuggers, run configurations,
# SDKs, build tools and the project model): cargo metadata, deps of ide-lsp/dap/run/sdk/tools.
unused='^crates/(ide-agent|ide-analysis|ide-android|ide-cli|ide-clipboard|ide-coverage|ide-db|ide-docker|ide-fonts|ide-github|ide-http|ide-mcp|ide-notebook|ide-profiler|ide-scaffold|ide-search|ide-spell|ide-ssh|ide-streams|ide-vcs|ide-web)/'
# SDKs, build tools, the project model, Find Usages candidates, debug stream traces):
# cargo metadata, ide-host's direct deps ide-search/ide-streams and the deps of
# ide-lsp/dap/run/sdk/tools.
unused='^crates/(ide-agent|ide-analysis|ide-android|ide-cli|ide-clipboard|ide-coverage|ide-db|ide-docker|ide-fonts|ide-github|ide-http|ide-mcp|ide-notebook|ide-profiler|ide-scaffold|ide-spell|ide-ssh|ide-vcs|ide-web)/'
# The workflow's paths, less those handled per language below.
smoke='^(crates/|Cargo\.(toml|lock)$|src/features/(run|debugger)/|src/platform/|smoke/|package\.json$|pnpm-lock\.yaml$|\.github/workflows/language-smoke\.yml$|\.github/tool-versions\.env$)'
smoke='^(crates/|Cargo\.(toml|lock)$|src/features/(run|debugger|build-tools)/|src/platform/|src/workbench/|src/ui/|src/editor/(api|navigationProviders|relatedProviders|core/cm/(cornerInset|iconArea)|lsp/(availability|diagnostics|files|hint|lsp|positions))\.ts$|src/bindings\.ts$|src/styles/tokens\.css$|src/test/setup\.ts$|src-tauri/icons/128x128\.png$|smoke/|vite\.config\.ts$|tsconfig\.json$|package\.json$|pnpm-(lock|workspace)\.yaml$|patches/|\.github/workflows/language-smoke\.yml$|\.github/tool-versions\.env$)'
langs=""
while read -r f; do
case "$f" in
+5 -1
Переглянути файл
@@ -73,10 +73,14 @@ Shared agent skills live in `.agents/skills/` (`.claude/skills/` links to them):
## Commands
- `pnpm tauri dev` — run the app with worktree isolation (Node 22.18+).
- Optional: `mise install` provisions the contributor toolchain; `mise tasks` lists the task aliases.
See [Development setup](docs/en/contribute/setup.mdx). The direct commands below still work without mise.
- `pnpm tauri dev` — run the app with worktree isolation. Use Node 22.22.2 or later on the 22.x line.
`pnpm dev:app` also enables the global Tauri API. `pnpm dev:status` reports
this worktree's running MCP bridges and actual ports.
- `pnpm build` — typecheck + bundle frontend.
- `pnpm dogfood:build` / `pnpm dogfood:install` (or `mise run dogfood:build` / `mise run dogfood:install`) — build and locally install the grey-icon dogfood desktop app sharing release settings and data.
- `pnpm dogfood:remote <remote_name> [--restart | --no-restart] [--clean]` (or `mise run dogfood:remote <remote_name>`) — sync backend sources to a host from **Tools › SSH Configurations**, build `openidea-server`, and stage it for Remote Development.
- `cargo nextest run --workspace` (or `cargo test`), `cargo clippy --workspace --all-targets -- -D warnings`, `cargo fmt --all`.
- `cargo test -p ide-host --test language_smoke -- --ignored --exact <language>` — code intelligence
on `fixtures/` with that language's real server installed (CI: `Language smoke`, pinned versions).
Створено
+135 -123
Переглянути файл
@@ -1203,27 +1203,27 @@ dependencies = [
[[package]]
name = "cranelift-assembler-x64"
version = "0.136.6"
version = "0.136.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aecefa88696b62f833cc0c997d19c93246b0268e2aaf23e0e8692e527f6de088"
checksum = "c19fba13ee427c4dd29488ea51127e945bf07fd9d79093f14c9cc57f74acf757"
dependencies = [
"cranelift-assembler-x64-meta",
]
[[package]]
name = "cranelift-assembler-x64-meta"
version = "0.136.6"
version = "0.136.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1391a2546f5edf06a0ff5e9430d73c2713fd536aefec53200dc21846d1467f53"
checksum = "dd88c766346fcc14bbadbd68cb11e9bc1e555e99f7e8f6b1f4c27a73ca659bec"
dependencies = [
"cranelift-srcgen",
]
[[package]]
name = "cranelift-bforest"
version = "0.136.6"
version = "0.136.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9528915fbc2c950702329e08c6d72aaff8ece9b7ecdbd225742825c09a445227"
checksum = "f19d43d75dd963d6b1a653f2e03d4eed4365ca2e598ec57e52c15afdad6c3276"
dependencies = [
"cranelift-entity",
"wasmtime-internal-core",
@@ -1231,9 +1231,9 @@ dependencies = [
[[package]]
name = "cranelift-bitset"
version = "0.136.6"
version = "0.136.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9dd69a6db85c1bcff989809e0e0b3b06506425f32b545c46aeafda5fe7775d6a"
checksum = "45d0b93e50856858c89c61cbe3f6d4b07596da22eb5a03a95b19420e1d08a275"
dependencies = [
"serde",
"serde_derive",
@@ -1242,9 +1242,9 @@ dependencies = [
[[package]]
name = "cranelift-codegen"
version = "0.136.6"
version = "0.136.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "24c2db6c26cd96393cf785c4b51b900738963cc7422aa0045416a7641ae2f6cd"
checksum = "efbdff32d3b6b4f33f1ba8a4ac747b97ce569b1d6834c3089c1c0933b94e618c"
dependencies = [
"bumpalo",
"cranelift-assembler-x64",
@@ -1273,9 +1273,9 @@ dependencies = [
[[package]]
name = "cranelift-codegen-meta"
version = "0.136.6"
version = "0.136.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e284270142e7f1dcb73a992a62a8b3716b4062a65a52d8f2732c6ebf6f7f342f"
checksum = "67fd11ff24916a2c1ff852ce4bb664fcf2c2970ed551de44dd5b573321123703"
dependencies = [
"cranelift-assembler-x64-meta",
"cranelift-codegen-shared",
@@ -1286,24 +1286,24 @@ dependencies = [
[[package]]
name = "cranelift-codegen-shared"
version = "0.136.6"
version = "0.136.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6595667b7d505cf85d5bdd014e6f57ad6128183238f8e372319d9384782472f5"
checksum = "ba5d321229c3e00a17d7bb3633529ffdf97a13bcf4962fd2e92f1e0fd39360aa"
[[package]]
name = "cranelift-control"
version = "0.136.6"
version = "0.136.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f26ffdbfcd24c3833d730849e6d132af34a400a2b89b44446015c01eecbea21d"
checksum = "71cd63450256d0f80f7a0527e133452f84fa6e1ca73c7db6ca2a9e8cc89d1c18"
dependencies = [
"arbitrary",
]
[[package]]
name = "cranelift-entity"
version = "0.136.6"
version = "0.136.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ffb08ccd8a77fb31cdbbda2afa2333d8f85299b1bc0d1c194259ba66d160d74"
checksum = "18d2f259130db1bbb89500d26944971a9beeb410de91ff14039203f055d7f9f0"
dependencies = [
"cranelift-bitset",
"serde",
@@ -1313,9 +1313,9 @@ dependencies = [
[[package]]
name = "cranelift-frontend"
version = "0.136.6"
version = "0.136.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b447e4f2bb44b1188185a77f478e5a91b7723a40b3b58c3e2d5b26df2ed5a665"
checksum = "cf37a38d982d45fe2c065d55e4de76e596b443b6acceb3ca726c2072c8ba6d7b"
dependencies = [
"cranelift-codegen",
"hashbrown 0.17.1",
@@ -1326,15 +1326,15 @@ dependencies = [
[[package]]
name = "cranelift-isle"
version = "0.136.6"
version = "0.136.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2f0989e943f3a9d41989595826bba544df9fda64bcddd4df0c06fb2e26af3cb3"
checksum = "8ce8f84e2d44326879e18016d763457a2cb5d775e4a5822cd7473fc171fca063"
[[package]]
name = "cranelift-native"
version = "0.136.6"
version = "0.136.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5fa10df59e776c42dae5b6ba5216ba5321707a2136abd2219e615c54b234fc1b"
checksum = "df64a0392edac7b38fb2965ce8e205e7c5e219e4c531ed3cd1929c782f21853d"
dependencies = [
"cranelift-codegen",
"libc",
@@ -1343,9 +1343,9 @@ dependencies = [
[[package]]
name = "cranelift-srcgen"
version = "0.136.6"
version = "0.136.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "36508559c8839a8b6ee091f9deaa9cfe620a82f1abb5e358a0a0c65290583622"
checksum = "3748e3c77c0717359cd4c089e1dc057221eb8598a9c18b0b5afccb5685975abb"
[[package]]
name = "crc"
@@ -2154,7 +2154,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
dependencies = [
"libc",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -2386,7 +2386,7 @@ checksum = "94e7099f6313ecacbe1256e8ff9d617b75d1bcb16a6fddef94866d225a01a14a"
dependencies = [
"io-lifetimes 2.0.4",
"rustix",
"windows-sys 0.59.0",
"windows-sys 0.52.0",
]
[[package]]
@@ -4144,8 +4144,9 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
[[package]]
name = "ide-agent"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"base64 0.22.1",
"blake3",
"dunce",
"encoding_rs",
@@ -4156,6 +4157,8 @@ dependencies = [
"ide-vcs",
"ide-vfs",
"parking_lot",
"rustix",
"semver",
"serde",
"serde_json",
"specta",
@@ -4169,7 +4172,7 @@ dependencies = [
[[package]]
name = "ide-analysis"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"ast-grep-core",
"ide-core",
@@ -4183,7 +4186,7 @@ dependencies = [
[[package]]
name = "ide-android"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"ide-core",
"serde",
@@ -4194,7 +4197,7 @@ dependencies = [
[[package]]
name = "ide-build"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"blake3",
"chardetng",
@@ -4212,7 +4215,7 @@ dependencies = [
[[package]]
name = "ide-cli"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"dirs 6.0.0",
"serde",
@@ -4226,7 +4229,7 @@ dependencies = [
[[package]]
name = "ide-clipboard"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"gtk",
"objc2 0.6.5",
@@ -4237,7 +4240,7 @@ dependencies = [
[[package]]
name = "ide-command"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"heck 0.5.0",
"proc-macro2",
@@ -4248,7 +4251,7 @@ dependencies = [
[[package]]
name = "ide-core"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"dunce",
"encoding_rs",
@@ -4265,7 +4268,7 @@ dependencies = [
[[package]]
name = "ide-coverage"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"ide-core",
"ide-run",
@@ -4279,7 +4282,7 @@ dependencies = [
[[package]]
name = "ide-dap"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"base64 0.22.1",
"futures",
@@ -4308,7 +4311,7 @@ dependencies = [
[[package]]
name = "ide-db"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"base64 0.22.1",
"bb8",
@@ -4346,7 +4349,7 @@ dependencies = [
[[package]]
name = "ide-docker"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"ide-core",
"serde",
@@ -4357,9 +4360,23 @@ dependencies = [
"which",
]
[[package]]
name = "ide-drag-out"
version = "0.1.50"
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"
version = "0.1.50"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4380,7 +4397,7 @@ dependencies = [
[[package]]
name = "ide-flutter"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"ide-android",
"ide-core",
@@ -4391,7 +4408,7 @@ dependencies = [
[[package]]
name = "ide-fonts"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"objc2-core-foundation",
"objc2-core-text",
@@ -4403,7 +4420,7 @@ dependencies = [
[[package]]
name = "ide-github"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"ide-core",
"ide-vcs",
@@ -4416,7 +4433,7 @@ dependencies = [
[[package]]
name = "ide-heap"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"criterion",
"ide-core",
@@ -4434,7 +4451,7 @@ dependencies = [
[[package]]
name = "ide-host"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4509,8 +4526,9 @@ dependencies = [
[[package]]
name = "ide-http"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"hyper-util",
"ide-core",
"ide-vfs",
"parking_lot",
@@ -4528,7 +4546,7 @@ dependencies = [
[[package]]
name = "ide-index"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"blake3",
"criterion",
@@ -4550,7 +4568,7 @@ dependencies = [
[[package]]
name = "ide-jdwp"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"ide-jvm-inspect",
"proptest",
@@ -4562,7 +4580,7 @@ dependencies = [
[[package]]
name = "ide-jsonrpc"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"encoding_rs",
"futures",
@@ -4579,7 +4597,7 @@ dependencies = [
[[package]]
name = "ide-jvm-attach"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"libc",
"tempfile",
@@ -4588,7 +4606,7 @@ dependencies = [
[[package]]
name = "ide-jvm-inspect"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"futures",
"serde",
@@ -4599,7 +4617,7 @@ dependencies = [
[[package]]
name = "ide-language"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"blake3",
"criterion",
@@ -4658,7 +4676,7 @@ dependencies = [
[[package]]
name = "ide-lsp"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"criterion",
"dunce",
@@ -4687,7 +4705,7 @@ dependencies = [
[[package]]
name = "ide-mcp"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"bytes",
"dunce",
@@ -4706,7 +4724,7 @@ dependencies = [
[[package]]
name = "ide-notebook"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"futures",
"ide-core",
@@ -4729,7 +4747,7 @@ dependencies = [
[[package]]
name = "ide-plugin"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"blake3",
"dunce",
@@ -4752,7 +4770,7 @@ dependencies = [
[[package]]
name = "ide-profiler"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"ide-core",
"ide-jvm-attach",
@@ -4766,7 +4784,7 @@ dependencies = [
[[package]]
name = "ide-remote"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"dunce",
"futures",
@@ -4786,7 +4804,7 @@ dependencies = [
[[package]]
name = "ide-run"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"dunce",
"encoding_rs",
@@ -4810,7 +4828,7 @@ dependencies = [
[[package]]
name = "ide-scaffold"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"ide-core",
"ide-tools",
@@ -4826,8 +4844,9 @@ dependencies = [
[[package]]
name = "ide-sdk"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"dirs 6.0.0",
"dunce",
"flate2",
"ide-core",
@@ -4849,7 +4868,7 @@ dependencies = [
[[package]]
name = "ide-search"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"criterion",
"encoding_rs",
@@ -4870,7 +4889,7 @@ dependencies = [
[[package]]
name = "ide-spell"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"ide-core",
"parking_lot",
@@ -4883,7 +4902,7 @@ dependencies = [
[[package]]
name = "ide-ssh"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"dirs 6.0.0",
"flate2",
@@ -4908,7 +4927,7 @@ dependencies = [
[[package]]
name = "ide-streams"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"ide-core",
"ide-language",
@@ -4921,7 +4940,7 @@ dependencies = [
[[package]]
name = "ide-syntax"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"ide-core",
"ide-language",
@@ -4936,7 +4955,7 @@ dependencies = [
[[package]]
name = "ide-terminal"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"ide-core",
"libc",
@@ -4950,7 +4969,7 @@ dependencies = [
[[package]]
name = "ide-text"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"criterion",
"ide-core",
@@ -4963,7 +4982,7 @@ dependencies = [
[[package]]
name = "ide-tools"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"flate2",
"hex",
@@ -4984,7 +5003,7 @@ dependencies = [
[[package]]
name = "ide-vcs"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"blake3",
"dunce",
@@ -5005,7 +5024,7 @@ dependencies = [
[[package]]
name = "ide-vfs"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"chardetng",
"dunce",
@@ -5017,6 +5036,7 @@ dependencies = [
"ignore",
"notify",
"parking_lot",
"rayon",
"rustix",
"serde",
"serde_json",
@@ -5031,7 +5051,7 @@ dependencies = [
[[package]]
name = "ide-web"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"dirs 6.0.0",
"ide-core",
@@ -5047,7 +5067,7 @@ dependencies = [
[[package]]
name = "ide-workspace"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"blake3",
"dunce",
@@ -5209,7 +5229,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "20fd6de4ccfcc187e38bc21cfa543cb5a302cb86a8b114eb7f0bf0dc9f8ac00f"
dependencies = [
"io-lifetimes 3.0.1",
"windows-sys 0.60.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -5247,7 +5267,7 @@ checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
dependencies = [
"hermit-abi",
"libc",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -6676,7 +6696,7 @@ dependencies = [
[[package]]
name = "openidea"
version = "0.1.49"
version = "0.1.50"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -6696,6 +6716,7 @@ dependencies = [
"ide-dap",
"ide-db",
"ide-docker",
"ide-drag-out",
"ide-extension",
"ide-fonts",
"ide-github",
@@ -7405,9 +7426,9 @@ dependencies = [
[[package]]
name = "pulley-interpreter"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "335e459f9c7809af04768799880504d014d07e8e2fc6ae682fe2a105d8ced33f"
checksum = "99ecf828c291348e4066f8e45bf37c35ea6012b07a9201e7911c21f03ad1af3e"
dependencies = [
"cranelift-bitset",
"log",
@@ -7417,9 +7438,9 @@ dependencies = [
[[package]]
name = "pulley-macros"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dd492ac929a6ca0357362d9fa0a09e31290feac5914550ccfb539b21f89c4b9e"
checksum = "20e35ece122b2e8bbd7ea9db0709b3d32f20555b73985efc3eaf6afa4ef2ecdf"
dependencies = [
"proc-macro2",
"quote",
@@ -7949,7 +7970,7 @@ dependencies = [
"errno",
"libc",
"linux-raw-sys",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -8017,7 +8038,7 @@ dependencies = [
"security-framework",
"security-framework-sys",
"webpki-root-certs",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -9764,7 +9785,7 @@ dependencies = [
"getrandom 0.3.4",
"once_cell",
"rustix",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -11098,9 +11119,9 @@ dependencies = [
[[package]]
name = "wasmtime"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f32390bdc8d7cdb6259a1b855178bfed88226b4004b209fd48fb30e0deb01cd3"
checksum = "263d6a66a772efff2c98a1aa367e8e61dae32d2ecf95f85f4776733762322aa7"
dependencies = [
"addr2line",
"async-trait",
@@ -11140,9 +11161,9 @@ dependencies = [
[[package]]
name = "wasmtime-environ"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c10f8ef1c9ee5e0f125c775fe56a4d07b8525db30a96e6358c61d93bd11dee4"
checksum = "5f2f0898bedc77f110dca6f70394780f89af68a8ca19e12559ee73d4187a6fe9"
dependencies = [
"anyhow",
"cpp_demangle",
@@ -11171,9 +11192,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-component-macro"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "620c53182ebd26c9fff5b90dd53cf8ec3103c381403fd32f8d395da31a9e4a46"
checksum = "b140c28283bd2255a4bb8834621f7200bbe7581cbca91d803b5ba4adf9119a5e"
dependencies = [
"anyhow",
"proc-macro2",
@@ -11186,15 +11207,15 @@ dependencies = [
[[package]]
name = "wasmtime-internal-component-util"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "011e31ca343d9ba0ec623153cd94131b6f03973ef1a0ab791161f642e4a16a93"
checksum = "853075a197694ba7f0749e7af78b59e12c0956dff5b16dafbfc49c3b90cdbc93"
[[package]]
name = "wasmtime-internal-core"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ab15e50a060b746493e6e95ef3ce4e6e7ebfdd7cc336a7dff0f0277e01b447ef"
checksum = "e6e13ab3aa598d863643ef9ec043d63fde7effca4465270446d5b868936b27a6"
dependencies = [
"hashbrown 0.17.1",
"libm",
@@ -11203,9 +11224,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-cranelift"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc3d27440a83fba26dd2784a997e13d9acb3606a75fb127c324929b52221c5c5"
checksum = "660103cff91df46f9f06568f3889b8b59a6ae0f56756abfcc002a0a69974cc9f"
dependencies = [
"cranelift-codegen",
"cranelift-control",
@@ -11229,9 +11250,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-fiber"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e54b28d0d453ca8932e4504065ae66a78f01fcb22b1a2ee287128d732fa9d6f"
checksum = "c4d0e958516bdf283b83015283774e11c86b66f2f4bd7d2ea52e9799fa59cddb"
dependencies = [
"cc",
"libc",
@@ -11243,9 +11264,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-jit-debug"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9293e75a3048b900f7b7c524702abca16d8a2332f970324eefc519f454cd5d69"
checksum = "ad61b1e661871bb7d11b5543202a05c44ed8682806b438f68ced629a22719463"
dependencies = [
"cc",
"wasmtime-internal-versioned-export-macros",
@@ -11253,9 +11274,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-jit-icache-coherence"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b852e568831b913d410541bb37edc45a5002e472208fbdbaf844ed801dd4255f"
checksum = "52c641b9e1bab449c7316896f01d4a0c426e2a502a5a8098e1af4a0392053e7a"
dependencies = [
"libc",
"wasmtime-internal-core",
@@ -11264,9 +11285,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-unwinder"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a1f7349c9834a542275ad757340079e6453fccb429efce581454d23f85af92c0"
checksum = "03303a9abd333edcbd44fee3b1e0905ad156d3bcec311323d061cdff92e7d1f3"
dependencies = [
"cranelift-codegen",
"log",
@@ -11276,9 +11297,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-versioned-export-macros"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "30b3e0768a450d9dea3e16b83f2498f0b08db0e32bad695e35564eef017be3f1"
checksum = "8db0c7f417e5ca3ba92d127d17b980529455d01c141be99204e6d309630c42de"
dependencies = [
"proc-macro2",
"quote",
@@ -11287,9 +11308,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-wit-bindgen"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b9d085c540b95d0ffebf98c266e6f152e1acf96a9f676f224a74307b9d422c15"
checksum = "6292ee4f797f9befb64aa2b3477ec8576501d6302ec21fd2785a8d3f94cf8717"
dependencies = [
"anyhow",
"bitflags 2.13.2",
@@ -11301,9 +11322,9 @@ dependencies = [
[[package]]
name = "wasmtime-wasi"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "17f8ce6b9e77539b5f52d440346f876a84c513ec1b07162845282f8652f7f7f9"
checksum = "3175ff29e2992269f51ec372f7757941f11f87b265a614761726960d42ef6e4d"
dependencies = [
"async-trait",
"bitflags 2.13.2",
@@ -11325,9 +11346,9 @@ dependencies = [
[[package]]
name = "wasmtime-wasi-io"
version = "49.0.6"
version = "49.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "da9f90eb7ce6edbead27dba3a58843398875defa73b8dce4bbc29d0ce3dc9b40"
checksum = "3bb561839e32b61bf0cdd51efe3874fac5de1bd5775a5b7c41bdf70993e367ea"
dependencies = [
"async-trait",
"bytes",
@@ -11601,7 +11622,7 @@ version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
dependencies = [
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -11769,15 +11790,6 @@ dependencies = [
"windows-targets 0.52.6",
]
[[package]]
name = "windows-sys"
version = "0.59.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
dependencies = [
"windows-targets 0.52.6",
]
[[package]]
name = "windows-sys"
version = "0.60.2"
@@ -12050,7 +12062,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f3fd376f71958b862e7afb20cfe5a22830e1963462f3a17f49d82a6c1d1f42d"
dependencies = [
"bitflags 2.13.2",
"windows-sys 0.59.0",
"windows-sys 0.52.0",
]
[[package]]
+2 -1
Переглянути файл
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
exclude = ["sdk", "plugins"]
[workspace.package]
version = "0.1.49"
version = "0.1.50"
edition = "2024"
rust-version = "1.96"
license = "Apache-2.0"
@@ -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" }
+5
Переглянути файл
@@ -7,6 +7,7 @@ license.workspace = true
[dependencies]
encoding_rs.workspace = true
base64.workspace = true
blake3.workspace = true
ide-vfs.workspace = true
ide-core.workspace = true
@@ -25,6 +26,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());
+18 -48
Переглянути файл
@@ -194,14 +194,14 @@ impl AgentCatalogs {
(shared.paths.models_file.clone(), shared.paths.project_root.clone(), provider.to_owned())
}
fn fallback(shared: &Shared, provider: &str) -> CatalogData {
/// The catalog saved for this project, for before this run looked anything up.
fn saved(shared: &Shared, provider: &str) -> CatalogData {
let cache = shared.known.lock();
let Some(known) = cache.get(provider) else { return CatalogData::default() };
known.catalogs.get(&shared.root_key()).map(|saved| saved.catalog.clone()).unwrap_or_else(|| CatalogData {
config: known.config.clone(),
thought_levels: known.thought_levels.clone(),
refreshed_at_ms: None,
})
cache
.get(provider)
.and_then(|known| known.catalogs.get(&shared.root_key()))
.map(|saved| saved.catalog.clone())
.unwrap_or_default()
}
pub(crate) fn cached(&self, shared: &Shared, provider: &str) -> CatalogData {
@@ -210,32 +210,14 @@ impl AgentCatalogs {
.entries
.get(&Self::key(shared, provider))
.and_then(|e| e.catalog.clone())
.unwrap_or_else(|| Self::fallback(shared, provider))
.unwrap_or_else(|| Self::saved(shared, provider))
}
/// Availability for an explicit session switch must come from a recent discovery for this
/// launch, not from the display fallback or a different project's session report.
pub(super) fn fresh_model(
&self,
shared: &Shared,
spec: &provider::ProviderSpec,
model: &str,
) -> Option<crate::AgentConfigValue> {
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
let select = |catalog: &CatalogData| {
let age = self.epoch_ms() - catalog.refreshed_at_ms?;
if !(0.0..FRESH_FOR.as_millis() as f64).contains(&age) {
return None;
}
catalog.model_option()?.values.iter().find(|value| value.value == model).cloned()
};
let state = self.state.lock();
if let Some(entry) = state.entries.get(&Self::key(shared, &spec.id)) {
return select(entry.catalog.as_ref().filter(|_| entry.context == context)?);
}
let cache = shared.known.lock();
let saved = cache.get(&spec.id)?.catalogs.get(&shared.root_key())?;
(saved.fingerprint == context.fingerprint()).then(|| select(&saved.catalog)).flatten()
/// The entry a chat may switch to: exactly what the picker offers from the cached catalog,
/// however long ago it was read. Refreshing keeps that catalog current; a listed model is
/// never refused because the catalog aged.
pub(super) fn listed_model(&self, shared: &Shared, provider: &str, model: &str) -> Option<crate::AgentConfigValue> {
self.cached(shared, provider).model_option()?.values.iter().find(|value| value.value == model).cloned()
}
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
@@ -246,14 +228,7 @@ impl AgentCatalogs {
}
drop(state);
let cache = shared.known.lock();
let known = cache.get(provider)?;
known
.catalogs
.get(&shared.root_key())
.map(|saved| &saved.catalog.thought_levels)
.unwrap_or(&known.thought_levels)
.get(model)
.cloned()
cache.get(provider)?.catalogs.get(&shared.root_key())?.catalog.thought_levels.get(model).cloned()
}
pub(super) async fn load_levels(
@@ -297,7 +272,7 @@ impl AgentCatalogs {
}
fn snapshot(&self, shared: &Shared, provider: &str, entry: &Entry) -> AgentModelCatalog {
let catalog = entry.catalog.clone().unwrap_or_else(|| Self::fallback(shared, provider));
let catalog = entry.catalog.clone().unwrap_or_default();
let model_failure = entry.requested_model.as_ref().and_then(|model| entry.model_failures.get(model));
let unknown_model = entry
.requested_model
@@ -382,12 +357,11 @@ impl AgentCatalogs {
},
);
}
let fallback =
state.entries.get(&key).filter(|entry| entry.catalog.is_none()).map(|_| Self::fallback(shared, &spec.id));
state.generation += 1;
let generation = state.generation;
let entry = state.entries.get_mut(&key).expect("catalog entry");
let catalog = entry.catalog.as_ref().or(fallback.as_ref()).expect("cached catalog");
let empty = CatalogData::default();
let catalog = entry.catalog.as_ref().unwrap_or(&empty);
let fresh = entry.successful.is_some_and(|at| now.duration_since(at) < FRESH_FOR);
let target = model
.filter(|model| {
@@ -496,7 +470,7 @@ impl AgentCatalogs {
entry.flight_model = None;
let success = match result {
Ok(found) => {
let previous = entry.catalog.take().unwrap_or_else(|| Self::fallback(shared, &key.2));
let previous = entry.catalog.take().unwrap_or_default();
let mut cache = shared.known.lock();
let known = cache.entry(key.2.clone()).or_default();
let mut catalog = CatalogData {
@@ -510,13 +484,9 @@ impl AgentCatalogs {
catalog.thought_levels.insert(model, levels);
}
}
known.config = catalog.config.clone();
known.thought_levels = catalog.thought_levels.clone();
if let Some(commands) = found.commands {
known.commands.insert(shared.root_key(), commands);
}
known.authoritative = true;
known.refreshed_at_ms = catalog.refreshed_at_ms;
known.catalogs.insert(
shared.root_key(),
SavedCatalog { fingerprint: entry.context.fingerprint(), catalog: catalog.clone() },
+23 -12
Переглянути файл
@@ -230,11 +230,9 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
let old = config::options_of(&response(&["old", "retained"], &["low", "high"]));
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
assert!(cached.refreshing);
assert_eq!(model_values(&cached), ["old", "retained"]);
assert!(cached.refreshed_at_ms.is_none(), "session reports are not fresh discovery");
assert!(model_values(&cached).is_empty(), "nothing is offered before the first discovery");
let pending = harness.next().await;
assert_eq!(pending.params["mcpServers"], json!([]));
pending.reply.send(Ok(response(&["retained", "new"], &["medium"]))).unwrap();
@@ -258,7 +256,10 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
assert_eq!(provider.config, fresh.config);
restored.shared.remember(PROVIDER, Some(&old), None, Some("old"));
assert_eq!(restored.shared.known_config(PROVIDER), fresh.config);
assert_eq!(restored.shared.known.lock()[PROVIDER].refreshed_at_ms, fresh.refreshed_at_ms);
assert_eq!(
restored.shared.paths.catalogs.cached(&restored.shared, PROVIDER).refreshed_at_ms,
fresh.refreshed_at_ms
);
assert!(!tmp.path().join("store").exists(), "refresh never creates tasks");
}
@@ -308,6 +309,11 @@ async fn discovered_model_reloads_the_same_session_on_the_next_message() {
switch_chat_model(ChatSwitch::Resume).await;
}
#[tokio::test]
async fn discovered_model_from_an_aged_catalog_can_still_be_selected() {
switch_chat_model(ChatSwitch::Aged).await;
}
#[tokio::test]
async fn discovered_model_leaves_the_original_session_intact_after_resume_failure() {
switch_chat_model(ChatSwitch::ResumeFails).await;
@@ -356,6 +362,7 @@ async fn discovered_model_lookup_does_not_overwrite_a_newer_selection() {
#[derive(Clone, Copy)]
enum ChatSwitch {
Live,
Aged,
Resume,
ResumeFails,
Unavailable,
@@ -376,7 +383,8 @@ async fn switch_chat_model(scenario: ChatSwitch) {
let mut harness = Harness::with_initialize(json!({
"protocolVersion": 1, "agentCapabilities": { "loadSession": true }
}));
let mut manager = make_manager(tmp.path(), Arc::default(), &harness);
let catalogs = Arc::new(AgentCatalogs::default());
let mut manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let task = manager
.create(NewAgentTask {
prompt: AgentPrompt { text: "first".into(), ..Default::default() },
@@ -443,7 +451,11 @@ async fn switch_chat_model(scenario: ChatSwitch) {
}
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
let live = matches!(scenario, ChatSwitch::Live);
let live = matches!(scenario, ChatSwitch::Live | ChatSwitch::Aged);
if matches!(scenario, ChatSwitch::Aged) {
// The catalog stays what the picker offers however long ago it was read.
advance(&catalogs, 20 * 60);
}
let resumed_launch = if missing_settings { 3 } else { 2 };
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
@@ -684,7 +696,7 @@ async fn next_chat_request(
}
#[tokio::test]
async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
async fn a_cache_from_before_project_catalogs_offers_nothing_until_discovery_succeeds() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let options = config::options_of(&response(&["legacy"], &["low"]));
@@ -700,12 +712,11 @@ async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
assert_eq!(model_values(&cached), ["legacy"]);
assert!(model_values(&cached).is_empty());
assert!(cached.refreshing && cached.refreshed_at_ms.is_none());
harness.next().await.reply.send(Err("Sign in required".into())).unwrap();
let failed = completed(&mut events).await;
assert_eq!(failed.config, cached.config);
assert!(failed.error.as_deref().unwrap().contains("Sign in required"));
harness.next().await.reply.send(Ok(response(&["current"], &["low"]))).unwrap();
let found = completed(&mut events).await;
assert_eq!(model_values(&found), ["current"]);
}
#[tokio::test]
+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"));
}
}
+333 -84
Переглянути файл
@@ -10,6 +10,7 @@
mod acp;
mod async_questions;
mod catalogs;
mod cli_update;
mod config;
mod conversation;
mod elicitation;
@@ -22,13 +23,19 @@ mod provider;
pub mod registry;
pub mod security;
mod shell;
mod skills;
pub mod skill_installer;
pub mod skills;
mod timeline;
mod worktree;
pub use catalogs::AgentCatalogs;
pub use cli_update::{AgentCliOffer, AgentCliUpdateResult};
pub use external::ExternalSession;
pub use model::*;
pub use skill_installer::{
InstallRemoteSkillRequest, RemoteSkillBrowseResult, RemoteSkillCandidate, RemoteSkillFile, RemoteSkillPreview,
SkillScanWarning, SkillScanWarningKind,
};
use conversation::{Conversation, SavedSubagent, Session};
use ide_core::{IdeError, IdeResult, IpcPath};
@@ -52,6 +59,10 @@ pub type SecurityHook = Arc<dyn Fn() -> ide_core::settings::AgentSecuritySetting
/// Returns the user's choice of the approvals new tasks start with.
pub type NewTaskApprovalsHook = Arc<dyn Fn() -> ide_core::settings::NewTaskApprovals + Send + Sync>;
/// Returns the roots of the project's workspace an agent may work in: the project and the
/// attached projects the user trusts.
pub type WorkspaceRootsHook = Arc<dyn Fn() -> Vec<PathBuf> + Send + Sync>;
/// Entry changes are batched for this long before they are sent.
const FLUSH_DELAY: Duration = Duration::from_millis(40);
/// Updates that arrive this late after `session/load` returns are still replayed history.
@@ -129,9 +140,39 @@ pub type McpServersFn = dyn Fn() -> Vec<McpServer> + Send + Sync;
/// Returns the executable of the running built-in MCP server, if any.
pub type McpExecutableFn = dyn Fn() -> Option<PathBuf> + Send + Sync;
/// The `[agents.skills.<name>]` policies a session resolves against: the user's (global
/// `settings.toml`), the workspace's (`.openidea/settings.toml`), and whether the workspace
/// is trusted (an untrusted one can only turn skills off).
#[derive(Clone, Debug)]
pub struct SkillsPolicy {
pub user: BTreeMap<String, AgentSkillPolicy>,
pub workspace: BTreeMap<String, AgentSkillPolicy>,
pub workspace_trusted: bool,
/// All workspace folders (the project root plus any multi-repo workspace members).
pub workspace_roots: Vec<PathBuf>,
/// Validated `<dir>` folders contributed by live OpenIDEA plugins (`[[contributes.skills]]`).
pub plugin_dirs: Vec<PathBuf>,
}
impl Default for SkillsPolicy {
fn default() -> Self {
Self {
user: BTreeMap::new(),
workspace: BTreeMap::new(),
workspace_trusted: true,
workspace_roots: Vec::new(),
plugin_dirs: Vec::new(),
}
}
}
/// Returns the skill policies for this project.
pub type SkillsPolicyFn = dyn Fn() -> SkillsPolicy + Send + Sync;
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
struct CopilotBinaryKey {
command: String,
github_account: Option<String>,
modified: Option<std::time::SystemTime>,
len: Option<u64>,
}
@@ -140,9 +181,10 @@ 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>>,
workspace_roots: RwLock<Option<WorkspaceRootsHook>>,
known: Arc<Mutex<HashMap<String, Known>>>,
providers: RwLock<Vec<provider::ProviderSpec>>,
/// Last probe of each provider.
@@ -153,32 +195,41 @@ struct Shared {
idle_release_ms: AtomicU64,
mcp_servers_hook: RwLock<Option<Arc<McpServersFn>>>,
mcp_executable_hook: RwLock<Option<Arc<McpExecutableFn>>>,
skills_policy_hook: RwLock<Option<Arc<SkillsPolicyFn>>>,
/// Monotonic id for [`AgentEvent::Attention`] episodes.
attention_seq: AtomicU64,
}
/// What an agent offered in its last session, for the New Task page.
/// What an agent offered, for the New Task page.
#[derive(Clone, Default, Serialize, Deserialize)]
struct Known {
#[serde(default)]
config: Vec<AgentConfigOption>,
/// Thinking levels reported for each model value, including its last choice.
#[serde(default, rename = "thoughtLevels")]
thought_levels: BTreeMap<String, Vec<AgentConfigOption>>,
/// By project root: skills and custom commands differ per project.
#[serde(default, rename = "projectCommands")]
commands: HashMap<String, Vec<AgentCommand>>,
/// Successful discovery, unlike a session report, owns availability.
#[serde(default)]
authoritative: bool,
#[serde(default, rename = "refreshedAtMs")]
refreshed_at_ms: Option<f64>,
/// Authoritative availability and freshness are scoped to project and launch context.
/// Model catalogs by project root, valid for the launch context they were read with.
#[serde(default, rename = "projectCatalogs")]
catalogs: HashMap<String, catalogs::SavedCatalog>,
}
impl Shared {
/// The workspace roots offered to a session besides its own directory and project, for an
/// agent that takes them (`sessionCapabilities.additionalDirectories`).
fn additional_directories(&self, init: &acp::Negotiated, cwd: &Path, project_root: Option<&Path>) -> Vec<String> {
let Some(hook) = self.workspace_roots.read().clone().filter(|_| init.session("additionalDirectories")) else {
return Vec::new();
};
let canonical = |p: &Path| dunce::canonicalize(p).unwrap_or_else(|_| p.to_path_buf());
let own: Vec<PathBuf> = std::iter::once(cwd).chain(project_root).map(canonical).collect();
let mut roots = Vec::new();
for root in hook().iter().map(|r| canonical(r)) {
let root = root.to_string_lossy().into_owned();
if !own.iter().any(|o| o.to_string_lossy() == root) && !roots.contains(&root) {
roots.push(root);
}
}
roots
}
fn spec(&self, id: &str) -> Option<provider::ProviderSpec> {
self.providers.read().iter().find(|p| p.id == id).cloned()
}
@@ -193,6 +244,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),
}
@@ -211,10 +263,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.
@@ -288,7 +342,8 @@ impl Shared {
self.paths.project_root.to_string_lossy().into_owned()
}
/// Cache levels only when `model` confirms which model the session reported them for.
/// Keeps the commands a session offered and the effort levels it reported for `model`, the
/// only model whose levels it describes.
fn remember(
&self,
provider: &str,
@@ -297,43 +352,22 @@ impl Shared {
model: Option<&str>,
) {
let acp = self.spec(provider).is_some_and(|spec| spec.driver == provider::Driver::Acp);
let mut cache = self.known.lock();
let known = cache.entry(provider.to_owned()).or_default();
let mut changed = false;
// Running tasks retain their own reported settings. Once discovery has
// succeeded, a session's older list/defaults cannot change New Task choices.
if !known.authoritative
&& let Some(config) = config.filter(|c| !c.is_empty())
{
if let Some(model) = model {
let levels: Vec<_> = config.iter().filter(|o| config::is_per_model_option(o)).cloned().collect();
if known.thought_levels.get(model) != Some(&levels) {
known.thought_levels.insert(model.to_owned(), levels);
changed = true;
}
}
if known.config != config {
known.config = config.to_vec();
if let Some(commands) = commands.filter(|c| !c.is_empty()) {
let mut cache = self.known.lock();
let known = cache.entry(provider.to_owned()).or_default();
if known.commands.get(&self.root_key()).map(Vec::as_slice) != Some(commands) {
known.commands.insert(self.root_key(), commands.to_vec());
self.persist_known(&cache);
changed = true;
}
}
// Discovery reads one model's options; a session on another model reports that model's.
let learned = model.filter(|_| acp && known.authoritative).zip(config).map(|(model, config)| {
if acp && let Some((model, config)) = model.zip(config) {
let levels: Vec<_> = config.iter().filter(|o| config::is_per_model_option(o)).cloned().collect();
(model, levels)
});
if let Some(commands) = commands.filter(|c| !c.is_empty())
&& known.commands.get(&self.root_key()).map(Vec::as_slice) != Some(commands)
{
known.commands.insert(self.root_key(), commands.to_vec());
changed = true;
}
if changed {
self.persist_known(&cache);
}
drop(cache);
if let Some((model, levels)) = learned.filter(|(_, levels)| !levels.is_empty()) {
self.paths.catalogs.learn_levels(self, provider, model, levels);
if !levels.is_empty() {
self.paths.catalogs.learn_levels(self, provider, model, levels);
}
}
if changed {
self.emit(AgentEvent::Providers);
@@ -522,6 +556,8 @@ struct Task {
idle_epoch: AtomicU64,
/// Turned on when per-session MCP overrides changed while a turn was busy; dropped once idle.
mcp_reload_pending: AtomicBool,
/// Turned on when per-session skill overrides changed while a turn was busy; dropped once idle.
skills_reload_pending: AtomicBool,
/// Settings already sent this session (`(option, value)`), so a refusal is not retried.
config_sent: Mutex<HashSet<(String, String)>>,
dirty: Mutex<BTreeSet<(Session, usize)>>,
@@ -559,9 +595,10 @@ impl AgentManager {
paths,
runtime,
connector,
sink: RwLock::new(None),
sinks: RwLock::new(HashMap::new()),
security: RwLock::new(None),
new_task_approvals: RwLock::new(None),
workspace_roots: RwLock::new(None),
known,
providers,
probes: Mutex::new(HashMap::new()),
@@ -569,6 +606,7 @@ impl AgentManager {
idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),
mcp_servers_hook: RwLock::new(None),
mcp_executable_hook: RwLock::new(None),
skills_policy_hook: RwLock::new(None),
attention_seq: AtomicU64::new(0),
});
shared.paths.catalogs.subscribe(&shared);
@@ -602,12 +640,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);
@@ -618,6 +666,11 @@ impl AgentManager {
*self.shared.new_task_approvals.write() = Some(hook);
}
/// Sets the callback that lists the workspace roots offered to agents besides a task's own.
pub fn set_workspace_roots_hook(&self, hook: WorkspaceRootsHook) {
*self.shared.workspace_roots.write() = Some(hook);
}
/// The agents (custom ones re-read), whether each is installed, and what they offered last time.
pub fn providers(&self) -> Vec<AgentProvider> {
let specs = provider::load(self.shared.paths.custom_agents_dir.as_deref(), self.shared.env_secrets());
@@ -708,10 +761,15 @@ impl AgentManager {
*self.shared.mcp_executable_hook.write() = Some(Arc::from(hook));
}
/// Provides the user and workspace skill policies and the workspace's trust.
pub fn set_skills_policy_hook(&self, hook: Box<SkillsPolicyFn>) {
*self.shared.skills_policy_hook.write() = Some(Arc::from(hook));
}
/// The slash commands to complete for `provider`, in `task`'s directory or (without one)
/// in the project: what the agent offered last time there, unadvertised builtins,
/// and, for Claude Code, skills and custom commands on disk it has not listed (for Hermes,
/// its profile's skills).
/// for Claude Code the skills and custom commands on disk it has not listed (for
/// Hermes, its profile's skills), and the skills hub's active skills for every agent.
pub async fn commands(&self, provider: &str, task: Option<&str>) -> IdeResult<Vec<AgentCommand>> {
let (provider, offered, cwd) = match task {
Some(id) => {
@@ -747,18 +805,55 @@ impl AgentManager {
}
let home = self.shared.paths.home_dir.clone();
if provider == "hermes" || provider.starts_with("hermes-") {
let hermes_home = home.clone();
let hermes_provider = provider.clone();
let found = blocking(move || {
let profile = hermes::root(home.as_deref()).and_then(|root| hermes::profile_home(&root, &provider));
let profile =
hermes::root(hermes_home.as_deref()).and_then(|root| hermes::profile_home(&root, &hermes_provider));
Ok(profile.map(|p| skills::hermes(&p)).unwrap_or_default())
})
.await?;
return Ok(skills::merge(offered, found));
offered = skills::merge(offered, found);
} else if provider == "claude" || provider == "claude-acp" {
let claude_cwd = cwd.clone();
let found = blocking(move || Ok(skills::discover(&claude_cwd, home.as_deref()))).await?;
offered = skills::merge(offered, found);
}
if provider != "claude" && provider != "claude-acp" {
return Ok(offered);
}
let found = blocking(move || Ok(skills::discover(&cwd, home.as_deref()))).await?;
Ok(skills::merge(offered, found))
// The hub's active skills complete on every agent; its `off` ones drop out here
// (including entries `offered` already held), which is all the enforcement an ACP agent gets.
let holder = self.task_for_commands(&provider, task);
let states = match holder {
Some(holder) => holder.skill_states().await,
None => {
let (policy, root) = {
let shared = &self.shared;
let policy = shared.skills_policy_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
(policy, shared.paths.project_root.clone())
};
let roots = if policy.workspace_roots.is_empty() { vec![root] } else { policy.workspace_roots };
let plugin_dirs = policy.plugin_dirs;
let home = self.shared.paths.home_dir.clone();
blocking(move || {
Ok(skills::resolve(
skills::discover_skills_with_plugins(&roots, home.as_deref(), &plugin_dirs),
None,
&policy.workspace,
&policy.user,
policy.workspace_trusted,
))
})
.await
.unwrap_or_default()
}
};
Ok(skills::menu_commands(offered, &states))
}
/// The task to resolve skills for, when the commands are for one and its provider matches.
fn task_for_commands(&self, provider: &str, task: Option<&str>) -> Option<Arc<Task>> {
let task = self.task(task?).ok()?;
let matches = task.state.lock().task.provider == provider;
matches.then_some(task)
}
fn task(&self, id: &str) -> IdeResult<Arc<Task>> {
@@ -842,6 +937,7 @@ impl AgentManager {
retry: None,
background: Box::default(),
mcp_overrides: BTreeMap::new(),
skill_overrides: BTreeMap::new(),
stats: Box::default(),
};
let file = TaskFile {
@@ -960,6 +1056,7 @@ impl AgentManager {
retry: None,
background: Box::default(),
mcp_overrides: req.mcp_overrides,
skill_overrides: req.skill_overrides,
stats: Box::default(),
};
let file = TaskFile {
@@ -1126,6 +1223,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;
@@ -1146,17 +1253,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)));
}
@@ -1286,18 +1395,21 @@ impl AgentManager {
if !live.capabilities.fork || (keep < total && !live.capabilities.rollback) {
return Err(IdeError::invalid("this agent can't copy a conversation from there"));
}
let (cwd, provider_id, mcp_overrides) = {
let (cwd, provider_id, mcp_overrides, project_root) = {
let s = source.state.lock();
(s.task.cwd.0.clone(), s.task.provider.clone(), s.task.mcp_overrides.clone())
let t = &s.task;
(t.cwd.0.clone(), t.provider.clone(), t.mcp_overrides.clone(), t.project_root.clone().map(|p| p.0))
};
let mcp_servers = source.shared.mcp_servers_for_session(&provider_id, &live.init, &mcp_overrides);
let roots = source.shared.additional_directories(&live.init, &cwd, project_root.as_deref());
let skills_delivery = source.stage_skills(stage_key(live.driver), &cwd).await;
let cwd_s = dunce::canonicalize(&cwd).unwrap_or(cwd).to_string_lossy().into_owned();
let reply: Value = live
.peer
.request(
"session/fork",
{
let mut params = session_params(&cwd_s, &mcp_servers);
let mut params = session_params(&cwd_s, &mcp_servers, skills_delivery.as_ref(), &roots);
params["sessionId"] = json!(live.session);
params
},
@@ -1543,6 +1655,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)?;
@@ -1686,6 +1810,7 @@ impl AgentManager {
*task.deleted.lock() = true;
let _ = std::fs::remove_file(self.shared.paths.store_dir.join(format!("{id}.json")));
let _ = std::fs::remove_dir_all(task.turn_dir());
skills::remove_farm(&self.shared.paths.store_dir, id);
let saved = task.state.lock().saved.clone();
if let Some(saved) = saved
&& !self.tasks.read().values().any(|t| t.state.lock().saved.as_ref() == Some(&saved))
@@ -1947,6 +2072,38 @@ impl AgentManager {
Ok(out)
}
/// Sets the session's skill modes; like MCP overrides, a change reaches the agent when
/// its idle session is recycled and the next turn starts fresh.
pub fn set_skill_overrides(&self, id: &str, overrides: BTreeMap<String, AgentSkillMode>) -> IdeResult<AgentTask> {
let task = self.task(id)?;
let cleaned: BTreeMap<String, AgentSkillMode> = overrides
.into_iter()
.filter_map(|(k, v)| (!k.trim().is_empty()).then(|| (k.trim().to_owned(), v)))
.collect();
let (changed, busy, has_bg, out) = {
let mut s = task.state.lock();
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
let changed = s.task.skill_overrides != cleaned;
if changed {
s.task.skill_overrides = cleaned;
s.task.updated_ms = now_ms();
}
(changed, s.busy, !s.background_tasks.is_empty(), s.task.clone())
};
if changed {
task.persist();
task.emit_task();
if busy || has_bg || !task.permissions.lock().is_empty() {
task.skills_reload_pending.store(true, Ordering::Release);
} else {
task.recycle_resumable_session();
}
}
Ok(out)
}
/// Recycles idle resumable live sessions (or schedules reload after the running turn) when
/// global, workspace, or built-in IDE MCP server settings change.
pub fn notify_mcp_servers_changed(&self) {
@@ -1974,11 +2131,69 @@ 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();
}
}
impl Task {
/// The skills offered in this project: every discovery resolved against the policies
/// and the task's overrides.
async fn skill_states(&self) -> Vec<AgentSkillState> {
let (policy, overrides, home, roots) = {
let shared = &self.shared;
let policy = shared.skills_policy_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
let (overrides, task_root) = {
let s = self.state.lock();
(s.task.skill_overrides.clone(), s.task.project_root.as_ref().map(|p| p.0.clone()))
};
let mut roots = Vec::new();
if let Some(tr) = task_root {
roots.push(tr);
}
roots.extend(policy.workspace_roots.iter().cloned());
roots.push(shared.paths.project_root.clone());
(policy, overrides, shared.paths.home_dir.clone(), roots)
};
blocking(move || {
Ok(skills::resolve(
skills::discover_skills_with_plugins(&roots, home.as_deref(), &policy.plugin_dirs),
Some(&overrides),
&policy.workspace,
&policy.user,
policy.workspace_trusted,
))
})
.await
.unwrap_or_default()
}
/// Stages the session's skills into the task's farm and reports what its CLI takes.
/// Nothing staged for an ACP agent (its `/` menu is filtered instead), and a failed
/// stage (locked files, full disk) runs the session without the farm.
async fn stage_skills(&self, provider: &str, cwd: &Path) -> Option<skills::Delivery> {
let states = self.skill_states().await;
let (farm, home, out_cwd) = {
(
skills::farm_dir(&self.shared.paths.store_dir, &self.id),
self.shared.paths.home_dir.clone(),
cwd.to_path_buf(),
)
};
let provider = provider.to_owned();
match blocking(move || {
skills::stage(&farm, &provider, &states, &out_cwd, home.as_deref())
.map_err(|e| IdeError::internal(e.to_string()))
})
.await
{
Ok(delivery) => Some(delivery),
Err(e) => {
tracing::warn!("agent task {}: staging its skills failed: {e}", self.id);
None
}
}
}
fn restore(file: TaskFile, shared: Arc<Shared>) -> Arc<Self> {
let mut task = file.task;
config::add_client_options(&task.provider, &mut task.config);
@@ -2035,6 +2250,7 @@ impl Task {
turns: AtomicU64::new(0),
idle_epoch: AtomicU64::new(0),
mcp_reload_pending: AtomicBool::new(false),
skills_reload_pending: AtomicBool::new(false),
config_sent: Mutex::new(HashSet::new()),
dirty: Mutex::new(BTreeSet::new()),
streamed: Mutex::new(HashMap::new()),
@@ -2326,7 +2542,8 @@ impl Task {
if stop != "cancelled" {
self.emit_attention(AgentAttentionReason::Finished);
}
if self.mcp_reload_pending.swap(false, Ordering::AcqRel)
if (self.mcp_reload_pending.swap(false, Ordering::AcqRel)
|| self.skills_reload_pending.swap(false, Ordering::AcqRel))
&& self.state.lock().background_tasks.is_empty()
{
self.recycle_resumable_session();
@@ -2355,8 +2572,7 @@ impl Task {
async fn switch_discovered_model(&self, target: AgentConfigOption, value: String) -> IdeResult<()> {
let provider = self.state.lock().task.provider.clone();
let spec = self.shared.spec(&provider).ok_or_else(|| IdeError::not_found("no such agent"))?;
let candidate = self.shared.paths.catalogs.fresh_model(&self.shared, &spec, &value).ok_or_else(|| {
let candidate = self.shared.paths.catalogs.listed_model(&self.shared, &provider, &value).ok_or_else(|| {
IdeError::invalid(format!("{} has no value {value} in the current model catalog", target.name))
})?;
let selection = {
@@ -2799,9 +3015,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) {
@@ -2839,8 +3058,13 @@ impl Task {
let sign_in_message = spec.sign_in_message(&init.auth_methods);
let can_load = init.load_session();
let (capabilities, embedded) = capabilities_of(&init);
let mcp_overrides = self.state.lock().task.mcp_overrides.clone();
let (mcp_overrides, project_root) = {
let s = self.state.lock();
(s.task.mcp_overrides.clone(), s.task.project_root.clone().map(|p| p.0))
};
let mcp_servers = self.shared.mcp_servers_for_session(provider_id, &init, &mcp_overrides);
let roots = self.shared.additional_directories(&init, cwd, project_root.as_deref());
let skills_delivery = self.stage_skills(stage_key(spec.driver), cwd).await;
// Agents that compare canonical paths fail in a symlinked directory (macOS `/tmp`).
let cwd_s = dunce::canonicalize(cwd).unwrap_or_else(|_| cwd.to_path_buf()).to_string_lossy().into_owned();
@@ -2855,7 +3079,7 @@ impl Task {
}
if let (Some(id), true, false) = (saved, can_load, start_fresh) {
self.replaying.store(true, Ordering::Release);
let mut params = session_params(&cwd_s, &mcp_servers);
let mut params = session_params(&cwd_s, &mcp_servers, skills_delivery.as_ref(), &roots);
params["sessionId"] = json!(&id);
let loaded = self.request_with_auth(&peer, &init, &mut tried_auth, "session/load", params).await;
tokio::time::sleep(REPLAY_GRACE).await;
@@ -2895,7 +3119,7 @@ impl Task {
let (session_id, result) = match session {
Some(s) => s,
None => {
let params = session_params(&cwd_s, &mcp_servers);
let params = session_params(&cwd_s, &mcp_servers, skills_delivery.as_ref(), &roots);
let v = self.request_with_auth(&peer, &init, &mut tried_auth, "session/new", params).await.map_err(
|e| match self.sign_in_error(&e, Some(&sign_in_message)) {
Some(msg) => SessionOpenError { message: msg, allow_acp_fallback: false },
@@ -3850,6 +4074,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"))
}
@@ -3870,13 +4095,37 @@ struct McpForSession {
off: Vec<String>,
}
/// The driver a session's staged skills are staged for (`skills::stage` matches on it):
/// the native CLIs take the farm, everything else (an ACP agent) gets the `/` menu filter.
fn stage_key(driver: provider::Driver) -> &'static str {
match driver {
provider::Driver::Claude => "claude",
provider::Driver::Codex => "codex",
provider::Driver::Copilot => "copilot",
provider::Driver::Acp => "acp",
}
}
/// The session parameters `session/new`, `session/load` and `session/fork` share: the MCP
/// servers, and the ones off for this session, so an agent that also loads its own
/// configuration (Claude Code) can keep a same-named server of it off too.
fn session_params(cwd: &str, mcp: &McpForSession) -> Value {
/// configuration (Claude Code) can keep a same-named server of it off too — plus the
/// session's staged skills for the drivers that take them, and the workspace's other roots.
fn session_params(cwd: &str, mcp: &McpForSession, skills: Option<&skills::Delivery>, roots: &[String]) -> Value {
let mut params = json!({ "cwd": cwd, "mcpServers": mcp.servers });
if !roots.is_empty() {
params["additionalDirectories"] = json!(roots);
}
let mut meta = json!({});
if !mcp.off.is_empty() {
params["_meta"] = json!({ "openidea": { "mcpServersOff": mcp.off } });
meta["mcpServersOff"] = json!(mcp.off);
}
if let Some(skills) = skills
&& let Ok(v) = serde_json::to_value(skills)
{
meta["skills"] = v;
}
if !meta.is_null() && meta.as_object().is_some_and(|m| !m.is_empty()) {
params["_meta"] = json!({ "openidea": meta });
}
params
}
+129
Переглянути файл
@@ -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,9 @@ 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>,
/// Per-session skill modes (`skill name` -> mode), on top of the settings' policies.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub skill_overrides: BTreeMap<String, AgentSkillMode>,
/// 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)]
@@ -275,6 +280,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 {
@@ -594,6 +617,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.
@@ -664,6 +690,9 @@ pub struct NewAgentTask {
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
#[serde(default)]
pub mcp_overrides: BTreeMap<String, bool>,
/// Per-session skill modes (`skill name` -> mode).
#[serde(default)]
pub skill_overrides: BTreeMap<String, AgentSkillMode>,
/// Creates the task without sending `prompt` (it only names the task): the composer's
/// `!` command runs in it first.
#[serde(default)]
@@ -682,6 +711,8 @@ pub struct AgentChange {
pub removed: u32,
/// Path before a rename; the left side of its diff reads this path.
pub old_path: Option<String>,
/// The repository the file is in, when the task's project holds nested repositories.
pub repo: Option<IpcPath>,
}
/// A commit made while the task ran, with the files it changed against its first parent.
@@ -856,6 +887,104 @@ fn default_true() -> bool {
true
}
pub use ide_core::settings::{AgentSkillMode, AgentSkillPolicy};
/// Which CLI's own folders a skill was discovered in (Settings › Agents › Skills groups by it).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AgentSkillSource {
/// The project's `.agents/skills` and `.openidea/skills`.
#[default]
Workspace,
/// The user's `~/.agents/skills` (what `npx skills add` fills).
User,
/// Contributed by an enabled OpenIDEA plugin (`[[contributes.skills]]`).
Plugin,
/// The project's `.claude/skills`.
ClaudeWorkspace,
/// `~/.claude/skills`.
ClaudeUser,
/// The project's `.github/skills` (Copilot's repository skills).
GithubWorkspace,
/// `~/.copilot/skills` and `~/.copilot/installed-plugins/*`.
CopilotUser,
/// The project's `.codex/skills`.
CodexWorkspace,
/// `~/.codex/skills`.
CodexUser,
/// The project's `.cursor/skills`.
CursorWorkspace,
/// `~/.cursor/skills`.
CursorUser,
}
impl AgentSkillSource {
/// Whether skills of this source are only read, never delivered by OpenIDEA: the CLI
/// discovers them itself, so "off" holds only where the CLI supports a native disable.
pub fn discovered(&self) -> bool {
!matches!(self, Self::Workspace | Self::User | Self::Plugin)
}
}
/// One discovered skill: a folder with a `SKILL.md`.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentSkill {
/// The frontmatter `name`, else the folder's name.
pub name: String,
pub description: String,
/// Optional `argument-hint` from frontmatter, completed in the `/` menu.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub hint: Option<String>,
/// Canonical folder holding `SKILL.md` (symlinks resolved, so duplicates collapse).
pub path: IpcPath,
pub source: AgentSkillSource,
/// Other skill roots whose symlinked entry resolved to this same canonical `path`.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub also_in: Vec<AgentSkillSource>,
/// False when frontmatter sets `user-invocable: false` (omitted from `/` completion).
#[serde(default = "default_true")]
pub user_invocable: bool,
/// True when frontmatter sets `disable-model-invocation: true` (defaults to `slashOnly`).
#[serde(default)]
pub disable_model_invocation: bool,
/// True when frontmatter sets `context: fork` (passed through natively to supporting CLIs).
#[serde(default)]
pub context_fork: bool,
/// Optional `paths` / `globs` patterns from frontmatter (passed through natively to supporting CLIs).
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub paths: Vec<String>,
/// The `SKILL.md` passes validation (`name` matches its folder, `description` present).
pub valid: bool,
/// What validation found (`name` mismatch, missing or over-long description…).
pub warnings: Vec<String>,
}
/// A skill as Settings › Agents › Skills shows it: discovery plus the effective mode and
/// which layer decided it.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentSkillState {
pub skill: AgentSkill,
pub mode: AgentSkillMode,
/// What set `mode`: a session override, the workspace, the user's settings, workspace
/// trust, or nothing (the default `auto`).
pub origin: AgentSkillOrigin,
}
/// Which layer decided a skill's [`AgentSkillState::mode`].
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AgentSkillOrigin {
#[default]
None,
Session,
Workspace,
User,
/// An untrusted workspace's skills and policies may only turn skills off.
Trust,
}
/// An external MCP configuration file discovered on disk (user CLI config or workspace file).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
+34 -2
Переглянути файл
@@ -172,6 +172,12 @@ struct Session {
mcp_config: Option<tempfile::TempPath>,
/// MCP servers switched off for this session (`--disallowedTools`), its own config's too.
mcp_off: Vec<String>,
/// The staged skills folder passed as `--add-dir` (its `.claude/skills` holds the copies).
skills_add_dir: Option<PathBuf>,
/// The workspace's other roots, each passed as `--add-dir`.
additional_dirs: Vec<String>,
/// The staged skills' `--settings` JSON (`skillOverrides` for the native ones too).
skills_settings: Option<String>,
shim: Weak<Shim>,
st: Mutex<State>,
/// Serializes (re)starting the process.
@@ -356,10 +362,14 @@ impl Shim {
None
}
});
let skills = params.pointer("/_meta/openidea/skills");
let session = Arc::new(Session {
id: id.to_owned(),
mcp_config,
mcp_off,
skills_add_dir: skills.and_then(|s| s.get("claudeAddDir")).and_then(Value::as_str).map(PathBuf::from),
additional_dirs: additional_dirs(params),
skills_settings: skills.and_then(|s| s.get("claudeSettings")).and_then(Value::as_str).map(str::to_owned),
shim: Arc::downgrade(self),
st: Mutex::new(State {
proc: None,
@@ -405,9 +415,9 @@ impl Shim {
"agentCapabilities": {
"loadSession": true,
"promptCapabilities": { "image": true, "embeddedContext": true },
"sessionCapabilities": { "fork": {} },
"sessionCapabilities": { "fork": {}, "additionalDirectories": {} },
"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 +502,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"))?;
@@ -668,6 +683,17 @@ impl Session {
if !self.mcp_off.is_empty() {
args.extend(["--disallowedTools".to_owned(), self.mcp_off.join(",")]);
}
// The staged skills: `.claude/skills` of the added directory is discovered like the
// project's own, and the settings hold the modes of the skills it sees natively too.
if let Some(dir) = &self.skills_add_dir {
args.extend(["--add-dir".to_owned(), dir.to_string_lossy().into_owned()]);
}
for dir in &self.additional_dirs {
args.extend(["--add-dir".to_owned(), dir.clone()]);
}
if let Some(settings) = &self.skills_settings {
args.extend(["--settings".to_owned(), settings.clone()]);
}
args.extend(start.args());
let launch =
Launch { program: shim.config.program.clone(), args, cwd: self.cwd.clone(), env: shim.config.env.clone() };
@@ -1502,6 +1528,12 @@ fn write_mcp_config(json: &str) -> std::io::Result<tempfile::TempPath> {
/// The servers switched off for the session (`_meta.openidea.mcpServersOff`) as Claude Code
/// permission rules that deny all of a server's tools (`mcp__<server>`), so a server of
/// Claude Code's own configuration stays off too.
/// The session's `additionalDirectories`: the workspace's other roots.
fn additional_dirs(params: &Value) -> Vec<String> {
let dirs = params.get("additionalDirectories").and_then(Value::as_array);
dirs.into_iter().flatten().filter_map(Value::as_str).map(str::to_owned).collect()
}
fn mcp_off(params: &Value) -> Vec<String> {
params
.pointer("/_meta/openidea/mcpServersOff")
+7
Переглянути файл
@@ -1275,3 +1275,10 @@ fn mcp_servers_become_an_mcp_config() {
drop(path);
assert!(!kept.exists());
}
#[test]
fn additional_directories_are_read_from_the_session_params() {
let params = json!({ "cwd": "/w/api", "additionalDirectories": ["/w/web", 3, "/w/docs"] });
assert_eq!(additional_dirs(&params), ["/w/web", "/w/docs"]);
assert!(additional_dirs(&json!({ "cwd": "/w/api" })).is_empty());
}
+64 -10
Переглянути файл
@@ -334,6 +334,38 @@ fn str_param<'a>(params: &'a Value, key: &str) -> Result<&'a str, ResponseError>
params.get(key).and_then(Value::as_str).ok_or_else(|| invalid(format!("missing {key}")))
}
/// Fills a `thread/start`/`thread/resume`/`thread/fork` request's `config` with the session's
/// MCP servers and its staged skills: the off ones, by path (`skills.config` entries with
/// `enabled = false`, which the CLI honors for the copies it discovers natively too).
fn apply_thread_config(params: &Value, request: &mut Value) {
let mut config = translate::mcp_config(params).unwrap_or_else(|| json!({}));
let off: Vec<Value> = params
.pointer("/_meta/openidea/skills/codexOff")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|entry| {
let path = entry.get(1)?.as_str()?;
Some(json!({ "path": path, "enabled": false }))
})
.collect();
if !off.is_empty()
&& let Some(map) = config.as_object_mut()
{
map.insert("skills".into(), json!({ "config": off }));
}
if !config.as_object().is_some_and(|m| m.is_empty()) {
request["config"] = config;
}
// The workspace's other roots join the thread's own: they are where `workspace-write`
// may write and what the model is told the workspace holds.
if let Some(extra) = params.get("additionalDirectories").and_then(Value::as_array).filter(|a| !a.is_empty())
&& let Some(cwd) = params.get("cwd").filter(|c| c.is_string())
{
request["runtimeWorkspaceRoots"] = std::iter::once(cwd).chain(extra).cloned().collect();
}
}
impl CodexShim {
fn codex(&self) -> &Peer {
self.codex.get().expect("attached before any message")
@@ -381,7 +413,7 @@ impl CodexShim {
"loadSession": true,
"promptCapabilities": { "image": true, "audio": false, "embeddedContext": true },
"mcpCapabilities": { "http": false, "sse": false, "stdio": true },
"sessionCapabilities": { "fork": {}, "close": {} },
"sessionCapabilities": { "fork": {}, "close": {}, "additionalDirectories": {} },
"_meta": { "openidea": { "rollback": true, "steer": true } },
},
"agentInfo": { "name": "codex", "title": "Codex", "version": version },
@@ -414,6 +446,31 @@ impl CodexShim {
}
}
/// Hands the session's staged skills to the app-server: the farm's `codex` tree joins
/// its discovery roots. Best-effort: a CLI version without `skills/extraRoots/set`
/// (the method arrived later than some pinned installs) runs without the farm, as
/// before.
async fn apply_skill_roots(&self, session: &str, params: &Value) {
let roots = params
.pointer("/_meta/openidea/skills/codexExtraRoots")
.and_then(Value::as_array)
.map(|a| a.iter().filter_map(Value::as_str).collect::<Vec<_>>())
.unwrap_or_default();
if roots.is_empty() {
return;
}
let set = tokio::time::timeout(
Duration::from_secs(5),
self.call("skills/extraRoots/set", json!({ "extraRoots": roots })),
)
.await;
match set {
Ok(Ok(_)) => {}
Ok(Err(e)) => tracing::info!("codex session {session}: could not set the extra skill roots: {}", e.message),
Err(e) => tracing::info!("codex session {session}: could not set the extra skill roots: {e}"),
}
}
/// Registers a thread codex opened for a session of its own; returns its `configOptions`.
fn open_thread(&self, result: &Value, models: &[ModelInfo], settings: Option<Settings>) -> (String, Value) {
let thread = result.get("thread").unwrap_or(&Value::Null);
@@ -434,14 +491,13 @@ impl CodexShim {
let models = self.models().await?;
self.prepare_project_trust(params).await;
let mut request = json!({ "cwd": params.get("cwd") });
if let Some(config) = translate::mcp_config(params) {
request["config"] = config;
}
apply_thread_config(params, &mut request);
let result = self.call("thread/start", request).await?;
let (id, options) = self.open_thread(&result, &models, None);
if id.is_empty() {
return Err(error(codes::INTERNAL_ERROR, "codex started no thread"));
}
self.apply_skill_roots(&id, params).await;
self.publish_skills(&id).await;
Ok(json!({ "sessionId": id, "configOptions": options }))
}
@@ -452,9 +508,7 @@ impl CodexShim {
let models = self.models().await?;
self.prepare_project_trust(params).await;
let mut request = json!({ "threadId": id, "cwd": params.get("cwd") });
if let Some(config) = translate::mcp_config(params) {
request["config"] = config;
}
apply_thread_config(params, &mut request);
let result = self.call("thread/resume", request).await?;
let (_, options) = self.open_thread(&result, &models, None);
let cwd = self.state.lock().threads.get(id).and_then(|t| t.cwd.clone());
@@ -462,6 +516,7 @@ impl CodexShim {
for update in translate::history(thread, cwd.as_deref()) {
self.emit(id, update);
}
self.apply_skill_roots(id, params).await;
self.publish_skills(id).await;
Ok(json!({ "configOptions": options }))
}
@@ -472,9 +527,7 @@ impl CodexShim {
self.prepare_project_trust(params).await;
let settings = self.state.lock().threads.get(source).and_then(|t| t.settings.clone());
let mut request = json!({ "threadId": source, "cwd": params.get("cwd") });
if let Some(config) = translate::mcp_config(params) {
request["config"] = config;
}
apply_thread_config(params, &mut request);
if let Some(s) = &settings {
request["model"] = json!(s.model_slug(&models));
request["approvalPolicy"] = json!(s.mode.approval_policy());
@@ -482,6 +535,7 @@ impl CodexShim {
}
let result = self.call("thread/fork", request).await?;
let (id, options) = self.open_thread(&result, &models, settings);
self.apply_skill_roots(&id, params).await;
self.publish_skills(&id).await;
Ok(json!({ "sessionId": id, "configOptions": options }))
}
+11
Переглянути файл
@@ -1847,3 +1847,14 @@ fn skills_become_commands_with_their_invocation_names() {
assert!(skill_commands(&json!({"data": []})).unwrap()["availableCommands"].as_array().unwrap().is_empty());
assert!(skill_commands(&json!({})).is_none());
}
#[test]
fn workspace_roots_join_the_thread_roots() {
let params = json!({ "cwd": "/w/api", "mcpServers": [], "additionalDirectories": ["/w/web"] });
let mut request = json!({});
apply_thread_config(&params, &mut request);
assert_eq!(request["runtimeWorkspaceRoots"], json!(["/w/api", "/w/web"]));
let mut request = json!({});
apply_thread_config(&json!({ "cwd": "/w/api", "mcpServers": [] }), &mut request);
assert!(request.get("runtimeWorkspaceRoots").is_none());
}
+22 -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(
@@ -371,6 +372,24 @@ fn error(code: i64, message: impl Into<String>) -> ResponseError {
ResponseError { code, message: message.into(), data: None }
}
/// Adds the session's staged skills to a `session.create`/`session.resume` request:
/// `skillDirectories` (the farm's `copilot` tree) and `disabledSkills` (the off and
/// slash-only ones; Copilot invokes skills with the model only, so a slash-only skill has
/// no other switch here).
fn apply_skills(params: &Value, req: &mut Value) {
let skills = params.pointer("/_meta/openidea/skills");
if let Some(dirs) = skills.and_then(|s| s.get("copilotSkillDirectories")).and_then(Value::as_array)
&& !dirs.is_empty()
{
req["skillDirectories"] = json!(dirs.iter().filter_map(Value::as_str).collect::<Vec<_>>());
}
if let Some(disabled) = skills.and_then(|s| s.get("copilotDisabledSkills")).and_then(Value::as_array)
&& !disabled.is_empty()
{
req["disabledSkills"] = json!(disabled.iter().filter_map(Value::as_str).collect::<Vec<_>>());
}
}
fn invalid(message: impl Into<String>) -> ResponseError {
error(codes::INVALID_PARAMS, message)
}
@@ -495,6 +514,7 @@ impl CopilotShim {
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
req["disabledMcpServers"] = disabled;
}
apply_skills(params, &mut req);
let created = self.call("session.create", req).await?;
let session_id = created
@@ -545,6 +565,7 @@ impl CopilotShim {
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
req["disabledMcpServers"] = disabled;
}
apply_skills(params, &mut req);
let resumed = self.call("session.resume", req).await?;
if let Ok(current) = self.call("session.model.getCurrent", json!({ "sessionId": session_id })).await {
+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()));
+130 -2
Переглянути файл
@@ -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)]
@@ -138,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 =
@@ -164,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)
}
@@ -311,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(),
@@ -339,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)
}
@@ -955,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,
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+315 -240
Переглянути файл
@@ -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");
@@ -957,7 +986,7 @@ async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
wait_for(&mgr_a, &task.id, AgentStatus::NeedsInput).await;
assert_eq!(names(mgr_a.commands("claude", None).await.unwrap()), ["review", "triage"]);
assert_eq!(names(mgr_a.commands("claude", Some(&task.id)).await.unwrap()), ["review", "triage"]);
// Other agents get only what they offered, plus verified native builtins.
// Other agents also receive the project's active skills from the skills hub, plus verified native builtins.
assert_eq!(
names(mgr_a.commands("codex", None).await.unwrap()),
[
@@ -972,6 +1001,7 @@ async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
"goal",
"rename",
"logout",
"triage",
]
);
mgr_a.cancel(&task.id, None).unwrap();
@@ -981,7 +1011,6 @@ async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
// Another project shares the settings but not the commands.
let mgr_b = manager_at(&b, &models, Arc::new(FakeAgent::default()));
let claude = mgr_b.providers().into_iter().find(|p| p.id == "claude").unwrap();
assert_eq!(claude.config.len(), 2);
assert!(claude.commands.is_empty());
assert!(mgr_b.commands("claude", None).await.unwrap().is_empty());
let mgr_a = manager_at(&a, &models, Arc::new(FakeAgent::default()));
@@ -1168,7 +1197,6 @@ async fn a_task_runs_asks_for_permission_and_survives_a_restart() {
}
let providers = mgr.providers();
let claude = providers.iter().find(|p| p.id == "claude").unwrap();
assert_eq!(claude.config.iter().map(|o| o.id.as_str()).collect::<Vec<_>>(), ["model", "mode"]);
assert_eq!(claude.commands.len(), 1);
// A new manager (IDE restart) finds the task and resumes its session without duplicating history.
@@ -1177,7 +1205,6 @@ async fn a_task_runs_asks_for_permission_and_survives_a_restart() {
let mgr2 = manager(tmp.path(), agent2.clone());
assert_eq!(mgr2.entries(&task.id, None).unwrap().len(), 5);
assert_eq!(mgr2.task(&task.id).unwrap().state.lock().task.title, "Lexer fix");
assert_eq!(mgr2.providers().iter().find(|p| p.id == "claude").unwrap().config.len(), 2);
mgr2.prompt(&task.id, text("again"), false).await.unwrap();
tokio::time::sleep(Duration::from_millis(50)).await;
wait_for(&mgr2, &task.id, AgentStatus::Ready).await;
@@ -2138,52 +2165,6 @@ async fn usage_limits_and_late_settings() {
assert!(agent.calls.lock().iter().any(|c| c == "session/set_config_option \"high\""));
let config = mgr.task(&task.id).unwrap().state.lock().task.config.clone();
assert_eq!(config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("high"));
for _ in 0..100 {
if mgr
.shared
.known
.lock()
.get("claude")
.and_then(|k| k.thought_levels.get("big"))
.and_then(|levels| levels.first())
.and_then(|o| o.current.as_deref())
== Some("high")
{
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
assert_eq!(mgr.shared.known.lock()["claude"].thought_levels["big"][0].current.as_deref(), Some("high"));
}
#[tokio::test(flavor = "multi_thread")]
async fn remembered_settings_drop_per_model_choices_for_the_next_task() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
// The effort list depends on the model: what the last session ran means nothing once
// the user picks another model, so provider-wide defaults never include it.
*agent.extra_options.lock() = vec![json!({"id": "effort", "category": "thought_level",
"type": "select", "currentValue": "high",
"options": [{"value": "low", "name": "Low"}, {"value": "high", "name": "High"}]})];
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let provider = mgr.providers().into_iter().find(|p| p.id == "claude").unwrap();
assert!(provider.config.iter().all(|o| o.id != "effort"), "a per-model option isn't offered stale");
let model = provider.config.iter().find(|o| o.id == "model").unwrap();
assert_eq!(model.current.as_deref(), Some("big"), "the model choice survives");
}
fn effort_options(levels: &[&str], current: &str) -> Vec<Value> {
@@ -2191,51 +2172,6 @@ fn effort_options(levels: &[&str], current: &str) -> Vec<Value> {
"options": levels.iter().map(|v| json!({"value": v, "name": v})).collect::<Vec<_>>()})]
}
#[tokio::test(flavor = "multi_thread")]
async fn thinking_levels_are_remembered_per_provider_and_model() {
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")),
("plain".into(), vec![]),
]);
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.set_config(&task.id, "model", "small".into()).await.unwrap();
mgr.set_config(&task.id, "effort", "medium".into()).await.unwrap();
mgr.set_config(&task.id, "model", "plain".into()).await.unwrap();
let p = mgr.providers().into_iter().find(|p| p.id == "claude").unwrap();
let big = &p.thought_levels["big"][0];
assert_eq!(big.current.as_deref(), Some("high"));
assert_eq!(big.values.iter().map(|v| v.value.as_str()).collect::<Vec<_>>(), ["low", "high"]);
let small = &p.thought_levels["small"][0];
assert_eq!(small.current.as_deref(), Some("medium"));
assert_eq!(small.values.iter().map(|v| v.value.as_str()).collect::<Vec<_>>(), ["minimal", "medium"]);
assert!(p.thought_levels["plain"].is_empty());
assert!(!p.thought_levels.contains_key("unknown"));
assert!(mgr.providers().iter().find(|p| p.id == "codex").unwrap().thought_levels.is_empty());
let saved: HashMap<String, Known> =
serde_json::from_slice(&std::fs::read(&mgr.shared.paths.models_file).unwrap()).unwrap();
assert_eq!(saved["claude"].thought_levels, p.thought_levels);
mgr.shutdown();
let restored = manager(tmp.path(), agent);
assert_eq!(restored.providers().into_iter().find(|p| p.id == "claude").unwrap().thought_levels, p.thought_levels);
restored.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
// Idle selections use cached model controls or discover them before the next prompt.
@@ -2274,12 +2210,9 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
}
restored.set_config(&task.id, "model", "big".into()).await.unwrap();
restored.set_config(&task.id, option, value.into()).await.unwrap();
let p = restored.providers().into_iter().find(|p| p.id == "claude-acp").unwrap();
let big = p.thought_levels.get("big").and_then(|levels| levels.first());
assert_eq!(big.map(|o| o.values.len()), Some(2), "{option}: {:?}", p.thought_levels);
let saved: HashMap<String, Known> =
serde_json::from_slice(&std::fs::read(&restored.shared.paths.models_file).unwrap()).unwrap();
assert_eq!(saved["claude-acp"].thought_levels, p.thought_levels, "{option}");
let levels = restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp").thought_levels;
let big = levels.get("big").and_then(|levels| levels.first());
assert_eq!(big.map(|o| o.values.len()), Some(2), "{option}: {levels:?}");
restored.shutdown();
}
}
@@ -2333,6 +2266,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();
@@ -2462,100 +2445,6 @@ async fn upfront_effort_is_validated_after_changing_model_before_the_prompt() {
}
}
#[tokio::test(flavor = "multi_thread")]
async fn unreported_model_switch_does_not_cache_the_previous_models_levels() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
*agent.extra_options.lock() = effort_options(&["low", "high"], "high");
let mgr = manager(tmp.path(), agent);
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.set_config(&task.id, "model", "small".into()).await.unwrap();
let p = mgr.providers().into_iter().find(|p| p.id == "claude").unwrap();
assert!(!p.thought_levels.contains_key("small"));
assert_eq!(p.thought_levels["big"][0].current.as_deref(), Some("high"));
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn cached_effort_is_not_sent_without_real_session_options() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
*agent.extra_options.lock() = effort_options(&["low", "high"], "low");
let mgr = manager(tmp.path(), agent.clone());
let new = |config| NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
config,
isolation: Isolation::Local,
base: None,
..Default::default()
};
let warm = mgr.create(new(vec![])).await.unwrap();
wait_for(&mgr, &warm.id, AgentStatus::Ready).await;
agent.calls.lock().clear();
agent.empty_config.store(true, Ordering::Release);
let task = mgr
.create(new(vec![
AgentConfigChoice { id: "model".into(), value: "big".into() },
AgentConfigChoice { id: "effort".into(), value: "high".into() },
]))
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
assert!(!agent.calls.lock().iter().any(|c| c == "session/set_config_option \"high\""));
assert!(
mgr.task(&task.id).unwrap().state.lock().task.config.iter().any(|o| o.id == "effort"),
"remembered session settings remain visible until the agent refreshes them"
);
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn reported_levels_refresh_even_without_a_model_option() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
*agent.extra_options.lock() = effort_options(&["low", "high"], "high");
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
for levels in [effort_options(&["minimal", "medium"], "medium"), vec![]] {
agent.update("s1", json!({"sessionUpdate": "config_option_update", "configOptions": levels}));
let expected = config::parse_options(&json!(levels));
for _ in 0..100 {
if mgr.shared.known.lock()["claude"].thought_levels["big"] == expected {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
assert_eq!(mgr.shared.known.lock()["claude"].thought_levels["big"], expected);
}
mgr.shutdown();
}
#[test]
fn retry_updates_become_a_countdown() {
let update =
@@ -3113,49 +3002,6 @@ async fn a_failed_probe_is_retried_instead_of_remembered() {
assert!(!mgr.shared.probes.lock().contains_key("claude"));
}
/// A session report that changes the cached provider config notifies subscribers,
/// so the composer re-lists models without waiting for the next task (#1490).
/// Reports that change nothing stay silent.
#[tokio::test(flavor = "multi_thread")]
async fn remembered_config_changes_notify_subscribers_once() {
let tmp = tempfile::tempdir().unwrap();
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
let events = Arc::new(Mutex::new(Vec::new()));
let sink = events.clone();
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
events.lock().clear();
let reported = config::options_of(&json!({ "configOptions": [
{ "id": "model", "category": "model", "type": "select", "currentValue": "default",
"options": [{ "value": "default" }, { "value": "custom-opus" }] },
] }));
mgr.shared.remember("claude", Some(&reported), None, Some("default"));
assert!(
events.lock().iter().any(|ev| matches!(ev, AgentEvent::Providers)),
"a first report changing the cache notifies subscribers"
);
events.lock().clear();
// The same report again: the cache is unchanged, so subscribers hear nothing.
mgr.shared.remember("claude", Some(&reported), None, Some("default"));
assert!(events.lock().is_empty(), "an unchanged report must stay silent");
// A changed model list notifies again, and providers() serves the new list.
let updated = config::options_of(&json!({ "configOptions": [
{ "id": "model", "category": "model", "type": "select", "currentValue": "default",
"options": [{ "value": "default" }, { "value": "custom-opus" }, { "value": "custom-sonnet" }] },
] }));
mgr.shared.remember("claude", Some(&updated), None, Some("default"));
assert!(
events.lock().iter().any(|ev| matches!(ev, AgentEvent::Providers)),
"a changed model list notifies subscribers"
);
let claude = mgr.providers().into_iter().find(|p| p.id == "claude").unwrap();
let model = claude.config.iter().find(|o| o.category.as_deref() == Some("model")).unwrap();
let values: Vec<_> = model.values.iter().map(|v| v.value.as_str()).collect();
assert_eq!(values, ["default", "custom-opus", "custom-sonnet"]);
}
#[tokio::test(flavor = "multi_thread")]
async fn idle_agents_stop_and_resume_their_session_on_the_next_message() {
let new = || NewAgentTask {
@@ -3789,6 +3635,123 @@ async fn turn_changed(mgr: &AgentManager, id: &str) -> Vec<(String, ide_vcs::Cha
changes.into_iter().map(|c| (c.rel_path, c.kind, c.added, c.removed)).collect()
}
#[tokio::test(flavor = "multi_thread")]
async fn a_task_lists_what_it_changed_in_a_nested_repository() {
let tmp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(tmp.path()).unwrap();
let root = base.join("project");
for repo in [root.clone(), root.join("libs/validation")] {
std::fs::create_dir_all(&repo).unwrap();
std::fs::write(repo.join("a.txt"), "one\n").unwrap();
for args in [&["init", "-q", "-b", "main"][..], &["add", "a.txt"], &["commit", "-q", "-m", "init"]] {
let ok = std::process::Command::new("git")
.args(["-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false"])
.args(args)
.current_dir(&repo)
.status()
.unwrap()
.success();
assert!(ok, "{args:?}");
}
}
let mgr = manager(&base.join("ide"), Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask {
project_root: Some(IpcPath(root.clone())),
prompt: text("Hello"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
one_turn(&mgr, &task.id, None, || {
std::fs::write(root.join("a.txt"), "two\n").unwrap();
std::fs::write(root.join("libs/validation/b.txt"), "new\n").unwrap();
})
.await;
let changed: Vec<(String, Option<IpcPath>)> =
mgr.changes(&task.id).await.unwrap().into_iter().map(|c| (c.rel_path, c.repo)).collect();
assert_eq!(
changed,
[
("a.txt".to_owned(), Some(IpcPath(root.clone()))),
("libs/validation/b.txt".to_owned(), Some(IpcPath(root.join("libs/validation")))),
]
);
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
assert_eq!(std::fs::read_to_string(root.join("a.txt")).unwrap(), "one\n");
assert!(!root.join("libs/validation/b.txt").exists());
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn the_last_turn_of_a_task_spans_nested_repositories() {
use ide_vcs::ChangeKind::{Added, Modified};
let tmp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(tmp.path()).unwrap();
let root = base.join("project");
let nested = root.join("libs/validation");
let git = |repo: &Path, args: &[&str]| {
let ok = std::process::Command::new("git")
.args(["-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false"])
.args(args)
.current_dir(repo)
.status()
.unwrap()
.success();
assert!(ok, "{args:?}");
};
for repo in [&root, &nested] {
std::fs::create_dir_all(repo).unwrap();
std::fs::write(repo.join("a.txt"), "one\n").unwrap();
git(repo, &["init", "-q", "-b", "main"]);
git(repo, &["add", "a.txt"]);
git(repo, &["commit", "-q", "-m", "init"]);
}
let mgr = manager(&base.join("ide"), Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask {
project_root: Some(IpcPath(root.clone())),
prompt: text("Hello"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
one_turn(&mgr, &task.id, None, || std::fs::write(root.join("a.txt"), "two\n").unwrap()).await;
one_turn(&mgr, &task.id, Some("more"), || {
std::fs::write(nested.join("a.txt"), "two\n").unwrap();
std::fs::write(nested.join("b.txt"), "new\n").unwrap();
// Committed in the nested repository: still the turn's.
std::fs::write(nested.join("c.txt"), "committed\n").unwrap();
git(&nested, &["add", "c.txt"]);
git(&nested, &["commit", "-q", "-m", "c"]);
})
.await;
// Only the second turn's files, from the nested repository, named from the project.
assert_eq!(
turn_changed(&mgr, &task.id).await,
[
("libs/validation/a.txt".into(), Modified, 1, 1),
("libs/validation/b.txt".into(), Added, 1, 0),
("libs/validation/c.txt".into(), Added, 1, 0),
]
);
let repos: Vec<_> = mgr.turn_changes(&task.id).await.unwrap().into_iter().map(|c| c.repo).collect();
assert_eq!(repos, [Some(IpcPath(nested.clone())), Some(IpcPath(nested.clone())), Some(IpcPath(nested.clone()))]);
let then = mgr.base_text(&task.id, nested.join("a.txt"), AgentChangesView::LastTurn).await.unwrap();
assert_eq!(then.as_deref(), Some("one\n"));
mgr.rollback_changes(&task.id, None, AgentChangesView::LastTurn).await.unwrap();
assert_eq!(std::fs::read_to_string(nested.join("a.txt")).unwrap(), "one\n");
assert!(!nested.join("b.txt").exists());
assert_eq!(std::fs::read_to_string(root.join("a.txt")).unwrap(), "two\n", "the first turn's change stays");
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn the_last_turn_lists_and_rolls_back_only_its_own_changes() {
use ide_vcs::ChangeKind::{Added, Deleted, Modified};
@@ -4453,6 +4416,7 @@ async fn per_session_mcp_overrides_filter_session_and_reload_when_idle() {
base: None,
mcp_overrides: BTreeMap::from([("slack".into(), false)]),
idle: false,
skill_overrides: BTreeMap::new(),
})
.await
.unwrap();
@@ -4480,6 +4444,82 @@ async fn per_session_mcp_overrides_filter_session_and_reload_when_idle() {
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn per_session_skill_overrides_filter_commands_persist_and_reload_when_idle() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
std::fs::create_dir_all(root.join(".agents/skills/tdd")).unwrap();
std::fs::write(root.join(".agents/skills/tdd/SKILL.md"), "---\nname: tdd\ndescription: TDD\n---\n").unwrap();
std::fs::create_dir_all(root.join(".claude/skills/noisy")).unwrap();
std::fs::write(root.join(".claude/skills/noisy/SKILL.md"), "---\nname: noisy\ndescription: Noisy\n---\n").unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(root, agent.clone());
mgr.set_skills_policy_hook(Box::new({
let root = root.to_path_buf();
move || SkillsPolicy {
user: BTreeMap::from([("tdd".into(), AgentSkillPolicy { mode: AgentSkillMode::Off })]),
workspace_roots: vec![root.clone()],
..SkillsPolicy::default()
}
}));
// Start task with `tdd` (default off) enabled for this session and `noisy` turned off.
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
config: Vec::new(),
isolation: Isolation::Local,
base: None,
mcp_overrides: BTreeMap::new(),
idle: false,
skill_overrides: BTreeMap::from([
("tdd".into(), AgentSkillMode::Auto),
("noisy".into(), AgentSkillMode::Off),
]),
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let cmd_names: Vec<String> =
mgr.commands("claude", Some(&task.id)).await.unwrap().into_iter().map(|c| c.name).collect();
assert!(cmd_names.contains(&"tdd".to_string()), "{cmd_names:?}");
assert!(
!cmd_names.contains(&"noisy".to_string()),
"`noisy` offered on disk must be stripped when off: {cmd_names:?}"
);
// Flip overrides while idle -> recycles resumable session so next turn calls `session/load`.
let updated = mgr
.set_skill_overrides(
&task.id,
BTreeMap::from([("tdd".into(), AgentSkillMode::Off), ("noisy".into(), AgentSkillMode::Auto)]),
)
.unwrap();
assert_eq!(updated.skill_overrides.get("tdd"), Some(&AgentSkillMode::Off));
assert_eq!(updated.skill_overrides.get("noisy"), Some(&AgentSkillMode::Auto));
let cmd_names_after: Vec<String> =
mgr.commands("claude", Some(&task.id)).await.unwrap().into_iter().map(|c| c.name).collect();
assert!(!cmd_names_after.contains(&"tdd".to_string()), "{cmd_names_after:?}");
assert!(cmd_names_after.contains(&"noisy".to_string()), "{cmd_names_after:?}");
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
assert_eq!(agent.mcp_calls.lock().last().map(|c| c.0.as_str()), Some("session/load"));
mgr.shutdown();
// Persisted task file preserves `skill_overrides` across restart.
let restored_mgr = manager(root, Arc::new(FakeAgent::default()));
let restored = restored_mgr.subscribe(Arc::new(|_| {})).into_iter().find(|t| t.id == task.id).unwrap();
assert_eq!(restored.skill_overrides.get("tdd"), Some(&AgentSkillMode::Off));
assert_eq!(restored.skill_overrides.get("noisy"), Some(&AgentSkillMode::Auto));
restored_mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails() {
#[derive(Clone, Copy)]
@@ -4581,6 +4621,7 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
base: None,
mcp_overrides: BTreeMap::new(),
idle: false,
skill_overrides: BTreeMap::new(),
})
.await
.unwrap();
@@ -4606,6 +4647,7 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
base: None,
mcp_overrides: BTreeMap::new(),
idle: false,
skill_overrides: BTreeMap::new(),
})
.await
.unwrap();
@@ -4684,10 +4726,43 @@ done
#[test]
fn session_params_name_the_servers_off() {
let mcp = McpForSession { servers: vec![json!({ "name": "docs" })], off: vec!["github".into()] };
let params = session_params("/p", &mcp);
let params = session_params("/p", &mcp, None, &[]);
assert_eq!(params["cwd"], "/p");
assert_eq!(params["mcpServers"][0]["name"], "docs");
assert_eq!(params["_meta"]["openidea"]["mcpServersOff"], json!(["github"]));
let none = McpForSession { servers: Vec::new(), off: Vec::new() };
assert!(session_params("/p", &none).get("_meta").is_none());
assert!(session_params("/p", &none, None, &[]).get("_meta").is_none());
}
#[test]
fn session_params_offer_the_workspace_roots() {
let none = McpForSession { servers: Vec::new(), off: Vec::new() };
let params = session_params("/w/api", &none, None, &["/w/web".to_owned()]);
assert_eq!(params["additionalDirectories"], json!(["/w/web"]));
assert!(session_params("/w/api", &none, None, &[]).get("additionalDirectories").is_none());
}
#[tokio::test]
async fn workspace_roots_go_to_agents_that_take_them() {
let tmp = tempfile::tempdir().unwrap();
let [api, web, worktree] = ["api", "web", "worktree"].map(|d| tmp.path().join(d));
for d in [&api, &web, &worktree] {
std::fs::create_dir_all(d).unwrap();
}
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
let hook_roots = [api.clone(), web.clone(), web.clone()];
mgr.set_workspace_roots_hook(Arc::new(move || hook_roots.to_vec()));
let init = |capabilities: Value| acp::Negotiated {
generation: 1,
capabilities,
agent_info: None,
auth_methods: Vec::new(),
meta: None,
};
let takes = init(json!({ "sessionCapabilities": { "additionalDirectories": {} } }));
let web = dunce::canonicalize(&web).unwrap().to_string_lossy().into_owned();
assert_eq!(mgr.shared.additional_directories(&takes, &api, None), vec![web.clone()]);
// A task in a worktree of `api` isn't offered the project's own checkout.
assert_eq!(mgr.shared.additional_directories(&takes, &worktree, Some(&api)), vec![web]);
assert!(mgr.shared.additional_directories(&init(json!({})), &api, None).is_empty());
}
+238 -30
Переглянути файл
@@ -25,6 +25,98 @@ fn discover(path: &Path) -> IdeResult<Option<Repo>> {
Ok(repo)
}
/// The repositories of a project with nested ones (an own `.git` under the project root, not a
/// submodule), with the folder their files are named from: the root of the repository holding
/// `cwd`, else `cwd`. `None` when only the repository holding `cwd` (if any) is there.
fn nested_repos(cwd: &Path) -> IdeResult<Option<(PathBuf, Vec<Repo>)>> {
let Ok(cwd) = dunce::canonicalize(cwd) else { return Ok(None) };
let found = ide_vcs::Repos::discover(&cwd, &|_| false)?;
if found.all().iter().all(|r| cwd.starts_with(r.root())) {
return Ok(None);
}
let base = found.all().iter().map(|r| r.root()).filter(|r| cwd.starts_with(r)).max().unwrap_or(&cwd).to_path_buf();
let mut repos = Vec::new();
for r in found.all() {
repos.extend(discover(r.root())?);
}
Ok(Some((base, repos)))
}
/// Whether the project at `cwd` holds repositories nested in it: its changes are each one's.
pub(crate) fn spans_repos(cwd: &Path) -> bool {
nested_repos(cwd).is_ok_and(|r| r.is_some())
}
/// The repositories a turn's files are in, and the folder those files are named from.
struct TurnRepos {
base: PathBuf,
repos: Vec<Repo>,
/// The project holds nested repositories: each one's `HEAD` is recorded on its own.
nested: bool,
}
impl TurnRepos {
fn of(cwd: &Path) -> IdeResult<Option<Self>> {
if let Some((base, repos)) = nested_repos(cwd)? {
return Ok(Some(Self { base, repos, nested: true }));
}
Ok(discover(cwd)?.map(|repo| Self { base: repo.root().to_path_buf(), repos: vec![repo], nested: false }))
}
/// The innermost repository holding `path`.
fn owner(&self, path: &Path) -> Option<&Repo> {
self.repos.iter().filter(|r| path.starts_with(r.root())).max_by_key(|r| r.root().as_os_str().len())
}
/// `repo`'s `HEAD` as the turn `start` began.
fn head_then<'a>(&self, start: &'a TurnStart, repo: &Repo) -> Option<&'a str> {
if self.nested { start.heads.get(&root_key(repo.root())) } else { start.head.as_ref() }.map(String::as_str)
}
}
fn root_key(root: &Path) -> String {
root.to_string_lossy().into_owned()
}
/// `path` as a task in `base` names it, if it is not in a repository nested below `repo` (that
/// one lists it itself; to `repo` its folder is untracked).
fn nested_rel(base: &Path, repo: &Repo, roots: &[PathBuf], path: &Path) -> Option<String> {
let rel = path.strip_prefix(base).ok()?;
if path.is_dir()
|| roots.iter().any(|n| n.as_path() != repo.root() && n.starts_with(repo.root()) && path.starts_with(n))
{
return None;
}
Some(rel.to_string_lossy().replace('\\', "/"))
}
/// The uncommitted changes in every repository of the project, against each one's `HEAD`.
fn nested_changes(cwd: &Path) -> IdeResult<Vec<AgentChange>> {
let Some((base, repos)) = nested_repos(cwd)? else { return Ok(Vec::new()) };
let roots: Vec<PathBuf> = repos.iter().map(|r| r.root().to_path_buf()).collect();
let mut out: Vec<AgentChange> = Vec::new();
for repo in &repos {
let listed = match repo.head()?.1 {
Some(head) => changes(repo.root(), &head)?,
None => {
repo.status()?.into_iter().filter(|s| s.path.is_file()).map(|s| added(s.path, s.rel_path)).collect()
}
};
for mut c in listed {
let Some(rel) = nested_rel(&base, repo, &roots, &c.path.0) else { continue };
if out.iter().any(|o| o.path == c.path) {
continue;
}
c.rel_path = rel;
c.old_path = None;
c.repo = Some(IpcPath(repo.root().to_path_buf()));
out.push(c);
}
}
out.sort_by(|a, b| a.rel_path.cmp(&b.rel_path));
Ok(out)
}
fn repo_at(path: &Path) -> IdeResult<Repo> {
discover(path)?.ok_or_else(|| IdeError::unavailable(format!("{} is not in a git repository", path.display())))
}
@@ -38,6 +130,9 @@ pub(crate) fn head_of(path: &Path) -> IdeResult<(String, String)> {
/// `HEAD`'s commit in `cwd`, `None` outside a repository or before its first commit.
pub(crate) fn head_commit(cwd: &Path) -> IdeResult<Option<String>> {
if spans_repos(cwd) {
return Ok(Some("HEAD".to_owned()));
}
match discover(cwd)? {
Some(repo) => Ok(repo.head()?.1),
None => Ok(None),
@@ -127,6 +222,7 @@ pub(crate) fn changes(cwd: &Path, base: &str) -> IdeResult<Vec<AgentChange>> {
added,
removed,
old_path: f.old_path,
repo: None,
}
})
.collect();
@@ -143,6 +239,9 @@ pub(crate) fn changes(cwd: &Path, base: &str) -> IdeResult<Vec<AgentChange>> {
/// Files renamed since `rev`, by their new repository-relative path: the old path, as a deletion
/// to roll back along with the rename.
pub(crate) fn rename_sources(cwd: &Path, rev: &str) -> IdeResult<BTreeMap<String, AgentChange>> {
if spans_repos(cwd) {
return Ok(BTreeMap::new());
}
let Some(repo) = discover(cwd)? else { return Ok(BTreeMap::new()) };
let root = repo.root().to_path_buf();
Ok(repo
@@ -157,6 +256,7 @@ pub(crate) fn rename_sources(cwd: &Path, rev: &str) -> IdeResult<BTreeMap<String
added: 0,
removed: 0,
old_path: None,
repo: None,
};
Some((f.path, source))
})
@@ -165,7 +265,7 @@ pub(crate) fn rename_sources(cwd: &Path, rev: &str) -> IdeResult<BTreeMap<String
fn added(path: IpcPath, rel_path: String) -> AgentChange {
let added = std::fs::read_to_string(&*path).map_or(0, |t| t.lines().count() as u32);
AgentChange { path, rel_path, kind: ChangeKind::Added, added, removed: 0, old_path: None }
AgentChange { path, rel_path, kind: ChangeKind::Added, added, removed: 0, old_path: None, repo: None }
}
/// The commits from `base` (exclusive) to `head` (inclusive) in `cwd`, newest first, each
@@ -201,6 +301,7 @@ pub(crate) fn commits(cwd: &Path, base: &str, head: &str) -> IdeResult<Vec<Agent
added,
removed,
old_path: f.old_path,
repo: None,
}
})
.collect();
@@ -266,6 +367,9 @@ impl TaskBase {
pub(crate) fn changes(&self, before: &BTreeMap<String, Stamp>) -> IdeResult<Vec<AgentChange>> {
let (cwd, start) = match self {
Self::Worktree { cwd, base } => return Ok(without_untouched(changes(cwd, base)?, before)),
Self::Local { cwd, .. } if spans_repos(cwd) => {
return Ok(without_untouched(nested_changes(cwd)?, before));
}
Self::Local { cwd, start } => (cwd, start.as_deref()),
};
let Some(repo) = discover(cwd)? else { return Ok(Vec::new()) };
@@ -324,6 +428,9 @@ impl TaskBase {
/// reads cannot put a file in both lists.
pub(crate) fn grouped_changes(&self, before: &BTreeMap<String, Stamp>) -> IdeResult<AgentChanges> {
let cwd = self.cwd();
if spans_repos(cwd) {
return Ok(AgentChanges { uncommitted: self.changes(before)?, commits: Vec::new() });
}
let Some(repo) = discover(cwd)? else { return Ok(AgentChanges::default()) };
let head = repo.head()?.1;
let uncommitted = match &head {
@@ -353,6 +460,8 @@ impl TaskBase {
pub(crate) fn rev(&self) -> IdeResult<Option<String>> {
let (cwd, start) = match self {
Self::Worktree { base, .. } => return Ok(Some(base.clone())),
// Each repository goes back to its own `HEAD`.
Self::Local { cwd, .. } if spans_repos(cwd) => return Ok(Some("HEAD".to_owned())),
Self::Local { cwd, start } => (cwd, start.as_deref()),
};
let Some(repo) = discover(cwd)? else { return Ok(None) };
@@ -545,6 +654,18 @@ pub(crate) fn stamp(path: &Path) -> Stamp {
pub(crate) fn snapshot(cwd: &Path) -> IdeResult<BTreeMap<String, Stamp>> {
// Paths and stamps only: no diff and no line counts, which read every untracked file
// and held up starting a task in a checkout with many of them.
if let Some((base, repos)) = nested_repos(cwd)? {
let roots: Vec<PathBuf> = repos.iter().map(|r| r.root().to_path_buf()).collect();
let mut out = BTreeMap::new();
for repo in &repos {
for s in repo.status()? {
if let Some(rel) = nested_rel(&base, repo, &roots, &s.path) {
out.insert(rel, stamp(&s.path));
}
}
}
return Ok(out);
}
let Some(repo) = Repo::discover(cwd)? else { return Ok(BTreeMap::new()) };
Ok(repo.status()?.into_iter().map(|s| (s.rel_path, stamp(&s.path))).collect())
}
@@ -587,10 +708,16 @@ fn saved_name(rel: &str) -> String {
/// into `dir`, so rolling back the task's changes to them restores the user's own edits.
/// Whether anything was saved.
pub(crate) fn save_before(cwd: &Path, before: &BTreeMap<String, Stamp>, dir: &Path) -> IdeResult<bool> {
let Some(repo) = Repo::discover(cwd)? else { return Ok(false) };
let root = match nested_repos(cwd)? {
Some((base, _)) => base,
None => match Repo::discover(cwd)? {
Some(repo) => repo.root().to_path_buf(),
None => return Ok(false),
},
};
let mut saved = false;
for (rel, stamp) in before {
let path = repo.root().join(rel);
let path = root.join(rel);
if stamp.is_none() || !std::fs::metadata(&path).is_ok_and(|m| m.is_file() && m.len() <= SAVED_MAX) {
continue;
}
@@ -625,7 +752,8 @@ pub(crate) fn restore(
}
None => match rev {
Some(rev) => {
let repo = Repo::discover(cwd)?.ok_or_else(|| IdeError::invalid("not in a git repository"))?;
let at = change.repo.as_ref().map_or(cwd, |r| r.0.as_path());
let repo = Repo::discover(at)?.ok_or_else(|| IdeError::invalid("not in a git repository"))?;
repo.file_bytes_at(&change.path.0, Some(rev))?
}
None => None,
@@ -665,6 +793,9 @@ pub(crate) struct TurnStart {
/// `HEAD` then (`None` outside a repository or before its first commit).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub head: Option<String>,
/// With nested repositories, each one's `HEAD` then, by its root.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub heads: BTreeMap<String, String>,
/// The files already changed then, stamped.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub before: BTreeMap<String, Stamp>,
@@ -680,8 +811,16 @@ pub(crate) struct TurnStart {
/// The copies `previous` saved of files unchanged since are kept rather than made again, so
/// starting a turn copies little more than what the turn before it changed.
pub(crate) fn start_turn(cwd: &Path, dir: &Path, previous: Option<&TurnStart>) -> IdeResult<TurnStart> {
let Some(repo) = discover(cwd)? else { return Ok(TurnStart::default()) };
let head = repo.head()?.1;
let Some(at) = TurnRepos::of(cwd)? else { return Ok(TurnStart::default()) };
let mut heads = BTreeMap::new();
let head = if at.nested {
for repo in &at.repos {
heads.extend(repo.head()?.1.map(|h| (root_key(repo.root()), h)));
}
None
} else {
at.repos[0].head()?.1
};
// As the turn's end is read, so the two compare.
let before = snapshot(cwd)?;
let mut saved = BTreeSet::new();
@@ -702,7 +841,7 @@ pub(crate) fn start_turn(cwd: &Path, dir: &Path, previous: Option<&TurnStart>) -
}
}
for (rel, stamp) in &before {
let path = repo.root().join(rel);
let path = at.base.join(rel);
if stamp.is_none()
|| saved.contains(rel)
|| !std::fs::metadata(&path).is_ok_and(|m| m.is_file() && m.len() <= SAVED_MAX)
@@ -715,7 +854,7 @@ pub(crate) fn start_turn(cwd: &Path, dir: &Path, previous: Option<&TurnStart>) -
saved.insert(rel.clone());
}
}
Ok(TurnStart { head, before, saved, changed: None })
Ok(TurnStart { head, heads, before, saved, changed: None })
}
/// The files that changed in `cwd` since the turn `start` began: in the working tree (as
@@ -724,20 +863,25 @@ pub(crate) fn changed_in_turn(cwd: &Path, start: &TurnStart) -> IdeResult<(Vec<S
let end = snapshot(cwd)?;
let worktree = changed_between(&start.before, &end);
let mut all: BTreeSet<String> = worktree.iter().cloned().collect();
if let Some(repo) = discover(cwd)?
&& let (Some(from), Some(to)) = (&start.head, repo.head()?.1)
&& *from != to
{
let Some(at) = TurnRepos::of(cwd)? else { return Ok((worktree, all)) };
for repo in &at.repos {
let (Some(from), Some(to)) = (at.head_then(start, repo), repo.head()?.1) else { continue };
if from == to {
continue;
}
// Named from the base, as the working tree's files are.
let prefix = rel_in(&at.base, repo.root())?;
let named = |rel: String| if prefix.is_empty() { rel } else { format!("{prefix}/{rel}") };
for f in repo.diff_revisions(from, &to)? {
all.extend(f.old_path);
all.insert(f.path);
all.extend(f.old_path.map(named));
all.insert(named(f.path));
}
}
Ok((worktree, all))
}
/// The content of `rel` as the turn `start` began (`None`: no file), its copies in `dir`.
fn at_turn_start(repo: &Repo, rel: &str, start: &TurnStart, dir: &Path) -> IdeResult<Option<Vec<u8>>> {
fn at_turn_start(at: &TurnRepos, rel: &str, start: &TurnStart, dir: &Path) -> IdeResult<Option<Vec<u8>>> {
match start.before.get(rel) {
Some(None) => Ok(None),
Some(Some(_)) => match start.saved.contains(rel).then(|| saved_copy(dir, rel)).flatten() {
@@ -746,10 +890,13 @@ fn at_turn_start(repo: &Repo, rel: &str, start: &TurnStart, dir: &Path) -> IdeRe
"{rel} had changes when the turn started that weren't saved; roll it back in Git instead"
))),
},
None => match &start.head {
Some(head) => repo.file_bytes_at(&repo.root().join(rel), Some(head)),
None => Ok(None),
},
None => {
let path = at.base.join(rel);
match at.owner(&path).and_then(|repo| Some((repo, at.head_then(start, repo)?))) {
Some((repo, head)) => repo.file_bytes_at(&path, Some(head)),
None => Ok(None),
}
}
}
}
@@ -771,13 +918,13 @@ pub(crate) fn turn_changes(
dir: &Path,
changed: &BTreeSet<String>,
) -> IdeResult<Vec<AgentChange>> {
let Some(repo) = discover(cwd)? else { return Ok(Vec::new()) };
let Some(at) = TurnRepos::of(cwd)? else { return Ok(Vec::new()) };
let mut out = Vec::new();
for rel in changed {
let path = repo.root().join(rel);
let path = at.base.join(rel);
// A folder (a submodule, say) or a file that can't be read has nothing to compare.
let Some(now) = existing(&path) else { continue };
let (kind, (added, removed)) = match at_turn_start(&repo, rel, start, dir) {
let (kind, (added, removed)) = match at_turn_start(&at, rel, start, dir) {
Ok(then) if then == now => continue,
Ok(then) => {
let kind = match (&then, &now) {
@@ -790,19 +937,29 @@ pub(crate) fn turn_changes(
// Its start wasn't saved: listed, without counts.
Err(_) => (ChangeKind::Modified, (0, 0)),
};
out.push(AgentChange { path: IpcPath(path), rel_path: rel.clone(), kind, added, removed, old_path: None });
out.push(AgentChange {
rel_path: rel.clone(),
kind,
added,
removed,
old_path: None,
repo: at.nested.then(|| at.owner(&path).map(|r| IpcPath(r.root().to_path_buf()))).flatten(),
path: IpcPath(path),
});
}
Ok(out)
}
/// The text of `path` as the turn `start` began, `None` when there was no file.
pub(crate) fn turn_text(cwd: &Path, path: &Path, start: &TurnStart, dir: &Path) -> IdeResult<Option<String>> {
let Some(repo) = discover(cwd)? else { return Ok(None) };
let rel = rel_in(repo.root(), path)?;
if let (None, Some(head)) = (start.before.get(&rel), &start.head) {
let Some(at) = TurnRepos::of(cwd)? else { return Ok(None) };
let rel = rel_in(&at.base, path)?;
if !start.before.contains_key(&rel)
&& let Some(head) = at.owner(&at.base.join(&rel)).and_then(|repo| at.head_then(start, repo))
{
return file_at(cwd, path, head);
}
let Some(bytes) = at_turn_start(&repo, &rel, start, dir)? else { return Ok(None) };
let Some(bytes) = at_turn_start(&at, &rel, start, dir)? else { return Ok(None) };
let encoding = match ide_vfs::load_text(path) {
Ok(loaded) => encoding_rs::Encoding::for_label(loaded.encoding.as_bytes()).unwrap_or(encoding_rs::UTF_8),
Err(_) => ide_vfs::detect_encoding(&bytes, None),
@@ -828,12 +985,15 @@ fn rel_in(root: &Path, path: &Path) -> IdeResult<String> {
/// Puts `change` back as it was when the turn `start` began.
pub(crate) fn restore_turn(cwd: &Path, start: &TurnStart, dir: &Path, change: &AgentChange) -> IdeResult<()> {
let repo = repo_at(cwd)?;
put(&change.path.0, at_turn_start(&repo, &change.rel_path, start, dir)?)
let at = TurnRepos::of(cwd)?
.ok_or_else(|| IdeError::unavailable(format!("{} is not in a git repository", cwd.display())))?;
put(&change.path.0, at_turn_start(&at, &change.rel_path, start, dir)?)
}
pub(crate) fn file_at(cwd: &Path, path: &Path, rev: &str) -> IdeResult<Option<String>> {
let Some(repo) = discover(cwd)? else { return Ok(None) };
// With nested repositories, the file's own one.
let at = if spans_repos(cwd) { path.parent().unwrap_or(cwd) } else { cwd };
let Some(repo) = discover(at)? else { return Ok(None) };
let encoding = match ide_vfs::load_text(path) {
Ok(loaded) => encoding_rs::Encoding::for_label(loaded.encoding.as_bytes()).unwrap_or(encoding_rs::UTF_8),
Err(_) => ide_vfs::detect_encoding(&repo.file_bytes_at(path, Some(rev))?.unwrap_or_default(), None),
@@ -962,6 +1122,54 @@ mod tests {
assert!(ok, "git {args:?}");
}
#[test]
fn a_project_with_nested_repositories_sees_changes_in_each_one() {
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap();
let (nested, deeper) = (root.join("libs/validation"), root.join("libs/validation/pkg/sdk"));
for repo in [&root, &nested, &deeper] {
std::fs::create_dir_all(repo).unwrap();
git(repo, &["init", "-q", "-b", "main"]);
std::fs::write(repo.join("a.txt"), "one\n").unwrap();
git(repo, &["add", "a.txt"]);
git(repo, &["commit", "-q", "-m", "init"]);
}
assert!(spans_repos(&root));
std::fs::write(root.join("mine.txt"), "the user's\n").unwrap();
let before = snapshot(&root).unwrap();
assert_eq!(before.keys().collect::<Vec<_>>(), ["mine.txt"]);
std::fs::write(root.join("a.txt"), "two\n").unwrap();
std::fs::write(nested.join("a.txt"), "two\n").unwrap();
std::fs::write(nested.join("b.txt"), "new\n").unwrap();
std::fs::write(deeper.join("a.txt"), "two\n").unwrap();
let at = TaskBase::Local { cwd: root.clone(), start: None };
let changed = at.changes(&before).unwrap();
let listed: Vec<(&str, &Path)> =
changed.iter().map(|c| (c.rel_path.as_str(), c.repo.as_ref().unwrap().0.as_path())).collect();
assert_eq!(
listed,
[
("a.txt", root.as_path()),
("libs/validation/a.txt", nested.as_path()),
("libs/validation/b.txt", nested.as_path()),
("libs/validation/pkg/sdk/a.txt", deeper.as_path()),
]
);
assert_eq!(at.grouped_changes(&before).unwrap().uncommitted.len(), 4);
assert_eq!(file_at(&root, &nested.join("a.txt"), "HEAD").unwrap().as_deref(), Some("one\n"));
let rev = at.rev().unwrap();
for change in &changed {
restore(&root, rev.as_deref(), change, &before, None).unwrap();
}
for repo in [&root, &nested, &deeper] {
assert_eq!(std::fs::read_to_string(repo.join("a.txt")).unwrap(), "one\n");
}
assert!(!nested.join("b.txt").exists());
assert!(root.join("mine.txt").exists(), "the user's own change stays");
}
#[test]
fn worktree_changes_are_listed_against_the_base() {
let tmp = tempfile::tempdir().unwrap();
+112 -13
Переглянути файл
@@ -15,8 +15,8 @@ pub use fingerprint::{LaunchFingerprint, launch_fingerprint, menu_fingerprint};
pub use launch_resources::process_launch_resources;
pub use modules::record_module_build;
pub use single::{
SingleFileTarget, compile_file_plan, find_javac, javac_step, module_classpath, single_file_classpath,
single_file_target,
SingleFileTarget, compile_file_plan, find_javac, javac_step, module_classpath, module_classpaths,
single_file_classpath, single_file_target,
};
pub use structure::{
StructureJdk, StructureRoots, artifact_file, artifact_output, language_release, structure_outputs, structure_plan,
@@ -916,6 +916,47 @@ fn launch_plan(
Ok(plan)
}
/// Directory of the linked Maven reactor that builds the launch module at `module`;
/// launches of one reactor can share a build ([`build_for_launches`]).
pub fn launch_reactor(root: &Path, model: &BuildModel, module: &Path) -> Option<String> {
maven_reactor(model.maven.as_ref()?, &rel_str(root, module)).map(|top| top.dir.clone())
}
/// One Maven step building every module of `modules` (all of one reactor) with what they
/// depend on: `-pl a,b -am`, so their shared upstream modules build once (#3971).
fn merged_launch_plan(
root: &Path,
model: &BuildModel,
modules: &[PathBuf],
test: bool,
kind: BuildKind,
cancel: &CancellationToken,
) -> IdeResult<BuildPlan> {
let mut plan = launch_plan(root, model, &modules[0], test, kind, cancel)?;
if plan.system != BuildSystem::Maven || modules.len() == 1 {
return Ok(plan);
}
let mut selection = Vec::new();
for module in modules {
let one = launch_plan(root, model, module, test, kind, cancel)?;
if one.steps.len() != 1 || one.steps[0].cwd != plan.steps[0].cwd {
return Err(IdeError::invalid("launch modules belong to different Maven reactors"));
}
match one.steps[0].args.iter().position(|a| a == "-pl") {
Some(i) => selection.push(one.steps[0].args[i + 1].clone()),
// The reactor root itself builds every module.
None => return Ok(one),
}
}
selection.sort();
selection.dedup();
let step = &mut plan.steps[0];
if let Some(i) = step.args.iter().position(|a| a == "-pl") {
step.args[i + 1] = selection.join(",");
}
Ok(plan)
}
#[derive(Debug)]
pub struct LaunchBuild {
pub class_dirs: Vec<PathBuf>,
@@ -932,7 +973,21 @@ pub fn build_for_launch(
kind: BuildKind,
cancel: &CancellationToken,
) -> IdeResult<LaunchBuild> {
let plan = launch_plan(root, model, module, test, kind, cancel)?;
let mut built = build_for_launches(root, model, &[module.to_path_buf()], test, kind, cancel)?;
Ok(built.pop().unwrap())
}
/// [`build_for_launch`] of several modules of one Maven reactor in a single Maven run:
/// one result per module, in order, sharing the build's failure.
pub fn build_for_launches(
root: &Path,
model: &BuildModel,
modules: &[PathBuf],
test: bool,
kind: BuildKind,
cancel: &CancellationToken,
) -> IdeResult<Vec<LaunchBuild>> {
let plan = merged_launch_plan(root, model, modules, test, kind, cancel)?;
let result = run(root, &plan, cancel, &|_| {})?;
let failure = if !result.success {
let errors: Vec<String> = result
@@ -949,17 +1004,21 @@ pub fn build_for_launch(
} else {
None
};
let class_dirs = if plan.system == BuildSystem::Maven
&& let Some(m) = &model.maven
{
maven_launch_projects(root, m, module, test)
.iter()
.flat_map(|p| launch_class_dirs(plan.system, &subdir(root, &p.dir), test && subdir(root, &p.dir) == module))
.collect()
} else {
launch_class_dirs(plan.system, module, test)
let class_dirs = |module: &Path| {
if plan.system == BuildSystem::Maven
&& let Some(m) = &model.maven
{
maven_launch_projects(root, m, module, test)
.iter()
.flat_map(|p| {
launch_class_dirs(plan.system, &subdir(root, &p.dir), test && subdir(root, &p.dir) == module)
})
.collect()
} else {
launch_class_dirs(plan.system, module, test)
}
};
Ok(LaunchBuild { class_dirs, failure })
Ok(modules.iter().map(|m| LaunchBuild { class_dirs: class_dirs(m), failure: failure.clone() }).collect())
}
fn launch_class_dirs(system: BuildSystem, module: &Path, test: bool) -> Vec<PathBuf> {
@@ -1659,6 +1718,46 @@ mod tests {
}
}
#[test]
fn launches_of_one_reactor_merge_into_one_module_selection() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
for dir in ["app", "lib", "unrelated"] {
write(root, &format!("{dir}/pom.xml"), "<project/>");
}
let mut model = reactor_model();
let cancel = CancellationToken::new();
let modules = |dirs: &[&str]| dirs.iter().map(|d| root.join(d)).collect::<Vec<_>>();
let selection = |plan: BuildPlan| {
let args = &plan.steps[0].args;
args.iter().position(|a| a == "-pl").map(|i| (args[i + 1].clone(), args[i + 2].clone(), args.len()))
};
assert_eq!(launch_reactor(root, &model, &root.join("lib")).as_deref(), Some(""));
let plan = merged_launch_plan(root, &model, &modules(&["lib", "app", "lib"]), false, BuildKind::Build, &cancel)
.unwrap();
assert_eq!(plan.steps.len(), 1);
assert_eq!(plan.steps[0].args.last().unwrap(), "compile");
assert_eq!(selection(plan), Some(("app,lib".into(), "-am".into(), 10)));
// One module: exactly the single launch's step.
let single = merged_launch_plan(root, &model, &modules(&["app"]), true, BuildKind::Rebuild, &cancel).unwrap();
let expected = launch_plan(root, &model, &root.join("app"), true, BuildKind::Rebuild, &cancel).unwrap();
assert_eq!(single.steps[0].args, expected.steps[0].args);
// The reactor root among them builds the whole reactor.
model.maven.as_mut().unwrap().projects[0].packaging = "jar".into();
let whole = merged_launch_plan(root, &model, &modules(&["app", ""]), false, BuildKind::Build, &cancel).unwrap();
assert_eq!(selection(whole), None);
// Another linked reactor can't join the step.
let m = model.maven.as_mut().unwrap();
m.projects[4].aggregated = false;
m.projects[4].command = "other".into();
m.projects[0].modules.retain(|p| p != "unrelated/pom.xml");
assert_eq!(launch_reactor(root, &model, &root.join("unrelated")).as_deref(), Some("unrelated"));
assert!(
merged_launch_plan(root, &model, &modules(&["app", "unrelated"]), false, BuildKind::Build, &cancel)
.is_err()
);
}
#[cfg(unix)]
#[test]
fn external_launch_returns_upstream_outputs_and_blocks_failure_or_cancellation() {
+157 -47
Переглянути файл
@@ -129,31 +129,73 @@ pub fn module_classpath(
cache: &Path,
cancel: &ide_core::CancellationToken,
) -> IdeResult<String> {
let target = module_target(root, model, module, test)?;
let fingerprint = launch_fingerprint(root, model, &target.module, test, local_repo, cancel)?;
let cache_path = classpath_cache_path(root, cache, &target.module, test);
if let (Some(fingerprint), Some(path)) = (&fingerprint, &cache_path)
&& let Ok(bytes) = fs::read(path)
&& let Ok(cached) = serde_json::from_slice::<CachedClasspath>(&bytes)
&& cached.version == CLASSPATH_CACHE_VERSION
&& cached.fingerprint == *fingerprint
&& classpath_entries_exist(root, &cached.classpath)
{
return Ok(cached.classpath);
module_classpaths(root, model, &[module.to_path_buf()], test, local_repo, cache, cancel)
}
/// [`module_classpath`] of `modules[0]`. The other modules, launched together with it
/// (#3971), share its Maven probe when they have no cached classpath, which leaves
/// theirs cached for their own launches.
pub fn module_classpaths(
root: &Path,
model: &BuildModel,
modules: &[PathBuf],
test: bool,
local_repo: Option<PathBuf>,
cache: &Path,
cancel: &ide_core::CancellationToken,
) -> IdeResult<String> {
let mut probes: Vec<Probe> = Vec::new();
for (i, module) in modules.iter().enumerate() {
let target = match module_target(root, model, module, test) {
Ok(target) => target,
Err(e) if i == 0 => return Err(e),
Err(_) => continue,
};
if i > 0 && (target.top.dir != probes[0].0.top.dir || probes.iter().any(|p| p.0.module == target.module)) {
continue;
}
let fingerprint = launch_fingerprint(root, model, &target.module, test, local_repo.clone(), cancel)?;
let cache_path = classpath_cache_path(root, cache, &target.module, test);
if let (Some(fingerprint), Some(path)) = (&fingerprint, &cache_path)
&& let Ok(bytes) = fs::read(path)
&& let Ok(cached) = serde_json::from_slice::<CachedClasspath>(&bytes)
&& cached.version == CLASSPATH_CACHE_VERSION
&& cached.fingerprint == *fingerprint
&& classpath_entries_exist(root, &cached.classpath)
{
if i == 0 {
return Ok(cached.classpath);
}
continue;
}
probes.push(Probe(target, fingerprint, cache_path));
}
let classpath = classpath(root, model, &target, if test { "test" } else { "runtime" }, true)?;
let scope = if test { "test" } else { "runtime" };
let targets: Vec<&SingleFileTarget> = probes.iter().map(|p| &p.0).collect();
let classpaths = match classpaths(root, model, &targets, scope, true) {
Ok(classpaths) => classpaths,
// Another module's failure must not cost this launch its own probe.
Err(_) if targets.len() > 1 && !cancel.is_cancelled() => classpaths(root, model, &targets[..1], scope, true)?,
Err(e) => return Err(e),
};
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
if let (Some(fingerprint), Some(path)) = (fingerprint, cache_path) {
let cached = CachedClasspath { version: CLASSPATH_CACHE_VERSION, fingerprint, classpath: classpath.clone() };
if let Err(error) = cache_classpath(&path, &cached) {
tracing::debug!(path = %path.display(), %error, "Cannot cache the Java launch classpath");
for (Probe(_, fingerprint, cache_path), classpath) in probes.into_iter().zip(&classpaths) {
if let (Some(fingerprint), Some(path)) = (fingerprint, cache_path) {
let cached =
CachedClasspath { version: CLASSPATH_CACHE_VERSION, fingerprint, classpath: classpath.clone() };
if let Err(error) = cache_classpath(&path, &cached) {
tracing::debug!(path = %path.display(), %error, "Cannot cache the Java launch classpath");
}
}
}
Ok(classpath)
Ok(classpaths.into_iter().next().unwrap())
}
/// A module whose classpath the Maven probe resolves, with its cache key and file.
struct Probe(SingleFileTarget, Option<LaunchFingerprint>, Option<PathBuf>);
/// One cache file per module and scope. Mirroring the module path keeps nested
/// modules and their different dependency scopes from overwriting each other.
fn classpath_cache_path(root: &Path, cache: &Path, module: &Path, test: bool) -> Option<PathBuf> {
@@ -195,6 +237,62 @@ fn classpath(
scope: &str,
compile_first: bool,
) -> IdeResult<String> {
Ok(classpaths(root, model, &[target], scope, compile_first)?.pop().unwrap())
}
/// The classpath of each of `targets` (modules of one reactor) from one Maven probe.
fn classpaths(
root: &Path,
model: &BuildModel,
targets: &[&SingleFileTarget],
scope: &str,
compile_first: bool,
) -> IdeResult<Vec<String>> {
let top = &targets[0].top;
let probe = CP_FILE;
let mut args = vec!["-B", "-Dstyle.color=never", maven::LOCAL_REPO_TRACKING_ARG];
args.extend(top.options.iter().map(String::as_str));
// The reactor root among them builds every module.
let selection = if targets.iter().any(|t| t.pl.is_empty()) {
String::new()
} else {
let mut pl: Vec<&str> = targets.iter().map(|t| t.pl.as_str()).collect();
pl.sort();
pl.dedup();
pl.join(",")
};
if !selection.is_empty() {
args.extend(["-pl", selection.as_str(), "-am"]);
}
let output_arg = format!("-Dmdep.outputFile={probe}");
let scope_arg = format!("-Dmdep.includeScope={scope}");
// A launch build may only have reached `compile`. Running `compile` in this
// same Maven session lets the dependency plugin resolve Reactor siblings from
// their target/classes without paying for package-phase plugins.
if compile_first {
args.push("compile");
}
args.extend(["dependency:build-classpath", output_arg.as_str(), scope_arg.as_str(), "-q"]);
let top_dir = subdir(root, &top.dir);
let mut command = ProcCommand::new(&top.command);
command.args(&args).envs(&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() {
let stdout = String::from_utf8_lossy(&status.stdout);
let stderr = String::from_utf8_lossy(&status.stderr);
// Maven reports reactor/dependency failures on stdout, not only stderr.
let tail: Vec<&str> = stdout.lines().chain(stderr.lines()).filter(|l| !l.trim().is_empty()).collect();
let tail = tail.iter().rev().take(5).rev().cloned().collect::<Vec<_>>().join("\n");
return Err(IdeError::internal(format!("cannot resolve the compile classpath:\n{tail}")));
}
targets.iter().map(|target| target_classpath(root, model, target)).collect()
}
/// The classpath of `target` after a probe: its reactor class directories, then
/// the dependencies Maven wrote to the module's probe file.
fn target_classpath(root: &Path, model: &BuildModel, target: &SingleFileTarget) -> IdeResult<String> {
let mut entries: Vec<String> = Vec::new();
// The module's own classes first: the file almost always uses classes next to it.
let own: &[&str] = if target.test { &["target/test-classes", "target/classes"] } else { &["target/classes"] };
@@ -220,37 +318,8 @@ fn classpath(
}
}
}
let probe = CP_FILE;
let mut args = vec!["-B", "-Dstyle.color=never", maven::LOCAL_REPO_TRACKING_ARG];
args.extend(target.top.options.iter().map(String::as_str));
if !target.pl.is_empty() {
args.extend(["-pl", target.pl.as_str(), "-am"]);
}
let output_arg = format!("-Dmdep.outputFile={probe}");
let scope_arg = format!("-Dmdep.includeScope={scope}");
// A launch build may only have reached `compile`. Running `compile` in this
// same Maven session lets the dependency plugin resolve Reactor siblings from
// their target/classes without paying for package-phase plugins.
if compile_first {
args.push("compile");
}
args.extend(["dependency:build-classpath", output_arg.as_str(), scope_arg.as_str(), "-q"]);
let top_dir = subdir(root, &target.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() {
let stdout = String::from_utf8_lossy(&status.stdout);
let stderr = String::from_utf8_lossy(&status.stderr);
// Maven reports reactor/dependency failures on stdout, not only stderr.
let tail: Vec<&str> = stdout.lines().chain(stderr.lines()).filter(|l| !l.trim().is_empty()).collect();
let tail = tail.iter().rev().take(5).rev().cloned().collect::<Vec<_>>().join("\n");
return Err(IdeError::internal(format!("cannot resolve the compile classpath:\n{tail}")));
}
// With `-am` every visited module writes its own file; only this module's counts.
let cp_file = target.module.join(probe);
let cp_file = target.module.join(CP_FILE);
let content = fs::read_to_string(&cp_file).map_err(|e| {
IdeError::internal(format!("cannot resolve the compile classpath: {} ({e})", cp_file.display()))
})?;
@@ -528,6 +597,47 @@ mod tests {
assert!(args.lines().any(|a| a == "-Dmdep.includeScope=test"), "{args}");
}
/// Modules launched together resolve their classpaths in one Maven probe and leave
/// the others' cached; a probe another module breaks still resolves the first one.
#[cfg(unix)]
#[test]
fn launch_modules_share_one_classpath_probe() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
fixture(root);
write(root, "lib/src/main/java/demo/Lib.java", "class Lib {}");
let script = root.join("mvnw");
fs::write(
&script,
"#!/bin/sh\necho \"$@\" >> calls.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\ncase \"$pl\" in *lib*) [ -f lib/broken ] && exit 1;; esac\nfor m in $(echo \"$pl\" | tr ',' ' '); do mkdir -p \"$m/target\" repo; touch \"repo/$m.jar\"; printf \"$PWD/repo/$m.jar\" > \"$m/target/ide-compile-cp.txt\"; done\n",
)
.unwrap();
fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
let model = crate::load(root, &root.join("cache"), None);
let cache = root.join("cache");
let cancel = CancellationToken::new();
let calls = || fs::read_to_string(root.join("calls.txt")).unwrap_or_default().lines().count();
let modules = [root.join("app"), root.join("lib"), root.join("app")];
let app = module_classpaths(root, &model, &modules, false, None, &cache, &cancel).unwrap();
assert!(app.contains("/repo/app.jar") && !app.contains("repo/lib.jar"), "{app}");
assert_eq!(calls(), 1);
assert!(fs::read_to_string(root.join("calls.txt")).unwrap().contains("-pl app,lib -am compile"));
let lib = module_classpath(root, &model, &root.join("lib"), false, None, &cache, &cancel).unwrap();
assert!(lib.contains("/repo/lib.jar"), "{lib}");
assert_eq!(calls(), 1, "lib's classpath came from the shared probe");
// A probe another module breaks is retried for the first module alone.
write(root, "lib/src/main/java/demo/Lib.java", "class Lib { int changed; }");
write(root, "lib/broken", "");
let app = module_classpaths(root, &model, &[root.join("app"), root.join("lib")], false, None, &cache, &cancel)
.unwrap();
assert!(app.contains("/repo/app.jar"), "{app}");
assert_eq!(calls(), 3, "the shared probe failed, then app was probed alone");
// The first module's own failure stays its failure.
assert!(module_classpath(root, &model, &root.join("lib"), false, None, &cache, &cancel).is_err());
}
/// The launch classpath follows the Maven runner JDK and is reused until that
/// build input changes; the probe does not run packaging plugins.
#[cfg(unix)]
+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
+43 -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")]
@@ -273,6 +288,8 @@ pub struct SmartKeysSettings {
pub pair_quotes: bool,
pub surround_selection: bool,
pub tab_out_of_pair: bool,
/// A `;` typed before the closing `)` of a statement goes to the end of the statement.
pub semicolon_at_statement_end: bool,
/// Simultaneous `<tag></tag>` editing: renaming a tag renames its matching tag.
pub simultaneous_tag_editing: bool,
/// Reformat on paste: `none` | `indentBlock` | `indentEachLine`.
@@ -294,6 +311,7 @@ impl Default for SmartKeysSettings {
pair_quotes: true,
surround_selection: true,
tab_out_of_pair: true,
semicolon_at_statement_end: true,
simultaneous_tag_editing: true,
reformat_on_paste: "indentEachLine".into(),
escape_on_paste: true,
@@ -420,6 +438,9 @@ pub struct TextAttributesOverride {
pub effect: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub effect_color: Option<String>,
/// IDEA's `ERROR_STRIPE_COLOR`: the diff overview-lane marker of a change type.
#[serde(skip_serializing_if = "Option::is_none")]
pub error_stripe_color: Option<String>,
}
/// Editor › Code Style › <Language> › Tabs and Indents (unset fields inherit).
@@ -543,3 +564,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
Переглянути файл
@@ -92,10 +92,18 @@ pub enum IdeEvent {
/// 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 {
id: u32,
paths: Vec<crate::IpcPath>,
/// Files the edit renamed, as the edit named them: editors open on them follow.
moves: Vec<crate::FileMove>,
/// Made by an agent through the MCP server's tools: undoable like a refactoring, but
/// not announced as one.
by_agent: bool,
+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);
}
}
+29
Переглянути файл
@@ -72,6 +72,16 @@ impl WindowButtonLayout {
let right = side(parts.next());
(!left.is_empty() || !right.is_empty()).then_some(Self { left, right })
}
/// The layout on Linux: the desktop's `gtk-decoration-layout` when a desktop session is running.
/// Without one (WSLg, a bare compositor) GTK reports its built-in fallback, close only, which
/// leaves no way to minimise or maximise the frameless window, so the default applies.
pub fn for_linux(gtk_layout: Option<&str>, var: impl Fn(&str) -> Option<String>) -> Self {
let desktop = ["XDG_CURRENT_DESKTOP", "XDG_SESSION_DESKTOP", "DESKTOP_SESSION"]
.iter()
.any(|key| var(key).is_some_and(|value| !value.trim().is_empty()));
gtk_layout.filter(|_| desktop).and_then(Self::from_gtk_decoration_layout).unwrap_or_default()
}
}
#[cfg(test)]
@@ -118,6 +128,25 @@ mod tests {
}
}
#[test]
fn linux_layout_needs_a_desktop_session() {
let env = |vars: &'static [(&'static str, &'static str)]| {
move |key: &str| vars.iter().find(|(k, _)| *k == key).map(|(_, v)| v.to_string())
};
let gnome = env(&[("XDG_CURRENT_DESKTOP", "ubuntu:GNOME")]);
assert_eq!(WindowButtonLayout::for_linux(Some("appmenu:close"), gnome), layout(&[], &[Close]).unwrap());
let kde = env(&[("DESKTOP_SESSION", "plasma")]);
assert_eq!(
WindowButtonLayout::for_linux(Some("close,maximize,minimize:icon"), kde),
layout(&[Close, Maximize, Minimize], &[]).unwrap()
);
// WSLg: no desktop session, GTK's fallback layout.
let wslg = env(&[("WAYLAND_DISPLAY", "wayland-0"), ("XDG_CURRENT_DESKTOP", " ")]);
assert_eq!(WindowButtonLayout::for_linux(Some("menu:close"), wslg), WindowButtonLayout::default());
let gnome = env(&[("XDG_SESSION_DESKTOP", "gnome")]);
assert_eq!(WindowButtonLayout::for_linux(None, gnome), WindowButtonLayout::default());
}
#[test]
fn default_layout_is_on_the_right() {
assert_eq!(WindowButtonLayout::default(), layout(&[], &[Minimize, Maximize, Close]).unwrap());
+77 -16
Переглянути файл
@@ -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,
@@ -140,6 +130,11 @@ pub struct AgentSettings {
#[serde(deserialize_with = "or_default")]
#[specta(type = BTreeMap<String, AgentMcpServer>)]
pub mcp_servers: BTreeMap<String, AgentMcpServer>,
/// How agent skills may run, keyed by skill name (`[agents.skills.<name>]`); `SKILL.md`
/// files on disk are never modified.
#[serde(deserialize_with = "or_default")]
#[specta(type = BTreeMap<String, AgentSkillPolicy>)]
pub skills: BTreeMap<String, AgentSkillPolicy>,
}
impl Default for AgentSettings {
@@ -152,9 +147,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,
@@ -163,6 +155,7 @@ impl Default for AgentSettings {
new_task_approvals: NewTaskApprovals::Bypass,
defaults: BTreeMap::new(),
mcp_servers: BTreeMap::new(),
skills: BTreeMap::new(),
}
}
}
@@ -218,6 +211,34 @@ impl Default for AgentMcpServer {
}
}
/// How an agent skill may run (`[agents.skills.<name>] mode = …`).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AgentSkillMode {
/// The model decides when to use it.
#[default]
Auto,
/// Only when the user invokes it with `/name`.
SlashOnly,
/// Never.
Off,
}
/// A skill's policy in Settings › Agents › Skills, stored without touching its `SKILL.md`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct AgentSkillPolicy {
#[serde(deserialize_with = "or_default")]
#[specta(type = AgentSkillMode)]
pub mode: AgentSkillMode,
}
impl Default for AgentSkillPolicy {
fn default() -> Self {
Self { mode: AgentSkillMode::Auto }
}
}
/// A hand-edited value these settings don't know reads as the default, rather than
/// failing the whole settings file.
fn or_default<'de, D, T>(d: D) -> Result<T, D::Error>
@@ -1185,6 +1206,7 @@ pub struct LanguagesSettings {
pub typescript: TypeScriptSettings,
pub prettier: ExternalFormatterSettings,
pub oxfmt: ExternalFormatterSettings,
pub biome: ExternalFormatterSettings,
pub ruff: ExternalFormatterSettings,
pub java: JavaSettings,
pub ruby: RubySettings,
@@ -1205,6 +1227,10 @@ impl Default for LanguagesSettings {
typescript: TypeScriptSettings::default(),
prettier: ExternalFormatterSettings::default(),
oxfmt: ExternalFormatterSettings::default(),
biome: ExternalFormatterSettings {
languages: BIOME_LANGUAGES.iter().map(|&l| l.into()).collect(),
..ExternalFormatterSettings::default()
},
ruff: ExternalFormatterSettings {
languages: vec!["python".into()],
..ExternalFormatterSettings::default()
@@ -1233,6 +1259,7 @@ pub struct ArduinoSettings {
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct MarkdownSettings {
pub preview_layout: MarkdownPreviewLayout,
/// Preview (and notebook Markdown cell) font size in px; unset follows the editor font size.
pub preview_font_size: Option<u32>,
/// "Detect commands that can be run right from Markdown files": gutter run icons on
@@ -1244,10 +1271,23 @@ pub struct MarkdownSettings {
impl Default for MarkdownSettings {
fn default() -> Self {
Self { preview_font_size: None, run_commands: true, command_directory: None }
Self {
preview_layout: MarkdownPreviewLayout::default(),
preview_font_size: None,
run_commands: true,
command_directory: None,
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum MarkdownPreviewLayout {
#[default]
SideBySide,
Stacked,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "lowercase")]
pub enum MarkdownCommandDirectory {
@@ -1262,6 +1302,7 @@ impl LanguagesSettings {
match tool {
ExternalFormatter::Prettier => &self.prettier,
ExternalFormatter::Oxfmt => &self.oxfmt,
ExternalFormatter::Biome => &self.biome,
ExternalFormatter::Ruff => &self.ruff,
}
}
@@ -1273,6 +1314,7 @@ impl LanguagesSettings {
pub enum ExternalFormatter {
Prettier,
Oxfmt,
Biome,
Ruff,
}
@@ -1282,16 +1324,21 @@ impl ExternalFormatter {
match self {
Self::Prettier => "prettier",
Self::Oxfmt => "oxfmt",
Self::Biome => "biome",
Self::Ruff => "ruff",
}
}
}
/// An external formatter (Prettier, oxfmt, Ruff) and the languages it formats.
/// The languages Biome formats (of those Prettier formats).
pub const BIOME_LANGUAGES: [&str; 8] =
["css", "graphql", "javascript", "javascriptreact", "typescript", "typescriptreact", "json", "jsonc"];
/// An external formatter (Prettier, oxfmt, Biome, Ruff) and the languages it formats.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct ExternalFormatterSettings {
/// Empty path: project node_modules (Prettier/oxfmt), managed installation, then PATH.
/// Empty path: project node_modules (Prettier/oxfmt/Biome), managed installation, then PATH.
pub path: String,
/// Ruff only: directory containing its configuration, or a configuration file.
pub configuration_directory: String,
@@ -1868,6 +1915,20 @@ mod tests {
}
}
#[test]
fn markdown_preview_layout_defaults_and_round_trips() {
let old: Settings = serde_json::from_str(r#"{"languages":{"markdown":{"previewFontSize":16}}}"#).unwrap();
assert_eq!(old.languages.markdown.preview_layout, MarkdownPreviewLayout::SideBySide);
assert_eq!(old.languages.markdown.preview_font_size, Some(16));
let stacked: Settings =
serde_json::from_str(r#"{"languages":{"markdown":{"previewLayout":"stacked"}}}"#).unwrap();
assert_eq!(stacked.languages.markdown.preview_layout, MarkdownPreviewLayout::Stacked);
let saved = serde_json::to_value(&stacked).unwrap();
assert_eq!(saved["languages"]["markdown"]["previewLayout"], "stacked");
assert_eq!(serde_json::from_value::<Settings>(saved).unwrap().languages.markdown, stacked.languages.markdown);
}
#[test]
fn cmake_profile_argument_arrays_round_trip() {
let mut settings = Settings::default();
+19
Переглянути файл
@@ -110,6 +110,17 @@ pub struct WorkspaceEditPrecondition {
}
impl WorkspaceEdit {
/// The files and folders the edit renames, in order.
pub fn moves(&self) -> Vec<FileMove> {
self.files
.iter()
.filter_map(|f| match f {
FileEdit::Rename { from, to } => Some(FileMove { from: from.clone(), to: to.clone() }),
_ => None,
})
.collect()
}
/// Coalesces aliases of the same file before applying edits against its original text.
/// Resource operations separate batches because later edits may use the new contents.
pub fn deduplicate(&mut self) {
@@ -184,6 +195,14 @@ pub enum FileEdit {
},
}
/// One file or folder move.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct FileMove {
pub from: crate::IpcPath,
pub to: crate::IpcPath,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum Severity {
+24
Переглянути файл
@@ -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,
@@ -145,6 +151,7 @@ pub struct CommitSettings {
/// Commit from the Commit tool window; off = Local Changes in the Git tool
/// window and a Commit dialog.
pub non_modal: bool,
pub include_changes_by_default: bool,
/// Start with an empty message instead of the last one / the changelist's.
pub clear_initial_message: bool,
pub analyze_code: bool,
@@ -176,12 +183,15 @@ 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 {
fn default() -> Self {
Self {
non_modal: true,
include_changes_by_default: true,
clear_initial_message: false,
analyze_code: true,
check_todo: true,
@@ -201,6 +211,7 @@ impl Default for CommitSettings {
agent: String::new(),
agent_model: String::new(),
agent_effort: String::new(),
agent_button: true,
}
}
}
@@ -606,3 +617,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);
}
}
+13 -6
Переглянути файл
@@ -49,6 +49,8 @@ pub struct AdapterSpec {
pub connect: Option<String>,
/// A plugin language's adapter: start exactly this approved program.
pub pinned: Option<ProgramPin>,
/// See [`DebuggerConfig::resolve_lazy_variables`].
pub resolve_lazy_variables: bool,
}
/// Built-in adapters used when no language definition names `adapter`.
@@ -60,6 +62,7 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
transport: transport.to_owned(),
connect: None,
install_hint: Some(hint.to_owned()),
resolve_lazy_variables: false,
pinned: None,
};
Some(match adapter {
@@ -130,12 +133,15 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
),
"rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
// A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
"java-debug" => cfg(
"com.microsoft.java.debug.plugin.jar",
&[],
"tcp",
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
),
"java-debug" => DebuggerConfig {
resolve_lazy_variables: true,
..cfg(
"com.microsoft.java.debug.plugin.jar",
&[],
"tcp",
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
)
},
// The Java language server's own debugger, for modules jdtls doesn't serve; the host
// runs the executable of the java-analyzer serving the module.
JAVA_ANALYZER => cfg(
@@ -186,6 +192,7 @@ pub fn resolve(config: &DebuggerConfig, cwd: PathBuf) -> AdapterSpec {
server_host: None,
connect: config.connect.clone(),
pinned: config.pinned.clone(),
resolve_lazy_variables: config.resolve_lazy_variables,
}
}
+90
Переглянути файл
@@ -0,0 +1,90 @@
//! Exception breakpoints on a chosen class. The manager keeps one list; a session given a backend
//! for them at start arms it before `configurationDone`, so a throw in the program's first line
//! stops, and again after each `setExceptionBreakpoints`, which drops them in java-debug.
use crate::session::Session;
use crate::{DebugManager, jvm_memory};
use ide_jvm_inspect::ExceptionClassSpec;
use serde::{Deserialize, Serialize};
use specta::Type;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct ExceptionClassBreakpoint {
pub id: String,
/// Fully qualified binary name (`com.acme.Outer$Inner`); its subclasses stop too.
pub class_name: String,
pub caught: bool,
pub uncaught: bool,
pub enabled: bool,
/// Patterns (`com.acme.*`, `*Test`, a full name) for the class whose code throws.
pub class_filters: Vec<String>,
pub class_exclusion_filters: Vec<String>,
}
/// What a session's exception class breakpoints can do.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct ExceptionClassSupport {
/// Whose class names the session takes: `java`.
pub family: String,
pub condition: bool,
pub class_filters: bool,
/// Filters on the class whose code catches the exception.
pub catch_filters: bool,
}
/// The JVM backends stop through java-debug's own exception events, which a condition or a
/// catch-location filter cannot veto.
pub(crate) fn support(s: &Session) -> Option<ExceptionClassSupport> {
s.exception_classes.is_some().then(|| ExceptionClassSupport {
family: "java".into(),
condition: false,
class_filters: true,
catch_filters: false,
})
}
fn spec(b: &ExceptionClassBreakpoint) -> ExceptionClassSpec {
ExceptionClassSpec {
id: b.id.clone(),
class_name: b.class_name.clone(),
caught: b.caught,
uncaught: b.uncaught,
enabled: b.enabled,
class_filters: b.class_filters.clone(),
class_exclusion_filters: b.class_exclusion_filters.clone(),
}
}
impl DebugManager {
/// Arms the manager's list in `s`; the caller holds `s.exception_turn`. `clear`: also when the
/// list is empty, to take down what an earlier list armed.
pub(crate) async fn arm_exception_classes(&self, s: &Session, clear: bool) {
let Some(backend) = &s.exception_classes else { return };
let specs: Vec<_> = self.exception_classes.lock().iter().map(spec).collect();
// Without either, no VM is known yet: `configure` arms once it is.
let target = jvm_memory::vm_target(s);
if (specs.is_empty() && !clear) || (target.pid.is_none() && target.attach_port.is_none()) {
return;
}
match backend.set(&target, &specs).await {
Ok(states) => tracing::debug!("exception class breakpoints of session {}: {states:?}", s.id.0),
Err(e) => tracing::debug!("exception class breakpoints of session {} failed: {e}", s.id.0),
}
}
/// Stores exception breakpoints on chosen classes (kept without a session, armed on start)
/// and arms them in every session that takes them. Also in one still starting: one that has
/// armed already would miss the list, and one that has not answers `vmNotFound` until then.
pub async fn set_exception_class_breakpoints(&self, list: Vec<ExceptionClassBreakpoint>) {
*self.exception_classes.lock() = list;
for s in self.live_sessions() {
if s.exception_classes.is_none() || s.conn.is_closed() {
continue;
}
let _turn = s.exception_turn.lock().await;
self.arm_exception_classes(&s, true).await;
}
}
}
+1
Переглянути файл
@@ -102,6 +102,7 @@ pub(crate) fn bare_session_of(name: &str, request: &str) -> BareSession {
server_host: None,
connect: None,
pinned: None,
resolve_lazy_variables: false,
};
let session = Session::new(
DebugSessionId(1),
+109 -19
Переглянути файл
@@ -12,6 +12,7 @@ pub mod adapter;
pub mod attach;
mod cargo;
pub mod connection;
mod exception_classes;
pub mod jdwp;
mod js_cdp;
mod js_debug;
@@ -24,6 +25,7 @@ pub mod unity;
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
use connection::{Connection, DapError};
pub use exception_classes::{ExceptionClassBreakpoint, ExceptionClassSupport};
use futures::future::join_all;
use ide_core::{DebugSessionId, IdeError, IdeResult, SharedSink};
use ide_language::LanguageRegistry;
@@ -236,6 +238,11 @@ pub struct Variable {
/// > 0 when expandable.
pub variables_reference: i64,
pub evaluate_name: Option<String>,
/// `value` is not computed yet (DAP `presentationHint.lazy`): the single variable that
/// `variables` returns for `variables_reference` holds the value and its children.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
#[specta(optional)]
pub lazy: bool,
}
/// A completion the adapter offers for an expression (DAP `completions`).
@@ -278,6 +285,8 @@ pub struct SessionExceptionFilters {
pub session: DebugSessionId,
pub adapter: String,
pub filters: Vec<ExceptionFilter>,
/// Set when the session takes exception breakpoints on a chosen class.
pub classes: Option<ExceptionClassSupport>,
}
/// What triggered a hot reload; `flutter debug_adapter` takes it as `reason`.
@@ -331,6 +340,7 @@ pub struct DebugManager {
states: Mutex<HashMap<PathBuf, Vec<BreakpointState>>>,
/// Explicit exception filter choices (filter id → enabled); unset filters use the adapter default.
exception_choices: Mutex<BTreeMap<String, bool>>,
exception_classes: Mutex<Vec<ExceptionClassBreakpoint>>,
function_breakpoints: Mutex<Vec<FunctionBreakpoint>>,
data_breakpoints: Mutex<Vec<DataBreakpoint>>,
/// In-flight stops, by session: a second Stop sets `stop_force`, the waiting one kills.
@@ -727,9 +737,46 @@ pub(crate) fn variable_from(v: &Value) -> Variable {
type_name: s("type").filter(|t| !t.is_empty()),
variables_reference: v.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
evaluate_name: s("evaluateName"),
lazy: v.pointer("/presentationHint/lazy").and_then(Value::as_bool).unwrap_or(false),
}
}
async fn session_variables(session: &Session, reference: i64) -> IdeResult<Vec<Variable>> {
let body =
session.conn.request_timeout("variables", json!({ "variablesReference": reference }), REQUEST_TIMEOUT).await?;
Ok(body
.get("variables")
.and_then(Value::as_array)
.map(|v| v.iter().map(variable_from).collect())
.unwrap_or_default())
}
async fn resolve_in(session: &Session, variable: Variable) -> IdeResult<Variable> {
if !variable.lazy || variable.variables_reference <= 0 {
return Ok(variable);
}
let mut inner = session_variables(session, variable.variables_reference).await?;
Ok(match (inner.pop(), inner.is_empty()) {
(Some(value), true) => Variable {
type_name: value.type_name.or(variable.type_name),
evaluate_name: variable.evaluate_name.or(value.evaluate_name),
name: variable.name,
value: value.value,
variables_reference: value.variables_reference,
lazy: value.lazy,
},
_ => variable,
})
}
/// A value that cannot be computed stays lazy, so the row can still be opened by hand.
async fn resolve_lazy(session: &Session, variable: Variable) -> Variable {
if !variable.lazy {
return variable;
}
resolve_in(session, variable.clone()).await.unwrap_or(variable)
}
impl DebugManager {
pub fn new(languages: Arc<LanguageRegistry>) -> Arc<Self> {
Self::with_launcher(languages, Arc::new(ProcessLauncher))
@@ -746,6 +793,7 @@ impl DebugManager {
breakpoints: Mutex::default(),
states: Mutex::default(),
exception_choices: Mutex::default(),
exception_classes: Mutex::default(),
function_breakpoints: Mutex::default(),
data_breakpoints: Mutex::default(),
stopping: Mutex::default(),
@@ -794,6 +842,18 @@ impl DebugManager {
config: LaunchConfig,
owner: SessionOwner,
custom_command: impl FnOnce(&str) -> Option<String>,
) -> IdeResult<DebugSessionId> {
self.start_with_exception_classes(config, owner, custom_command, None).await
}
/// [`start_with`](Self::start_with), the session arming [`Self::set_exception_class_breakpoints`]
/// through `exception_classes`.
pub async fn start_with_exception_classes(
&self,
config: LaunchConfig,
owner: SessionOwner,
custom_command: impl FnOnce(&str) -> Option<String>,
exception_classes: Option<Arc<dyn ide_jvm_inspect::ExceptionClassBreakpoints>>,
) -> IdeResult<DebugSessionId> {
let mut arguments = launch_arguments(&config)?;
// An IDE-side marker (never sent to the adapter): the session is a Flutter
@@ -935,7 +995,19 @@ impl DebugManager {
}
}
let port = debug_server.map(|s| s.port);
self.start_session(id, owner, config.name, config.adapter, None, config.request, arguments, spec, port).await
self.start_session(
id,
owner,
config.name,
config.adapter,
None,
config.request,
arguments,
spec,
port,
exception_classes,
)
.await
}
/// `startDebugging` reverse request: a child session on the same adapter.
@@ -960,6 +1032,7 @@ impl DebugManager {
configuration,
parent.spec.clone(),
parent.port,
None,
)
.await
.map(|_| ())
@@ -977,6 +1050,7 @@ impl DebugManager {
arguments: Value,
spec: AdapterSpec,
reuse_port: Option<u16>,
exception_classes: Option<Arc<dyn ide_jvm_inspect::ExceptionClassBreakpoints>>,
) -> IdeResult<DebugSessionId> {
if request != "launch" && request != "attach" {
return Err(IdeError::invalid(format!("request must be `launch` or `attach`, got `{request}`")));
@@ -991,8 +1065,9 @@ impl DebugManager {
let rdbg_pid = (adapter_name == "rdbg" && request == "launch")
.then(|| io.child.as_ref().and_then(tokio::process::Child::id))
.flatten();
let session =
Arc::new(Session::new(id, owner, name, adapter_name, parent, request, conn, spec, io.port, io.child));
let mut session = Session::new(id, owner, name, adapter_name, parent, request, conn, spec, io.port, io.child);
session.exception_classes = exception_classes;
let session = Arc::new(session);
if let Some(launch_type) = arguments.get("type").and_then(Value::as_str) {
let _ = session.launch_type.set(launch_type.to_owned());
}
@@ -1217,8 +1292,12 @@ impl DebugManager {
tracing::debug!("setDataBreakpoints failed: {e}");
}
let has_filters = s.caps.lock().get("exceptionBreakpointFilters").and_then(Value::as_array).is_some();
if has_filters {
let _ = self.send_exception_breakpoints(s).await;
{
let _turn = s.exception_turn.lock().await;
if has_filters {
let _ = self.send_exception_breakpoints(s).await;
}
self.arm_exception_classes(s, false).await;
}
if s.supports("supportsConfigurationDoneRequest") {
if s.adapter == kotlin::ADAPTER {
@@ -1439,6 +1518,7 @@ impl DebugManager {
session: s.id,
adapter: s.adapter.clone(),
filters: exception_filters_from(&s.caps.lock()),
classes: exception_classes::support(s),
})
.collect()
}
@@ -1454,9 +1534,11 @@ impl DebugManager {
if exception_filters_from(&s.caps.lock()).is_empty() {
continue;
}
let _turn = s.exception_turn.lock().await;
if let Err(e) = self.send_exception_breakpoints(&s).await {
tracing::debug!("setExceptionBreakpoints on session {} failed: {e}", s.id.0);
}
self.arm_exception_classes(&s, false).await;
}
Ok(())
}
@@ -1497,6 +1579,7 @@ impl DebugManager {
type_name: body.get("type").and_then(Value::as_str).filter(|t| !t.is_empty()).map(str::to_owned),
variables_reference: body.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
evaluate_name: evaluate_name.or(Some(name)),
lazy: false,
})
}
@@ -1567,16 +1650,18 @@ impl DebugManager {
}
pub async fn variables(&self, s: DebugSessionId, reference: i64) -> IdeResult<Vec<Variable>> {
let body = self
.session(s)?
.conn
.request_timeout("variables", json!({ "variablesReference": reference }), REQUEST_TIMEOUT)
.await?;
Ok(body
.get("variables")
.and_then(Value::as_array)
.map(|v| v.iter().map(variable_from).collect())
.unwrap_or_default())
let session = self.session(s)?;
let vars = session_variables(&session, reference).await?;
if !session.spec.resolve_lazy_variables {
return Ok(vars);
}
Ok(join_all(vars.into_iter().map(|v| resolve_lazy(&session, v))).await)
}
/// Computes a lazy variable's value (DAP `presentationHint.lazy`); any other variable, or one
/// whose value the adapter does not give as a single variable, comes back unchanged.
pub async fn resolve_variable(&self, s: DebugSessionId, variable: Variable) -> IdeResult<Variable> {
resolve_in(&*self.session(s)?, variable).await
}
/// Evaluates in the `repl` context.
@@ -1602,13 +1687,18 @@ impl DebugManager {
args["frameId"] = f.into();
}
let body = session.conn.request_timeout("evaluate", args, REQUEST_TIMEOUT).await?;
Ok(Variable {
let result = Variable {
name: expression.clone(),
value: body.get("result").and_then(Value::as_str).unwrap_or_default().to_owned(),
type_name: body.get("type").and_then(Value::as_str).filter(|t| !t.is_empty()).map(str::to_owned),
variables_reference: body.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
evaluate_name: Some(expression),
})
lazy: body.pointer("/presentationHint/lazy").and_then(Value::as_bool).unwrap_or(false),
};
if !session.spec.resolve_lazy_variables {
return Ok(result);
}
Ok(resolve_lazy(&session, result).await)
}
/// Completions for `text` at `line` / `column` (0-based, UTF-16) in the frame's scope; none
@@ -1713,7 +1803,7 @@ impl DebugManager {
// A step runs its thread; other threads stopped by their own events stay stopped.
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
Ok(())
}
@@ -1825,7 +1915,7 @@ impl DebugManager {
step_settled(&session, sent)?;
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
Ok(())
}
+7
Переглянути файл
@@ -118,6 +118,11 @@ pub(crate) struct Session {
pub kotlin_mirror: Mutex<Option<crate::kotlin::SourceMirror>>,
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
pub stream_tracer: parking_lot::Mutex<Option<Arc<dyn ide_jvm_inspect::StreamTracer>>>,
/// Given at start: the class breakpoints must be armed before `configurationDone`.
pub(crate) exception_classes: Option<Arc<dyn ide_jvm_inspect::ExceptionClassBreakpoints>>,
/// Held from `setExceptionBreakpoints`, which drops the class breakpoints, until they are
/// armed again, so that the last list armed is the manager's.
pub(crate) exception_turn: tokio::sync::Mutex<()>,
pub(crate) stream_trace: parking_lot::Mutex<Option<crate::stream_trace::ActiveTrace>>,
/// The last trace that finished, until the stop its records were read in ends.
pub(crate) stream_trace_done: parking_lot::Mutex<Option<crate::stream_trace::DoneTrace>>,
@@ -286,6 +291,8 @@ impl Session {
kotlin_mirror: Mutex::new(None),
jvm_memory: tokio::sync::Mutex::default(),
stream_tracer: parking_lot::Mutex::new(None),
exception_classes: None,
exception_turn: tokio::sync::Mutex::default(),
stream_trace: parking_lot::Mutex::new(None),
stream_trace_done: parking_lot::Mutex::new(None),
quirks: kotlin_lsp::Quirks::default(),
+72 -7
Переглянути файл
@@ -1,5 +1,6 @@
//! Protocol flow against an in-memory fake adapter.
mod exception_classes;
mod jvm_inspect;
mod stream_trace;
@@ -505,13 +506,29 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
"scopes" => {
ok!(msg, json!({"scopes": [{"name": "Locals", "variablesReference": 100, "expensive": false}]}))
}
"variables" => ok!(
msg,
json!({"variables": [
{"name": "x", "value": "1", "type": "int", "variablesReference": 0},
{"name": "req", "value": "{Req}", "type": "Req", "variablesReference": 101, "evaluateName": "req"},
]})
),
// 200 holds a lazy value (java-debug's toString(), js-debug's getters): asked for, its
// reference answers one nameless child with the value and the reference of its fields.
"variables" => match msg["arguments"]["variablesReference"].as_i64() {
Some(200) => ok!(
msg,
json!({"variables": [
{"name": "order", "value": "Order@7", "type": "Order", "variablesReference": 201,
"evaluateName": "order", "presentationHint": {"lazy": true}},
{"name": "n", "value": "2", "type": "int", "variablesReference": 0, "presentationHint": {"lazy": false}},
]})
),
Some(201) => ok!(
msg,
json!({"variables": [{"name": "", "value": "Order@7 \"Order(1)\"", "variablesReference": 202, "evaluateName": "order"}]})
),
_ => ok!(
msg,
json!({"variables": [
{"name": "x", "value": "1", "type": "int", "variablesReference": 0},
{"name": "req", "value": "{Req}", "type": "Req", "variablesReference": 101, "evaluateName": "req"},
]})
),
},
"evaluate" => ok!(msg, json!({"result": "42", "type": "int", "variablesReference": 0})),
"completions" => ok!(
msg,
@@ -2020,6 +2037,7 @@ fn godot_registry(port: u16, command: &str, args: &[&str]) -> Arc<LanguageRegist
transport: "tcp".into(),
connect: Some(format!("127.0.0.1:{port}")),
install_hint: Some("Open the project in the Godot editor".into()),
resolve_lazy_variables: false,
pinned: None,
}),
};
@@ -2763,6 +2781,53 @@ async fn step_of_one_thread_keeps_the_others_suspended() {
assert_eq!(session.suspended.ticket(), ticket + 1);
h.manager.step_in_target(id, 7, 1).await.unwrap();
assert!(!session.suspended.get());
// The UI stays on a thread that is still stopped only when told the step ran one thread.
for thread in [7, 8] {
let continued =
h.wait_event(|e| matches!(e, DebugEvent::Continued { thread_id, .. } if *thread_id == thread)).await;
assert!(matches!(continued, DebugEvent::Continued { all_threads_continued: false, .. }), "{continued:?}");
}
}
#[tokio::test]
async fn lazy_variables_are_resolved_when_the_adapter_declares_them_safe() {
let h = harness(Script::default());
let id = h.start(java_config("launch")).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
let vars = h.manager.variables(id, 200).await.unwrap();
let order = &vars[0];
assert_eq!(
(order.name.as_str(), order.value.as_str(), order.type_name.as_deref()),
("order", "Order@7 \"Order(1)\"", Some("Order"))
);
assert_eq!((order.variables_reference, order.lazy), (202, false));
assert_eq!(order.evaluate_name.as_deref(), Some("order"));
assert_eq!((vars[1].name.as_str(), vars[1].lazy), ("n", false));
}
#[tokio::test]
async fn lazy_variables_stay_lazy_for_other_adapters() {
let h = harness(Script::default());
let id = h.start(config()).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
let vars = h.manager.variables(id, 200).await.unwrap();
assert_eq!((vars[0].value.as_str(), vars[0].variables_reference, vars[0].lazy), ("Order@7", 201, true));
assert_eq!(requests(&h, "variables").len(), 1, "nothing is computed until asked for");
let order = h.manager.resolve_variable(id, vars[0].clone()).await.unwrap();
assert_eq!((order.name.as_str(), order.value.as_str()), ("order", "Order@7 \"Order(1)\""));
assert_eq!((order.variables_reference, order.lazy), (202, false));
let n = h.manager.resolve_variable(id, vars[1].clone()).await.unwrap();
assert_eq!((n.value.as_str(), requests(&h, "variables").len()), ("2", 2), "only lazy values are computed");
}
#[test]
fn java_debug_declares_its_lazy_variables_safe_to_resolve() {
let languages = LanguageRegistry::load(None).unwrap();
for registry in [&languages, &LanguageRegistry::from_configs(Vec::new())] {
assert!(adapter::find_config(registry, "java-debug").unwrap().resolve_lazy_variables);
assert!(!adapter::find_config(registry, "js-debug").unwrap().resolve_lazy_variables);
}
}
#[tokio::test]
+154
Переглянути файл
@@ -0,0 +1,154 @@
//! Exception breakpoints on a chosen class, armed through a session's backend.
use super::*;
use ide_jvm_inspect::{ExceptionArmState, ExceptionClassBreakpoints, ExceptionClassSpec, InspectFuture, VmTarget};
/// The target, the list, and the DAP requests sent before it.
type ArmCall = (VmTarget, Vec<ExceptionClassSpec>, Vec<String>);
/// Records each list it is given with the DAP requests sent before it.
struct FakeArmer {
log: Log,
calls: Mutex<Vec<ArmCall>>,
}
impl FakeArmer {
fn new(h: &Harness) -> Arc<Self> {
Arc::new(Self { log: h.log.clone(), calls: Mutex::default() })
}
fn lists(&self) -> Vec<Vec<String>> {
self.calls.lock().iter().map(|(_, specs, _)| specs.iter().map(|s| s.class_name.clone()).collect()).collect()
}
/// The DAP requests sent before each call.
fn before(&self) -> Vec<Vec<String>> {
self.calls.lock().iter().map(|(_, _, sent)| sent.clone()).collect()
}
}
impl ExceptionClassBreakpoints for FakeArmer {
fn set<'a>(
&'a self,
target: &'a VmTarget,
breakpoints: &'a [ExceptionClassSpec],
) -> InspectFuture<'a, Vec<(String, ExceptionArmState)>> {
let sent = self
.log
.lock()
.iter()
.filter(|m| m["type"] == "request")
.map(|m| m["command"].as_str().unwrap().to_owned())
.collect();
self.calls.lock().push((target.clone(), breakpoints.to_vec(), sent));
let states = breakpoints.iter().map(|b| (b.id.clone(), ExceptionArmState::Armed)).collect();
Box::pin(async move { Ok(states) })
}
}
fn class_bp(id: &str, class_name: &str) -> ExceptionClassBreakpoint {
ExceptionClassBreakpoint {
id: id.into(),
class_name: class_name.into(),
caught: true,
uncaught: true,
enabled: true,
class_filters: vec![],
class_exclusion_filters: vec![],
}
}
/// A java-debug attach to a JVM on another machine: the target is known from the request alone.
fn attach() -> LaunchConfig {
LaunchConfig {
extra_json: Some(json!({"hostName": "10.0.0.5", "port": 5005}).to_string()),
..java_config("attach")
}
}
async fn start(h: &Harness, config: LaunchConfig, armer: &Arc<FakeArmer>) -> DebugSessionId {
let backend: Arc<dyn ExceptionClassBreakpoints> = armer.clone();
h.manager.start_with_exception_classes(config, h.owner.clone(), |_| None, Some(backend)).await.unwrap()
}
#[tokio::test]
async fn armed_after_the_exception_filters_and_before_configuration_done() {
let h = harness(Script::default());
let armer = FakeArmer::new(&h);
let filtered = ExceptionClassBreakpoint {
caught: false,
enabled: false,
class_filters: vec!["com.acme.*".into()],
class_exclusion_filters: vec!["*Test".into()],
..class_bp("b", "com.acme.Boom")
};
h.manager.set_exception_class_breakpoints(vec![class_bp("a", "java.lang.IllegalStateException"), filtered]).await;
start(&h, attach(), &armer).await;
assert_eq!(armer.before(), [["initialize", "attach", "setExceptionBreakpoints"]]);
let (target, specs, _) = armer.calls.lock()[0].clone();
assert_eq!((target.pid, target.attach_host.as_deref(), target.attach_port), (None, Some("10.0.0.5"), Some(5005)));
assert_eq!(
specs[1],
ExceptionClassSpec {
id: "b".into(),
class_name: "com.acme.Boom".into(),
caught: false,
uncaught: true,
enabled: false,
class_filters: vec!["com.acme.*".into()],
class_exclusion_filters: vec!["*Test".into()],
}
);
assert!(h.commands().contains(&"configurationDone".to_owned()));
}
#[tokio::test]
async fn armed_again_after_every_set_exception_breakpoints() {
let h = harness(Script::default());
let armer = FakeArmer::new(&h);
h.manager.set_exception_class_breakpoints(vec![class_bp("a", "com.acme.Boom")]).await;
start(&h, attach(), &armer).await;
h.manager.set_exception_breakpoints(BTreeMap::from([("raised".into(), true)])).await.unwrap();
assert_eq!(armer.lists(), [["com.acme.Boom"], ["com.acme.Boom"]]);
let last = armer.before().pop().unwrap();
assert_eq!(last.iter().filter(|c| *c == "setExceptionBreakpoints").count(), 2, "{last:?}");
}
#[tokio::test]
async fn a_new_list_reaches_the_sessions_that_take_it() {
let h = harness(Script::default());
let armer = FakeArmer::new(&h);
start(&h, attach(), &armer).await;
let other = h.start(attach()).await.unwrap();
assert!(armer.lists().is_empty(), "nothing to arm at start");
h.manager.set_exception_class_breakpoints(vec![class_bp("a", "com.acme.Boom")]).await;
h.manager.set_exception_class_breakpoints(vec![]).await;
assert_eq!(armer.lists(), [vec!["com.acme.Boom".to_owned()], vec![]], "an empty list takes them down");
let filters = h.manager.exception_filters(None);
let support = |id| filters.iter().find(|f| f.session == id).unwrap().classes.clone();
assert_eq!(support(other), None);
let java = filters.iter().find(|f| f.session != other).unwrap().session;
assert_eq!(
support(java),
Some(ExceptionClassSupport {
family: "java".into(),
condition: false,
class_filters: true,
catch_filters: false
})
);
}
#[tokio::test]
async fn nothing_is_sent_before_the_jvm_is_known() {
let h = harness(Script::default());
let armer = FakeArmer::new(&h);
h.manager.set_exception_class_breakpoints(vec![class_bp("a", "com.acme.Boom")]).await;
// The fake adapter sends no `process` event before `configurationDone`: no pid to name.
start(&h, java_config("launch"), &armer).await;
assert!(armer.lists().is_empty());
}
+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",
+111 -4
Переглянути файл
@@ -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;
@@ -21,6 +22,9 @@ const LIMIT: usize = 16 * 1024 * 1024;
pub struct DbJdbcDriver {
pub id: String,
pub name: String,
/// Data source preset id; absent for a generic JDBC profile.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub vendor: Option<String>,
pub jars: Vec<String>,
pub class_name: String,
pub url_template: String,
@@ -145,7 +149,7 @@ impl DbManager {
fn jdbc_approval(&self, source: &DataSource) -> IdeResult<(PathBuf, String)> {
let registry = self.jdbc_registry()?;
let key = serde_json::to_vec(&(&self.root, &source.id)).map_err(|e| IdeError::internal(e.to_string()))?;
let settings = serde_json::to_vec(&(
let mut settings = serde_json::to_vec(&(
&source.jdbc_driver,
&source.url,
&source.user,
@@ -154,6 +158,9 @@ impl DbManager {
&source.options,
))
.map_err(|e| IdeError::internal(e.to_string()))?;
if self.jdbc_password_isolated(source) {
settings.extend_from_slice(b"\0jdbc-password");
}
Ok((
registry.with_file_name("jdbc-approvals").join(blake3::hash(&key).to_hex().as_str()),
blake3::hash(&settings).to_hex().to_string(),
@@ -194,6 +201,9 @@ impl DbManager {
.into_iter()
.find(|d| d.id == source.jdbc_driver)
.ok_or_else(|| IdeError::invalid("Select an installed JDBC driver profile"))?;
if !source.vendor.is_empty() && driver.vendor.as_deref() != Some(source.vendor.as_str()) {
return Err(IdeError::invalid("The JDBC driver profile is not associated with this data source type"));
}
JdbcPool::connect(source, password, driver, self.jdbc_registry()?.with_file_name("jdbc"))
.await
.map(Box::new)
@@ -302,7 +312,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 +470,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 +612,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 +662,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']);
+161 -22
Переглянути файл
@@ -25,8 +25,8 @@ pub use conn::{Held, Pool, QueryResult, ResultColumn};
pub use history::HistoryEntry;
pub use plan::{PlanNode, PlanProperty};
pub use source::{
DataSource, DbColor, DbDriver, DbIntrospection, DbOptions, DbProperty, DbSnowflake, DbSnowflakeAuth, DbSsh,
DbSshAuth, DbSslMode, DbTxMode,
DataSource, DbColor, DbDriver, DbIntrospection, DbOptions, DbProperty, DbSchemaSelection, DbSnowflake,
DbSnowflakeAuth, DbSsh, DbSshAuth, DbSslMode, DbTxMode, DbVisibilityChange,
};
pub use sql::{CellValue, DbRowEdit, SortKey};
@@ -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);
}
}
});
@@ -475,6 +475,29 @@ impl DbManager {
}
}
fn non_password_snowflake(source: &DataSource) -> Option<DbSnowflake> {
let settings = match source.driver {
DbDriver::Snowflake => source.resolved().map(|source| source.snowflake()).unwrap_or_default(),
DbDriver::Jdbc => source.snowflake.clone()?,
_ => return None,
};
(settings.auth != DbSnowflakeAuth::Password).then_some(settings)
}
fn jdbc_password_isolated(&self, source: &DataSource) -> bool {
source.driver == DbDriver::Jdbc
&& (Self::non_password_snowflake(source).is_some()
|| self
.sources()
.unwrap_or_default()
.iter()
.any(|stored| stored.id == source.id && Self::non_password_snowflake(stored).is_some()))
}
fn password_key(&self, source: &DataSource) -> String {
if self.jdbc_password_isolated(source) { secrets::jdbc_key(&source.id) } else { source.id.clone() }
}
/// The connection settings of target `target` ([`DataSource::resolved`]), with
/// its database for `<id>:<database>`.
pub fn source(&self, target: &str) -> IdeResult<DataSource> {
@@ -495,15 +518,21 @@ impl DbManager {
Ok(source)
}
/// Saves the data source list; connections of removed or changed sources are closed.
/// Saves the data source list, preserving connections when only visibility rules change.
/// Global ones (`global`) go to the app-wide list, the others to the project's.
pub async fn save_sources(&self, sources: Vec<DataSource>) -> IdeResult<()> {
pub async fn save_sources(&self, mut sources: Vec<DataSource>) -> IdeResult<()> {
if sources.iter().any(|s| s.global && s.plugin_owner.is_some()) {
return Err(IdeError::invalid("plugin-owned data sources must stay project-scoped"));
}
let old = {
let _guard = plugin::EDIT.lock();
let old = self.sources().unwrap_or_default();
for source in sources.iter_mut().filter(|s| s.driver == DbDriver::Jdbc) {
// Retain the credential scope even when URL-only settings supplied the old authenticator.
if let Some(settings) = old.iter().find(|s| s.id == source.id).and_then(Self::non_password_snowflake) {
source.snowflake = Some(settings);
}
}
let (global, project): (Vec<_>, Vec<_>) = sources.iter().cloned().partition(|s| s.global);
match &self.global {
// Rewritten only when it changes: other projects' windows edit the same file.
@@ -522,9 +551,10 @@ impl DbManager {
};
for o in old {
match sources.iter().find(|s| s.id == o.id) {
Some(n) if *n == o => {}
Some(n) if o.same_except_visibility(n) => {}
gone_or_changed => {
let keys = [o.id.clone(), secrets::ssh_key(&o.id), Self::sso_credential(&o.id)];
let keys =
[o.id.clone(), secrets::jdbc_key(&o.id), secrets::ssh_key(&o.id), Self::sso_credential(&o.id)];
match gone_or_changed {
None => {
self.catalogs.forget(&o.id);
@@ -555,6 +585,31 @@ impl DbManager {
Ok(())
}
/// Updates one scope of a source's visibility against its latest saved rules.
pub fn save_source_visibility(&self, id: &str, available: &[String], change: DbVisibilityChange) -> IdeResult<()> {
let _guard = plugin::EDIT.lock();
let mut sources = source::load(&self.root)?;
let scoped_global = self.global.as_ref().filter(|_| !sources.iter().any(|source| source.id == id));
if let Some((dir, _)) = scoped_global {
sources = source::load_global(dir)?;
}
let selected = sources
.iter_mut()
.find(|source| source.id == id)
.ok_or_else(|| IdeError::not_found(format!("no data source {id}")))?;
let previous = selected.introspection.clone();
change.apply(&mut selected.introspection, available);
if selected.introspection == previous {
return Ok(());
}
if let Some((dir, _)) = scoped_global {
source::save_global(dir, &sources)?;
} else {
source::save(&self.root, &sources)?;
}
Ok(())
}
/// Watches the data source files (the project's and the global one) for edits made
/// outside the IDE; `on_change` runs on a background thread once they settle, and
/// should call [`DbManager::reconcile_sources`]. Stops when the result is dropped.
@@ -563,9 +618,9 @@ impl DbManager {
SourcesWatch::start(&self.root, self.global.as_ref().map(|(dir, _)| dir.as_path()), on_change)
}
/// Re-reads the data sources after their files changed on disk: connections of
/// removed or changed sources close, as on [`DbManager::save_sources`] (saved
/// passwords stay, the source may come back). Returns whether the list the tree
/// Re-reads the data sources after their files changed on disk and closes affected
/// connections as on [`DbManager::save_sources`] (saved passwords stay, the source
/// may come back). Returns whether the list the tree
/// shows changed, or the files no longer parse (the tree reports the error).
pub async fn reconcile_sources(&self) -> bool {
let now = match self.sources() {
@@ -580,7 +635,7 @@ impl DbManager {
return false;
}
for o in &before {
if now.iter().find(|s| s.id == o.id) != Some(o) {
if now.iter().find(|s| s.id == o.id).is_none_or(|n| !o.same_except_visibility(n)) {
self.disconnect_source(&o.id).await;
}
}
@@ -590,7 +645,12 @@ impl DbManager {
/// Remembers `password` for the session, and in the saved passwords when
/// the data source saves passwords (`None` forgets it).
pub async fn set_password(&self, id: &str, password: Option<String>, save: bool) -> IdeResult<()> {
self.remember(id, id.to_owned(), password, save).await
let source = self.sources()?.into_iter().find(|s| s.id == id);
let (store, key) = match source.as_ref() {
Some(source) => (self.store_of(source), self.password_key(source)),
None => (&self.saved_passwords, id.to_owned()),
};
self.remember(store, key, password, save).await
}
/// [`DbManager::set_password`] for the SSH password / key passphrase.
@@ -602,10 +662,10 @@ impl DbManager {
self.ssh.set_secret(&c, secret, save);
return Ok(());
}
self.remember(id, secrets::ssh_key(id), secret, save).await
self.remember(self.saved_for(id), secrets::ssh_key(id), secret, save).await
}
async fn remember(&self, id: &str, key: String, secret: Option<String>, save: bool) -> IdeResult<()> {
async fn remember(&self, store: &SecretStore, key: String, secret: Option<String>, save: bool) -> IdeResult<()> {
match &secret {
Some(p) => {
self.session_passwords.lock().insert(key.clone(), p.clone());
@@ -614,7 +674,6 @@ impl DbManager {
self.session_passwords.lock().remove(&key);
}
}
let store = self.saved_for(id);
let result = match (secret, save) {
(Some(p), true) => store.set(&key, &p),
_ => {
@@ -640,7 +699,10 @@ impl DbManager {
}
async fn password(&self, source: &DataSource) -> Option<String> {
match self.secret(source, source.id.clone(), source.driver != DbDriver::Sqlite && source.save_password).await {
match self
.secret(source, self.password_key(source), source.driver != DbDriver::Sqlite && source.save_password)
.await
{
Some(p) => Some(p),
None => source.url_password(),
}
@@ -847,12 +909,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 +924,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 +984,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;
}
@@ -1758,6 +1825,78 @@ mod tests {
);
}
#[tokio::test]
async fn switching_from_snowflake_key_pair_keeps_the_jdbc_password_separate() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let db = manager(tmp.path()).with_global_sources(tmp.path().join("global"));
let native = DataSource {
id: "snowflake".into(),
name: "Snowflake".into(),
driver: DbDriver::Snowflake,
save_password: true,
url_only: true,
url: "jdbc:snowflake://example.invalid/?authenticator=SNOWFLAKE_JWT".into(),
..Default::default()
};
db.save_sources(vec![native.clone()]).await?;
db.set_password(&native.id, Some("native-passphrase".into()), true).await?;
let jdbc = DataSource { driver: DbDriver::Jdbc, url: "jdbc:fixture:".into(), ..native.clone() };
// Test Connection can use the JDBC draft before the user saves it.
assert_eq!(db.password(&jdbc).await, None);
assert_eq!(db.password(&native).await.as_deref(), Some("native-passphrase"));
db.approve_jdbc_source(&jdbc)?;
db.save_sources(vec![jdbc.clone()]).await?;
assert_eq!(db.password(&db.source(&jdbc.id)?).await, None);
db.set_password(&jdbc.id, Some("jdbc-password".into()), true).await?;
let reopened = manager(tmp.path()).with_global_sources(tmp.path().join("global"));
let saved = reopened.source(&jdbc.id)?;
assert_eq!(reopened.password(&saved).await.as_deref(), Some("jdbc-password"));
let err = reopened.pool(&jdbc.id).await.err().expect("no JDBC profile installed");
assert!(err.message.contains("Select an installed JDBC driver profile"));
source::save(&reopened.root, std::slice::from_ref(&jdbc))?;
let err = reopened.pool(&jdbc.id).await.err().expect("edited settings need approval");
assert!(err.message.contains("Review this project's JDBC URL and properties"));
source::save(&reopened.root, std::slice::from_ref(&saved))?;
let global = DataSource { global: true, ..saved };
reopened.save_sources(vec![global.clone()]).await?;
assert_eq!(reopened.password(&reopened.source(&jdbc.id)?).await.as_deref(), Some("jdbc-password"));
let native = DataSource { global: true, ..native };
reopened.save_sources(vec![native.clone()]).await?;
assert_eq!(reopened.password(&native).await.as_deref(), Some("native-passphrase"));
reopened.save_sources(Vec::new()).await?;
assert_eq!(reopened.password(&native).await, None);
assert_eq!(reopened.password(&global).await, None);
Ok(())
}
#[tokio::test]
async fn switching_from_snowflake_password_keeps_the_password() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let db = manager(tmp.path());
let native = DataSource {
id: "snowflake".into(),
name: "Snowflake".into(),
driver: DbDriver::Snowflake,
save_password: true,
url_only: true,
url: "jdbc:snowflake://example.invalid/?authenticator=snowflake".into(),
..Default::default()
};
db.save_sources(vec![native.clone()]).await?;
db.set_password(&native.id, Some("existing-password".into()), true).await?;
let jdbc = DataSource { driver: DbDriver::Jdbc, url: "jdbc:fixture:".into(), ..native };
assert_eq!(db.password(&jdbc).await.as_deref(), Some("existing-password"));
db.save_sources(vec![jdbc.clone()]).await?;
let reopened = manager(tmp.path());
assert_eq!(reopened.password(&reopened.source(&jdbc.id)?).await.as_deref(), Some("existing-password"));
Ok(())
}
#[tokio::test]
async fn moves_plaintext_passwords_of_older_versions_off_disk() {
let tmp = tempfile::tempdir().unwrap();
+5
Переглянути файл
@@ -18,6 +18,11 @@ pub fn ssh_key(id: &str) -> String {
format!("{id}#ssh")
}
/// JDBC password when the original credential is a Snowflake passphrase or token.
pub fn jdbc_key(id: &str) -> String {
format!("{id}#jdbc")
}
fn file_key(project: &str, key: &str) -> String {
format!("{project}|{key}")
}
+213
Переглянути файл
@@ -6,6 +6,7 @@
use ide_core::{IdeError, IdeResult, IpcPath, project_dir};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::BTreeMap;
use std::path::Path;
pub(crate) const FILE: &str = "data-sources.toml";
@@ -101,6 +102,9 @@ pub struct DbIntrospection {
pub databases: Vec<String>,
pub all_schemas: bool,
pub schemas: Vec<String>,
/// A database can replace the source's schema rules with all schemas or a list of exact names.
#[serde(skip_serializing_if = "BTreeMap::is_empty")]
pub schemas_by_database: BTreeMap<String, DbSchemaSelection>,
/// `pg_catalog`, `information_schema`, `mysql`…, and service databases (`rdsadmin`…).
pub show_system: bool,
/// PostgreSQL template databases (`template0`, `template1`).
@@ -117,6 +121,7 @@ impl Default for DbIntrospection {
databases: Vec::new(),
all_schemas: true,
schemas: Vec::new(),
schemas_by_database: BTreeMap::new(),
show_system: false,
show_templates: false,
object_filter: String::new(),
@@ -124,6 +129,111 @@ impl Default for DbIntrospection {
}
}
impl DbIntrospection {
pub(crate) fn with_visibility_from(self, source: &Self) -> Self {
Self {
all_databases: source.all_databases,
databases: source.databases.clone(),
all_schemas: source.all_schemas,
schemas: source.schemas.clone(),
schemas_by_database: source.schemas_by_database.clone(),
object_filter: source.object_filter.clone(),
..self
}
}
/// 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 == '*')
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default)]
pub struct DbSchemaSelection {
pub all: bool,
pub names: Vec<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase")]
pub enum DbVisibilityChange {
Databases { selection: DbSchemaSelection },
Schemas { selection: DbSchemaSelection },
DatabaseSchemas { database: String, selection: Option<DbSchemaSelection> },
}
impl DbVisibilityChange {
pub(crate) fn apply(self, introspection: &mut DbIntrospection, available: &[String]) {
let available: std::collections::HashSet<_> = available.iter().map(String::as_str).collect();
let keep_names = |before: &mut Vec<String>, selection: DbSchemaSelection, exact: bool| {
if selection.all || (!exact && before.iter().any(|name| name.contains(['*', '?']))) {
return;
}
before.retain(|name| !available.contains(if exact { name.as_str() } else { name.trim() }));
let mut seen: std::collections::HashSet<_> = before.iter().cloned().collect();
before.extend(
selection
.names
.into_iter()
.filter(|name| (exact || !name.contains(['*', '?'])) && seen.insert(name.clone())),
);
};
match self {
Self::Databases { selection } => {
introspection.all_databases = selection.all;
keep_names(&mut introspection.databases, selection, false);
}
Self::Schemas { selection } => {
introspection.all_schemas = selection.all;
keep_names(&mut introspection.schemas, selection, false);
}
Self::DatabaseSchemas { database, selection } => match selection {
Some(selection) => {
let rule = introspection.schemas_by_database.entry(database).or_default();
rule.all = selection.all;
keep_names(&mut rule.names, selection, true);
}
None => {
introspection.schemas_by_database.remove(&database);
}
},
}
}
}
/// Advanced tab: a driver property. PostgreSQL: run-time parameters (and
/// `application_name`); MySQL: session variables (and `charset`, `collation`);
/// SQLite: pragmas. See [`crate::conn`].
@@ -391,6 +501,14 @@ pub fn parse_url(raw: &str) -> IdeResult<ParsedUrl> {
}
impl DataSource {
pub(crate) fn same_except_visibility(&self, other: &Self) -> bool {
if self == other {
return true;
}
let introspection = other.introspection.clone().with_visibility_from(&self.introspection);
*self == Self { introspection, ..other.clone() }
}
/// The settings to connect with: with [`DataSource::url_only`], host, port,
/// database, user, SSL and driver properties come from the URL (properties
/// of the Advanced tab still apply after the URL's).
@@ -622,6 +740,81 @@ mod tests {
assert_eq!(load(tmp.path()).unwrap(), vec![s]);
}
#[test]
fn visibility_change_preserves_patterns_unavailable_names_and_other_scopes() {
let mut introspection = DbIntrospection {
schemas: vec!["app_*".into(), "unavailable_?".into()],
databases: vec!["reporting".into(), "offline".into()],
schemas_by_database: BTreeMap::from([
("reporting".into(), DbSchemaSelection { all: false, names: vec!["private".into()] }),
("sandbox".into(), DbSchemaSelection { all: false, names: vec!["experiments".into()] }),
]),
show_system: true,
..Default::default()
};
DbVisibilityChange::Schemas { selection: DbSchemaSelection { all: false, names: vec!["demo".into()] } }
.apply(&mut introspection, &["app_sales".into(), "demo".into()]);
assert_eq!(introspection.schemas, ["app_*", "unavailable_?"]);
DbVisibilityChange::Databases { selection: DbSchemaSelection { all: false, names: vec!["sandbox".into()] } }
.apply(&mut introspection, &["reporting".into(), "sandbox".into()]);
assert_eq!(introspection.databases, ["offline", "sandbox"]);
DbVisibilityChange::DatabaseSchemas {
database: "reporting".into(),
selection: Some(DbSchemaSelection {
all: false,
names: vec!["finance".into(), "finance".into(), "private".into()],
}),
}
.apply(&mut introspection, &["public".into(), "finance".into()]);
assert_eq!(introspection.schemas_by_database["reporting"].names, ["private", "finance"]);
assert_eq!(introspection.schemas_by_database["sandbox"].names, ["experiments"]);
assert!(introspection.show_system);
}
#[test]
fn schema_override_can_omit_default_fields() {
let introspection: DbIntrospection = toml::from_str(
r#"
[schemasByDatabase.reporting]
all = true
[schemasByDatabase.sandbox]
names = ["finance"]
"#,
)
.unwrap();
assert_eq!(
introspection.schemas_by_database,
BTreeMap::from([
("reporting".into(), DbSchemaSelection { all: true, names: vec![] }),
("sandbox".into(), DbSchemaSelection { all: false, names: vec!["finance".into()] }),
])
);
}
#[test]
fn round_trips_database_schema_overrides() {
let tmp = tempfile::tempdir().unwrap();
let source = DataSource {
id: "postgres".into(),
name: "PostgreSQL Demo".into(),
driver: DbDriver::Postgres,
introspection: DbIntrospection {
all_schemas: false,
schemas: vec!["app_*".into()],
schemas_by_database: BTreeMap::from([
("analytics".into(), DbSchemaSelection { all: true, names: vec![] }),
("reporting.eu".into(), DbSchemaSelection { all: false, names: vec!["public".into()] }),
("sandbox".into(), DbSchemaSelection { all: false, names: vec![] }),
]),
..Default::default()
},
..Default::default()
};
save(tmp.path(), std::slice::from_ref(&source)).unwrap();
assert_eq!(load(tmp.path()).unwrap(), vec![source]);
}
#[test]
fn sqlserver_defaults() {
assert_eq!(DbDriver::SqlServer.default_port(), Some(1433));
@@ -765,4 +958,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"));
+84 -3
Переглянути файл
@@ -17,12 +17,14 @@ async fn jdbc_profiles_persist_and_project_files_cannot_start_drivers() -> IdeRe
db.save_jdbc_driver(DbJdbcDriver {
id: "fixture".into(),
name: "Test".into(),
vendor: None,
jars: vec![jar.display().to_string()],
class_name: "test.Driver".into(),
url_template: "jdbc:test:".into(),
})?;
let reopened = manager(tmp.path());
assert_eq!(reopened.jdbc_drivers()?[0].class_name, "test.Driver");
assert_eq!(reopened.jdbc_drivers()?[0].vendor, None);
let source = DataSource {
id: "local".into(),
name: "local".into(),
@@ -53,6 +55,40 @@ async fn jdbc_profiles_persist_and_project_files_cannot_start_drivers() -> IdeRe
Ok(())
}
#[tokio::test]
async fn named_jdbc_sources_persist_the_type_and_reject_a_profile_for_another_type() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let jar = tmp.path().join("fixture.jar");
std::fs::write(&jar, [])?;
let db = manager(tmp.path());
db.save_jdbc_driver(DbJdbcDriver {
id: "fixture".into(),
name: "Test".into(),
vendor: Some("tidb".into()),
jars: vec![jar.display().to_string()],
class_name: "test.Driver".into(),
url_template: String::new(),
})?;
let source = DataSource {
id: "local".into(),
name: "local".into(),
driver: DbDriver::Jdbc,
vendor: "mariadb".into(),
jdbc_driver: "fixture".into(),
url: "jdbc:test:".into(),
..Default::default()
};
db.save_sources(vec![source]).await?;
let reopened = manager(tmp.path());
let source = reopened.source("local")?;
assert_eq!(reopened.jdbc_drivers()?[0].vendor.as_deref(), Some("tidb"));
assert_eq!(source.driver, DbDriver::Jdbc);
assert_eq!(source.vendor, "mariadb");
let err = reopened.test(&source, None, None).await.unwrap_err();
assert!(err.message.contains("not associated with this data source type"));
Ok(())
}
#[tokio::test]
#[ignore = "requires DUCKDB_JDBC_JAR and a local Java 17+ runtime"]
async fn duckdb_custom_driver_through_database_manager() -> IdeResult<()> {
@@ -63,6 +99,7 @@ async fn duckdb_custom_driver_through_database_manager() -> IdeResult<()> {
db.save_jdbc_driver(DbJdbcDriver {
id: "duck".into(),
name: "DuckDB".into(),
vendor: None,
jars: vec![jar],
class_name: "org.duckdb.DuckDBDriver".into(),
url_template: "jdbc:duckdb:".into(),
@@ -90,7 +127,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, ()) =
@@ -132,6 +172,7 @@ async fn clickhouse_vendor_driver_reads_catalog_and_results() -> IdeResult<()> {
db.save_jdbc_driver(DbJdbcDriver {
id: "clickhouse".into(),
name: "ClickHouse JDBC".into(),
vendor: Some("clickhouse".into()),
jars,
class_name: "com.clickhouse.jdbc.ClickHouseDriver".into(),
url_template: "jdbc:clickhouse://".into(),
@@ -140,6 +181,7 @@ async fn clickhouse_vendor_driver_reads_catalog_and_results() -> IdeResult<()> {
id: "test".into(),
name: "ClickHouse JDBC".into(),
driver: DbDriver::Jdbc,
vendor: "clickhouse".into(),
jdbc_driver: "clickhouse".into(),
url: format!("jdbc:clickhouse://127.0.0.1:{port}/default"),
user: "fixture".into(),
@@ -178,6 +220,7 @@ async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
db.save_jdbc_driver(DbJdbcDriver {
id: "fixture".into(),
name: "Fixture".into(),
vendor: None,
jars: vec![std::env::var("JDBC_FIXTURE_JAR").unwrap()],
class_name: "ai.openidea.jdbc.SelfTest$Fixture".into(),
url_template: String::new(),
@@ -207,9 +250,47 @@ 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(),
vendor: None,
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(())
}
+68 -1
Переглянути файл
@@ -2,7 +2,8 @@
use ide_core::{CancellationToken, IdeResult};
use ide_db::{
CellValue, DataSource, DbDriver, DbManager, DbOptions, DbProperty, DbRowEdit, DbTableKind, QueryResult, SortKey,
CellValue, DataSource, DbDriver, DbManager, DbOptions, DbProperty, DbRowEdit, DbSchemaSelection, DbTableKind,
DbVisibilityChange, QueryResult, SortKey,
};
async fn setup() -> (tempfile::TempDir, DbManager) {
@@ -242,6 +243,72 @@ async fn manual_commit_keeps_a_transaction_until_commit_or_rollback() -> IdeResu
Ok(())
}
#[tokio::test]
async fn visibility_edits_preserve_the_held_transaction() -> IdeResult<()> {
let (tmp, db) = setup().await;
let c = CancellationToken::new();
db.set_manual_commit("s1", true).await?;
db.execute("s1", "INSERT INTO users (name) VALUES ('dee')", 1, &c).await?;
assert_eq!(count(&db).await, "4");
let mut source = db.source("s1")?;
source.introspection.all_schemas = false;
source.introspection.schemas.clear();
db.save_sources(vec![source.clone()]).await?;
assert!(db.is_connected("s1"), "saving rules must keep the active connection");
assert_eq!(count(&db).await, "4", "the held transaction must still see its uncommitted row");
db.save_source_visibility(
"s1",
&["main".into()],
DbVisibilityChange::Schemas { selection: DbSchemaSelection { all: true, names: vec![] } },
)?;
assert!(db.source("s1")?.introspection.all_schemas);
assert_eq!(count(&db).await, "4", "the scoped save must keep the live transaction");
db.reconcile_sources().await;
let root = tmp.path();
let ssh = std::sync::Arc::new(ide_ssh::SshManager::new(root.join("ssh-passwords.json")));
let other = DbManager::new(root.to_path_buf(), root.join("passwords.json"), root.join("history.json"), ssh);
source = db.source("s1")?;
source.introspection.object_filter = "user*".into();
other.save_sources(vec![source.clone()]).await?;
assert!(db.reconcile_sources().await);
assert_eq!(count(&db).await, "4", "a visibility edit from another window must keep the transaction");
db.finish_transaction("s1", true).await?;
assert_eq!(count(&db).await, "4");
source.introspection.show_system = true;
db.save_sources(vec![source]).await?;
assert!(!db.is_connected("s1"), "raw metadata option changes keep their invalidation path");
Ok(())
}
#[tokio::test]
async fn visibility_save_does_not_mask_an_unreconciled_connection_edit() -> IdeResult<()> {
let (tmp, db) = setup().await;
let first = db.source("s1")?;
let second = DataSource { id: "s2".into(), name: "Another source".into(), ..first.clone() };
db.save_sources(vec![first.clone(), second.clone()]).await?;
db.reconcile_sources().await;
assert!(db.is_connected("s1"));
let root = tmp.path();
let ssh = std::sync::Arc::new(ide_ssh::SshManager::new(root.join("ssh-passwords.json")));
let external = DbManager::new(root.to_path_buf(), root.join("passwords.json"), root.join("history.json"), ssh);
external.save_sources(vec![DataSource { read_only: true, ..first }, second]).await?;
db.save_source_visibility(
"s2",
&["main".into()],
DbVisibilityChange::Schemas { selection: DbSchemaSelection { all: false, names: vec![] } },
)?;
assert!(db.is_connected("s1"));
assert!(db.reconcile_sources().await);
assert!(!db.is_connected("s1"));
assert!(!db.source("s2")?.introspection.all_schemas);
Ok(())
}
#[tokio::test]
async fn targets_name_a_database_of_a_data_source() -> IdeResult<()> {
let (_tmp, db) = setup().await;
+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() };
+80 -2
Переглянути файл
@@ -18,7 +18,7 @@ use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::OnceLock;
use std::sync::{Condvar, Mutex, OnceLock};
use std::time::Duration;
/// Listing and lifecycle commands normally answer in well under a second; a
@@ -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))
}
@@ -305,9 +315,56 @@ pub fn container_stats(ep: &DockerEndpoint, id: &str) -> IdeResult<DockerContain
parse_container_stats(&out).ok_or_else(|| IdeError::not_found("no container stats returned"))
}
/// How long log lines collect before they are handed on together.
const LOG_BATCH: Duration = Duration::from_millis(30);
/// Streams a container's logs (`tail` last lines, then follows while `follow`)
/// until it ends or `cancel` fires.
/// until it ends or `cancel` fires. Lines arrive in batches, at most one per
/// [`LOG_BATCH`]: a webview delivers each IPC message on its own, so a message
/// per line made a 1000-line tail take tens of seconds on Windows.
pub fn logs(
ep: &DockerEndpoint,
id: &str,
tail: u32,
follow: bool,
timestamps: bool,
cancel: &CancellationToken,
on_lines: &(dyn Fn(Vec<DockerLogLine>) + Sync),
) -> IdeResult<()> {
batched(LOG_BATCH, on_lines, |on_line| stream_logs(ep, id, tail, follow, timestamps, cancel, on_line))
}
/// Runs `produce` with a per-item callback and hands the items to `emit` in order,
/// collected over `every`, from a second thread so a quiet stream still flushes.
fn batched<T: Send, R>(every: Duration, emit: &(dyn Fn(Vec<T>) + Sync), produce: impl FnOnce(&dyn Fn(T)) -> R) -> R {
let pending = Mutex::new(Vec::new());
let finished = (Mutex::new(false), Condvar::new());
let flush = || {
let items = std::mem::take(&mut *pending.lock().unwrap_or_else(|e| e.into_inner()));
if !items.is_empty() {
emit(items);
}
};
std::thread::scope(|scope| {
scope.spawn(|| {
let (done, wake) = &finished;
let mut stop = done.lock().unwrap_or_else(|e| e.into_inner());
loop {
stop = wake.wait_timeout(stop, every).unwrap_or_else(|e| e.into_inner()).0;
flush();
if *stop {
break;
}
}
});
let result = produce(&|item| pending.lock().unwrap_or_else(|e| e.into_inner()).push(item));
*finished.0.lock().unwrap_or_else(|e| e.into_inner()) = true;
finished.1.notify_one();
result
})
}
fn stream_logs(
ep: &DockerEndpoint,
id: &str,
tail: u32,
@@ -316,6 +373,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 {
@@ -591,6 +653,22 @@ pub fn cli(
mod local_tests {
use super::*;
#[test]
fn log_lines_arrive_in_order_as_few_batches() {
let batches = Mutex::new(Vec::<Vec<u32>>::new());
let result = batched(Duration::from_millis(30), &|b| batches.lock().unwrap().push(b), |line| {
(0..1000).for_each(line);
std::thread::sleep(Duration::from_millis(80));
line(1000);
"done"
});
assert_eq!(result, "done");
let batches = batches.into_inner().unwrap();
assert_eq!(batches.concat(), (0..=1000).collect::<Vec<_>>(), "every line once, in order");
assert!(batches.len() <= 3, "a burst is one message, not one per line: {} batches", batches.len());
assert_eq!(batches.last().unwrap(), &[1000], "a line after a quiet spell is flushed on its own");
}
#[test]
fn the_selected_context_overrides_docker_host() {
let local = "unix:///var/run/docker.sock";
+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())
}
}
+2 -1
Переглянути файл
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
pub const MANIFEST_FILE: &str = "plugin.toml";
/// The plugin API (engine) version this host implements.
pub const ENGINE_VERSION: &str = "1.14.0";
pub const ENGINE_VERSION: &str = "1.15.0";
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
pub const LEGACY_API: &str = "0.1";
/// Marketplace categories, in the order they are shown.
@@ -164,6 +164,7 @@ pub const EVENT_KINDS: &[&str] = &[
"file-saved",
"files-changed",
"editor-focused",
"caret-moved",
"action-performed",
"vcs-changed",
"problems-changed",
+22 -1
Переглянути файл
@@ -122,13 +122,34 @@ pub struct Prepared {
pub key: Option<String>,
/// User-facing one-liner for the plugin details page ("Insert Date").
pub label: String,
/// When set, this entry is skipped with a plugin load warning instead of failing the plugin.
pub warning: Option<String>,
/// Makes it take effect. Must not fail for reasons `prepare` could have checked.
pub commit: Commit,
}
impl Prepared {
pub fn new(label: impl Into<String>, commit: impl FnOnce() -> Result<Disposable, String> + Send + 'static) -> Self {
Self { capabilities: Vec::new(), files: Vec::new(), key: None, label: label.into(), commit: Box::new(commit) }
Self {
capabilities: Vec::new(),
files: Vec::new(),
key: None,
label: label.into(),
warning: None,
commit: Box::new(commit),
}
}
/// Skips an invalid declaration with a load warning while letting the rest of the plugin load.
pub fn skipped(warning: impl Into<String>) -> Self {
Self {
capabilities: Vec::new(),
files: Vec::new(),
key: None,
label: String::new(),
warning: Some(warning.into()),
commit: Box::new(|| Ok(Disposable::noop())),
}
}
pub fn key(mut self, key: impl Into<String>) -> Self {
+6
Переглянути файл
@@ -270,6 +270,12 @@ impl ExtensionRegistry {
let prepared = point
.prepare(pkg, decl)
.map_err(|e| format!("contributes.{point_id}[{i}]: {}", strip_prefix(&e, point_id)))?;
if let Some(warning) = prepared.warning {
let msg = format!("contributes.{point_id}[{i}]: {}", strip_prefix(&warning, point_id));
tracing::warn!(plugin = %pkg.id(), "{msg}");
set.warnings.push(msg);
continue;
}
for cap in &prepared.capabilities {
if !set.capabilities.contains(cap) {
set.capabilities.push(cap.clone());
+64 -8
Переглянути файл
@@ -2,7 +2,7 @@
use crate::Host;
use ide_core::event::NotifyLevel;
use ide_core::settings::{ExternalFormatter, LanguagesSettings, Settings};
use ide_core::settings::{BIOME_LANGUAGES, ExternalFormatter, LanguagesSettings, Settings};
use ide_core::{ChangeSet, DocId, IdeError, IdeEvent, IdeResult, LanguageId, Pos, Range, TextEdit};
use ide_language::{LanguageConfig, PhpAlignment, Syntax};
use ide_lsp::types::FormatOptions;
@@ -10,9 +10,28 @@ use ide_tools::{Tools, formatter};
use std::path::Path;
const OXFMT_CONFIGS: [&str; 4] = [".oxfmtrc.json", ".oxfmtrc.jsonc", "oxfmt.config.ts", "oxfmt.config.mts"];
/// A Biome configuration, or Biome installed as a project dependency (it then uses its defaults).
const BIOME_MARKERS: [&str; 3] = ["biome.json", "biome.jsonc", "node_modules/@biomejs/biome/package.json"];
/// Reformat Code uses Biome below a Biome configuration or installation, unless the nearest
/// configuration turns its formatter off (Biome lints, another tool formats).
fn biome_formats(file: &Path) -> bool {
let config = ["biome.json", "biome.jsonc"]
.iter()
.filter_map(|name| formatter::find_up(file, Path::new(name)))
.max_by_key(|path| path.components().count());
match config {
Some(config) => !std::fs::read_to_string(&config)
.ok()
.and_then(|text| serde_json::from_str::<serde_json::Value>(&ide_core::jsonc::strip(&text)).ok())
.is_some_and(|v| v.pointer("/formatter/enabled") == Some(&serde_json::Value::Bool(false))),
None => BIOME_MARKERS.iter().any(|name| formatter::find_up(file, Path::new(name)).is_some()),
}
}
fn supports_external_format(language: &LanguageConfig, tool: ExternalFormatter) -> bool {
match language.formatter.as_ref().map(|f| f.tool.as_str()) {
Some("prettier") if tool == ExternalFormatter::Biome => BIOME_LANGUAGES.contains(&language.id.as_str()),
Some("prettier") => matches!(tool, ExternalFormatter::Prettier | ExternalFormatter::Oxfmt),
Some("ruff") => tool == ExternalFormatter::Ruff,
_ => false,
@@ -20,9 +39,9 @@ fn supports_external_format(language: &LanguageConfig, tool: ExternalFormatter)
}
/// The external formatter of a file, for a language with an external formatter.
/// `forced` names the tool (Reformat with Prettier, oxfmt, or Ruff). Ruff is
/// the base formatter for Python; oxfmt can replace Prettier for its languages
/// when configured or selected. A tool that cannot format the language is
/// `forced` names the tool (Reformat with Prettier, oxfmt, Biome, or Ruff). Ruff is
/// the base formatter for Python; Biome, then oxfmt, can replace Prettier for their
/// languages when configured or selected. A tool that cannot format the language is
/// rejected even when explicitly requested.
fn external_tool(
forced: Option<ExternalFormatter>,
@@ -30,7 +49,7 @@ fn external_tool(
file: &Path,
settings: &LanguagesSettings,
) -> IdeResult<Option<ExternalFormatter>> {
use ExternalFormatter::{Oxfmt, Prettier, Ruff};
use ExternalFormatter::{Biome, Oxfmt, Prettier, Ruff};
let Some(language) = language.filter(|l| l.formatter.is_some()) else {
return match forced {
Some(tool) => Err(IdeError::invalid(format!(
@@ -56,8 +75,11 @@ fn external_tool(
if language.formatter.as_ref().is_some_and(|f| f.tool == "ruff") {
return Ok(enabled(Ruff).then_some(Ruff));
}
let oxfmt_config = || OXFMT_CONFIGS.iter().any(|name| formatter::find_up(file, Path::new(name)).is_some());
Ok(if enabled(Oxfmt) && (settings.oxfmt.prefer || oxfmt_config()) {
let found = |names: &[&str]| names.iter().any(|name| formatter::find_up(file, Path::new(name)).is_some());
let biome = enabled(Biome) && supports_external_format(language, Biome);
Ok(if biome && (settings.biome.prefer || biome_formats(file)) {
Some(Biome)
} else if enabled(Oxfmt) && (settings.oxfmt.prefer || found(&OXFMT_CONFIGS)) {
Some(Oxfmt)
} else {
enabled(Prettier).then_some(Prettier)
@@ -385,7 +407,7 @@ async fn provider_edits(
#[cfg(test)]
mod tests {
use super::*;
use ExternalFormatter::{Oxfmt, Prettier, Ruff};
use ExternalFormatter::{Biome, Oxfmt, Prettier, Ruff};
use ide_core::LanguageId;
use ide_language::LanguageRegistry;
@@ -428,6 +450,40 @@ mod tests {
assert_eq!(prettier.message, "Prettier cannot format Python files");
let oxfmt = tool(Some(Oxfmt), "python", file, &settings).unwrap_err();
assert_eq!(oxfmt.message, "oxfmt cannot format Python files");
let biome = tool(Some(Biome), "python", file, &settings).unwrap_err();
assert_eq!(biome.message, "Biome cannot format Python files");
}
#[test]
fn biome_config_or_dependency_selects_biome_for_its_languages() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
std::fs::create_dir_all(root.join("web/src")).unwrap();
let (web, api, readme) = (root.join("web/src/app.ts"), root.join("api/main.ts"), root.join("web/README.md"));
let mut settings = LanguagesSettings::default();
for marker in BIOME_MARKERS {
let path = root.join("web").join(marker);
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
std::fs::write(&path, "{}").unwrap();
assert_eq!(tool(None, "typescript", &web, &settings).unwrap(), Some(Biome), "{marker}");
assert_eq!(tool(None, "typescript", &api, &settings).unwrap(), Some(Prettier), "{marker}");
// Biome doesn't format Markdown: Prettier keeps it.
assert_eq!(tool(None, "markdown", &readme, &settings).unwrap(), Some(Prettier), "{marker}");
std::fs::remove_file(&path).unwrap();
}
std::fs::write(root.join("web/biome.json"), "{}").unwrap();
std::fs::write(root.join("web/.oxfmtrc.json"), "{}").unwrap();
assert_eq!(tool(None, "css", &web, &settings).unwrap(), Some(Biome));
settings.biome.languages.retain(|l| l != "css");
assert_eq!(tool(None, "css", &web, &settings).unwrap(), Some(Oxfmt));
// Biome only lints here: Prettier keeps formatting.
std::fs::remove_file(root.join("web/.oxfmtrc.json")).unwrap();
std::fs::write(root.join("web/biome.json"), r#"{ "formatter": { "enabled": false } }"#).unwrap();
assert_eq!(tool(None, "typescript", &web, &settings).unwrap(), Some(Prettier));
settings.biome.prefer = true;
assert_eq!(tool(None, "typescript", &api, &settings).unwrap(), Some(Biome));
let markdown = tool(Some(Biome), "markdown", &readme, &settings).unwrap_err();
assert_eq!(markdown.message, "Biome cannot format Markdown files");
}
#[test]
+3 -3
Переглянути файл
@@ -72,7 +72,7 @@ pub struct Host {
/// Projects the MCP server serves without a window.
pub mcp_background: mcp::BackgroundProjects,
pub(crate) agent_catalogs: Arc<ide_agent::AgentCatalogs>,
pub trust: trust::TrustStore,
pub trust: std::sync::Arc<trust::TrustStore>,
pub(crate) mcp_approvals: Arc<trust::McpServerApprovals>,
pub config_dir: PathBuf,
/// Persistent user state, including credentials and recovery history.
@@ -169,7 +169,7 @@ impl Host {
mcp_agent_runs: Default::default(),
mcp_background: Default::default(),
agent_catalogs: Arc::default(),
trust: trust::TrustStore::load(&config_dir, &data_dir),
trust: std::sync::Arc::new(trust::TrustStore::load(&config_dir, &data_dir)),
mcp_approvals: Arc::new(trust::McpServerApprovals::load(&data_dir)),
proxy_password: ide_ssh::secrets::SecretFile::new(data_dir.join("proxy-password.json")),
proxy_session_password: Mutex::default(),
@@ -345,7 +345,7 @@ impl Host {
}
if let Some(plugins) = plugins::editor_plugin_host() {
plugins.invalidate_client_navigation(&project.root, Some(window), None);
plugins.set_active_file(window, None);
plugins.set_active_file(window, None, None);
}
if !project.light {
self.environment.project_closed();
+22 -5
Переглянути файл
@@ -23,7 +23,25 @@ const DEFAULT_TREE_DEPTH: i64 = 5;
const TREE_LIMIT: usize = 100;
pub fn tools() -> Vec<Tool> {
vec![read_file(), list_directory_tree()]
vec![get_workspace_roots(), read_file(), list_directory_tree()]
}
// --- get_workspace_roots ---------------------------------------------------------
fn get_workspace_roots() -> Tool {
Tool::new(
"get_workspace_roots",
"Returns the root directories of the IDE workspace: this project and the trusted projects attached to it
in the same window, as absolute paths. A task works in one directory, but its workspace can hold several projects.
Call this when asked about the workspace, project or working directories, and before planning a change that may span
projects. Other tools reach an attached project by its root as `projectPath`.",
|call| async move {
let root = call.root().to_path_buf();
let mut roots = vec![root.clone()];
roots.extend(crate::mcp::tool::trusted_attachments(&call.host.trust, &root));
Output::json(json!({ "projectRoot": root, "roots": roots }))
},
)
}
// --- read_file -----------------------------------------------------------------
@@ -184,10 +202,9 @@ marked directory are not marked again.",
}
let deadline = Instant::now() + Duration::from_millis(timeout.max(0) as u64);
let cancel = call.cancel.clone();
let marks = Marks {
root: call.root().to_path_buf(),
excludes: FileMask::new(&[], &call.project().search_excludes()).ok(),
};
// Matched from the root holding the directory: an attached project has its own exclusions.
let root = call.project().root_of(&dir);
let marks = Marks { excludes: FileMask::new(&[], &call.project().search_excludes_in(&root)).ok(), root };
// The directory itself, when it or one above it is left out.
let root_mark = marker(ide_index::walk_skips(call.root(), &dir), marks.ide_excluded(&dir, true));
let mut tree = TreeRender {
+2
Переглянути файл
@@ -16,6 +16,8 @@ mod search;
pub mod service;
mod symbols;
mod tool;
pub(crate) use tool::trusted_attachments;
mod util;
use crate::Host;
+19 -7
Переглянути файл
@@ -668,8 +668,8 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
if hits.len() > limit {
break;
}
// Find in Files keeps a window of very long lines and drops the matches outside it:
// such lines are matched again in the file's whole text.
// Find in Files reports a very long line in windows cut around its matches: such lines
// are matched again in the file's whole text, so a match keeps its real end.
let long = |m: &ide_search::LineMatch| m.text_offset > 0 || m.text.encode_utf16().count() + 1 >= LINE_WINDOW;
let whole = if file.matches.iter().any(long) {
crate::ops::fs::fs_read_text(&host, call.window(), file.path.0.clone())
@@ -679,11 +679,15 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
} else {
None
};
// One window per far-apart match: a line is expanded once.
let mut expanded = std::collections::HashSet::new();
for m in &file.matches {
if let Some((ranges, text)) = &whole
&& long(m)
{
hits.extend(line_hits(path, text, ranges, m.line));
if expanded.insert(m.line) {
hits.extend(line_hits(path, text, ranges, m.line));
}
continue;
}
let line_end = m.text_offset + m.text.encode_utf16().count() as u32;
@@ -833,8 +837,6 @@ async fn file_search(call: Call) -> IdeResult<Output> {
.add(build_glob(&normalize_glob(&q, call.root(), &[])?)?)
.build()
.map_err(|_| IdeError::invalid(format!("Invalid glob pattern: {q}")))?;
// Ignored names and "Exclude files" patterns, which `read_dir` does not flag.
let excludes = if include_excluded { None } else { Some(FileMask::new(&[], &call.project().search_excludes())?) };
let root = call.root().to_path_buf();
let content = call.project().content_roots();
// Where a folder's exclusions are matched from: the content root holding it, or the project.
@@ -858,6 +860,15 @@ async fn file_search(call: Call) -> IdeResult<Output> {
.map(|r| (r.clone(), r))
.collect(),
};
// Ignored names and "Exclude files" patterns, which `read_dir` does not flag, by walked root.
let mut excludes = Vec::new();
if !include_excluded {
for (_, base) in &roots {
if !excludes.iter().any(|(b, _)| b == base) {
excludes.push((base.clone(), FileMask::new(&[], &call.project().search_excludes_in(base))?));
}
}
}
let host = call.host();
let walk = Walk {
host: host.clone(),
@@ -894,7 +905,7 @@ struct Walk {
window: String,
root: PathBuf,
include_excluded: bool,
excludes: Option<FileMask>,
excludes: Vec<(PathBuf, FileMask)>,
glob: GlobSet,
scope: PathScope,
limit: usize,
@@ -927,7 +938,8 @@ impl Walk {
continue;
}
let Ok(in_base) = entry.path.strip_prefix(base) else { continue };
if self.excludes.as_ref().is_some_and(|m| !m.matches(&in_base.to_string_lossy().replace('\\', "/"))) {
let mask = self.excludes.iter().find(|(b, _)| b == base).map(|(_, m)| m);
if mask.is_some_and(|m| !m.matches(&in_base.to_string_lossy().replace('\\', "/"))) {
continue;
}
match entry.kind {
+6 -4
Переглянути файл
@@ -65,10 +65,7 @@ impl Call {
}
/// The projects attached to this one that the user trusts (each is trusted on its own).
fn trusted_attachments(&self) -> Vec<PathBuf> {
attached_projects(self.root())
.into_iter()
.filter(|root| self.host.trust.trusted(root).unwrap_or(false))
.collect()
trusted_attachments(&self.host.trust, self.root())
}
pub async fn ask(&self, request: ide_core::event::McpUiRequest) -> IdeResult<()> {
self.host.mcp_requests.ask(self, request).await
@@ -327,6 +324,11 @@ pub fn ensure_inside(root: &Path, path: &Path) -> IdeResult<()> {
resolve_inside(root, &path.to_string_lossy()).map(|_| ())
}
/// The projects attached to the one at `root` that the user trusts (each is trusted on its own).
pub(crate) fn trusted_attachments(trust: &crate::trust::TrustStore, root: &Path) -> Vec<PathBuf> {
attached_projects(root).into_iter().filter(|p| trust.trusted(p).unwrap_or(false)).collect()
}
/// The projects attached to the one at `root` (its workspace members), `root` itself left out.
pub(crate) fn attached_projects(root: &Path) -> Vec<PathBuf> {
ide_workspace::workspace::Workspace::load(root)
+375 -9
Переглянути файл
@@ -5,10 +5,12 @@ 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, AgentSkillMode, AgentSkillPolicy, AgentSkillState, AgentTask,
CustomAgentInput, ExternalSession, InstallRemoteSkillRequest, McpExternalSource, McpImportSelection,
McpProbeResult, McpScope, McpServer, McpServerInput, McpTransport, NewAgentTask, RemoteSkillBrowseResult,
RemoteSkillPreview, SkillsPolicy,
};
use ide_command::command;
use ide_core::error::ErrorKind;
@@ -17,12 +19,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)]
@@ -343,6 +361,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)]
@@ -351,6 +413,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<()> {
@@ -961,6 +1030,293 @@ pub fn agent_set_mcp_overrides(
host.project(window)?.agents.set_mcp_overrides(&task, overrides)
}
/// Updates per-session skill modes on `task`.
#[command(trust = always)]
pub fn agent_set_skill_overrides(
host: &Host,
window: &str,
task: String,
overrides: std::collections::BTreeMap<String, AgentSkillMode>,
) -> IdeResult<AgentTask> {
host.project(window)?.agents.set_skill_overrides(&task, overrides)
}
/// Every skill discovered in the project, the user's folders and enabled plugins, with
/// the mode a session runs it with (without any session's own overrides).
#[command(trust = always)]
pub async fn agent_skills_list(host: &Host, window: &str) -> IdeResult<Vec<AgentSkillState>> {
let project = host.project(window).ok().filter(|p| !p.light);
let policy = host_skills_policy(host, project.as_deref());
let home = dirs::home_dir();
tokio::task::spawn_blocking(move || {
Ok(ide_agent::skills::resolve(
ide_agent::skills::discover_skills_with_plugins(
&policy.workspace_roots,
home.as_deref(),
&policy.plugin_dirs,
),
None,
&policy.workspace,
&policy.user,
policy.workspace_trusted,
))
})
.await
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// Sets how `name` may run in `scope`, in the settings file of that scope, and returns the
/// updated list. `SKILL.md` files are never touched; the default `auto` removes the entry.
#[command(trust = always)]
pub fn agent_skills_set_mode(
host: &Host,
window: &str,
name: String,
scope: McpScope,
mode: AgentSkillMode,
) -> IdeResult<Vec<AgentSkillState>> {
let name = name.trim().to_owned();
if name.is_empty() {
return Err(IdeError::invalid("a skill needs a name"));
}
let project = host.project(window).ok().filter(|p| !p.light);
let (mut user, mut workspace) = skills_maps(host, project.as_ref());
match scope {
McpScope::User => {
let changed = if mode == AgentSkillMode::Auto {
user.remove(&name).is_some()
} else {
user.insert(name, AgentSkillPolicy { mode }).map(|p| p.mode) != Some(mode)
};
if changed {
persist_skills_map(host, None, scope, &user)?;
}
}
McpScope::Workspace => {
let map =
workspace.as_mut().ok_or_else(|| IdeError::invalid("Open a project to configure workspace skills"))?;
let changed = if mode == AgentSkillMode::Auto {
map.remove(&name).is_some()
} else {
map.insert(name, AgentSkillPolicy { mode }).map(|p| p.mode) != Some(mode)
};
if changed {
let map = map.clone();
persist_skills_map(host, project.as_ref(), scope, &map)?;
}
}
}
let policy = host_skills_policy(host, project.as_deref());
let home = dirs::home_dir();
Ok(ide_agent::skills::resolve(
ide_agent::skills::discover_skills_with_plugins(&policy.workspace_roots, home.as_deref(), &policy.plugin_dirs),
None,
&policy.workspace,
&policy.user,
policy.workspace_trusted,
))
}
/// Resolves a GitHub `owner/repo[/path][@ref]` source and lists the `SKILL.md` skills in it.
#[command(trust = always)]
pub async fn agent_skills_browse(
host: &Host,
source: String,
request: RequestId,
) -> IdeResult<RemoteSkillBrowseResult> {
let cancel = host.begin_request(request);
let search_path = ide_core::tool_path::search_path();
let res = tokio::task::spawn_blocking(move || {
let fetcher = ide_agent::skill_installer::GitHubHttpFetcher::new(&search_path)?;
ide_agent::skill_installer::browse_skills(&fetcher, &source, &cancel)
})
.await
.map_err(join_err);
host.end_request(request);
res?
}
/// Fetches one skill's `SKILL.md`, file list, and static security scan warnings before installation.
#[command(trust = always)]
pub async fn agent_skills_preview(
host: &Host,
window: &str,
owner: String,
repo: String,
git_ref: String,
subpath: String,
request: RequestId,
) -> IdeResult<RemoteSkillPreview> {
let cancel = host.begin_request(request);
let ws_root = host.project(window).ok().filter(|p| !p.light).map(|p| p.root.clone());
let home = dirs::home_dir();
let search_path = ide_core::tool_path::search_path();
let res = tokio::task::spawn_blocking(move || {
let fetcher = ide_agent::skill_installer::GitHubHttpFetcher::new(&search_path)?;
ide_agent::skill_installer::preview_skill(
&fetcher,
ide_agent::skill_installer::RepoRef { owner: &owner, repo: &repo, git_ref: &git_ref },
&subpath,
home.as_deref(),
ws_root.as_deref(),
&cancel,
)
})
.await
.map_err(join_err);
host.end_request(request);
res?
}
/// Installs the selected skill subtree into `~/.agents/skills` (User) or `<workspace>/.agents/skills` (Workspace).
#[command(trust = always)]
pub async fn agent_skills_install(
host: &Host,
window: &str,
input: InstallRemoteSkillRequest,
request: RequestId,
) -> IdeResult<Vec<AgentSkillState>> {
let project = host.project(window).ok().filter(|p| !p.light);
if input.scope == McpScope::Workspace {
host.require_trust(window)?;
}
let ws_root = project.as_ref().map(|p| p.root.clone());
let home = dirs::home_dir();
let cancel = host.begin_request(request);
let search_path = ide_core::tool_path::search_path();
let install_home = home.clone();
let install_ws = ws_root.clone();
let res = tokio::task::spawn_blocking(move || {
let fetcher = ide_agent::skill_installer::GitHubHttpFetcher::new(&search_path)?;
ide_agent::skill_installer::install_skill(
&fetcher,
&input,
install_home.as_deref(),
install_ws.as_deref(),
&cancel,
)
})
.await
.map_err(join_err);
host.end_request(request);
res??;
let event = IdeEvent::SettingsChanged { key: "agents.skills".into() };
for p in host.projects() {
p.agents.notify_mcp_servers_changed();
p.sink.emit(event.clone());
}
let policy = host_skills_policy(host, project.as_deref());
tokio::task::spawn_blocking(move || {
Ok(ide_agent::skills::resolve(
ide_agent::skills::discover_skills_with_plugins(
&policy.workspace_roots,
home.as_deref(),
&policy.plugin_dirs,
),
None,
&policy.workspace,
&policy.user,
policy.workspace_trusted,
))
})
.await
.map_err(join_err)?
}
/// The user's and the workspace's skill policies (`[agents.skills.<name>]`).
fn skills_maps(
host: &Host,
project: Option<&std::sync::Arc<crate::Project>>,
) -> (std::collections::BTreeMap<String, AgentSkillPolicy>, Option<std::collections::BTreeMap<String, AgentSkillPolicy>>)
{
let user = host.global_settings.effective().agents.skills.clone();
let workspace =
project.map(|p| p.settings.layer(ide_workspace::settings::SettingsScope::Project).agents.skills.clone());
(user, workspace)
}
/// Saves `map` into its scope's settings and tells the windows.
fn persist_skills_map(
host: &Host,
project: Option<&std::sync::Arc<crate::Project>>,
scope: McpScope,
map: &std::collections::BTreeMap<String, AgentSkillPolicy>,
) -> IdeResult<()> {
let value = if map.is_empty() {
serde_json::Value::Null
} else {
serde_json::to_value(map).map_err(|e| IdeError::invalid(e.to_string()))?
};
let event = IdeEvent::SettingsChanged { key: "agents.skills".into() };
match scope {
McpScope::User => {
host.global_settings.set(ide_workspace::settings::SettingsScope::Global, "agents.skills", value)?;
for p in host.projects() {
p.settings.reload();
p.agents.notify_mcp_servers_changed();
p.sink.emit(event.clone());
}
}
McpScope::Workspace => {
let p = project.ok_or_else(|| IdeError::invalid("Open a project to configure workspace skills"))?;
p.settings.set(ide_workspace::settings::SettingsScope::Project, "agents.skills", value)?;
p.agents.notify_mcp_servers_changed();
p.sink.emit(event);
}
}
Ok(())
}
/// Workspace folders to scan for skills: the project root plus any multi-repo workspace members.
pub(crate) fn workspace_skill_roots(root: &std::path::Path) -> Vec<std::path::PathBuf> {
let mut roots = vec![root.to_path_buf()];
if let Ok(Some(ws)) = ide_workspace::workspace::Workspace::load(root) {
for member in ws.projects {
if member.exists() && !roots.contains(&member) {
roots.push(member);
}
}
}
roots
}
/// The skill policies a session of `project` (or global Settings without a project) resolves against.
fn host_skills_policy(host: &Host, project: Option<&crate::Project>) -> SkillsPolicy {
match project {
Some(project) => {
let workspace_trusted = project.trusted.load(std::sync::atomic::Ordering::Acquire);
let plugin_dirs = host
.plugin_host()
.map(|plugins| plugins.skill_dirs(Some(&project.root), workspace_trusted))
.unwrap_or_default();
SkillsPolicy {
user: project.settings.layer(ide_workspace::settings::SettingsScope::Global).agents.skills.clone(),
workspace: project
.settings
.layer(ide_workspace::settings::SettingsScope::Project)
.agents
.skills
.clone(),
workspace_trusted,
workspace_roots: workspace_skill_roots(&project.root),
plugin_dirs,
}
}
None => {
let plugin_dirs = host.plugin_host().map(|plugins| plugins.skill_dirs(None, true)).unwrap_or_default();
SkillsPolicy {
user: host.global_settings.effective().agents.skills.clone(),
workspace: Default::default(),
workspace_trusted: true,
workspace_roots: Vec::new(),
plugin_dirs,
}
}
}
}
fn validate_project_root(root: &std::path::Path, requested: Option<&std::path::Path>) -> IdeResult<std::path::PathBuf> {
let Some(requested) = requested else {
return Ok(root.to_path_buf());
@@ -1077,7 +1433,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,
@@ -1113,8 +1472,15 @@ ide_command::domain!(
agent_set_config,
agent_set_env,
agent_set_mcp_overrides,
agent_set_skill_overrides,
agent_skills_browse,
agent_skills_install,
agent_skills_list,
agent_skills_preview,
agent_skills_set_mode,
agent_stop_background,
agent_subscribe,
agent_unarchive,
agent_unqueue,
agent_unsubscribe,
);
+28 -7
Переглянути файл
@@ -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 };
@@ -73,11 +81,12 @@ pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
/// Every Cucumber source of the project (its folder and the content roots outside it).
pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>> {
let project = host.project(window)?;
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());
let mut out = Vec::new();
for root in std::iter::once(project.root.clone()).chain(project.content_roots()) {
let mut excludes = project.search_excludes_in(&root);
// 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());
out.extend(sources_in(&root, &excludes));
}
out.sort_by(|a, b| a.path.cmp(&b.path));
@@ -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"));
}
+125 -22
Переглянути файл
@@ -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);
@@ -810,6 +906,7 @@ pub async fn build_run(
let detected = project.detected_roots.read().clone();
let config_dir = host.config_dir.clone();
let token = host.begin_project_request(window, request);
let launch_project = project.clone();
let result = tokio::task::spawn_blocking(move || {
// Fast path (#2476): an unchanged single-project Maven build skips
// Maven entirely. Previous diagnostics stay: nothing changed, so they
@@ -907,7 +1004,12 @@ pub async fn build_run(
};
let result = compile::run(&root, &plan, &token, &|e| {
let _ = on_event.send(e);
})?;
});
if kind == BuildKind::Rebuild {
// The clean removed outputs that earlier launch snapshots still hold.
launch_project.java_launch_snapshots.lock().forget_reusable_snapshots();
}
let result = result?;
if result.success && single && kind == BuildKind::Build {
let model = with_profiles(load(&root, &cache, &settings), &cache);
compile::record_menu_build(&cache, &root, &model, file.as_deref(), &token);
@@ -1333,4 +1435,5 @@ ide_command::domain!(
maven_dependency_declaration,
maven_exclude_dependency,
maven_goto_declaration,
maven_managed_declarations,
);
+163 -24
Переглянути файл
@@ -2,13 +2,14 @@
//! remote server ([`crate::rpc`]). `db_export_file` stays in the desktop
//! shell: its path comes from a local save dialog, so the export must land
//! on the user's machine, not the side the project runs on.
use super::Channel;
use crate::Host;
use ide_command::command;
use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
use ide_db::split::SqlStatement;
use ide_db::{
CompletionModel, DataSource, Databases, DbObjectKind, DbRowEdit, HistoryEntry, PlanNode, QueryResult,
SchemaObjects, SortKey, TableDetails, TableInfo, TablePage,
CompletionModel, DataSource, Databases, DbObjectKind, DbRowEdit, DbVisibilityChange, HistoryEntry, PlanNode,
QueryResult, SchemaObjects, SortKey, TableDetails, TableInfo, TablePage,
};
use serde::{Deserialize, Serialize};
use specta::Type;
@@ -24,6 +25,14 @@ pub struct StatementOutcome {
pub error: Option<String>,
}
#[derive(Serialize, Deserialize, Type)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum ExecutionEvent {
Started { index: u32 },
Completed { index: u32, outcome: StatementOutcome },
Done { error: Option<IdeError> },
}
#[command(trust = trusted)]
pub fn db_approve_jdbc_source(host: &Host, window: &str, source: DataSource) -> IdeResult<()> {
host.project(window)?.db.approve_jdbc_source(&source)
@@ -63,6 +72,25 @@ pub async fn db_save_sources(host: &Host, window: &str, sources: Vec<DataSource>
// Replaces the project's data sources with `sources`.
let db = host.project(window)?.db.clone();
db.save_sources(sources).await?;
sources_changed(host, window)
}
#[command(trust = trusted)]
pub async fn db_save_source_visibility(
host: &Host,
window: &str,
id: String,
available: Vec<String>,
change: DbVisibilityChange,
) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
tokio::task::spawn_blocking(move || db.save_source_visibility(&id, &available, change))
.await
.map_err(|e| IdeError::internal(e.to_string()))??;
sources_changed(host, window)
}
fn sources_changed(host: &Host, window: &str) -> IdeResult<()> {
let root = host.project(window)?.root.clone();
for project in host.projects().into_iter().filter(|p| p.root == root) {
project.sink.emit(ide_core::IdeEvent::DbSourcesChanged);
@@ -357,36 +385,79 @@ pub async fn db_execute(
max_rows: u32,
schema: Option<String>,
) -> IdeResult<Vec<StatementOutcome>> {
// Runs `statements` in order on data source `id`, stopping at the first
// error. Each result reads past its first `skip` rows (a later page) and keeps
// `max_rows`. `schema` is the console's active context: the connection running
// each statement is put in it first. Cancel with `cancel_request(request)`.
let mut outcomes = Vec::new();
execute_statements(host, window, request, &id, statements, skip, max_rows, schema.as_deref(), |event| {
if let ExecutionEvent::Completed { outcome, .. } = event {
outcomes.push(outcome);
}
Ok(())
})
.await?;
Ok(outcomes)
}
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn db_execute_stream(
host: &Host,
window: &str,
request: RequestId,
id: String,
statements: Vec<SqlStatement>,
max_rows: u32,
schema: Option<String>,
on_progress: Channel<ExecutionEvent>,
) -> IdeResult<()> {
let result = execute_statements(host, window, request, &id, statements, 0, max_rows, schema.as_deref(), |event| {
on_progress.send(event)
})
.await;
// The invocation reply can reach the viewer before a large result frame.
on_progress.send(ExecutionEvent::Done { error: result.err() })
}
/// Runs in order on one request and stops on cancellation or the first error.
#[allow(clippy::too_many_arguments)]
async fn execute_statements(
host: &Host,
window: &str,
request: RequestId,
id: &str,
statements: Vec<SqlStatement>,
skip: u32,
max_rows: u32,
schema: Option<&str>,
mut emit: impl FnMut(ExecutionEvent) -> IdeResult<()>,
) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
let cancel = host.begin_request(request);
let mut out = Vec::new();
for statement in statements {
match db
.execute_from(&id, &statement.text, skip as usize, max_rows.max(1) as usize, &cancel, schema.as_deref())
.await
{
Ok(result) => out.push(StatementOutcome { statement, result: Some(result), error: None }),
Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => {
host.end_request(request);
return Err(e);
let result = async {
for (index, statement) in statements.into_iter().enumerate() {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
Err(e) if e.kind == ide_core::error::ErrorKind::PermissionDenied && out.is_empty() => {
// Not connected for lack of a password: the UI asks and retries.
host.end_request(request);
return Err(e);
}
Err(e) => {
out.push(StatementOutcome { statement, result: None, error: Some(e.message) });
emit(ExecutionEvent::Started { index: index as u32 })?;
let outcome = match db
.execute_from(id, &statement.text, skip as usize, max_rows.max(1) as usize, &cancel, schema)
.await
{
Ok(result) => StatementOutcome { statement, result: Some(result), error: None },
Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => return Err(e),
// The UI may retry a login failure only before any statement has completed.
Err(e) if e.kind == ide_core::error::ErrorKind::PermissionDenied && index == 0 => return Err(e),
Err(e) => StatementOutcome { statement, result: None, error: Some(e.message) },
};
let failed = outcome.error.is_some();
emit(ExecutionEvent::Completed { index: index as u32, outcome })?;
if failed {
break;
}
}
Ok(())
}
.await;
host.end_request(request);
Ok(out)
result
}
#[allow(clippy::too_many_arguments)]
@@ -539,6 +610,7 @@ ide_command::domain!(
db_disconnect,
db_drop_database,
db_execute,
db_execute_stream,
db_explain,
db_finish_transaction,
db_history,
@@ -550,6 +622,7 @@ ide_command::domain!(
db_object_ddl,
db_remove_history,
db_retain_catalog,
db_save_source_visibility,
db_save_sources,
db_saved_catalog,
db_schema_objects,
@@ -567,3 +640,69 @@ ide_command::domain!(
db_test_tunnel,
db_trust_ssh_host,
);
#[cfg(test)]
mod tests {
use super::*;
use crate::HostConfig;
use ide_db::DbDriver;
use std::sync::Arc;
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_reporting_error_stops_the_batch_and_releases_the_request() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("project");
std::fs::create_dir(&root).unwrap();
let host = Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(|_| {})),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
let window = "main";
host.open_project(window, &root).unwrap();
host.set_project_trust(&root, true, false).await.unwrap();
let id = "test";
let file = root.join("test.sqlite");
std::fs::File::create(&file).unwrap();
db_save_sources(
&host,
window,
vec![DataSource { id: id.into(), name: id.into(), file: Some(file.into()), ..Default::default() }],
)
.await
.unwrap();
let statements =
ide_db::split::split("CREATE TABLE items (n INTEGER); INSERT INTO items VALUES (1);", DbDriver::Sqlite);
let request = RequestId(1);
let error = execute_statements(&host, window, request, id, statements, 0, 10, None, |event| match event {
ExecutionEvent::Started { index: 0 } => Ok(()),
ExecutionEvent::Completed { index: 0, outcome } => {
assert!(outcome.error.is_none(), "{:?}", outcome.error);
Err(IdeError::internal("cannot report result"))
}
_ => panic!("the failed callback must stop execution"),
})
.await
.unwrap_err();
assert_eq!(error.message, "cannot report result");
// After cleanup, cancel is remembered for the next request with this id.
host.cancel_request(request);
assert!(host.begin_request(request).is_cancelled());
let query = ide_db::split::split(
"SELECT 99 AS n UNION ALL SELECT count(*) FROM items ORDER BY n DESC",
DbDriver::Sqlite,
);
let outcomes = db_execute(&host, window, RequestId(2), id.into(), query, 1, 10, None).await.unwrap();
assert_eq!(outcomes[0].result.as_ref().unwrap().rows, vec![vec![Some("0".into())]]);
}
}
+31 -1
Переглянути файл
@@ -129,7 +129,8 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
};
host.require_trust(window)?;
let server_port = debug_server_port(&config);
let result = host.debugger.start_with(config, owner, custom).await;
let exception_classes = server_port.and_then(|port| exception_class_backend(host, window, port));
let result = host.debugger.start_with_exception_classes(config, owner, custom, exception_classes).await;
flush_output();
if let Ok(id) = &result {
let sink = host.window_sink(label);
@@ -208,6 +209,18 @@ fn attach_jvm_inspector(host: &Host, window: &str, session: DebugSessionId, port
}
}
/// Given before the session starts, unlike the inspector: the breakpoints are armed before
/// `configurationDone`, so a throw in `main`'s first line stops.
fn exception_class_backend(
host: &Host,
window: &str,
port: u16,
) -> Option<std::sync::Arc<dyn ide_jvm_inspect::ExceptionClassBreakpoints>> {
let project = host.project(window).ok()?;
let module = project.lsp.java_debug_server_module(port)?;
Some(std::sync::Arc::new(ide_lsp::JdtExceptionBreakpoints::new(project.lsp.clone(), module)))
}
/// A JVM the debugger starts itself: an Application or Spring Boot configuration, launched by
/// java-debug, java-analyzer or the Kotlin debugger (JAR Application debugs through a run with a
/// JDWP agent).
@@ -342,6 +355,11 @@ pub async fn debug_variables(host: &Host, session: DebugSessionId, reference: i6
host.debugger.variables(session, reference).await
}
#[command(trust = trusted)]
pub async fn debug_resolve_variable(host: &Host, session: DebugSessionId, variable: Variable) -> IdeResult<Variable> {
host.debugger.resolve_variable(session, variable).await
}
#[command(trust = trusted)]
pub async fn debug_evaluate(
host: &Host,
@@ -448,6 +466,16 @@ pub async fn debug_set_exception_breakpoints(
host.debugger.set_exception_breakpoints(choices).await
}
/// Exception breakpoints on chosen classes (all sessions that take them, and later ones).
#[command(trust = trusted)]
pub async fn debug_set_exception_class_breakpoints(
host: &Host,
breakpoints: Vec<ExceptionClassBreakpoint>,
) -> IdeResult<()> {
host.debugger.set_exception_class_breakpoints(breakpoints).await;
Ok(())
}
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn debug_set_variable(
@@ -834,6 +862,7 @@ ide_command::domain!(
debug_listen_for_jvm,
debug_pause,
debug_redefine_classes,
debug_resolve_variable,
debug_restart_frame,
debug_resume,
debug_run_to,
@@ -843,6 +872,7 @@ ide_command::domain!(
debug_set_breakpoints,
debug_set_data_breakpoints,
debug_set_exception_breakpoints,
debug_set_exception_class_breakpoints,
debug_set_function_breakpoints,
debug_set_variable,
debug_stack_trace,
+99 -2
Переглянути файл
@@ -2,7 +2,10 @@
use crate::Host;
use ide_command::command;
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, RequestId};
use ide_workspace::dependencies::{DependencyVersionSource, DependencyVersions, cargo, go, maven, npm};
use ide_workspace::dependencies::{
DependencyVersionSource, DependencyVersions, PythonRequirements, UnsatisfiedRequirement, cargo, go, maven, npm,
python,
};
use std::collections::BTreeMap;
use std::hash::{DefaultHasher, Hash, Hasher};
use std::path::{Path, PathBuf};
@@ -254,6 +257,50 @@ pub async fn dependency_versions(
result
}
/// The requirements of a `requirements*.txt` / `pyproject.toml` the project's interpreter
/// doesn't satisfy; `None` for other files, or with no local interpreter to ask.
#[command(trust = trusted)]
pub async fn python_requirements(
host: &Host,
window: &str,
doc: DocId,
request: RequestId,
) -> IdeResult<Option<PythonRequirements>> {
let project = host.project(window)?;
let config_dir = host.config_dir.clone();
let cancel = host.begin_project_read_request(window, request);
let result = host
.blocking(move || {
let snap = project.documents.snapshot(doc)?;
let name = snap.path.file_name().and_then(|n| n.to_str()).unwrap_or_default();
if snap.large || snap.read_only {
return Ok(None);
}
let dependencies = python::requirements(name, &snap.text);
if dependencies.is_empty() {
return Ok(None);
}
// Running the interpreter runs project code (sitecustomize, .pth files).
project.require_trust()?;
let Some(python) = crate::ops::sdk::effective_python(&config_dir, &project, snap.path.parent()) else {
return Ok(None);
};
let requirements: Vec<&str> = dependencies.iter().map(|d| d.requirement.as_str()).collect();
let states = ide_sdk::python::unsatisfied_requirements(&python, &requirements, &cancel)?;
let unsatisfied = dependencies
.into_iter()
.zip(states)
.filter_map(|(dependency, state)| {
state.map(|s| UnsatisfiedRequirement { dependency, installed: s.installed })
})
.collect();
Ok(Some(PythonRequirements { python: python.into(), unsatisfied }))
})
.await;
host.end_request(request);
result
}
#[cfg(test)]
mod tests {
use super::*;
@@ -313,6 +360,56 @@ mod tests {
host.close_project("main");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn requirements_are_checked_against_the_project_virtualenv() {
let Some(base) = ide_core::tool_path::find_command(
"python3",
&ide_core::tool_path::search_path_in(&std::env::temp_dir()),
&std::env::temp_dir(),
) else {
return;
};
let temp = tempfile::tempdir().unwrap();
let base_dir = dunce::canonicalize(temp.path()).unwrap();
let root = base_dir.join("project");
std::fs::create_dir(&root).unwrap();
let status = std::process::Command::new(base)
.args(["-I", "-m", "venv", "--without-pip"])
.arg(root.join(".venv"))
.status()
.unwrap();
assert!(status.success());
let text = "# 中文\nopenidea-missing-xyz>=1\n-r other.txt\n";
let path = root.join("requirements.txt");
std::fs::write(&path, text).unwrap();
let host = Host::new(HostConfig {
config_dir: base_dir.join("config"),
data_dir: base_dir.join("data"),
local_data_dir: base_dir.join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(|_| {})),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
let project = host.open_project("main", &root).unwrap();
let info = project.documents.open(&path).unwrap();
// Restricted Mode never runs the interpreter.
assert!(python_requirements(&host, "main", info.id, RequestId(429)).await.is_err());
project.trusted.store(true, std::sync::atomic::Ordering::Release);
let found = python_requirements(&host, "main", info.id, RequestId(430)).await.unwrap().unwrap();
assert!(found.python.0.starts_with(root.join(".venv")));
assert_eq!(found.unsatisfied.len(), 1);
assert_eq!(found.unsatisfied[0].dependency.package, "openidea-missing-xyz");
assert_eq!(found.unsatisfied[0].installed, None);
let other = root.join("notes.txt");
std::fs::write(&other, text).unwrap();
let info = project.documents.open(&other).unwrap();
assert!(python_requirements(&host, "main", info.id, RequestId(431)).await.unwrap().is_none());
host.close_project("main");
}
struct CachedNpm;
impl DependencyVersionSource for CachedNpm {
fn id(&self) -> &'static str {
@@ -361,4 +458,4 @@ mod tests {
}
}
ide_command::domain!(dependencies: dependency_versions);
ide_command::domain!(dependencies: dependency_versions, python_requirements);
+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,
+6 -3
Переглянути файл
@@ -85,7 +85,7 @@ pub async fn doc_set_line_ending(host: &Host, window: &str, doc: DocId, line_end
}
/// Structure view: LSP document symbols when available (with tree-sitter
/// visibility), tree-sitter otherwise.
/// visibility and type-alias kinds), tree-sitter otherwise.
/// Tree-sitter answers come from the per-document tree cache (incremental
/// re-parse); large documents get no syntax structure.
#[command(trust = always)]
@@ -113,10 +113,13 @@ pub async fn doc_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec
};
let syntax = || project.syntax.outline(doc, &snap.language, snap.version, &snap.text);
Ok(match lsp {
// Server symbols carry no visibility; borrow it from the syntax tree.
// Server symbols carry no visibility, nor a kind for type aliases; borrow them from
// the syntax tree.
Some(mut items) => {
if !snap.large {
ide_language::merge_visibility(&mut items, &syntax());
let syntax = syntax();
ide_language::merge_visibility(&mut items, &syntax);
ide_language::merge_kinds(&mut items, &syntax);
}
items
}
+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());
+128 -49
Переглянути файл
@@ -1,5 +1,5 @@
use super::Channel;
use crate::Host;
use crate::{Host, Project};
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId};
use ide_vfs::FileEntry;
@@ -21,6 +21,7 @@ pub async fn fs_compare_directories(
window: &str,
left: PathBuf,
right: PathBuf,
mode: ide_vfs::DirectoryCompareMode,
request: RequestId,
on_progress: Channel<ide_vfs::DirectoryCompareProgress>,
) -> IdeResult<Vec<ide_vfs::DirectoryCompareEntry>> {
@@ -29,19 +30,58 @@ pub async fn fs_compare_directories(
let result = host
.blocking(move || {
let last = std::cell::Cell::new(std::time::Instant::now() - std::time::Duration::from_secs(1));
ide_vfs::compare_directories(&left, &right, Some(&project.root), &project.exclude_globs(), &cancel, |p| {
// Bound IPC traffic even when hashing multi-gigabyte files.
if last.get().elapsed() >= std::time::Duration::from_millis(80) || p.total == Some(p.compared) {
let _ = on_progress.send(p);
last.set(std::time::Instant::now());
}
})
ide_vfs::compare_directories(
&left,
&right,
mode,
Some(&project.root),
&project.exclude_globs(),
&cancel,
|p| {
// Bound IPC traffic even when hashing multi-gigabyte files.
if last.get().elapsed() >= std::time::Duration::from_millis(80) || p.total == Some(p.compared) {
let _ = on_progress.send(p);
last.set(std::time::Instant::now());
}
},
)
})
.await;
host.end_request(request);
result
}
fn comparison_entry_path(path: &Path) -> IdeResult<()> {
if path.as_os_str().is_empty() || path.components().any(|c| !matches!(c, std::path::Component::Normal(_))) {
return Err(IdeError::invalid("expected a relative comparison entry path"));
}
Ok(())
}
fn copy_entry(
project: &Project,
source_root: &Path,
destination_root: &Path,
path: &Path,
overwrite: bool,
) -> IdeResult<()> {
let from = source_root.join(path);
let to = destination_root.join(path);
if overwrite {
project.history.record_deletion(&to, DELETE_SNAPSHOT_LIMIT);
}
project.with_disk_sync(|| {
ide_vfs::copy_merge(
&from,
&to,
overwrite,
Some(&project.root),
&project.exclude_globs(),
(source_root, destination_root),
)
})
}
#[command(trust = always)]
pub async fn fs_copy_merge(
host: &Host,
@@ -51,28 +91,63 @@ pub async fn fs_copy_merge(
path: PathBuf,
overwrite: bool,
) -> IdeResult<()> {
if path.as_os_str().is_empty() || path.components().any(|c| !matches!(c, std::path::Component::Normal(_))) {
return Err(ide_core::IdeError::invalid("expected a relative comparison entry path"));
comparison_entry_path(&path)?;
let project = host.project(window)?;
host.blocking(move || copy_entry(&project, &source_root, &destination_root, &path, overwrite)).await
}
/// Runs Compare Directories' synchronisation operations in order. A failed operation is
/// reported and the rest still run; cancellation stops before the next one.
#[command(trust = always)]
pub async fn fs_synchronize_directories(
host: &Host,
window: &str,
left: PathBuf,
right: PathBuf,
operations: Vec<ide_vfs::DirectorySyncOperation>,
request: RequestId,
on_progress: Channel<ide_vfs::DirectorySyncProgress>,
) -> IdeResult<Vec<ide_vfs::DirectorySyncFailure>> {
for op in &operations {
comparison_entry_path(Path::new(&op.path))?;
}
let project = host.project(window)?;
host.blocking(move || {
let from = source_root.join(&path);
let to = destination_root.join(&path);
if overwrite {
project.history.record_deletion(&to, DELETE_SNAPSHOT_LIMIT);
}
project.with_disk_sync(|| {
ide_vfs::copy_merge(
&from,
&to,
overwrite,
Some(&project.root),
&project.exclude_globs(),
(&source_root, &destination_root),
)
let cancel = host.begin_request(request);
let result = host
.blocking(move || {
use ide_vfs::DirectorySyncAction::*;
let total = operations.len() as u32;
let mut failures = Vec::new();
for (done, op) in operations.into_iter().enumerate() {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let _ = on_progress.send(ide_vfs::DirectorySyncProgress {
done: done as u32,
total,
path: op.path.clone(),
});
let path = Path::new(&op.path);
let result = match op.action {
CopyToLeft => copy_entry(&project, &right, &left, path, op.overwrite),
CopyToRight => copy_entry(&project, &left, &right, path, op.overwrite),
DeleteLeft => delete_recorded(Some(&project), &left.join(path), false).map(|_| ()),
DeleteRight => delete_recorded(Some(&project), &right.join(path), false).map(|_| ()),
};
if let Err(e) = result {
failures.push(ide_vfs::DirectorySyncFailure {
path: op.path,
action: op.action,
message: e.message,
});
}
}
let _ = on_progress.send(ide_vfs::DirectorySyncProgress { done: total, total, path: String::new() });
Ok(failures)
})
})
.await
.await;
host.end_request(request);
result
}
/// Files of a deleted folder snapshotted in Local History.
@@ -85,11 +160,13 @@ pub async fn fs_read_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<
host.blocking(move || {
let excludes = project
.map(|p| {
let globs = p.exclude_globs();
// An attached project's folders follow its own exclusions.
let root = p.root_of(&path);
let globs = p.exclude_globs_in(&root);
// `read_dir` matches relative to the enclosing repository: re-anchor
// project-root patterns (`/build`) when the project is a repo subfolder.
let repo = p.root.ancestors().find(|d| d.join(".git").exists());
match repo.and_then(|r| p.root.strip_prefix(r).ok()).filter(|rel| !rel.as_os_str().is_empty()) {
// root patterns (`/build`) when the project is a repo subfolder.
let repo = root.ancestors().find(|d| d.join(".git").exists());
match repo.and_then(|r| root.strip_prefix(r).ok()).filter(|rel| !rel.as_os_str().is_empty()) {
Some(rel) => {
let rel = rel.to_string_lossy().replace('\\', "/");
globs.into_iter().map(|g| if g.starts_with('/') { format!("/{rel}{g}") } else { g }).collect()
@@ -175,26 +252,27 @@ pub async fn fs_delete_with_undo(host: &Host, window: &str, path: PathBuf) -> Id
async fn delete_with_history(host: &Host, window: &str, path: PathBuf, undoable: bool) -> IdeResult<DeletionUndo> {
let project = if undoable { Some(host.project(window)?) } else { host.project(window).ok() };
host.blocking(move || {
let paths = ide_workspace::file_ops::deletion_paths(&path)?;
let mut undo = DeletionUndo::default();
if let Some(p) = &project {
if undoable {
undo = p.history.capture_deletion_undo(&paths, DELETE_SNAPSHOT_LIMIT);
} else {
for pth in &paths {
p.history.record_deletion(pth, DELETE_SNAPSHOT_LIMIT);
}
host.blocking(move || delete_recorded(project.as_deref(), &path, undoable)).await
}
fn delete_recorded(project: Option<&Project>, path: &Path, undoable: bool) -> IdeResult<DeletionUndo> {
let paths = ide_workspace::file_ops::deletion_paths(path)?;
let mut undo = DeletionUndo::default();
if let Some(p) = project {
if undoable {
undo = p.history.capture_deletion_undo(&paths, DELETE_SNAPSHOT_LIMIT);
} else {
for pth in &paths {
p.history.record_deletion(pth, DELETE_SNAPSHOT_LIMIT);
}
}
ide_workspace::file_ops::delete(&path)?;
// A checkout backend opens the paths for delete; Git's hook is a no-op.
if let Some(p) = project {
let _ = p.with_backend_of(&path, |r| r.files_deleted(&paths));
}
Ok(undo)
})
.await
}
ide_workspace::file_ops::delete(path)?;
// A checkout backend opens the paths for delete; Git's hook is a no-op.
if let Some(p) = project {
let _ = p.with_backend_of(path, |r| r.files_deleted(&paths));
}
Ok(undo)
}
#[command(trust = always)]
@@ -306,5 +384,6 @@ ide_command::domain!(
fs_read_text,
fs_rename,
fs_set_writable,
fs_synchronize_directories,
fs_undo_delete,
);
+155 -12
Переглянути файл
@@ -50,6 +50,7 @@ pub(crate) async fn resolve_launch(
if !project.lsp.java_served_by_jdtls(&module) {
return resolve_launch_without_jdtls(host, &project, module, test, policy, cancel).await;
}
let waiting = project.java_launches_waiting.add(module.clone(), test, policy);
let settings = project.settings.effective();
// A launch builds incrementally unless the configuration asks for Rebuild or NoBuild.
let build = policy != BuildPolicy::NoBuild;
@@ -98,6 +99,12 @@ pub(crate) async fn resolve_launch(
drop_processor_recreate_errors(&mut info);
}
}
let model = std::sync::Arc::new(model);
let members = if delegated {
build_members(&project, &model, &module, test, prefer_maven, &waiting, cancel).await?
} else {
Vec::new()
};
let lsp_ms = started.elapsed().as_millis();
let data_dir = host.local_data_dir.clone();
let cancel = cancel.clone();
@@ -106,16 +113,20 @@ pub(crate) async fn resolve_launch(
let local_repo = ide_sdk::apply::maven_local_repository(&project.root, &settings);
// Module outputs the launch runs from a snapshot of: the originals must not come back.
let mut snapshotted = Vec::new();
// The modules of the launches sharing this build also share its classpath probe.
let probed: Vec<PathBuf> =
std::iter::once(module.clone()).chain(members.iter().map(|m| m.module.clone())).collect();
let built = if delegated {
let rebuild_on_jdt_errors = rebuild_on_jdt_errors(policy, prefer_maven, info.error_count);
let outputs = project.java_launch_snapshots.lock().build(
&project.root,
&model,
&module,
cache::BuildOptions { test, policy, rebuild_on_jdt_errors },
cache::BuildOptions { test, policy, rebuild_on_jdt_errors, members },
local_repo.clone(),
&cancel,
)?;
drop(waiting);
let copies = use_snapshot(&mut info, &outputs.originals, &outputs.snapshot);
apply_external_build_result(&mut info, outputs.failure, outputs.authoritative);
snapshotted = outputs.originals;
@@ -138,10 +149,10 @@ pub(crate) async fn resolve_launch(
// m2e runs inside jdtls on the server JDK and can resolve a different
// Maven profile/classifier than the module build. Ask the same Maven
// process that built the module for its runtime/test dependencies.
let maven_cp = compile::module_classpath(
let maven_cp = compile::module_classpaths(
&project.root,
&model,
&module,
&probed,
test,
local_repo,
&project.build_cache_dir(),
@@ -301,19 +312,30 @@ fn finish_launch(
// The module/project JDK, else the JDK the Java language server builds the module with, else one
// matching its Java version.
let project_jdk = ide_sdk::apply::module_jdk(root, module, settings);
let from_server = info.java_home.as_deref().map(ide_sdk::java::java_executable).filter(|p| p.is_file());
let java = project_jdk.map(|j| ide_sdk::java::java_executable(&j.home)).or(from_server).or_else(|| {
// The build model's level includes what the module inherits from its parent POMs.
let release = model
// The build model's level includes what the module inherits from its parent POMs.
let release = || {
model
.maven
.as_ref()
.and_then(|m| m.projects.iter().find(|p| root.join(&p.dir) == module))
.and_then(|p| p.java_version)
.or_else(|| ide_sdk::java::project_java_version(module));
let jdks = ide_sdk::java::installed_jdks();
info.hints.extend(ide_sdk::java::missing_jdk_message(&jdks, release));
ide_sdk::java::pick_jdk(&jdks, release).map(|j| ide_sdk::java::java_executable(&j.home))
});
.or_else(|| ide_sdk::java::project_java_version(module))
};
let java = match project_jdk {
Some(j) => Some(ide_sdk::java::java_executable(&j.home)),
None => {
let release = release();
let server = info.java_home.as_deref().and_then(|home| server_java(home, release));
match server {
Some(java) => Some(java),
None => {
let jdks = ide_sdk::java::installed_jdks();
info.hints.extend(ide_sdk::java::missing_jdk_message(&jdks, release));
ide_sdk::java::pick_jdk(&jdks, release).map(|j| ide_sdk::java::java_executable(&j.home))
}
}
}
};
info.java_exec = Some(java.map(|p| p.to_string_lossy().into_owned()).unwrap_or_else(|| "java".to_owned()));
let exec = PathBuf::from(info.java_exec.as_deref().unwrap_or("java"));
let shorten = ide_run::java_cmdline::shortening_for(&exec, &info.class_paths, &info.module_paths, cfg!(windows));
@@ -328,6 +350,19 @@ fn finish_launch(
}
}
/// The `java` of the JDK a Java language server reports, when it can run classes compiled for
/// `release`: that JDK is the one the server runs on or defaults to, not necessarily one the
/// module's bytecode loads on. A home whose version is unknown is used only when `release` is too.
fn server_java(home: &Path, release: Option<u32>) -> Option<PathBuf> {
match ide_sdk::java::jdk_at(home) {
Some(jdk) if release.is_none_or(|release| jdk.major >= release) => {
Some(ide_sdk::java::java_executable(&jdk.home))
}
Some(_) => None,
None => Some(ide_sdk::java::java_executable(home)).filter(|java| release.is_none() && java.is_file()),
}
}
/// With Settings › Maven › Delegate IDE build/run actions to Maven, javac's verdict replaces
/// JDT's. Classes JDT wrote for sources with errors look up to date to Maven's incremental
/// compiler, so a launch JDT reports errors for recompiles everything.
@@ -406,6 +441,82 @@ fn apply_library_classpath(
}
/// Whether a launch should be built by the project's build system instead of jdtls.
/// The launches waiting for their build that join this launch's Maven run, each with
/// whether its JDT errors call for a clean rebuild (as its own launch would decide).
async fn build_members(
project: &std::sync::Arc<crate::Project>,
model: &std::sync::Arc<BuildModel>,
module: &Path,
test: bool,
prefer_maven: bool,
waiting: &cache::WaitingGuard,
cancel: &CancellationToken,
) -> IdeResult<Vec<cache::Member>> {
let others: Vec<_> = waiting.others().into_iter().filter(|o| project.lsp.java_served_by_jdtls(&o.module)).collect();
if others.is_empty() {
return Ok(Vec::new());
}
let joining = {
let (project, model, module) = (project.clone(), model.clone(), module.to_path_buf());
tokio::task::spawn_blocking(move || {
joining_launches(&project.root, &project.build_cache_dir(), &model, &module, test, others, prefer_maven)
})
.await
.map_err(|e| IdeError::internal(e.to_string()))?
};
let mut members = Vec::new();
for launch in joining {
// The build lock is held: the member's own launch reads the same diagnostics afterwards.
let errors = match project.lsp.java_launch(&launch.module, test, false, false, true, cancel).await {
Ok(info) => info.error_count,
Err(e) if e.kind == ErrorKind::Cancelled => return Err(e),
Err(e) => {
tracing::debug!(module = %launch.module.display(), "Not joining the launch build: {e}");
continue;
}
};
members.push(cache::Member {
module: launch.module.clone(),
rebuild_on_jdt_errors: rebuild_on_jdt_errors(launch.policy, prefer_maven, errors),
});
}
Ok(members)
}
/// Waiting launches that can share the Maven build of the launch of `module`: an
/// incremental build (Rebuild and "no error check" launches keep their own) of the same
/// scope, of another module of the same Maven reactor, delegated to Maven as this one is.
fn joining_launches(
root: &Path,
cache_dir: &Path,
model: &BuildModel,
module: &Path,
test: bool,
others: Vec<std::sync::Arc<cache::WaitingLaunch>>,
prefer_maven: bool,
) -> Vec<std::sync::Arc<cache::WaitingLaunch>> {
let Some(reactor) = compile::launch_reactor(root, model, module) else { return Vec::new() };
let mut seen = std::collections::HashSet::from([module.to_path_buf()]);
others
.into_iter()
.filter(|o| {
let is_maven =
model.maven.as_ref().is_some_and(|m| m.projects.iter().any(|p| root.join(&p.dir) == o.module));
o.test == test
&& matches!(o.policy, BuildPolicy::Automatic | BuildPolicy::Make)
&& compile::launch_reactor(root, model, &o.module).as_ref() == Some(&reactor)
&& seen.insert(o.module.clone())
&& delegates_to_external_build(
is_maven,
o.policy,
compile::launch_has_non_java_sources(root, model, &o.module, test),
cache::has_record(root, cache_dir, &o.module),
prefer_maven,
)
})
.collect()
}
/// A Rebuild has to clean the output; jdtls' full build only recompiles sources, so
/// Maven modules always delegate for it, even when every source is Java.
/// `prefer_maven` is Settings › Maven › Delegate IDE build/run actions to Maven.
@@ -557,6 +668,38 @@ fn drop_processor_recreate_errors(info: &mut JavaLaunchInfo) {
mod tests {
use super::*;
fn fake_jdk(dir: &Path, version: Option<&str>) -> PathBuf {
let bin = dir.join("bin");
std::fs::create_dir_all(&bin).unwrap();
std::fs::write(bin.join(if cfg!(windows) { "java.exe" } else { "java" }), "").unwrap();
if let Some(version) = version {
std::fs::write(dir.join("release"), format!("JAVA_VERSION=\"{version}\"\n")).unwrap();
}
dir.to_path_buf()
}
#[test]
fn a_server_jdk_older_than_the_module_release_is_not_used() {
let tmp = tempfile::tempdir().unwrap();
let jdk17 = fake_jdk(&tmp.path().join("17"), Some("17.0.12"));
let jdk21 = fake_jdk(&tmp.path().join("21"), Some("21.0.4"));
let unknown = fake_jdk(&tmp.path().join("unknown"), None);
// (server JDK, module release, used?)
let cases = [
(&jdk17, Some(21), false),
(&jdk17, Some(17), true),
(&jdk17, Some(11), true),
(&jdk17, None, true),
(&jdk21, Some(21), true),
(&unknown, None, true),
(&unknown, Some(21), false),
];
for (home, release, used) in cases {
assert_eq!(server_java(home, release).is_some(), used, "{} for release {release:?}", home.display());
}
assert!(server_java(&tmp.path().join("missing"), None).is_none());
}
#[test]
fn recognises_a_processor_recreating_its_output() {
assert!(processor_recreated_a_file(
+374 -53
Переглянути файл
@@ -2,10 +2,12 @@
use ide_build::compile::{self, LaunchFingerprint};
use ide_core::{CancellationToken, IdeError, IdeResult};
use ide_run::BuildPolicy;
use parking_lot::Mutex;
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use std::collections::{HashMap, HashSet};
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::Arc;
#[derive(Debug, Serialize, Deserialize)]
pub(super) struct Outputs {
@@ -49,6 +51,64 @@ pub(super) struct BuildOptions {
/// A JDT error makes a cache miss rebuild, but it must not prevent an unchanged
/// snapshot from being reused on the next launch.
pub rebuild_on_jdt_errors: bool,
/// Other launches of the same reactor waiting for their build (configurations started
/// together, #3971): their modules join this Maven run, and their launches then reuse
/// the snapshots recorded here instead of running Maven again.
pub members: Vec<Member>,
}
/// A launch module joining another launch's build; see [`BuildOptions::members`].
#[derive(Debug)]
pub(super) struct Member {
pub module: PathBuf,
pub rebuild_on_jdt_errors: bool,
}
/// Java launches from their start until their build: one launch's Maven run also builds
/// the modules of launches still waiting (configurations started together, #3971).
#[derive(Default)]
pub(crate) struct Waiting(Arc<Mutex<Vec<Arc<WaitingLaunch>>>>);
#[derive(Debug)]
pub(super) struct WaitingLaunch {
pub module: PathBuf,
pub test: bool,
pub policy: BuildPolicy,
}
/// Leaves [`Waiting`] when dropped.
pub(super) struct WaitingGuard {
all: Arc<Mutex<Vec<Arc<WaitingLaunch>>>>,
launch: Arc<WaitingLaunch>,
}
impl Waiting {
pub(super) fn add(&self, module: PathBuf, test: bool, policy: BuildPolicy) -> WaitingGuard {
let launch = Arc::new(WaitingLaunch { module, test, policy });
self.0.lock().push(launch.clone());
WaitingGuard { all: self.0.clone(), launch }
}
}
impl WaitingGuard {
/// The other launches still waiting, in the order they started.
pub(super) fn others(&self) -> Vec<Arc<WaitingLaunch>> {
self.all.lock().iter().filter(|l| !Arc::ptr_eq(l, &self.launch)).cloned().collect()
}
}
impl Drop for WaitingGuard {
fn drop(&mut self) {
self.all.lock().retain(|l| !Arc::ptr_eq(l, &self.launch));
}
}
/// A module whose launch snapshot can't be reused, ready to build.
struct Pending {
module: PathBuf,
record: PathBuf,
before: Option<LaunchFingerprint>,
previous: Option<Outputs>,
}
/// Owned by Project: running JVMs may still load superseded outputs until it drops.
@@ -56,11 +116,14 @@ pub(crate) struct Session {
cache: PathBuf,
initialized: bool,
unreferenced: Vec<PathBuf>,
/// A shared build that failed for a member, by (module, test): the member's own launch
/// reports it instead of running the same failing build again while its inputs are unchanged.
failed: HashMap<(PathBuf, bool), (LaunchFingerprint, String)>,
}
impl Session {
pub(crate) fn new(cache: PathBuf) -> Self {
Self { cache, initialized: false, unreferenced: Vec::new() }
Self { cache, initialized: false, unreferenced: Vec::new(), failed: HashMap::new() }
}
pub(super) fn initialize(&mut self) {
@@ -72,6 +135,16 @@ impl Session {
}
}
/// Build › Rebuild replaced the module outputs. The recorded snapshots were copied from
/// the outputs before the clean and may hold classes it removed (a class moved to another
/// package leaves its old file behind when jdtls wrote it), so none of them is reused:
/// the next launch copies the rebuilt outputs.
pub(crate) fn forget_reusable_snapshots(&mut self) {
if let Err(error) = forget_reusable_snapshots(&self.cache) {
tracing::warn!(%error, "Cannot invalidate Java launch snapshots");
}
}
pub(super) fn build(
&mut self,
root: &Path,
@@ -82,20 +155,84 @@ impl Session {
cancel: &CancellationToken,
) -> IdeResult<Outputs> {
self.initialize();
let BuildOptions { test, policy, rebuild_on_jdt_errors } = options;
let cache = &self.cache;
let record =
record_path(root, cache, module, test).ok_or_else(|| IdeError::internal("launch outside project"))?;
let snapshots = cache.join("java-launch/snapshots");
let fingerprint = || match compile::launch_fingerprint(root, model, module, test, local_repo.clone(), cancel) {
Ok(value) => Ok(value),
Err(e) if cancel.is_cancelled() => Err(e),
Err(e) => {
tracing::debug!(error = %e, "Cannot fingerprint Maven launch; rebuilding");
Ok(None)
}
let BuildOptions { test, policy, rebuild_on_jdt_errors, members } = options;
let mut lead = match self.prepare(root, model, module, test, policy, &local_repo, cancel)? {
Ok(outputs) => return Ok(outputs),
Err(pending) => pending,
};
let mut before = fingerprint()?;
if let Some((fingerprint, failure)) = self.failed.remove(&(module.to_path_buf(), test))
&& lead.before.as_ref() == Some(&fingerprint)
&& matches!(policy, BuildPolicy::Automatic | BuildPolicy::Make)
{
tracing::info!(module = %module.display(), "The shared Maven launch build failed for these inputs");
return Err(IdeError::internal(failure));
}
// JDT can report errors from its own classpath while the last Maven snapshot is
// still valid. Reuse that snapshot first; only a cache miss needs the expensive
// clean rebuild that replaces JDT's error-stub classes.
let policy = if rebuild_on_jdt_errors { BuildPolicy::Rebuild } else { policy };
let mut joined = Vec::new();
let mut rebuild = policy == BuildPolicy::Rebuild;
for member in members {
if let Err(pending) =
self.prepare(root, model, &member.module, test, BuildPolicy::Make, &local_repo, cancel)?
{
rebuild |= member.rebuild_on_jdt_errors;
joined.push(pending);
}
}
let modules: Vec<PathBuf> =
std::iter::once(&lead).chain(&joined).map(|pending| pending.module.clone()).collect();
if modules.len() > 1 {
tracing::info!(?modules, "Building the launch modules in one Maven run");
}
let kind = if rebuild { compile::BuildKind::Rebuild } else { compile::BuildKind::Build };
let mut built = compile::build_for_launches(root, model, &modules, test, kind, cancel)?.into_iter();
let lead_built = built.next().unwrap();
for (pending, built) in joined.into_iter().zip(built) {
match built.failure {
Some(failure) => {
if let Some(before) = pending.before {
self.failed.insert((pending.module, test), (before, failure));
}
}
None => {
self.finish(root, model, pending, test, built.class_dirs, None, rebuild, &local_repo, cancel)?;
}
}
}
if let Some(failure) = &lead_built.failure {
if policy != BuildPolicy::MakeAndContinueOnErrors {
return Err(IdeError::internal(failure.clone()));
}
if let Some(mut previous) =
lead.previous.take().filter(|p| (0..p.originals.len()).all(|i| p.snapshot.join(i.to_string()).is_dir()))
{
previous.fingerprint = None;
previous.failure = lead_built.failure;
write_record(&lead.record, &previous)?;
return Ok(previous);
}
}
self.finish(root, model, lead, test, lead_built.class_dirs, lead_built.failure, rebuild, &local_repo, cancel)
}
/// The reusable snapshot of `module` (`Ok`), else the module marked for a build (`Err`).
#[allow(clippy::too_many_arguments)]
fn prepare(
&mut self,
root: &Path,
model: &ide_build::BuildModel,
module: &Path,
test: bool,
policy: BuildPolicy,
local_repo: &Option<PathBuf>,
cancel: &CancellationToken,
) -> IdeResult<Result<Outputs, Pending>> {
let record =
record_path(root, &self.cache, module, test).ok_or_else(|| IdeError::internal("launch outside project"))?;
let snapshots = self.cache.join("java-launch/snapshots");
let mut before = fingerprint(root, model, module, test, local_repo, cancel)?;
let previous = fs::read(&record).ok().and_then(|bytes| serde_json::from_slice::<Outputs>(&bytes).ok());
// Timestamp-incremental builders (Maven, the Kotlin plugin) skip sources whose
// mtime did not advance. An external edit that preserves both length and mtime
@@ -115,7 +252,7 @@ impl Session {
tracing::debug!(path = %path.display(), %error, "Cannot re-stamp externally edited source");
}
}
before = fingerprint()?;
before = fingerprint(root, model, module, test, local_repo, cancel)?;
}
if let Some(outputs) = previous.as_ref()
&& policy != BuildPolicy::Rebuild
@@ -124,12 +261,8 @@ impl Session {
tracing::info!(module = %module.display(), test, "Reusing Maven launch snapshot");
let mut outputs = previous.unwrap();
outputs.authoritative = true;
return Ok(outputs);
return Ok(Ok(outputs));
}
// JDT can report errors from its own classpath while the last Maven snapshot is
// still valid. Reuse that snapshot first; only a cache miss needs the expensive
// clean rebuild that replaces JDT's error-stub classes.
let policy = if rebuild_on_jdt_errors { BuildPolicy::Rebuild } else { policy };
// Retain a non-reusable record even on failure, so removing the final mixed
// source still delegates to Maven to clean its old classes on the next launch.
fs::create_dir_all(record.parent().unwrap())?;
@@ -137,24 +270,25 @@ impl Session {
if let Some(previous) = &previous {
self.unreferenced.push(previous.snapshot.clone());
}
let kind = if policy == BuildPolicy::Rebuild { compile::BuildKind::Rebuild } else { compile::BuildKind::Build };
let built = compile::build_for_launch(root, model, module, test, kind, cancel)?;
if let Some(failure) = &built.failure {
if policy != BuildPolicy::MakeAndContinueOnErrors {
return Err(IdeError::internal(failure.clone()));
}
if let Some(mut previous) =
previous.filter(|p| (0..p.originals.len()).all(|i| p.snapshot.join(i.to_string()).is_dir()))
{
previous.fingerprint = None;
previous.failure = built.failure;
let mut file = tempfile::NamedTempFile::new_in(record.parent().unwrap())?;
serde_json::to_writer(file.as_file_mut(), &previous).map_err(|e| IdeError::internal(e.to_string()))?;
file.persist(&record).map_err(|e| IdeError::from(e.error))?;
return Ok(previous);
}
}
let originals = built.class_dirs;
Ok(Err(Pending { module: module.to_path_buf(), record, before, previous }))
}
/// Copies the built outputs of a prepared module into a new snapshot and records it
/// when the build succeeded on inputs that did not change meanwhile.
#[allow(clippy::too_many_arguments)]
fn finish(
&mut self,
root: &Path,
model: &ide_build::BuildModel,
pending: Pending,
test: bool,
originals: Vec<PathBuf>,
failure: Option<String>,
authoritative: bool,
local_repo: &Option<PathBuf>,
cancel: &CancellationToken,
) -> IdeResult<Outputs> {
let snapshots = self.cache.join("java-launch/snapshots");
fs::create_dir_all(&snapshots)?;
let snapshot = tempfile::Builder::new().prefix("launch-").tempdir_in(&snapshots)?.keep();
// Retain every new snapshot even if copying or publishing its record fails.
@@ -165,29 +299,46 @@ impl Session {
}
ide_vfs::copy(source, &snapshot.join(i.to_string()))?;
}
let after = fingerprint()?;
let after = fingerprint(root, model, &pending.module, test, local_repo, cancel)?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let mut outputs = Outputs {
fingerprint: None,
snapshot,
originals,
failure: built.failure,
authoritative: policy == BuildPolicy::Rebuild,
};
if outputs.failure.is_none() && before.is_some() && before == after {
outputs.fingerprint = before;
fs::create_dir_all(record.parent().unwrap())?;
let mut file = tempfile::NamedTempFile::new_in(record.parent().unwrap())?;
serde_json::to_writer(file.as_file_mut(), &outputs).map_err(|e| IdeError::internal(e.to_string()))?;
file.persist(&record).map_err(|e| IdeError::from(e.error))?;
let mut outputs = Outputs { fingerprint: None, snapshot, originals, failure, authoritative };
if outputs.failure.is_none() && pending.before.is_some() && pending.before == after {
outputs.fingerprint = pending.before;
write_record(&pending.record, &outputs)?;
self.unreferenced.retain(|path| path != &outputs.snapshot);
}
Ok(outputs)
}
}
fn fingerprint(
root: &Path,
model: &ide_build::BuildModel,
module: &Path,
test: bool,
local_repo: &Option<PathBuf>,
cancel: &CancellationToken,
) -> IdeResult<Option<LaunchFingerprint>> {
match compile::launch_fingerprint(root, model, module, test, local_repo.clone(), cancel) {
Ok(value) => Ok(value),
Err(e) if cancel.is_cancelled() => Err(e),
Err(e) => {
tracing::debug!(error = %e, "Cannot fingerprint Maven launch; rebuilding");
Ok(None)
}
}
}
fn write_record(record: &Path, outputs: &Outputs) -> IdeResult<()> {
fs::create_dir_all(record.parent().unwrap())?;
let mut file = tempfile::NamedTempFile::new_in(record.parent().unwrap())?;
serde_json::to_writer(file.as_file_mut(), outputs).map_err(|e| IdeError::internal(e.to_string()))?;
file.persist(record).map_err(|e| IdeError::from(e.error))?;
Ok(())
}
impl Drop for Session {
fn drop(&mut self) {
// Recheck all records: another module or launch mode may reference a path.
@@ -200,6 +351,32 @@ impl Drop for Session {
}
}
/// Clears the fingerprint of every launch record under `cache`, so no snapshot matches the
/// sources any more. The records stay: their modules keep delegating to Maven.
fn forget_reusable_snapshots(cache: &Path) -> std::io::Result<()> {
let records = cache.join("java-launch/records");
if !records.try_exists()? {
return Ok(());
}
let mut pending = vec![records];
while let Some(dir) = pending.pop() {
for entry in fs::read_dir(dir)? {
let entry = entry?;
let kind = entry.file_type()?;
if kind.is_dir() {
pending.push(entry.path());
} else if kind.is_file() && entry.path().extension().is_some_and(|ext| ext == "json") {
let outputs: Option<Outputs> = serde_json::from_slice(&fs::read(entry.path())?).unwrap_or(None);
if let Some(mut outputs) = outputs.filter(|o| o.fingerprint.is_some()) {
outputs.fingerprint = None;
write_record(&entry.path(), &outputs).map_err(|e| std::io::Error::other(e.message))?;
}
}
}
}
Ok(())
}
fn referenced_snapshots(cache: &Path) -> std::io::Result<HashSet<PathBuf>> {
let mut referenced = HashSet::new();
let records = cache.join("java-launch/records");
@@ -273,6 +450,122 @@ mod tests {
ide_build::load(root, &root.join("cache"), None)
}
/// A reactor of `lib` and the applications `a` and `b` depending on it; the build script
/// compiles every module and logs its arguments.
fn reactor_fixture(root: &Path) -> ide_build::BuildModel {
let pom = |artifact: &str, extra: &str| {
format!(
"<project><groupId>demo</groupId><artifactId>{artifact}</artifactId><version>1</version>{extra}</project>"
)
};
fs::write(
root.join("pom.xml"),
pom(
"root",
"<packaging>pom</packaging><modules><module>lib</module><module>a</module><module>b</module></modules>",
),
)
.unwrap();
let lib = "<dependencies><dependency><groupId>demo</groupId><artifactId>lib</artifactId><version>1</version></dependency></dependencies>";
for (module, extra) in [("lib", ""), ("a", lib), ("b", lib), ("other", "")] {
fs::create_dir_all(root.join(module).join("src/main/java")).unwrap();
fs::write(root.join(module).join("pom.xml"), pom(module, extra)).unwrap();
fs::write(root.join(module).join("src/main/java/Main.java"), module).unwrap();
}
let script = root.join("mvnw");
fs::write(&script, "#!/bin/sh\necho build \"$@\" >> calls\nif [ -f broken ]; then exit 1; fi\nfor m in lib a b; do mkdir -p $m/target/classes; cp $m/src/main/java/Main.java $m/target/classes/Main.class; done\n").unwrap();
fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
ide_build::load(root, &root.join("cache"), None)
}
fn calls(root: &Path) -> Vec<String> {
fs::read_to_string(root.join("calls")).unwrap_or_default().lines().map(str::to_owned).collect()
}
#[test]
fn waiting_launches_of_one_reactor_share_one_maven_build() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = reactor_fixture(root);
let cancel = CancellationToken::new();
let mut session = Session::new(root.join("cache"));
let (a, b) = (root.join("a"), root.join("b"));
let with = |rebuild_on_jdt_errors: bool| BuildOptions {
members: vec![Member { module: b.clone(), rebuild_on_jdt_errors }],
..Default::default()
};
let lead = session.build(root, &model, &a, with(false), None, &cancel).unwrap();
assert_eq!(fs::read_to_string(lead.snapshot.join("0/Main.class")).unwrap(), "a");
assert_eq!(fs::read_to_string(lead.snapshot.join("1/Main.class")).unwrap(), "lib");
// b's own launch runs from the snapshot the shared build recorded for it.
let member = session.build(root, &model, &b, BuildOptions::default(), None, &cancel).unwrap();
assert!(member.authoritative);
assert_eq!(fs::read_to_string(member.snapshot.join("0/Main.class")).unwrap(), "b");
assert_eq!(calls(root).len(), 1);
assert!(calls(root)[0].contains("-pl a,b -am") && calls(root)[0].ends_with(" compile"), "{:?}", calls(root));
// A member whose JDT errors call for a clean build makes the shared build a rebuild.
fs::write(root.join("lib/src/main/java/Main.java"), "lib 2").unwrap();
session.build(root, &model, &a, with(true), None, &cancel).unwrap();
assert!(calls(root)[1].contains("-pl a,b -am clean compile"), "{:?}", calls(root));
let member = session.build(root, &model, &b, BuildOptions::default(), None, &cancel).unwrap();
assert_eq!(fs::read_to_string(member.snapshot.join("1/Main.class")).unwrap(), "lib 2");
assert_eq!(calls(root).len(), 2);
// A failed shared build fails the member's launch without running Maven again,
// once: unchanged inputs built on their own afterwards fail in their own build.
fs::write(root.join("lib/src/main/java/Main.java"), "lib 3").unwrap();
fs::write(root.join("broken"), "").unwrap();
assert!(session.build(root, &model, &a, with(false), None, &cancel).is_err());
let failure = session.build(root, &model, &b, BuildOptions::default(), None, &cancel).unwrap_err();
assert!(failure.message.contains("Build failed"), "{failure:?}");
assert_eq!(calls(root).len(), 3);
assert!(session.build(root, &model, &b, BuildOptions::default(), None, &cancel).is_err());
assert_eq!(calls(root).len(), 4);
assert!(calls(root)[3].contains("-pl b -am"));
// With nothing waiting, a launch builds just its own module, as before.
fs::remove_file(root.join("broken")).unwrap();
session.build(root, &model, &a, BuildOptions::default(), None, &cancel).unwrap();
assert!(calls(root)[4].contains("-pl a -am compile"), "{:?}", calls(root));
}
#[test]
fn only_incremental_launches_of_the_same_reactor_and_scope_join_a_build() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = reactor_fixture(root);
let waiting = Waiting::default();
let lead = waiting.add(root.join("a"), false, BuildPolicy::Automatic);
let _guards = [
waiting.add(root.join("b"), false, BuildPolicy::Make),
waiting.add(root.join("lib"), false, BuildPolicy::Automatic),
waiting.add(root.join("b"), false, BuildPolicy::Automatic),
waiting.add(root.join("a"), false, BuildPolicy::Automatic),
waiting.add(root.join("lib"), true, BuildPolicy::Automatic),
waiting.add(root.join("lib"), false, BuildPolicy::Rebuild),
waiting.add(root.join("lib"), false, BuildPolicy::MakeAndContinueOnErrors),
waiting.add(root.join("lib"), false, BuildPolicy::NoBuild),
waiting.add(root.join("other"), false, BuildPolicy::Automatic),
];
let join = |prefer_maven| {
super::super::joining_launches(
root,
&root.join("cache"),
&model,
&root.join("a"),
false,
lead.others(),
prefer_maven,
)
.into_iter()
.map(|l| l.module.strip_prefix(root).unwrap().to_path_buf())
.collect::<Vec<_>>()
};
assert_eq!(join(true), [PathBuf::from("b"), PathBuf::from("lib")]);
// Without "Delegate to Maven", these Java-only modules build with the language server.
assert!(join(false).is_empty());
drop(_guards);
assert!(lead.others().is_empty());
}
/// Like [`fixture`], but the build script skips sources whose mtime did not advance,
/// mirroring Maven's (and the Kotlin plugin's) timestamp-incremental compilation.
fn fixture_timestamp_incremental(root: &Path) -> ide_build::BuildModel {
@@ -353,6 +646,34 @@ mod tests {
);
}
#[test]
fn a_menu_rebuild_stops_reusing_snapshots_that_hold_removed_classes() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let model = fixture(root);
let cancel = CancellationToken::new();
// A class jdtls wrote for a source since moved to another package; an incremental
// Maven build leaves it in target/classes.
fs::create_dir_all(root.join("target/classes")).unwrap();
fs::write(root.join("target/classes/Stale.class"), "stale").unwrap();
let mut session = Session::new(root.join("cache"));
let first = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
assert!(first.snapshot.join("0/Stale.class").is_file());
let reused = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
assert_eq!(reused.snapshot, first.snapshot);
// Build › Rebuild cleans the outputs and compiles again.
fs::remove_file(root.join("target/classes/Stale.class")).unwrap();
session.forget_reusable_snapshots();
assert!(has_record(root, &root.join("cache"), root));
let next = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
assert_ne!(next.snapshot, first.snapshot);
assert!(!next.snapshot.join("0/Stale.class").exists());
assert!(next.snapshot.join("0/Main.class").is_file());
let again = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
assert_eq!(again.snapshot, next.snapshot);
}
#[test]
fn jdt_errors_reuse_an_unchanged_snapshot_and_rebuild_only_on_a_cache_miss() {
let dir = tempfile::tempdir().unwrap();
+2 -1
Переглянути файл
@@ -1092,7 +1092,8 @@ pub async fn lsp_resolve_code_action(
#[command(trust = trusted)]
pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action: CodeAction) -> IdeResult<()> {
let project = host.project(window)?;
let action = if action.edit.is_none() && action.command.is_none() {
// A lazy action may carry a follow-up command beside its unresolved edit (vtsls' refactorings).
let action = if action.edit.is_none() && (action.command.is_none() || action.data.is_some()) {
let documents = project.documents.clone();
let version = blocking(move || documents.version(doc)).await?;
let action = resolve_action(host, window, doc, action).await?;
+80 -1
Переглянути файл
@@ -128,6 +128,70 @@ pub fn project_roots(host: &Host, window: &str) -> IdeResult<ide_workspace::Proj
Ok(host.project(window)?.roots())
}
/// A project attached to the window's project, with its own Project Structure.
#[derive(Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceMember {
pub root: ide_core::IpcPath,
/// Its project settings' Project Structure (not merged with the user settings).
pub structure: ide_core::settings::ProjectStructureSettings,
/// Roots detected from its build files.
pub detected: Vec<ide_workspace::SourceFolder>,
}
/// The workspace projects outside the window's project folder, for Mark Directory as there.
#[command(trust = always)]
pub fn project_workspace_members(host: &Host, window: &str) -> IdeResult<Vec<WorkspaceMember>> {
let project = host.project(window)?;
Ok(project
.attached_roots()
.into_iter()
.map(|root| WorkspaceMember {
structure: project.settings.for_project(&root).layer(SettingsScope::Project).project_structure,
detected: ide_workspace::roots::detect(&root),
root: root.into(),
})
.collect())
}
/// Sets a `projectStructure.*` key in the settings of `root`, a project attached to the window's
/// project (Mark Directory as there). Every open window holding that project follows.
#[command(trust = always)]
pub fn project_workspace_member_set(
host: &Arc<Host>,
window: &str,
root: PathBuf,
key: String,
value: String,
) -> IdeResult<()> {
let project = host.project(window)?;
if !project.attached_roots().contains(&root) {
return Err(ide_core::IdeError::invalid("Not a project attached to this one"));
}
if !key.starts_with("projectStructure.") {
return Err(ide_core::IdeError::invalid(format!("{key} is not a Project Structure setting")));
}
let value: serde_json::Value =
serde_json::from_str(&value).map_err(|e| ide_core::IdeError::invalid(e.to_string()))?;
project.settings.for_project(&root).set(SettingsScope::Project, &key, value)?;
let affected: Vec<_> = host
.projects()
.into_iter()
.filter(|p| p.root == root || p.member_excludes.read().contains_key(&root))
.collect();
host.runtime.spawn_blocking(move || {
for p in affected {
if p.root == root {
p.settings.reload();
p.sink.emit(IdeEvent::SettingsChanged { key: key.clone() });
}
p.refresh_index_scope();
p.sink.emit(IdeEvent::ProjectRootsChanged { root: p.root.clone().into() });
}
});
Ok(())
}
#[command(trust = always)]
pub fn cancel_request(host: &Host, id: RequestId) {
host.cancel_request(id);
@@ -335,6 +399,12 @@ pub fn set_settings(
project.agents.notify_mcp_servers_changed();
}
}
// A skill policy change re-resolves the modes; an idle session restarts to pick them up.
if key == "agents" || key == "agents.skills" || key.starts_with("agents.skills.") {
for project in affected() {
project.agents.notify_mcp_servers_changed();
}
}
// A new interpreter / toolchain / server executable restarts the language servers it affects.
// So do inspections that are compiler options (`ide-sdk` `configure_java_compiler`).
let code_style = key == "editor"
@@ -372,7 +442,14 @@ pub fn set_settings(
// Content roots and excludes (files.exclude, ignored names, excluded folders) reach the
// index and the watchers without reopening the project (the rescan runs in the background).
if roots_changed || key == "files" || key.starts_with("files.") {
let affected = affected();
let mut affected = affected();
// A workspace open in another window may hold this project: its excluded folders apply there.
if roots_changed
&& project_scope
&& let Some(own) = &current
{
affected.extend(host.projects().into_iter().filter(|p| p.member_excludes.read().contains_key(&own.root)));
}
host.runtime.spawn_blocking(move || {
for project in affected {
project.refresh_index_scope();
@@ -395,6 +472,8 @@ ide_command::domain!(
project_trust_remove_location,
project_trust_set,
project_trust_status,
project_workspace_member_set,
project_workspace_members,
settings_get,
settings_get_global,
settings_removed_theme,
+127 -3
Переглянути файл
@@ -3,10 +3,14 @@
use crate::Host;
use ide_command::command;
use ide_core::{IdeResult, RequestId, WorkspaceEdit};
use ide_core::{FileEdit, IdeResult, RequestId, WorkspaceEdit};
use ide_language::Syntax;
use ide_lsp::types::FileRenameEdits;
use ide_workspace::file_moves::moved_path;
use ide_workspace::roots::{ProjectRoots, RootKind};
use ide_workspace::{FileMove, UndoOutcome};
use std::path::PathBuf;
use parking_lot::Mutex;
use std::path::{Path, PathBuf};
use super::doc::blocking;
@@ -24,16 +28,110 @@ pub async fn refactor_file_move_edits(
) -> IdeResult<FileRenameEdits> {
let project = host.project(window)?;
let token = host.begin_request(request);
let result = project.lsp.will_rename_files(&pairs(&moves), token).await;
let result = project.lsp.will_rename_files(&pairs(&moves), token.clone()).await;
host.end_request(request);
let mut result = result?;
let syntax = host.syntax();
blocking(move || {
// basedpyright has no `workspace/willRenameFiles`; a Python server that answered wins.
if !result.edit.files.iter().any(|f| matches!(f, FileEdit::Edit { path, .. } if is_python(path))) {
let python = python_import_edits(&project, &syntax, &moves, &|| token.is_cancelled());
result.edit.files.extend(python.files);
}
project.documents.prepare_workspace_edit(&mut result.edit)?;
Ok(result)
})
.await
}
fn is_python(path: &Path) -> bool {
path.extension().is_some_and(|e| e == "py" || e == "pyi")
}
/// The dotted name of a Python module file or package folder, from its project's Python roots
/// (`src/a/b.py` → `a.b` in a `src` layout).
fn python_module(root: &Path, roots: &ProjectRoots, path: &Path, is_dir: bool) -> Option<String> {
let rel = path.strip_prefix(root).ok()?.to_string_lossy().replace('\\', "/");
let base = roots
.root_for(&rel)
.filter(|r| matches!(r.kind, RootKind::Source | RootKind::Test))
.map_or("", |r| r.path.as_str());
let inner = if base.is_empty() { rel.as_str() } else { rel.strip_prefix(base)?.trim_start_matches('/') };
let inner = if is_dir { inner } else { inner.strip_suffix(".py").or_else(|| inner.strip_suffix(".pyi"))? };
let inner = inner.strip_suffix("/__init__").unwrap_or(inner);
let valid = |s: &str| {
s.chars().next().is_some_and(|c| !c.is_ascii_digit()) && s.chars().all(|c| c == '_' || c.is_alphanumeric())
};
(!inner.is_empty() && inner.split('/').all(valid)).then(|| inner.replace('/', "."))
}
/// The package relative imports in `file` start from.
fn python_package(root: &Path, roots: &ProjectRoots, file: &Path) -> String {
let Some(module) = python_module(root, roots, file, false) else { return String::new() };
if file.file_stem().is_some_and(|s| s == "__init__") {
module
} else {
module.rsplit_once('.').map_or(String::new(), |(p, _)| p.to_owned())
}
}
/// Import updates in the project's Python files for `moves` (paths before the move).
fn python_import_edits(
project: &crate::project::Project,
syntax: &Syntax,
moves: &[FileMove],
cancelled: &(dyn Fn() -> bool + Sync),
) -> WorkspaceEdit {
let root = &project.root;
let roots = project.roots();
let renames: Vec<(String, String)> = moves
.iter()
.filter_map(|m| {
let is_dir = m.from.is_dir();
if !is_dir && (!is_python(&m.from) || m.from.file_stem().is_some_and(|s| s == "__init__")) {
return None;
}
let old = python_module(root, &roots, &m.from, is_dir)?;
let new = python_module(root, &roots, &m.to, is_dir)?;
(old != new).then_some((old, new))
})
.collect();
if renames.is_empty() {
return WorkspaceEdit::default();
}
let names: Vec<&str> = renames.iter().map(|(old, _)| old.rsplit('.').next().unwrap_or(old)).collect();
let found: Mutex<Vec<(PathBuf, Vec<ide_core::TextEdit>)>> = Mutex::new(Vec::new());
ide_vfs::walk_files(root, &project.exclude_globs(), |path| {
if cancelled() || !is_python(path) {
return;
}
let moved = moved_path(path, moves);
let text = match project.documents.text_of(path) {
Some(t) => t,
None => match std::fs::read_to_string(path) {
Ok(t) => t,
Err(_) => return,
},
};
if moved == path && !names.iter().any(|n| text.contains(n)) {
return;
}
let edits = syntax.python_import_edits(
&text,
&python_package(root, &roots, path),
&python_package(root, &roots, &moved),
&renames,
);
if !edits.is_empty() {
found.lock().push((path.to_path_buf(), edits));
}
});
let mut files = found.into_inner();
files.sort_by(|a, b| a.0.cmp(&b.0));
let files = files.into_iter().map(|(path, edits)| FileEdit::Edit { path: path.into(), edits, version: None });
WorkspaceEdit { files: files.collect(), ..Default::default() }
}
/// Applies `edit` (from [`refactor_file_move_edits`], possibly empty), moves the
/// files and notifies the servers. Returns the id for [`refactor_undo_file_move`].
#[command(trust = always)]
@@ -111,3 +209,29 @@ ide_command::domain!(
refactor_move_files,
refactor_undo_file_move,
);
#[cfg(test)]
mod tests {
use super::*;
use ide_workspace::roots::SourceFolder;
#[test]
fn python_module_names_follow_the_roots() {
let root = Path::new("/p");
let folder = |path: &str, kind| SourceFolder { path: path.into(), kind, detected_from: None };
let roots = ProjectRoots::compute(
vec![folder("src", RootKind::Source), folder("tests", RootKind::Test)],
&Default::default(),
);
let name = |p: &str, dir| python_module(root, &roots, &root.join(p), dir);
assert_eq!(name("src/tasks/models.py", false).as_deref(), Some("tasks.models"));
assert_eq!(name("src/tasks/__init__.py", false).as_deref(), Some("tasks"));
assert_eq!(name("src/tasks", true).as_deref(), Some("tasks"));
assert_eq!(name("tests/test_models.py", false).as_deref(), Some("test_models"));
assert_eq!(name("scripts/run.pyi", false).as_deref(), Some("scripts.run"));
assert_eq!(name("my-scripts/run.py", false), None);
assert_eq!(name("src/tasks/notes.txt", false), None);
assert_eq!(python_package(root, &roots, &root.join("src/tasks/cli.py")), "tasks");
assert_eq!(python_package(root, &roots, &root.join("src/tasks/__init__.py")), "tasks");
}
}
+2 -3
Переглянути файл
@@ -70,15 +70,14 @@ fn scan_roots(root: &Path, content_roots: Vec<PathBuf>) -> Vec<PathBuf> {
/// Every mapping source of the project, for the request-path index.
pub fn spring_route_sources(host: &Host, window: &str) -> IdeResult<Vec<RouteSource>> {
let project = host.project(window)?;
let excludes = project.search_excludes();
let mut out = Vec::new();
for root in scan_roots(&project.root, project.content_roots()) {
out.extend(sources_in(&root, &excludes));
out.extend(sources_in(&root, &project.search_excludes_in(&root)));
}
out.sort_by(|a, b| a.path.cmp(&b.path));
out.dedup_by(|a, b| a.path == b.path);
match out.len() {
0 => tracing::warn!("spring routes: no mapping source under {:?} (excludes: {})", project.root, excludes.len()),
0 => tracing::warn!("spring routes: no mapping source under {:?}", project.root),
n => tracing::info!("spring routes: {n} mapping sources under {:?}", project.root),
}
Ok(out)
+16
Переглянути файл
@@ -6,6 +6,7 @@ use ide_command::command;
use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
use ide_scaffold::{CreateRequest, Field, GeneratorInfo, Requirement, ScaffoldEvent, Values};
use std::path::PathBuf;
fn join_err(e: impl std::fmt::Display) -> IdeError {
IdeError::internal(e.to_string())
@@ -41,6 +42,19 @@ pub async fn scaffold_requirements(generator: String, values: Values) -> IdeResu
tokio::task::spawn_blocking(move || ide_scaffold::requirements(&generator, &values)).await.map_err(join_err)?
}
/// Whether a project named `name` cannot be created in `location`: something other than an
/// empty folder is already there.
#[command(trust = always)]
pub async fn scaffold_target_taken(location: PathBuf, name: String) -> IdeResult<bool> {
tokio::task::spawn_blocking(move || ide_scaffold::target_taken(&location.join(name.trim()))).await.map_err(join_err)
}
/// The first of `base`, `base1`, `base2`, … that names nothing in `location` yet.
#[command(trust = always)]
pub async fn scaffold_free_name(location: PathBuf, base: String) -> IdeResult<String> {
tokio::task::spawn_blocking(move || ide_scaffold::free_name(&location, &base)).await.map_err(join_err)
}
/// Creates a project, streaming progress through `on_event`, and returns its directory,
/// trusted. Cancellable with `cancel_request(request)`; a failed or cancelled run leaves nothing.
#[command(trust = always)]
@@ -69,6 +83,8 @@ ide_command::domain!(
scaffold:
scaffold_catalog,
scaffold_create,
scaffold_free_name,
scaffold_options,
scaffold_requirements,
scaffold_target_taken,
);
+32 -15
Переглянути файл
@@ -120,30 +120,47 @@ pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) ->
.map_err(join_err)?
}
/// 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>> {
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()?;
/// The interpreter of the workspace member `near` belongs to, else the project's.
pub(crate) fn effective_python(
config_dir: &std::path::Path,
project: &crate::Project,
near: Option<&std::path::Path>,
) -> Option<PathBuf> {
let project_root = &project.root;
let member = ide_workspace::workspace::Workspace::load(project_root).ok().flatten().and_then(|w| {
let near = near?;
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();
let settings = ide_workspace::SettingsStore::load(config_dir, Some(&root)).effective();
(root, settings)
}
None => (project.root.clone(), project.settings.effective()),
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()))
ide_sdk::apply::python_interpreter_near(&root, near, &settings).or_else(|| {
(&root != project_root)
.then(|| ide_sdk::apply::python_interpreter(project_root, &project.settings.effective()))
.flatten()
});
Ok(interpreter.map(Into::into))
})
}
/// The interpreter the project uses: the configured one, else its virtualenv.
#[command(trust = trusted)]
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 config_dir = host.config_dir.clone();
// Loading a member's settings needs more stack than a sync command's main thread has left.
tokio::task::spawn_blocking(move || Ok(effective_python(&config_dir, &project, near.as_deref()).map(Into::into)))
.await
.map_err(join_err)?
}
/// The PHP interpreter chosen in Settings › Languages & Frameworks › PHP; `None`: the `php` on `PATH`.
@@ -461,7 +478,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");
}
+16 -4
Переглянути файл
@@ -22,6 +22,17 @@ pub fn literal_range(l: ide_language::Literal) -> ide_search::LiteralRange {
ide_search::LiteralRange { start: l.start, end: l.end, kind }
}
/// Comments and string literals of `text`, for the search context of Find and Replace in Files.
pub(crate) fn literals_of(
project: &crate::project::Project,
syntax: &ide_language::Syntax,
path: &Path,
text: &str,
) -> Option<Vec<ide_search::LiteralRange>> {
let language = project.languages.detect(path, text.lines().next());
Some(syntax.literals(&language, text)?.into_iter().map(literal_range).collect())
}
/// Find in Files. Results stream through `on_event`; ends with `Done`.
/// Cancel with `cancel_request(request)`.
#[command(trust = always)]
@@ -98,10 +109,7 @@ pub(crate) fn search_project(
Some(ProjectFileSet::Test) => roots.is_test(rel),
_ => true,
};
let literals = |path: &Path, text: &str| {
let language = project.languages.detect(path, text.lines().next());
Some(syntax.literals(&language, text)?.into_iter().map(literal_range).collect())
};
let literals = |path: &Path, text: &str| literals_of(project, syntax, path, text);
let defaults = project.documents.file_defaults();
let decode = |path: &Path, bytes: &[u8]| ide_vfs::decode_text(bytes, defaults.fallback_for(path));
let mut total = SearchSummary::default();
@@ -115,6 +123,10 @@ pub(crate) fn search_project(
if let Some(prefix) = &prefix {
remaining.include = rebase_masks(&query.include, prefix);
remaining.exclude = rebase_masks(&query.exclude, prefix);
// An attached project's own excluded folders: the project's were rebased away.
if !query.include_excluded && project.member_excludes.read().contains_key(dir) {
remaining.exclude.extend(project.search_excludes_in(dir));
}
// Only paths elsewhere were asked for.
if remaining.include.is_empty() && !query.include.is_empty() {
continue;
+13 -3
Переглянути файл
@@ -75,9 +75,19 @@ pub async fn replace_in_files(
let summary = tokio::task::spawn_blocking(move || {
let targets = if all_in_scope { scope_targets(&project, &syntax, &query, targets, &cancel)? } else { targets };
let host = DocumentsHost(&project.documents);
ide_search::replace_files(&host, &query, &replacement, preserve_case, &targets, &cancel, &|e| {
let _ = events.send(e);
})
let literals = |path: &Path, text: &str| super::literals_of(&project, &syntax, path, text);
ide_search::replace_files_in_context(
&host,
&query,
&replacement,
preserve_case,
&targets,
Some(&literals),
&cancel,
&|e| {
let _ = events.send(e);
},
)
})
.await
.map_err(|e| ide_core::IdeError::internal(e.to_string()));
+30 -5
Переглянути файл
@@ -151,6 +151,8 @@ impl LogAccess {
pub struct VcsRoot {
/// Worktree root.
pub root: ide_core::IpcPath,
/// Root representing all mapped worktrees of the same Git repository in branch lists.
pub branch_root: ide_core::IpcPath,
/// Merge / rebase / cherry-pick / revert in progress.
pub operation: Option<String>,
/// Current branch; `None` when HEAD is detached (or unreadable).
@@ -348,11 +350,28 @@ pub fn vcs_roots(host: &Host, window: &str) -> IdeResult<Vec<VcsRoot>> {
let primary = repos.primary().map(|r| r.root().to_path_buf());
let mut all: Vec<&std::sync::Arc<Repo>> = repos.all().iter().collect();
all.sort_by_key(|r| Some(r.root()) != primary.as_deref());
Ok(all
.into_iter()
.map(|r| {
let roots: Vec<_> = all.into_iter().map(|repo| (repo, repo.metadata_dirs().ok())).collect();
let mut branch_roots = std::collections::HashMap::new();
for (repo, dirs) in &roots {
if let Some([git_dir, common_dir]) = dirs {
let first = branch_roots.entry(common_dir).or_insert(repo.root());
if git_dir == common_dir {
*first = repo.root();
}
}
}
Ok(roots
.iter()
.map(|(r, dirs)| {
let (head, head_commit) = r.head().unwrap_or_default();
VcsRoot { root: r.root().to_path_buf().into(), operation: r.operation().ok().flatten(), head, head_commit }
let branch_root = dirs.as_ref().and_then(|[_, common_dir]| branch_roots.get(common_dir));
VcsRoot {
root: r.root().into(),
branch_root: branch_root.copied().unwrap_or_else(|| r.root()).into(),
operation: r.operation().ok().flatten(),
head,
head_commit,
}
})
.collect())
}
@@ -633,8 +652,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"));
}
}
+415 -29
Переглянути файл
@@ -10,7 +10,7 @@ use ide_extension::ledger::{Ledger, Subject};
use ide_language::ProgramPin;
use ide_plugin::{
CommitChange, CommitDraft, EventKind, HostApi, HostError, HttpRequest, HttpResponse, NotificationLevel,
ProcessChunk, ProcessCommand, ProcessOutput, Prompt, RepositoryStatus, StatusItem,
ProcessChunk, ProcessCommand, ProcessOptions, ProcessOutput, Prompt, RepositoryStatus, StatusItem,
};
use parking_lot::{Mutex, RwLock};
use std::collections::{BTreeMap, BTreeSet, HashMap};
@@ -200,8 +200,14 @@ impl SecretStore for FileSecretStore {
/// Largest response body a plugin receives.
const MAX_RESPONSE: usize = 16 << 20;
/// Largest stdout / stderr kept from a process.
/// Largest stdout / stderr kept from a process by default.
const MAX_OUTPUT: usize = 16 << 20;
/// Hard ceiling for configurable process output capture.
const MAX_ALLOWED_OUTPUT: usize = 128 << 20;
/// Default in-flight stream buffer for lossless streaming backpressure.
const DEFAULT_STREAM_BUFFER: usize = 256 << 10;
/// Default total lifetime stream output limit for lossless streaming.
const DEFAULT_STREAM_MAX_TOTAL: usize = 32 << 20;
/// Most processes one plugin keeps running at once.
const MAX_PROCESSES: usize = 8;
/// Most output one stream of a handle holds until the plugin reads it.
@@ -317,11 +323,18 @@ fn clipboard_content(answer: super::ClipboardAnswer) -> Result<ide_plugin::Clipb
Ok(ide_plugin::ClipboardContent { text: text.filter(|t| !t.is_empty()), image })
}
/// A process a plugin started and has not released (API 1.3 `process.start`).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum StreamMode {
Tail,
Lossless,
}
/// A process a plugin started and has not released (API 1.3 `process.start`, API 1.15 `process.start-stream`).
/// Two reader threads copy its output into bounded buffers; the handle lives
/// as long as the plugin instance that started it.
struct Proc {
client: Option<String>,
can_read: parking_lot::Condvar,
state: Mutex<ProcState>,
}
@@ -335,6 +348,29 @@ struct ProcState {
status: Option<i32>,
/// Reader threads still copying its pipes into the buffers above.
readers: usize,
/// Active wait_process callers. While positive, reader threads buffer up to
/// max_total instead of buffer_limit so producers emitting more than the chunk
/// buffer do not deadlock waiting for process exit.
waiters: usize,
mode: StreamMode,
buffer_limit: usize,
max_total: usize,
total_stdout: usize,
total_stderr: usize,
overflow_err: Option<String>,
stopped: bool,
}
impl ProcState {
/// Ends a child whose output went over the limit. `kill_tree` reaps it, so its status
/// is noted here: a later reap must not wait on a process id that is already gone.
fn stop_overflowed(&mut self) {
self.stdin = None;
ide_core::process::kill_tree(&mut self.child);
if self.status.is_none() {
self.status = Some(self.child.try_wait().ok().flatten().and_then(|s| s.code()).unwrap_or(-1));
}
}
}
/// Which pipe a reader thread drains.
@@ -346,34 +382,100 @@ enum Stream {
impl Proc {
/// Copies `pipe` into the matching buffer until it closes, keeping the last
/// [`MAX_PENDING`] bytes, then notes that the reader finished.
/// [`MAX_PENDING`] bytes (in tail mode) or pausing on backpressure (in lossless mode),
/// then notes that the reader finished.
fn read(self: &Arc<Self>, mut pipe: impl Read + Send + 'static, stream: Stream) {
self.state.lock().readers += 1;
let this = Arc::clone(self);
std::thread::spawn(move || {
let mut buf = [0u8; 8 << 10];
loop {
{
let mut state = this.state.lock();
while state.mode == StreamMode::Lossless
&& !state.stopped
&& state.overflow_err.is_none()
&& match stream {
Stream::Out => {
// While wait_process is active, allow readers to buffer up to max_total
// to prevent pipe write backpressure from hanging the child process.
if state.waiters > 0 {
state.stdout.len() >= state.max_total
} else {
state.stdout.len() >= state.buffer_limit
}
}
Stream::Err => {
if state.waiters > 0 {
state.stderr.len() >= state.max_total
} else {
state.stderr.len() >= state.buffer_limit
}
}
}
{
this.can_read.wait(&mut state);
}
if state.stopped || state.overflow_err.is_some() {
break;
}
}
match pipe.read(&mut buf) {
Ok(0) => break,
Ok(n) => {
let mut state = this.state.lock();
let out = match stream {
Stream::Out => &mut state.stdout,
Stream::Err => &mut state.stderr,
};
out.extend_from_slice(&buf[..n]);
let over = out.len().saturating_sub(MAX_PENDING);
if over > 0 {
out.drain(..over);
let continuation = out.iter().take_while(|b| (**b & 0xC0) == 0x80).count();
out.drain(..continuation);
if state.stopped || state.overflow_err.is_some() {
break;
}
if state.mode == StreamMode::Lossless {
match stream {
Stream::Out => {
state.total_stdout = state.total_stdout.saturating_add(n);
if state.total_stdout > state.max_total {
let limit_mib = (state.max_total + (1 << 20) - 1) >> 20;
state.overflow_err =
Some(format!("process stdout exceeded {limit_mib} MiB limit"));
state.stop_overflowed();
this.can_read.notify_all();
break;
}
state.stdout.extend_from_slice(&buf[..n]);
}
Stream::Err => {
state.total_stderr = state.total_stderr.saturating_add(n);
if state.total_stderr > state.max_total {
let limit_mib = (state.max_total + (1 << 20) - 1) >> 20;
state.overflow_err =
Some(format!("process stderr exceeded {limit_mib} MiB limit"));
state.stop_overflowed();
this.can_read.notify_all();
break;
}
state.stderr.extend_from_slice(&buf[..n]);
}
}
} else {
let out = match stream {
Stream::Out => &mut state.stdout,
Stream::Err => &mut state.stderr,
};
out.extend_from_slice(&buf[..n]);
let over = out.len().saturating_sub(MAX_PENDING);
if over > 0 {
out.drain(..over);
let continuation = out.iter().take_while(|b| (**b & 0xC0) == 0x80).count();
out.drain(..continuation);
}
}
}
Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
Err(_) => break,
}
}
this.state.lock().readers -= 1;
let mut state = this.state.lock();
state.readers -= 1;
this.can_read.notify_all();
});
}
@@ -397,6 +499,7 @@ impl Proc {
/// does nothing.
fn kill(&self) {
let mut state = self.state.lock();
state.stopped = true;
state.stdin = None;
if state.status.is_none() {
ide_core::process::kill_tree(&mut state.child);
@@ -404,18 +507,23 @@ impl Proc {
state.status = Some(status.code().unwrap_or(-1));
}
}
self.can_read.notify_all();
}
/// 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 {
fn chunk(&self, max: usize) -> Result<ProcessChunk, HostError> {
let mut state = self.state.lock();
if let Some(err) = state.overflow_err.clone() {
return Err(HostError::Failed(err));
}
let eof = state.readers == 0;
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) }
self.can_read.notify_all();
Ok(ProcessChunk { stdout, stderr, status: state.status.filter(|_| drained) })
}
}
@@ -2668,6 +2776,22 @@ impl HostApi for PluginApi {
cancel: &CancellationToken,
timeout: Duration,
) -> Result<ProcessOutput, HostError> {
self.run_process_with_options(cmd, cwd, stdin, cancel, timeout, None)
}
fn run_process_with_options(
&self,
cmd: ProcessCommand,
cwd: Option<&Path>,
stdin: Option<String>,
cancel: &CancellationToken,
timeout: Duration,
options: Option<ProcessOptions>,
) -> Result<ProcessOutput, HostError> {
let max_output = options
.and_then(|o| o.max_output_bytes)
.map(|b| (b as usize).clamp(1 << 10, MAX_ALLOWED_OUTPUT))
.unwrap_or(MAX_OUTPUT);
let binary = self.approved_program_in_project(&cmd.program, cwd.or(cmd.approval_root.as_deref()))?;
let cwd = self.spawn_dir(cwd);
let mut command = StdCommand::new(&binary);
@@ -2694,15 +2818,15 @@ impl HostApi for PluginApi {
let mut overflow = false;
if let Some(p) = pipe {
let mut p = p;
let _ = p.by_ref().take((MAX_OUTPUT + 1) as u64).read_to_end(&mut out);
if out.len() > MAX_OUTPUT {
let _ = p.by_ref().take((max_output + 1) as u64).read_to_end(&mut out);
if out.len() > max_output {
overflow = true;
out.truncate(MAX_OUTPUT);
out.truncate(max_output);
}
let _ = std::io::copy(&mut p, &mut std::io::sink());
}
let mut text = String::from_utf8_lossy(&out).into_owned();
let mut end = text.len().min(MAX_OUTPUT);
let mut end = text.len().min(max_output);
while !text.is_char_boundary(end) {
end -= 1;
}
@@ -2728,15 +2852,35 @@ impl HostApi for PluginApi {
std::thread::sleep(Duration::from_millis(10));
};
let (stdout, stdout_overflow) = stdout.join().unwrap_or_default();
let (stderr, _) = stderr.join().unwrap_or_default();
if stdout_overflow {
let (stderr, stderr_overflow) = stderr.join().unwrap_or_default();
if options.is_some() {
// run_captured fails explicitly if either stdout or stderr exceeds the configured limit.
if stdout_overflow || stderr_overflow {
let stream = match (stdout_overflow, stderr_overflow) {
(true, true) => "stdout and stderr",
(true, false) => "stdout",
(false, true) => "stderr",
(false, false) => unreachable!(),
};
let limit_mib = (max_output + (1 << 20) - 1) >> 20;
tracing::warn!(
plugin = %self.id(),
program = %cmd.program,
limit_mib,
"process {stream} exceeded limit"
);
return Err(HostError::Failed(format!("{} {stream} exceeded {} MiB limit", cmd.program, limit_mib)));
}
} else if stdout_overflow {
// Documented legacy behavior for run / run-command: stdout overflow fails, but
// stderr overflow is silently truncated to 16 MiB.
tracing::warn!(
plugin = %self.id(),
program = %cmd.program,
limit_mib = MAX_OUTPUT >> 20,
limit_mib = (max_output >> 20),
"process stdout exceeded limit"
);
return Err(HostError::Failed(format!("{} stdout exceeded {} MiB limit", cmd.program, MAX_OUTPUT >> 20)));
return Err(HostError::Failed(format!("{} stdout exceeded 16 MiB limit", cmd.program)));
}
Ok(ProcessOutput { status: status.code(), stdout, stderr })
}
@@ -2761,6 +2905,16 @@ impl HostApi for PluginApi {
}
}
fn start_process(&self, cmd: ProcessCommand, cwd: Option<&Path>, client: Option<&str>) -> Result<u64, HostError> {
self.start_process_stream(cmd, cwd, client, None)
}
fn start_process_stream(
&self,
cmd: ProcessCommand,
cwd: Option<&Path>,
client: Option<&str>,
options: Option<ProcessOptions>,
) -> Result<u64, HostError> {
let binary = self.approved_program_in_project(&cmd.program, cwd.or(cmd.approval_root.as_deref()))?;
let cwd = self.spawn_dir(cwd);
if client.is_some_and(|c| self.shared.closed_clients.lock().contains(c)) {
@@ -2790,8 +2944,21 @@ impl HostApi for PluginApi {
.spawn()
.map_err(|e| HostError::Failed(format!("{}: {e}", binary.display())))?;
let (stdout, stderr) = (child.stdout.take(), child.stderr.take());
let (mode, buffer_limit, max_total) = match options {
Some(opts) => {
let buf =
opts.buffer_bytes.map(|b| (b as usize).clamp(4 << 10, 4 << 20)).unwrap_or(DEFAULT_STREAM_BUFFER);
let total = opts
.max_output_bytes
.map(|b| (b as usize).clamp(1 << 20, MAX_ALLOWED_OUTPUT))
.unwrap_or(DEFAULT_STREAM_MAX_TOTAL);
(StreamMode::Lossless, buf, total)
}
None => (StreamMode::Tail, MAX_PENDING, usize::MAX),
};
let proc = Arc::new(Proc {
client: client.map(str::to_owned),
can_read: parking_lot::Condvar::new(),
state: Mutex::new(ProcState {
stdin: child.stdin.take(),
child,
@@ -2799,6 +2966,14 @@ impl HostApi for PluginApi {
stderr: Vec::new(),
status: None,
readers: 0,
waiters: 0,
mode,
buffer_limit,
max_total,
total_stdout: 0,
total_stderr: 0,
overflow_err: None,
stopped: false,
}),
});
if let Some(pipe) = stdout {
@@ -2822,7 +2997,7 @@ impl HostApi for PluginApi {
fn poll_process(&self, id: u64, max: usize) -> Result<ProcessChunk, HostError> {
let proc = self.process(id)?;
proc.reap()?;
Ok(proc.chunk(max))
proc.chunk(max)
}
fn write_process(
@@ -2902,13 +3077,32 @@ impl HostApi for PluginApi {
cancel: &CancellationToken,
) -> Result<ProcessChunk, HostError> {
let proc = self.process(id)?;
// Track active waiters and wake reader threads so lossless streams continue
// draining into the retained buffer up to max_total without pipe deadlock.
struct WaitGuard<'a>(&'a Proc);
impl Drop for WaitGuard<'_> {
fn drop(&mut self) {
let mut state = self.0.state.lock();
state.waiters = state.waiters.saturating_sub(1);
self.0.can_read.notify_all();
}
}
let _guard = {
let mut state = proc.state.lock();
state.waiters += 1;
proc.can_read.notify_all();
WaitGuard(&proc)
};
let deadline = Instant::now() + timeout;
loop {
proc.reap()?;
let (ended, readers) = {
let (ended, readers, overflow) = {
let state = proc.state.lock();
(state.status.is_some(), state.readers)
(state.status.is_some(), state.readers, state.overflow_err.clone())
};
if let Some(err) = overflow {
return Err(HostError::Failed(err));
}
// Its output is only complete once its pipes reached the end too.
if ended && readers == 0 {
break;
@@ -2921,7 +3115,7 @@ impl HostApi for PluginApi {
}
std::thread::sleep(Duration::from_millis(10));
}
Ok(proc.chunk(max))
proc.chunk(max)
}
fn task_begin(&self, client: Option<&str>, title: String, cancellable: bool, cancel: CancellationToken) -> u64 {
@@ -3059,6 +3253,10 @@ impl HostApi for PluginApi {
dunce::canonicalize(files).map_err(failed)
}
fn install_dir(&self) -> Result<PathBuf, HostError> {
dunce::canonicalize(&self.pkg.dir).map_err(failed)
}
fn read_text_file(&self, real: &Path, max: usize) -> Result<String, HostError> {
// Unsaved editor contents win, as they do for project files.
if let Some(text) = self.shared.workspace().and_then(|w| w.buffer_text(real)) {
@@ -3749,6 +3947,19 @@ mod tests {
}
}
#[test]
fn install_dir_is_the_canonical_package_directory() {
let tmp = tempfile::tempdir().unwrap();
let pkg = tmp.path().join("acme.lint");
std::fs::create_dir_all(&pkg).unwrap();
std::fs::write(pkg.join("readme.pdf"), b"%PDF").unwrap();
let api = api(&pkg, Arc::default());
let install = api.install_dir().unwrap();
assert_eq!(install, dunce::canonicalize(&pkg).unwrap());
assert!(install.join("readme.pdf").is_file());
assert_ne!(install, api.plugin_dir().unwrap());
}
#[test]
fn storage_moves_an_older_storage_json_to_one_file_per_key() {
let tmp = tempfile::tempdir().unwrap();
@@ -4148,6 +4359,181 @@ mod tests {
api.release_process(id);
}
fn test_proc_api(dir: &Path) -> (PluginApi, impl Fn(&str, &str) -> ProcessCommand) {
let pins: Arc<RwLock<HashMap<(String, String), ProgramPin>>> = Arc::default();
#[cfg(unix)]
let (prog, path) = ("sh", PathBuf::from("/bin/sh"));
#[cfg(windows)]
let (prog, path) = {
let sysroot = std::env::var("SystemRoot").unwrap_or_else(|_| "C:\\Windows".into());
("powershell", PathBuf::from(sysroot).join(r"System32\WindowsPowerShell\v1.0\powershell.exe"))
};
pins.write().insert(("acme.lint".into(), format!("process:{prog}")), ProgramPin::approve(&path).unwrap());
let api = api(dir, pins);
let cmd = move |unix_script: &str, win_script: &str| {
#[cfg(unix)]
{
let _ = win_script;
ProcessCommand {
program: prog.into(),
args: vec!["-c".into(), unix_script.into()],
env: Vec::new(),
approval_root: None,
}
}
#[cfg(windows)]
{
let _ = unix_script;
ProcessCommand {
program: prog.into(),
args: vec!["-NoProfile".into(), "-Command".into(), win_script.into()],
env: Vec::new(),
approval_root: None,
}
}
};
(api, cmd)
}
#[test]
fn start_stream_lossless_backpressure_fast_producer() {
let tmp = tempfile::tempdir().unwrap();
let (api, make_cmd) = test_proc_api(tmp.path());
let cmd = make_cmd("head -c 65536 /dev/zero | tr '\\0' 'A'", "[Console]::Out.Write('A' * 65536)");
let options = ProcessOptions { buffer_bytes: Some(4096), max_output_bytes: Some(1 << 20) };
let id = api.start_process_stream(cmd, None, None, Some(options)).unwrap();
let mut total_out = String::new();
let deadline = Instant::now() + Duration::from_secs(10);
let status = loop {
let chunk = api.poll_process(id, 1024).unwrap();
total_out.push_str(&chunk.stdout);
if let Some(status) = chunk.status {
break status;
}
assert!(Instant::now() < deadline, "timed out waiting for process completion");
std::thread::sleep(Duration::from_millis(5));
};
assert_eq!(status, 0);
assert_eq!(total_out.len(), 65536);
assert!(total_out.chars().all(|c| c == 'A'));
api.release_process(id);
}
#[test]
fn start_stream_dual_stream_concurrency() {
let tmp = tempfile::tempdir().unwrap();
let (api, make_cmd) = test_proc_api(tmp.path());
let cmd = make_cmd(
"head -c 10000 /dev/zero | tr '\\0' 'O'; head -c 10000 /dev/zero | tr '\\0' 'E' >&2",
"[Console]::Out.Write('O' * 10000); [Console]::Error.Write('E' * 10000)",
);
let options = ProcessOptions { buffer_bytes: Some(4096), max_output_bytes: Some(1 << 20) };
let id = api.start_process_stream(cmd, None, None, Some(options)).unwrap();
let mut total_stdout = String::new();
let mut total_stderr = String::new();
let deadline = Instant::now() + Duration::from_secs(10);
let status = loop {
let chunk = api.poll_process(id, 1024).unwrap();
total_stdout.push_str(&chunk.stdout);
total_stderr.push_str(&chunk.stderr);
if let Some(status) = chunk.status {
break status;
}
assert!(Instant::now() < deadline, "timed out waiting for dual streams");
std::thread::sleep(Duration::from_millis(5));
};
assert_eq!(status, 0);
assert_eq!(total_stdout.len(), 10000);
assert_eq!(total_stderr.len(), 10000);
assert!(total_stdout.chars().all(|c| c == 'O'));
assert!(total_stderr.chars().all(|c| c == 'E'));
api.release_process(id);
}
#[test]
fn start_stream_total_limit_overflow() {
let tmp = tempfile::tempdir().unwrap();
let (api, make_cmd) = test_proc_api(tmp.path());
let cmd = make_cmd("head -c 2097152 /dev/zero | tr '\\0' 'X'", "[Console]::Out.Write('X' * 2097152)");
let options = ProcessOptions { buffer_bytes: Some(4096), max_output_bytes: Some(1 << 20) };
let id = api.start_process_stream(cmd, None, None, Some(options)).unwrap();
let deadline = Instant::now() + Duration::from_secs(10);
let mut err = None;
while Instant::now() < deadline {
match api.poll_process(id, 65536) {
Ok(chunk) => {
if chunk.status.is_some() {
break;
}
}
Err(e) => {
err = Some(e);
break;
}
}
std::thread::sleep(Duration::from_millis(10));
}
let err = err.expect("expected overflow error");
assert!(matches!(err, HostError::Failed(ref msg) if msg.contains("exceeded 1 MiB limit")), "{err}");
api.release_process(id);
}
#[test]
fn run_captured_configurable_limits() {
let tmp = tempfile::tempdir().unwrap();
let (api, make_cmd) = test_proc_api(tmp.path());
let token = CancellationToken::new();
let cmd = make_cmd("head -c 2097152 /dev/zero | tr '\\0' 'Z'", "[Console]::Out.Write('Z' * 2097152)");
let opts_ok = ProcessOptions { max_output_bytes: Some(4 << 20), buffer_bytes: None };
let out = api
.run_process_with_options(cmd.clone(), None, None, &token, Duration::from_secs(10), Some(opts_ok))
.unwrap();
assert_eq!(out.status, Some(0));
assert_eq!(out.stdout.len(), 2097152);
let opts_fail = ProcessOptions { max_output_bytes: Some(1 << 20), buffer_bytes: None };
let err = api
.run_process_with_options(cmd, None, None, &token, Duration::from_secs(10), Some(opts_fail))
.unwrap_err();
assert!(matches!(err, HostError::Failed(ref msg) if msg.contains("stdout exceeded 1 MiB limit")), "{err}");
// Stderr overflow in run_captured also fails explicitly
let cmd_err = make_cmd("head -c 2097152 /dev/zero >&2", "[Console]::Error.Write('E' * 2097152)");
let err = api
.run_process_with_options(cmd_err, None, None, &token, Duration::from_secs(10), Some(opts_fail))
.unwrap_err();
assert!(matches!(err, HostError::Failed(ref msg) if msg.contains("stderr exceeded 1 MiB limit")), "{err}");
}
#[test]
fn start_stream_wait_drains_producer_larger_than_buffer() {
let tmp = tempfile::tempdir().unwrap();
let (api, make_cmd) = test_proc_api(tmp.path());
let token = CancellationToken::new();
// Emits 64 KiB, which is 16x larger than the 4 KiB buffer. Calling wait drains without blocking on pipe.
let cmd = make_cmd("head -c 65536 /dev/zero | tr '\\0' 'W'", "[Console]::Out.Write('W' * 65536)");
let options = ProcessOptions { buffer_bytes: Some(4096), max_output_bytes: Some(1 << 20) };
let id = api.start_process_stream(cmd, None, None, Some(options)).unwrap();
let chunk = api.wait_process(id, 100_000, Duration::from_secs(10), &token).unwrap();
assert_eq!(chunk.status, Some(0));
assert_eq!(chunk.stdout.len(), 65536);
assert!(chunk.stdout.chars().all(|c| c == 'W'));
api.release_process(id);
}
#[test]
fn start_stream_cancellation_terminates_child() {
let tmp = tempfile::tempdir().unwrap();
let (api, make_cmd) = test_proc_api(tmp.path());
let cmd = make_cmd("sleep 60", "Start-Sleep -Seconds 60");
let id = api.start_process_stream(cmd, None, None, None).unwrap();
let proc = api.process(id).unwrap();
api.kill_process(id).unwrap();
assert!(proc.state.lock().child.try_wait().unwrap().is_some());
api.release_process(id);
}
#[test]
fn programs_run_only_as_approved() {
let tmp = tempfile::tempdir().unwrap();
+9 -3
Переглянути файл
@@ -110,10 +110,16 @@ pub fn plugin_answer_commit(plugins: &Arc<PluginHost>, request_id: String, answe
plugins.answer_commit(&request_id, answer)
}
/// The UI reports the focused editor's file (`editor-focused` events).
/// The UI reports the focused editor's file (`editor-focused` events), with its
/// caret so plugins can scope line labels without re-reading the document.
#[command(trust = always)]
pub fn plugin_set_active_file(plugins: &Arc<PluginHost>, window: &str, path: Option<String>) {
plugins.set_active_file(window, path);
pub fn plugin_set_active_file(
plugins: &Arc<PluginHost>,
window: &str,
path: Option<String>,
#[default] editor: Option<PluginEditor>,
) {
plugins.set_active_file(window, path, editor);
}
/// The invoking window's reply to a plugin command request.
+22 -3
Переглянути файл
@@ -53,6 +53,7 @@ mod run_detectors;
pub mod run_targets;
pub mod search;
mod semantic_tokens;
mod skills;
mod snippets;
mod theme;
mod types;
@@ -385,6 +386,8 @@ pub struct PluginHost {
run_detectors: Arc<run_detectors::RunDetectors>,
/// `[[contributes.javaAgents]]` of enabled plugins.
java_agents: Arc<java_agents::JavaAgents>,
/// `[[contributes.skills]]` of enabled plugins.
skills: Arc<skills::PluginSkills>,
/// `[[contributes.providers]]` of enabled plugins.
providers: Arc<providers::Providers>,
navigation: Mutex<navigation::NavigationIndex>,
@@ -411,6 +414,8 @@ pub struct PluginHost {
announced_theme: Mutex<Option<ActiveTheme>>,
/// [`PluginLanguages::revision`] last announced with `LanguagesChanged`.
announced_languages: AtomicU64,
/// [`skills::PluginSkills::revision`] last announced to open projects.
announced_skills: AtomicU64,
/// `PATH` used to resolve `process:` programs at grant time.
path_var: RwLock<PathVar>,
/// (plugin id, `process:` capability) → the approved program; read by the
@@ -470,7 +475,8 @@ impl PluginHost {
let run_detectors: Arc<run_detectors::RunDetectors> = Arc::default();
let providers: Arc<providers::Providers> = Arc::default();
let java_agents: Arc<java_agents::JavaAgents> = Arc::default();
register_builtin_points(&registry, &ui, &languages, &run_detectors, &java_agents, &providers)
let skills: Arc<skills::PluginSkills> = Arc::default();
register_builtin_points(&registry, &ui, &languages, &run_detectors, &java_agents, &providers, &skills)
.map_err(IdeError::internal)?;
let pins: Arc<RwLock<HashMap<(String, String), ProgramPin>>> = Arc::default();
let policy_pins = pins.clone();
@@ -506,6 +512,7 @@ impl PluginHost {
languages,
run_detectors,
java_agents,
skills,
providers,
navigation: Mutex::default(),
endpoints: Mutex::default(),
@@ -521,6 +528,7 @@ impl PluginHost {
startup_finished: AtomicBool::new(false),
announced_theme: Mutex::new(None),
announced_languages: AtomicU64::new(0),
announced_skills: AtomicU64::new(0),
path_var: RwLock::new(Arc::new(|| std::env::var_os("PATH"))),
pins,
};
@@ -1729,8 +1737,9 @@ impl PluginHost {
}
/// The UI reports which file its focused editor shows (`editor-focused`).
pub fn set_active_file(&self, client: &str, path: Option<String>) {
self.post_events(Some(client), vec![WorkbenchEvent::EditorFocused(path)]);
/// The editor snapshot carries the caret so line-scoped features stay current.
pub fn set_active_file(&self, client: &str, path: Option<String>, editor: Option<PluginEditor>) {
self.post_window_events(client, vec![WorkbenchEvent::EditorFocused(path)], editor);
}
/// Where plugin secrets are kept (default: files under the plugins
@@ -2914,6 +2923,16 @@ impl PluginHost {
if self.announced_languages.swap(languages, Ordering::AcqRel) != languages {
self.emit(None, PluginEvent::LanguagesChanged);
}
let skills = self.skills.revision();
if self.announced_skills.swap(skills, Ordering::AcqRel) != skills
&& let Some(workspace) = self.shared.workspace.read().clone()
&& let Some(host) = workspace.database_host()
{
for p in host.projects() {
p.agents.notify_mcp_servers_changed();
p.sink.emit(ide_core::IdeEvent::SettingsChanged { key: "agents.skills".into() });
}
}
let active = self.active_theme();
let mut announced = self.announced_theme.lock();
if *announced != active {
+2
Переглянути файл
@@ -66,6 +66,7 @@ pub fn register_builtin_points(
run_detectors: &Arc<super::run_detectors::RunDetectors>,
java_agents: &Arc<super::java_agents::JavaAgents>,
providers: &Arc<super::providers::Providers>,
skills: &Arc<super::skills::PluginSkills>,
) -> Result<(), String> {
registry.register(Arc::new(UiPoint::new(COMMANDS, ui.clone(), command)))?;
registry.register(Arc::new(super::theme::ThemesPoint::new(ui.clone())))?;
@@ -73,6 +74,7 @@ pub fn register_builtin_points(
registry.register(Arc::new(UiPoint::new(super::icons::POINT_ID, ui.clone(), super::icons::icon_theme)))?;
registry.register(Arc::new(super::run_detectors::RunDetectorsPoint::new(run_detectors.clone())))?;
registry.register(Arc::new(super::java_agents::JavaAgentsPoint::new(java_agents.clone())))?;
registry.register(Arc::new(super::skills::SkillsPoint::new(skills.clone())))?;
registry.register(Arc::new(super::navigation::IndexersPoint))?;
registry.register(Arc::new(super::providers::ProvidersPoint::new(providers.clone())))?;
registry.register(Arc::new(UiPoint::new(super::providers::SECRETS_POINT, ui.clone(), super::providers::secret)))?;
+250
Переглянути файл
@@ -0,0 +1,250 @@
//! The `skills` extension point (API 1.15): declarative `SKILL.md` folders inside a
//! plugin package (`[[contributes.skills]]`), discovered directly from live plugins'
//! package directories and staged into agent sessions through [`ide_agent::skills`].
//!
//! ```toml
//! [[contributes.skills]]
//! path = "skills/release-notes/SKILL.md"
//! ```
//!
//! Invalid entries emit a plugin load warning (`Prepared::skipped`) rather than failing
//! the whole plugin; `engines.openidea` compatibility (`^1.15`) remains a manifest check.
use super::PluginHost;
use ide_extension::{Disposable, ExtensionPoint, Package, Placement, Prepared, decode};
use parking_lot::RwLock;
use serde::Deserialize;
use std::collections::HashSet;
use std::path::{Component, Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
pub const POINT_ID: &str = "skills";
/// Maximum total size of all files inside one contributed skill folder (2 MiB).
pub const MAX_SKILL_DIR_BYTES: u64 = 2 << 20;
const MAX_SKILL_FILES: usize = 256;
const MAX_SKILL_DEPTH: usize = 16;
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
struct Decl {
path: PathBuf,
}
#[derive(Clone, Debug)]
struct ContributedSkill {
plugin_id: String,
name: String,
/// Package-relative directory holding `SKILL.md` (e.g. `skills/release-notes`).
rel_dir: PathBuf,
}
/// Contributed skills of loaded plugins.
#[derive(Default)]
pub struct PluginSkills {
items: RwLock<Vec<(u64, ContributedSkill)>>,
seq: AtomicU64,
revision: AtomicU64,
}
impl PluginSkills {
pub fn revision(&self) -> u64 {
self.revision.load(Ordering::Acquire)
}
fn add(self: &Arc<Self>, item: ContributedSkill) -> Disposable {
let seq = self.seq.fetch_add(1, Ordering::Relaxed);
self.items.write().push((seq, item));
self.revision.fetch_add(1, Ordering::AcqRel);
let weak = Arc::downgrade(self);
Disposable::new(move || {
if let Some(this) = weak.upgrade() {
this.items.write().retain(|(s, _)| *s != seq);
this.revision.fetch_add(1, Ordering::AcqRel);
}
})
}
}
pub struct SkillsPoint {
store: Arc<PluginSkills>,
}
impl SkillsPoint {
pub fn new(store: Arc<PluginSkills>) -> Self {
Self { store }
}
}
impl ExtensionPoint for SkillsPoint {
fn id(&self) -> &'static str {
POINT_ID
}
fn placement(&self) -> Placement {
Placement::Workspace
}
fn prepare(&self, pkg: &Package, decl: toml::Value) -> Result<Prepared, String> {
pkg.manifest.needs_api("contributes.skills", 15)?;
match self.prepare_entry(pkg, decl) {
Ok(prepared) => Ok(prepared),
Err(warning) => Ok(Prepared::skipped(warning)),
}
}
}
impl SkillsPoint {
fn prepare_entry(&self, pkg: &Package, decl: toml::Value) -> Result<Prepared, String> {
let d: Decl = decode(POINT_ID, decl)?;
if d.path.as_os_str().is_empty() || !d.path.components().all(|c| matches!(c, Component::Normal(_))) {
return Err(format!("{}: `path` must be a relative path inside the plugin", d.path.display()));
}
if d.path.file_name().and_then(|n| n.to_str()) != Some("SKILL.md") {
return Err(format!("{}: must point to `<dir>/SKILL.md`", d.path.display()));
}
let Some(rel_dir) = d.path.parent().filter(|p| !p.as_os_str().is_empty()) else {
return Err(format!("{}: must live inside a `<name>/SKILL.md` folder", d.path.display()));
};
let Some(folder) = rel_dir.file_name().and_then(|n| n.to_str()) else {
return Err(format!("{}: invalid skill folder name", d.path.display()));
};
// Reject duplicate skill folder names across distinct paths in the same plugin.
for other in pkg.manifest.declarations(POINT_ID) {
let Some(other_path) = other.get("path").and_then(|v| v.as_str()).map(Path::new) else { continue };
if other_path == d.path {
break;
}
if other_path.file_name().and_then(|n| n.to_str()) == Some("SKILL.md")
&& other_path.parent().and_then(|p| p.file_name()).and_then(|n| n.to_str()) == Some(folder)
{
return Err(format!("duplicate skill `{folder}` in plugin"));
}
}
let pkg_root = pkg.dir.canonicalize().map_err(|e| format!("plugin directory: {e}"))?;
let abs_dir = pkg.resolve(rel_dir)?;
if !abs_dir.is_dir() {
return Err(format!("{}: not a directory", rel_dir.display()));
}
let _ = pkg.resolve(&d.path)?;
let mut files = Vec::new();
let mut total_bytes = 0u64;
let mut visited_dirs = HashSet::new();
visited_dirs.insert(abs_dir.clone());
collect_skill_files(
&pkg_root,
&pkg.dir.join(rel_dir),
rel_dir,
0,
&mut visited_dirs,
&mut files,
&mut total_bytes,
folder,
)?;
files.sort();
let text = pkg.read_text(&d.path)?;
ide_agent::skills::validate_plugin_skill(&abs_dir, folder, &text)
.map_err(|e| format!("{}: {e}", d.path.display()))?;
let label = format!("/{folder}");
let key = folder.to_owned();
let item = ContributedSkill {
plugin_id: pkg.id().to_owned(),
name: folder.to_owned(),
rel_dir: rel_dir.to_path_buf(),
};
let store = self.store.clone();
let mut prepared = Prepared::new(label, move || Ok(store.add(item))).key(key);
prepared.files = files;
Ok(prepared)
}
}
#[allow(clippy::too_many_arguments)]
fn collect_skill_files(
pkg_root: &Path,
abs_dir: &Path,
rel_dir: &Path,
depth: usize,
visited_dirs: &mut HashSet<PathBuf>,
files: &mut Vec<PathBuf>,
total_bytes: &mut u64,
skill_name: &str,
) -> Result<(), String> {
if depth > MAX_SKILL_DEPTH {
return Err(format!("{}: directory nesting exceeds {MAX_SKILL_DEPTH} levels", rel_dir.display()));
}
let entries = std::fs::read_dir(abs_dir).map_err(|e| format!("{}: {e}", rel_dir.display()))?;
for entry in entries {
let entry = entry.map_err(|e| format!("{}: {e}", rel_dir.display()))?;
let name = entry.file_name();
let entry_abs = entry.path();
let entry_rel = rel_dir.join(&name);
let sym_meta = std::fs::symlink_metadata(&entry_abs).map_err(|e| format!("{}: {e}", entry_rel.display()))?;
let canon = entry_abs
.canonicalize()
.map_err(|_| format!("{}: broken symlink or unreadable entry", entry_rel.display()))?;
if !canon.starts_with(pkg_root) {
return Err(format!("{}: points outside the plugin", entry_rel.display()));
}
let meta = if sym_meta.file_type().is_symlink() {
std::fs::metadata(&entry_abs).map_err(|e| format!("{}: {e}", entry_rel.display()))?
} else {
sym_meta
};
if meta.is_dir() {
if !visited_dirs.insert(canon.clone()) {
return Err(format!("{}: cyclic directory link", entry_rel.display()));
}
collect_skill_files(
pkg_root,
&entry_abs,
&entry_rel,
depth + 1,
visited_dirs,
files,
total_bytes,
skill_name,
)?;
visited_dirs.remove(&canon);
} else if meta.is_file() {
if files.len() >= MAX_SKILL_FILES {
return Err(format!("skill `{skill_name}` exceeds {MAX_SKILL_FILES} files"));
}
*total_bytes = total_bytes.saturating_add(meta.len());
if *total_bytes > MAX_SKILL_DIR_BYTES {
return Err(format!("skill `{skill_name}` exceeds {} MiB", MAX_SKILL_DIR_BYTES >> 20));
}
files.push(entry_rel);
} else {
return Err(format!("{}: unsupported file type in skill folder", entry_rel.display()));
}
}
Ok(())
}
impl PluginHost {
/// Skill directories (`<plugin_dir>/<rel_dir>`) contributed by live plugins for `root`.
/// Project-local `.openidea/plugins/` packages only apply to their own trusted project.
pub fn skill_dirs(&self, root: Option<&Path>, workspace_trusted: bool) -> Vec<PathBuf> {
let mut entries: Vec<(String, String, PathBuf)> = Vec::new();
for (_, item) in self.skills.items.read().iter() {
let Ok(plugin) = self.get(&item.plugin_id) else { continue };
if !plugin.status().is_live() {
continue;
}
if let Some(dev_root) = plugin.dev_root.as_deref()
&& (!workspace_trusted || root != Some(dev_root))
{
continue;
}
entries.push((item.plugin_id.clone(), item.name.clone(), plugin.dir().join(&item.rel_dir)));
}
entries.sort_by(|a, b| a.0.cmp(&b.0).then_with(|| a.1.cmp(&b.1)));
entries.into_iter().map(|(_, _, path)| path).collect()
}
}
+2 -1
Переглянути файл
@@ -4,7 +4,8 @@ use super::theme::ThemeDef;
use ide_extension::package::PluginIcon;
use ide_extension::{CapabilityInfo, ContributionInfo, UiContribution};
pub use ide_plugin::{
ActionPerformed, ActionSource, EventKind, NotificationLevel, PickItem, Prompt, StatusItem, WorkbenchEvent,
ActionPerformed, ActionSource, CaretMoved, EventKind, NotificationLevel, PickItem, Prompt, StatusItem,
WorkbenchEvent,
};
use serde::{Deserialize, Serialize};
use specta::Type;
+213 -16
Переглянути файл
@@ -47,10 +47,14 @@ pub struct Project {
pub structure: Arc<StructureService>,
/// Roots auto-detected from build files; see [`Project::roots`].
pub detected_roots: Arc<RwLock<Vec<SourceFolder>>>,
/// The excluded folders of the workspace's other projects; see [`member_excludes`].
pub(crate) member_excludes: MemberExcludes,
/// Per-project cache directory (build tool sync results…).
pub cache_dir: PathBuf,
/// Superseded launch snapshots retained until this project session ends.
pub(crate) java_launch_snapshots: Mutex<crate::ops::java::cache::Session>,
/// Java launches waiting for their build, which can share one Maven run.
pub(crate) java_launches_waiting: crate::ops::java::cache::Waiting,
/// Reasons this window was already told why Kotlin is debugged with kotlin-debug-adapter.
pub(crate) kotlin_debug_notices: Mutex<HashSet<&'static str>>,
/// Database tool window: data sources and their connections.
@@ -121,7 +125,8 @@ impl Host {
}
let settings = SettingsStore::load(&self.config_dir, Some(&root));
let detected_roots = Arc::new(RwLock::new(ide_workspace::roots::detect(&root)));
let excludes = exclude_globs(&root, &settings.effective(), &detected_roots.read());
let member_excludes: MemberExcludes = Arc::new(RwLock::new(member_excludes(&settings, &root)));
let excludes = exclude_globs(&root, &settings.effective(), &detected_roots.read(), &member_excludes.read());
let build_cache = self.local_data_dir.join("cache").join(project_key(&root)).join("build");
let extra_roots = content_roots(&settings.effective(), &root, &build_cache, trusted.load(Ordering::Acquire));
mark("roots");
@@ -145,7 +150,7 @@ impl Host {
let index = ProjectIndex::open(
&root,
&self.local_data_dir.join("index").join(&project_key),
index_roots(&root, extra_roots.clone()),
index_roots(&root, extra_roots.clone(), &settings.effective(), &member_excludes.read()),
excludes.clone(),
languages.clone(),
self.syntax(),
@@ -281,6 +286,10 @@ impl Host {
lombok.jar(),
);
ide_sdk::apply::configure_gradle_runtime(cfg, root, server_root, &effective);
let gradle_dirs: Vec<_> = std::iter::once(data_dir.join("gradle"))
.chain(dirs::cache_dir().map(|dir| dir.join("openidea").join("gradle")))
.collect();
ide_sdk::apply::configure_gradle_classpath(cfg, &gradle_dirs);
ide_sdk::apply::configure_maven_sources(cfg, &effective);
ide_sdk::jdtls::launch_directly(cfg);
}
@@ -385,6 +394,7 @@ impl Host {
let sink = sink.clone();
let root = root.clone();
let detected_roots = detected_roots.clone();
let member_excludes = member_excludes.clone();
let history = history.clone();
let remote = self.remote.clone();
let runtime = self.runtime.clone();
@@ -447,12 +457,15 @@ impl Host {
if *detected_roots.read() != fresh {
// Detected excluded folders (`target`, `build`) leave the index too.
let effective = settings.effective();
let members = member_excludes.read();
index.set_scope(
index_roots(
&root,
content_roots(&effective, &root, &build_cache, trusted.load(Ordering::Acquire)),
&effective,
&members,
),
exclude_globs(&root, &effective, &fresh),
exclude_globs(&root, &effective, &fresh, &members),
);
*detected_roots.write() = fresh;
sink.emit(IdeEvent::ProjectRootsChanged { root: root.clone().into() });
@@ -569,9 +582,10 @@ impl Host {
let content_watchers = extra_roots
.iter()
.filter_map(|r| {
let globs = root_globs(&settings.effective(), &member_excludes.read(), r);
let w = content_root_watcher(
r,
&excludes,
globs.as_deref().unwrap_or(&excludes),
&sink,
&index,
&documents,
@@ -625,10 +639,12 @@ impl Host {
structure: Arc::new(StructureService::new(syntax.clone())),
syntax,
detected_roots,
member_excludes,
cache_dir: self.local_data_dir.join("cache").join(&project_key),
java_launch_snapshots: Mutex::new(crate::ops::java::cache::Session::new(
self.local_data_dir.join("cache").join(&project_key).join("build"),
)),
java_launches_waiting: Default::default(),
kotlin_debug_notices: Mutex::default(),
db,
http_history,
@@ -670,6 +686,16 @@ impl Host {
weak.upgrade().map(|p| p.settings.effective().agent_security).unwrap_or_default()
}));
}
{
let weak = Arc::downgrade(&project);
let trust = self.trust.clone();
project.agents.set_workspace_roots_hook(Arc::new(move || {
let Some(p) = weak.upgrade() else { return Vec::new() };
let mut roots = vec![p.root.clone()];
roots.extend(crate::mcp::trusted_attachments(&trust, &p.root));
roots
}));
}
self.insert_project(window, project.clone());
for (key, text, dirty) in &carried {
let _ = project.documents.restore_untitled_buffer(key, text, *dirty);
@@ -738,6 +764,27 @@ impl Host {
let approvals = self.mcp_approvals.clone();
let secrets = self.agent_secrets.clone();
let root = root.to_path_buf();
// The skill policies sessions resolve against: both settings layers and the
// workspace's trust as it stands when a session starts.
let skill_settings = settings.clone();
let skill_root = root.clone();
let trust = self.trust.clone();
let plugin_host = self.plugin_host.read().clone();
agents.set_skills_policy_hook(Box::new(move || {
let layer = |scope| skill_settings.layer(scope).agents.skills.clone();
let workspace_trusted = trust.window_trusted(&skill_root).unwrap_or(false);
let plugin_dirs = plugin_host
.upgrade()
.map(|plugins| plugins.skill_dirs(Some(&skill_root), workspace_trusted))
.unwrap_or_default();
ide_agent::SkillsPolicy {
user: layer(ide_workspace::settings::SettingsScope::Global),
workspace: layer(ide_workspace::settings::SettingsScope::Project),
workspace_trusted,
workspace_roots: crate::ops::agent::workspace_skill_roots(&skill_root),
plugin_dirs,
}
}));
agents.set_mcp_servers_hook(Box::new(move || {
crate::ops::agent::session_mcp_servers(&settings, &approvals, &secrets, &root)
}));
@@ -838,10 +885,12 @@ impl Host {
structure: Arc::new(StructureService::new(syntax.clone())),
syntax,
detected_roots: Arc::default(),
member_excludes: Arc::default(),
cache_dir: self.local_data_dir.join("cache").join(&project_key),
java_launch_snapshots: Mutex::new(crate::ops::java::cache::Session::new(
self.local_data_dir.join("cache").join(&project_key).join("build"),
)),
java_launches_waiting: Default::default(),
kotlin_debug_notices: Mutex::default(),
db,
http_history,
@@ -1231,8 +1280,23 @@ impl Project {
/// excluded roots, the ignored names and the "Exclude files" patterns (files,
/// and everything under such folders).
pub fn search_excludes(&self) -> Vec<String> {
let mut out: Vec<String> =
self.roots().excluded_globs().iter().map(|d| format!("{}/**", d.trim_start_matches('/'))).collect();
let mut folders = self.roots().excluded_globs();
folders.extend(nested_member_globs(&self.root, &self.member_excludes.read()));
self.search_masks(&folders)
}
/// [`Self::search_excludes`] for paths below `dir` (the project folder or a content root),
/// relative to it: an attached project's own excluded folders apply there, not this project's.
pub fn search_excludes_in(&self, dir: &Path) -> Vec<String> {
let own = self.member_excludes.read().get(dir).cloned();
match own {
Some(own) => self.search_masks(&own),
None => self.search_excludes(),
}
}
fn search_masks(&self, folders: &[String]) -> Vec<String> {
let mut out: Vec<String> = folders.iter().map(|d| format!("{}/**", d.trim_start_matches('/'))).collect();
let settings = self.settings.effective();
let names =
settings.files.ignored_names.iter().cloned().chain(settings.project_structure.exclude_file_patterns());
@@ -1264,7 +1328,7 @@ impl Project {
let Some(root) = root else {
return ide_lsp::CandidateFiles::default();
};
let mut exclude = self.search_excludes();
let mut exclude = self.search_excludes_in(&root);
// Directories the server analyses fully: their files are never read.
exclude.extend(q.skip.iter().filter_map(|dir| {
let rel = dir.strip_prefix(&root).ok()?.to_str()?.replace('\\', "/");
@@ -1283,7 +1347,28 @@ impl Project {
/// `files.exclude`, the ignored names and the effective excluded roots (user-marked and detected).
pub fn exclude_globs(&self) -> Vec<String> {
exclude_globs(&self.root, &self.settings.effective(), &self.detected_roots.read())
exclude_globs(&self.root, &self.settings.effective(), &self.detected_roots.read(), &self.member_excludes.read())
}
/// The exclude globs below `dir` (the project folder or a content root), relative to it: a
/// project attached to this one has its own excluded folders, the other roots share these.
pub fn exclude_globs_in(&self, dir: &Path) -> Vec<String> {
let own = root_globs(&self.settings.effective(), &self.member_excludes.read(), dir);
own.unwrap_or_else(|| self.exclude_globs())
}
/// The workspace projects outside this one's folder, which have exclusions of their own.
pub fn attached_roots(&self) -> Vec<PathBuf> {
self.member_excludes.read().keys().filter(|r| !r.starts_with(&self.root)).cloned().collect()
}
/// Where `path`'s exclusions are matched from: the workspace project outside this one holding
/// it, else the project folder (whose globs cover the projects inside it, anchored there).
pub fn root_of(&self, path: &Path) -> PathBuf {
let members = self.member_excludes.read();
let outside = members.keys().filter(|r| !r.starts_with(&self.root) && path.starts_with(r));
let member = outside.max_by_key(|r| r.components().count());
member.cloned().unwrap_or_else(|| self.root.clone())
}
/// Project Structure content roots besides the project folder (existing directories).
@@ -1308,6 +1393,7 @@ impl Project {
if self.light {
return;
}
*self.member_excludes.write() = member_excludes(&self.settings, &self.root);
let (roots, excludes) = (self.content_roots(), self.exclude_globs());
self.lsp.set_content_roots(language_server_roots(&self.root, roots.clone()));
self.lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
@@ -1316,12 +1402,16 @@ impl Project {
&self.settings.effective().languages.java.maven,
self.is_trusted(),
));
self.index.set_scope(index_roots(&self.root, roots.clone()), excludes.clone());
let settings = self.settings.effective();
self.index.set_scope(
index_roots(&self.root, roots.clone(), &settings, &self.member_excludes.read()),
excludes.clone(),
);
self.watcher.set_excludes(&excludes);
let mut watchers = self.content_watchers.lock();
watchers.retain(|(p, _)| roots.contains(p));
for (_, w) in watchers.iter() {
w.set_excludes(&excludes);
for (p, w) in watchers.iter() {
w.set_excludes(&self.exclude_globs_in(p));
}
for r in roots {
if watchers.iter().any(|(p, _)| *p == r) {
@@ -1329,7 +1419,7 @@ impl Project {
}
if let Some(w) = content_root_watcher(
&r,
&excludes,
&self.exclude_globs_in(&r),
&self.sink,
&self.index,
&self.documents,
@@ -1413,10 +1503,68 @@ pub fn history_retention(settings: &ide_core::settings::Settings) -> ide_workspa
}
/// Only explicit workspace containers exclude their root from indexed content.
fn index_roots(root: &Path, folders: Vec<PathBuf>) -> ide_index::IndexRoots {
fn index_roots(
root: &Path,
folders: Vec<PathBuf>,
settings: &ide_core::settings::Settings,
members: &BTreeMap<PathBuf, Vec<String>>,
) -> ide_index::IndexRoots {
let container =
ide_workspace::workspace::Workspace::load(root).ok().flatten().is_some_and(|w| w.is_container(root));
ide_index::IndexRoots { include_root: !container, folders: folders.into_iter().filter(|p| p != root).collect() }
let folders: Vec<PathBuf> = folders.into_iter().filter(|p| p != root).collect();
let excludes = folders.iter().filter_map(|f| Some((f.clone(), root_globs(settings, members, f)?))).collect();
ide_index::IndexRoots { include_root: !container, folders, excludes }
}
/// Excluded folders (as `/`-anchored globs) by workspace project.
type MemberExcludes = Arc<RwLock<BTreeMap<PathBuf, Vec<String>>>>;
/// The excluded folders of the workspace's projects besides `root`, each from its own Project
/// Structure settings and build files (as when it is opened alone), relative to its folder.
fn member_excludes(settings: &SettingsStore, root: &Path) -> BTreeMap<PathBuf, Vec<String>> {
let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root) else { return BTreeMap::new() };
// A workspace folder is no project of its own: its excluded folders apply in every member.
let shared = match workspace.is_container(root) {
true => linked_roots(root, &settings.effective(), &[]).excluded_globs(),
false => Vec::new(),
};
workspace
.projects
.into_iter()
.filter(|p| p != root && p.is_dir())
.map(|p| {
let own = settings.for_project(&p).effective();
let mut globs = shared.clone();
globs.extend(linked_roots(&p, &own, &ide_workspace::roots::detect(&p)).excluded_globs());
(p, globs)
})
.collect()
}
/// The exclude globs below the workspace project `dir`: the ignored names and "Exclude files"
/// patterns apply everywhere, excluded folders only in the project that marked them.
fn root_globs(
settings: &ide_core::settings::Settings,
members: &BTreeMap<PathBuf, Vec<String>>,
dir: &Path,
) -> Option<Vec<String>> {
let own = members.get(dir)?;
let mut globs = settings.file_excludes();
globs.extend(own.iter().cloned());
Some(globs)
}
/// The excluded folders of the workspace projects inside `root` (those its walk covers),
/// anchored at `root`.
fn nested_member_globs(root: &Path, members: &BTreeMap<PathBuf, Vec<String>>) -> Vec<String> {
let mut out = Vec::new();
for (dir, own) in members {
if let Ok(rel) = dir.strip_prefix(root) {
let rel = rel.to_string_lossy().replace('\\', "/");
out.extend(own.iter().map(|g| format!("/{rel}{g}")));
}
}
out
}
/// The member roots of an explicit workspace container (empty for a plain
@@ -1815,9 +1963,15 @@ fn linked_roots(root: &Path, settings: &ide_core::settings::Settings, detected:
ProjectRoots::compute(detected, &settings.project_structure)
}
fn exclude_globs(root: &Path, settings: &ide_core::settings::Settings, detected: &[SourceFolder]) -> Vec<String> {
fn exclude_globs(
root: &Path,
settings: &ide_core::settings::Settings,
detected: &[SourceFolder],
members: &BTreeMap<PathBuf, Vec<String>>,
) -> Vec<String> {
let mut globs = settings.file_excludes();
globs.extend(linked_roots(root, settings, detected).excluded_globs());
globs.extend(nested_member_globs(root, members));
globs
}
@@ -2303,7 +2457,8 @@ mod composer_tests {
#[cfg(test)]
mod content_roots_tests {
use super::content_roots;
use super::{SettingsStore, content_roots, exclude_globs, member_excludes, root_globs};
use std::path::Path;
#[test]
#[cfg(windows)]
@@ -2392,4 +2547,46 @@ mod content_roots_tests {
// ... while its files go to a language server of its own.
assert_eq!(super::language_server_roots(&root, roots), vec![other, nested]);
}
#[test]
fn each_workspace_project_excludes_its_own_folders() {
let tmp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(tmp.path()).unwrap();
let (config, root, nested, other) =
(base.join("config"), base.join("app"), base.join("app/mod"), base.join("lib"));
for dir in [&nested, &other] {
std::fs::create_dir_all(dir).unwrap();
}
let store = |dir: &Path| SettingsStore::load(&config, Some(dir));
let exclude = |dir: &Path, folders: serde_json::Value| {
store(dir)
.set(ide_workspace::settings::SettingsScope::Project, "projectStructure.excluded", folders)
.unwrap();
};
exclude(&root, serde_json::json!(["target"]));
exclude(&nested, serde_json::json!(["out"]));
exclude(&other, serde_json::json!(["gen/"]));
assert!(member_excludes(&store(&root), &root).is_empty(), "a plain project has no members");
ide_workspace::workspace::Workspace::attach(&root, "app", vec![root.clone(), nested.clone(), other.clone()])
.unwrap();
let members = member_excludes(&store(&root), &root);
assert_eq!(members[&other], ["/gen"]);
let settings = store(&root).effective();
let globs = exclude_globs(&root, &settings, &[], &members);
// The project's own folders, and those of the project its walk covers, anchored there.
assert!(globs.contains(&"/target".to_owned()) && globs.contains(&"/mod/out".to_owned()));
assert!(!globs.contains(&"/gen".to_owned()));
let own = root_globs(&settings, &members, &other).unwrap();
assert!(own.contains(&"/gen".to_owned()) && !own.contains(&"/target".to_owned()));
assert_eq!(root_globs(&settings, &members, &root), None, "the project folder has the project's");
// A workspace folder's own excluded folders apply in every member, as before.
let ws = base.join("ws");
ide_workspace::workspace::Workspace::save(&ws, "ws", vec![root.clone(), other.clone()], true).unwrap();
exclude(&ws, serde_json::json!(["dist"]));
let members = member_excludes(&store(&ws), &ws);
assert_eq!(members[&other], ["/dist", "/gen"]);
assert_eq!(members[&root], ["/dist", "/target"]);
}
}
+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 { .. }
+11 -5
Переглянути файл
@@ -6,15 +6,21 @@ use serde_json::json;
use std::path::Path;
use std::sync::Arc;
/// Codex's modes as it reported them last time, in "ask".
fn remember_codex_modes(data: &Path) {
/// Codex's modes as its catalog for `root` listed them last time, in "ask".
fn remember_codex_modes(data: &Path, root: &Path) {
std::fs::create_dir_all(data.join("agents")).unwrap();
let modes = json!({ "codex": { "config": [ {
let config = json!([ {
"id": "mode", "name": "Mode", "description": null, "category": "mode", "current": "ask",
"values": [ { "value": "read-only", "name": "Read Only", "description": null },
{ "value": "ask", "name": "Ask", "description": null },
{ "value": "full-access", "name": "Full Access", "description": null } ],
"via": "option" } ] } });
"via": "option" } ]);
let mut catalogs = serde_json::Map::new();
catalogs.insert(
root.to_string_lossy().into_owned(),
json!({ "fingerprint": "test", "config": config, "thoughtLevels": {} }),
);
let modes = json!({ "codex": { "projectCatalogs": catalogs } });
std::fs::write(data.join("agents/models.json"), modes.to_string()).unwrap();
}
@@ -30,7 +36,7 @@ async fn new_tasks_start_asking_for_approval_when_the_user_chose_so() {
let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
std::fs::create_dir_all(root.join(".openidea")).unwrap();
let (config, data) = (tmp.path().join("config"), tmp.path().join("data"));
remember_codex_modes(&data);
remember_codex_modes(&data, &root);
std::fs::create_dir_all(&config).unwrap();
std::fs::write(config.join("settings.toml"), "[agents]\nnewTaskApprovals = \"ask\"\n").unwrap();
// A project's own settings don't choose this.
+160
Переглянути файл
@@ -0,0 +1,160 @@
//! Each project of a workspace keeps its own excluded folders: they apply below that project only.
use ide_core::{NullSink, RequestId};
use ide_host::{Host, HostConfig, ops};
use ide_workspace::settings::SettingsScope;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
use std::time::Duration;
fn host(base: &Path) -> Host {
Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(NullSink)),
owner: |window| window,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
})
}
/// Files containing `needle` that Find in Files reports, by path.
async fn found(host: &Host) -> Vec<PathBuf> {
let hits = Arc::new(Mutex::new(Vec::new()));
let out = hits.clone();
let query = serde_json::from_value(serde_json::json!({"pattern": "needle", "isRegex": false, "caseSensitive": false, "wholeWord": false, "include": [], "exclude": [], "scope": {"kind": "project"}, "maxMatches": 100})).unwrap();
let channel = ops::Channel::new(move |event| {
if let ops::search::SearchEvent::File { file } = event {
out.lock().unwrap().push(file.path.0);
}
});
ops::search::search_start(host, "main", RequestId::next(), query, channel).await.unwrap();
let mut paths = std::mem::take(&mut *hits.lock().unwrap());
paths.sort();
paths
}
/// The folders of `dir` the Project view shows as excluded.
async fn excluded(host: &Host, dir: &Path) -> Vec<String> {
let entries = ops::fs::fs_read_dir(host, "main", dir.to_path_buf()).await.unwrap();
entries.into_iter().filter(|e| e.excluded).map(|e| e.name).collect()
}
fn indexed(host: &Host, name: &str) -> Vec<PathBuf> {
let project = host.project("main").unwrap();
assert!(project.index.wait_idle(Duration::from_secs(20)));
project.index.files_named(name)
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn attached_projects_keep_their_own_excluded_folders() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let (app, lib) = (base.join("app"), base.join("lib"));
// Both projects have a `gen` and a `dist` folder.
for root in [&app, &lib] {
for dir in ["gen", "dist", "src"] {
std::fs::create_dir_all(root.join(dir)).unwrap();
std::fs::write(root.join(dir).join(format!("{dir}.txt")), "needle\n").unwrap();
}
}
let config = base.join("config");
// `lib` excluded its `dist` when it was opened on its own.
ide_workspace::SettingsStore::load(&config, Some(&lib))
.set(SettingsScope::Project, "projectStructure.excluded", serde_json::json!(["dist"]))
.unwrap();
ide_workspace::workspace::Workspace::attach(&app, "app", vec![app.clone(), lib.clone()]).unwrap();
let host = host(&base);
host.trust.decide(&app, true, false).unwrap();
host.trust.decide(&lib, true, false).unwrap();
host.open_project("main", &app).unwrap();
ops::project::set_settings(&host, "main", SettingsScope::Project, "projectStructure.excluded", r#"["gen"]"#)
.unwrap();
host.project("main").unwrap().refresh_index_scope();
let expect = |paths: &[&str]| paths.iter().map(|p| base.join(p)).collect::<Vec<_>>();
// `app` excludes its `gen`, `lib` its `dist`: neither reaches into the other project.
assert_eq!(
found(&host).await,
expect(&["app/dist/dist.txt", "app/src/src.txt", "lib/gen/gen.txt", "lib/src/src.txt"])
);
assert_eq!(excluded(&host, &app).await, ["gen"]);
assert_eq!(excluded(&host, &lib).await, ["dist"]);
assert_eq!(indexed(&host, "gen.txt"), expect(&["lib/gen/gen.txt"]));
assert_eq!(indexed(&host, "dist.txt"), expect(&["app/dist/dist.txt"]));
// `lib` changes its exclusions in its own window: the workspace follows.
host.open_project("lib", &lib).unwrap();
ops::project::set_settings(&host, "lib", SettingsScope::Project, "projectStructure.excluded", "[]").unwrap();
let project = host.project("main").unwrap();
for _ in 0..100 {
if project.exclude_globs_in(&lib).iter().all(|g| g != "/dist") {
break;
}
tokio::time::sleep(Duration::from_millis(50)).await;
}
assert!(excluded(&host, &lib).await.is_empty());
assert_eq!(indexed(&host, "dist.txt"), expect(&["app/dist/dist.txt", "lib/dist/dist.txt"]));
ops::project::set_settings(&host, "lib", SettingsScope::Project, "projectStructure.excluded", r#"["dist"]"#)
.unwrap();
host.shutdown().await;
// Reopened: each project's exclusions come back from its own settings.
let host = self::host(&base);
host.open_project("main", &app).unwrap();
assert_eq!(
found(&host).await,
expect(&["app/dist/dist.txt", "app/src/src.txt", "lib/gen/gen.txt", "lib/src/src.txt"])
);
assert_eq!(indexed(&host, "dist.txt"), expect(&["app/dist/dist.txt"]));
host.shutdown().await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn mark_directory_as_excluded_writes_the_attached_projects_settings() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let (app, lib, other) = (base.join("app"), base.join("lib"), base.join("other"));
for dir in [app.join("gen"), lib.join("gen"), other.clone()] {
std::fs::create_dir_all(dir).unwrap();
}
ide_workspace::workspace::Workspace::attach(&app, "app", vec![app.clone(), lib.clone()]).unwrap();
let host = Arc::new(host(&base));
host.trust.decide(&app, true, false).unwrap();
host.open_project("main", &app).unwrap();
let members = ops::project::project_workspace_members(&host, "main").unwrap();
assert_eq!(members.iter().map(|m| &m.root.0).collect::<Vec<_>>(), [&lib]);
assert!(members[0].structure.excluded.is_empty());
let set = |root: &Path, key: &str, value: &str| {
ops::project::project_workspace_member_set(&host, "main", root.to_path_buf(), key.into(), value.into())
};
set(&lib, "projectStructure.excluded", r#"["gen"]"#).unwrap();
// Only Project Structure keys of the workspace's attached projects.
assert!(set(&other, "projectStructure.excluded", r#"["gen"]"#).is_err());
assert!(set(&lib, "editor.fontSize", "20").is_err());
let saved = ide_workspace::SettingsStore::load(&base.join("config"), Some(&lib));
assert_eq!(saved.effective().project_structure.excluded, ["gen"]);
let project = host.project("main").unwrap();
for _ in 0..100 {
if project.exclude_globs_in(&lib).contains(&"/gen".to_owned()) {
break;
}
tokio::time::sleep(Duration::from_millis(50)).await;
}
assert_eq!(excluded(&host, &lib).await, ["gen"]);
assert!(excluded(&host, &app).await.is_empty(), "the open project keeps its own");
assert!(
ide_workspace::SettingsStore::load(&base.join("config"), Some(&app))
.effective()
.project_structure
.excluded
.is_empty()
);
host.shutdown().await;
}
+112
Переглянути файл
@@ -0,0 +1,112 @@
use ide_core::{NullSink, RequestId};
use ide_host::{
Host, HostConfig,
ops::{Channel, fs::fs_synchronize_directories},
};
use ide_vfs::{DirectorySyncAction as Action, DirectorySyncOperation, DirectorySyncProgress};
use parking_lot::Mutex;
use std::{fs, path::Path, sync::Arc};
fn put(root: &Path, path: &str, content: &str) {
let path = root.join(path);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, content).unwrap();
}
fn op(path: &str, action: Action, overwrite: bool) -> DirectorySyncOperation {
DirectorySyncOperation { path: path.into(), action, overwrite }
}
fn host(base: &Path) -> 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,
})
}
#[tokio::test(flavor = "multi_thread")]
async fn runs_every_operation_reports_failures_and_stops_when_cancelled() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("project");
let (left, right) = (root.join("left"), root.join("right"));
put(&left, "only-left/deep/nested/a.txt", "nested");
put(&left, "changed.txt", "left");
put(&right, "changed.txt", "right");
put(&left, "kept.txt", "left");
put(&right, "kept.txt", "right");
put(&right, "shared/new.txt", "right");
fs::create_dir_all(left.join("shared")).unwrap();
let host = host(&base);
host.trust.decide(&root, true, false).unwrap();
host.open_project("main", &root).unwrap();
let progress = Arc::new(Mutex::new(Vec::<DirectorySyncProgress>::new()));
let seen = progress.clone();
let channel = Channel::new(move |p| seen.lock().push(p));
let failures = fs_synchronize_directories(
&host,
"main",
left.clone(),
right.clone(),
vec![
op("only-left", Action::CopyToRight, false),
// Not confirmed: the destination exists, so this one fails and the rest still run.
op("kept.txt", Action::CopyToRight, false),
op("changed.txt", Action::CopyToLeft, true),
op("shared", Action::CopyToLeft, false),
// A real delete would go to this machine's Trash; a missing entry still fails the same way.
op("missing.txt", Action::DeleteLeft, false),
],
RequestId::next(),
channel.clone(),
)
.await
.unwrap();
assert_eq!(fs::read_to_string(right.join("only-left/deep/nested/a.txt")).unwrap(), "nested");
assert_eq!(fs::read_to_string(right.join("kept.txt")).unwrap(), "right");
assert_eq!(fs::read_to_string(left.join("changed.txt")).unwrap(), "right");
assert_eq!(fs::read_to_string(left.join("shared/new.txt")).unwrap(), "right");
let failed: Vec<_> = failures.iter().map(|f| (f.path.as_str(), f.action)).collect();
assert_eq!(failed, [("kept.txt", Action::CopyToRight), ("missing.txt", Action::DeleteLeft)]);
let done: Vec<_> = progress.lock().iter().map(|p| (p.done, p.total)).collect();
assert_eq!(done, (0..=5).map(|d| (d, 5)).collect::<Vec<_>>());
// A path outside the roots rejects the whole batch before anything runs.
let error = fs_synchronize_directories(
&host,
"main",
left.clone(),
right.clone(),
vec![op("kept.txt", Action::CopyToRight, true), op("../escape", Action::DeleteLeft, false)],
RequestId::next(),
channel.clone(),
)
.await
.unwrap_err();
assert_eq!(error.kind, ide_core::error::ErrorKind::InvalidInput);
assert_eq!(fs::read_to_string(right.join("kept.txt")).unwrap(), "right");
let request = RequestId::next();
host.cancel_request(request);
let error = fs_synchronize_directories(
&host,
"main",
left.clone(),
right.clone(),
vec![op("kept.txt", Action::CopyToRight, true)],
request,
channel,
)
.await
.unwrap_err();
assert_eq!(error.kind, ide_core::error::ErrorKind::Cancelled);
assert_eq!(fs::read_to_string(right.join("kept.txt")).unwrap(), "right");
}
Loaded 100 of 1656 files, more files were not shown because too many files have changed in this diff. Show more