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

..
Автор SHA1 Повідомлення Дата
l0ng-ai f53f7c0208 feat(refactor): Java Move for classes, static members, nested types and instance methods
Move… (F6, Refactor This) in Java now asks for the destination and moves:
a top-level class to another package (package declaration, imports and
references follow), a static member or nested type to another class (or a
nested type to a new file), an instance method to the class of one of its
fields or parameters. jdtls offers these only as client-side commands
(java.action.applyRefactoringCommand), now enabled with
moveRefactoringSupport; the IDE picks the destination from
java/getMoveDestinations or java/searchSymbols, then java/move checks the move
and computes the edit, confirmed in Problems Detected when it warns.

Code actions can register client-side command handlers
(registerClientCommand); jdtls' changeSignature command opens the Change
Signature dialog. New IPC: lsp_java_move_destinations, lsp_java_source_types,
lsp_java_move. SignatureChanged is now ServerRefactored.
2026-11-16 15:34:57 +08:00
l0ng-ai 3cc4c1c9b1 feat(refactor): Change Signature dialog for Java methods (#3701)
Change Signature… (⌘F6, also in Refactor This) on a Java method opens a
dialog for its visibility, return type, name and parameters (add with a
default value for existing calls, remove, reorder), with Delegate via
overloading method and a signature preview. jdtls reads the method
(java/getChangeSignatureInfo) and checks the new signature and computes the
edit for the method, its overrides and its calls (java/getRefactorEdit
changeSignature); warnings are confirmed in Problems Detected before the edit,
and Preview lists the changes first. jdtls offers the refactoring only through
a client-side command, so Java had no Change Signature before.

New IPC: lsp_signature_info, lsp_change_signature.
2026-11-16 15:18:43 +08:00
l0ng-ai 9c07e3e136 feat(rails): go to declaration from callback symbols and routes (#3700)
Go to Declaration (and ⌘-click) on a method symbol in a callback
(before_action :load_user, skip_before_action, helper_method, validate,
if: :admin?) opens its def in the class, or in ApplicationController /
ApplicationRecord. In config/routes.rb, "controller#action" strings open the
action's def and resources / resource symbols open the controller.

Refs #900
2026-11-16 15:01:26 +08:00
l0ng-ai 844611c7d5 feat(navigation): Navigate › Related Symbol for header/source and Rails files (#3699)
Related Symbol… (⌃⌘↑ / Ctrl+Alt+Home, in the Navigate menu and the editor's
Go To submenu) goes to the files tied to the current one by convention: one
target opens directly, several open a Choose Target list, none shows
"No related symbols". Providers register through editor/relatedProviders.

- C, C++, Objective-C and CUDA: a header and its source files of the same
  name, the ones in the same folder first.
- Rails: a controller action and its views, a controller and all its views,
  helper and model, a view and its controller action, a helper and its
  controller and views, a model and its controller and migrations.

Refs #900
2026-11-16 14:58:13 +08:00
l0ng-ai c9c75fa3b7 feat(django): Django Template LSP for template tags, filters, templates and URL names (#3696)
Django Template files start djlsp (django-template-lsp, installed into its own
virtualenv on request) next to the HTML language server: completion, hover and
Go to Declaration for the project's template tags, filters, template names,
static files and URL names. The project interpreter's environment is passed as
its env_directories, so a virtualenv, conda or pixi environment outside the
project root is used too.

Refs #2581
2026-11-16 14:44:46 +08:00
Deng Liuтаdengliu 32abc77a74 feat(agents): multi-level MCP hub, CLI config discovery, and per-session MCP picker (#3626)
MCP servers can be configured at user and project level, imported from pasted JSON, tested with their tool list shown, and discovered from other agent CLIs' config files. Discovery reports only env and header key names, never values, and importing is explicit; external config files are never modified. Testing a server requires a trusted project. Each agent session can turn individual servers on or off from a picker; the overrides are stored with the task and applied when the session opens.

Closes #3608

Co-authored-by: dengliu <[email protected]>
2026-11-16 14:32:11 +08:00
LU XIANGRUIтаwildcatDownstairs de107e145c fix(vcs): keep the Git log commit card open while scrolling inside it (#3691)
A commit row closed its card on any capture-phase scroll so that scrolling the log, which moves the anchor, hides it; scrolling a long message inside the card fired the same listener. Scrolls inside the card no longer close it; the log and elsewhere still do.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 14:25:44 +08:00
LU XIANGRUIтаwildcatDownstairs 9adf35b097 fix(vcs): show the Git log's commit subject as git does, the first paragraph on one line (#3688)
The log index took the first non-empty line as a commit's title, while blame and code history use git's subject (%s). It now takes the first paragraph (up to the first blank or whitespace-only line) joined on one line, as git log --oneline does; the persisted summaries table moves to summaries-v3 and the old one is dropped on open.

Closes #3680

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 14:25:04 +08:00
l0ng-ai 0e473c6dac feat(cucumber): steps of feature files in every Gherkin language (#3693)
A feature file's # language: header picks its keywords for step navigation, the Undefined step inspection and Create step definition: the step and section keywords of Cucumber's 80 Gherkin languages (from gherkin-languages.json, MIT) load on demand, keywords without a trailing space take the text right after them, and And / But keep the previous step's kind.

Refs #797
2026-11-16 14:23:52 +08:00
LU XIANGRUIтаwildcatDownstairs b01f70390e feat(plugins): editorPanels extension point for editor-side web pages (#3677)
Adds `[[contributes.editorPanels]]` (API 1.9): a plugin web page at the right edge of every editor group, beside its text editor, for community minimaps (#130). It needs `editor.read`, takes `width` (40-400 px) and an optional `when`; the page's directory is checked and signed like web views.

Each group mounts one frame and keeps it while switching tabs (the page hears `onTarget` instead of reloading); it is hidden while the group shows something other than a text editor. Only frames of editor panels get `openidea.editor`, served straight from the editor rather than through plugin code: `get` / `onTarget`, the read-only document, `viewport` / `onViewport` (at most once a frame), `scrollTo` / `scrollBy`, and `highlights` / `onHighlights` (syntax colours resolved in the current scheme, at most 2000 lines per call). A fixture plugin draws a minimal minimap; plugins/README.md documents the point.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 14:20:49 +08:00
l0ng-ai efc1e607b8 feat(cucumber): cucumber-jvm step definitions in Java and Kotlin (#3690)
Step navigation, the Undefined step inspection and Create step definition cover cucumber-jvm: @Given("…") annotations and Java 8 lambdas in .java / .kt files are scanned and matched, and string patterns anchored with ^ or $ read as regular expressions. Created definitions in Java / Kotlin are annotated methods in the class with {int} / {double} / {string} parameters, cucumber-jvm method names and the keyword's io.cucumber.java.en import.

Refs #797
2026-11-16 14:16:50 +08:00
l0ng-ai f4469a2f53 feat(tools): install Phpactor from Settings (#3687)
Intelephense resolves @mixin only with a licence, so without one Laravel's
query()->whereIn(), whereBetween() and orderBy() (Eloquent Builder's
@mixin of the query builder) and ThinkPHP's model queries get no
completion, with or without laravel-ide-helper. Phpactor resolves them and
was already the PHP fallback server, but had to be installed by hand.

It now installs from Settings > Languages & Frameworks > Language Servers:
the release's phpactor.phar keeps its name and gets a launcher that runs
it through php. Two install-slot tests used real tool names (sqls,
marksman) that other tests install or uninstall in parallel; they now use
names of their own.

Refs #2260
2026-11-16 14:11:40 +08:00
l0ng-ai 708cca8e4f feat(cucumber): report undefined steps and create their definitions (#3685)
A .feature step no JavaScript / TypeScript step definition matches is reported by a new built-in Undefined step inspection (projects without such definitions are not checked). Alt+Enter appends a pending definition to the matching step file with {string} / {float} / {int} parameters, the previous primary keyword for And / But / *, and the playwright-bdd fixtures-first form in createBdd() files. String-literal patterns now unescape \\ as JavaScript does.

Refs #797
2026-11-16 14:07:43 +08:00
l0ng-ai f5b4e5ad8c test(run): list the sbt kind among the Build Tools service categories (#3682)
services.test.ts lists every built-in run configuration kind with its category; the sbt kind from #3679 was missing.
2026-11-16 14:02:15 +08:00
l0ng-ai 77984361b6 test(i18n): allow Thymeleaf and sbt to read the same in every locale (#3681)
Thymeleaf and sbt are product names, the same in Chinese as in English; i18n.test.ts failed on main until they were listed as kept as written.
2026-11-16 13:58:39 +08:00
Deng Liuтаdengliu 86ba75cbf4 feat(agents): native Copilot headless driver with automatic --acp fallback (#3444)
GitHub Copilot now runs over `copilot --headless --no-auto-update --stdio` (the protocol the Copilot SDK speaks) behind the in-process ACP shim, like the Claude Code and Codex drivers. It exposes the full model catalog with per-model efforts, the 200K / 1M context tier per session (also switched mid-session) and per-tier token pricing in the model picker, using Copilot's own defaults for model, effort and context tier.

When the headless protocol fails for a reason other than sign-in or a missing executable (catalog discovery, probe, session create/resume, or a protocol error before the first prompt streams), that Copilot executable (path, mtime, size) falls back to `copilot --acp` for the rest of the session; reloading agents clears it. Registry installs with `args = ["--acp"]` and no `driver` move to the native driver; an explicit `driver = "acp"` stays on ACP.

Verified with Copilot CLI 1.0.112: probe reports the native protocol and its sign-in method; a CLI that rejects `--headless` falls back to ACP v1, and back to native once the executable changes. ide-agent tests (282) and clippy, agents and locale vitest (831), typecheck, lint, format and knip pass; bindings unchanged.

Co-authored-by: dengliu <[email protected]>
2026-11-16 13:54:32 +08:00
GuoYuтаguoyucode d50348bc94 fix(search): search and index a project attached inside an ignoring root (#3678)
An attached project inside the project folder was left out of content roots on the assumption that the root's walk covers it, but a folder the root's repository ignores (a git worktree under an ignored .wt/) is never walked, and the index dropped it as a duplicate root. ide_index::walk_skips tells whether the root's walk skips a folder; such a project stays a content root, the index takes it as a root with its own ignore rules (innermost root wins), and Find in Files, Go to File and the MCP search tools walk it, showing its files by their path in the project.

Co-authored-by: guoyucode <[email protected]>
2026-11-16 13:51:01 +08:00
LU XIANGRUIтаwildcatDownstairs e8c6ff8f2f perf(database): filter PostgreSQL key columns by table first and detect identity columns in one query (#3666)
Index and foreign key queries pair key columns from one generate_series bounded by the server's max_index_keys instead of a series per catalog row, so the planner reaches the table's rows through the catalog index first (PG 18: indexes 6.8 ms -> 0.19 ms, table foreign keys 3.2 ms -> 0.18 ms). Completion detects identity columns through pg_depend (deptype 'i') instead of attidentity, so the query runs in one pass on openGauss / GaussDB and PostgreSQL before 10; the attidentity legacy rerun is gone. Adds an integration test for composite keys in reversed order, data page, DDL and identity columns, and a unit test over every PostgreSQL metadata query.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 13:47:46 +08:00
l0ng-ai 5150e8e81b feat(build): sbt tool window and sbt Task run configurations (#3679)
sbt builds are read statically from build.sbt: declared projects and folders, sbt.version and the build's own launcher. The sbt tool window lists the root project's tasks, the build's sbt run configurations and the other projects with their tasks; tasks run unscoped on the root project and as <id>/<task> on the others. sbt run and sbt test are detected as run configurations, and editing build.sbt re-reads the tree.

Refs #1065
2026-11-16 13:45:07 +08:00
l0ng-ai 88a2508bee fix(i18n): add the Thymeleaf completion detail to the text catalog (#3676)
The Thymeleaf attribute completion's detail label was missing from en.json / zh.json, failing textCatalog.test.ts on main.
2026-11-16 13:40:30 +08:00
l0ng-ai 61da1bc685 fix(vim): keys moved to the IDE never reach Vim (#3675)
A key set to IDE in the Vim shortcut conflicts table ran an IDE action when
one was bound, but otherwise fell through to Vim. Ctrl+A, Ctrl+X and Ctrl+V
in the editor are no IDE actions (Select All is an editor key binding, cut
and paste are the browser's), so with the IDE handler Ctrl+A still
incremented a number and Ctrl+V started Visual block. A key the user moved
from Vim to the IDE now skips Vim: the editor's key bindings run, else the
browser default. Keys that are the IDE's by default (Escape, Ctrl+C…) still
reach Vim when no IDE action wants them.

Fixes #3119
2026-11-16 13:35:15 +08:00
l0ng-ai 4f2fc3ecb1 fix(tools): reinstall Python tool environments moved from where they were created (#3674)
uv's launchers and venv script shebangs name the interpreter by absolute path,
so a managed virtual environment copied to another location (a data directory
moved outside the IDE, a relocated AppData) fails with "uv trampoline failed
to canonicalize script path". At start-up, a PipVenv tool whose activation
script names another location is removed, so it is installed again when
needed. The IDE's own data migrations already leave these environments behind.

Fixes #3581
2026-11-16 13:31:40 +08:00
kevinh 5b0006fa42 fix(build): show Project Structure build steps with forward slashes on Windows; fix three Windows-only tests (#3672)
Build step labels (Clean / Copy resources / Lay out / Pack) used native separators, so Windows showed backslashes; they now use /. Two ide-build tests compared native classpath and -d paths by string suffix and now compare by path component; the Unity shim test on Windows expects the shim's self-relative adapter path.

Co-authored-by: kevinh458 <[email protected]>
2026-11-16 13:30:18 +08:00
l0ng-ai d986b7408b feat(html): Thymeleaf templates in Spring projects (#3673)
HTML files in a project with src/main/resources/templates open in a Thymeleaf mode: th:* and data-th-* values are highlighted as standard expressions and th: / data-th- attribute names complete. Go to Declaration resolves fragment expressions to the template and its th:fragment, and message keys to each messages*.properties of the spring.messages.basename bundles.

Refs #2889
2026-11-16 13:28:47 +08:00
qq471754603таqq471754603 6b2bb0bb6a fix(macos): run on Big Sur and Monterey with Safari's staged WebKit (#3534)
When the system WebKit predates Safari 15.4 (macOS 11, and 12 before 12.3) and Safari's update has staged a newer WebKit, main re-execs once with DYLD_FRAMEWORK_PATH pointing at the staged frameworks and clears it again in the second process, so child processes keep the system frameworks. macOS 12.3+ and 13+ keep the system engine without a restart; an unreadable system version also keeps it.

- Entitlements: allow-dyld-environment-variables only; library validation stays on (the staged framework is Apple-signed).
- Bundle and link minimum back to 11.0 so Launch Services opens the app on Big Sur; .cargo/config.toml sets MACOSX_DEPLOYMENT_TARGET as a default a developer can override.
- The staged copy is checked with a stat before the system version is read, so current macOS never spawns defaults at startup.
- Debug builds skip the bindings export when the build checkout is absent.
- Boot error page, install and contributor docs describe the Big Sur case.

Tested by the contributor on macOS 11.7.11 (Safari 16.6.1 staged) and 26.5; by us on macOS 15.7.8 (no re-exec).

Co-authored-by: qq471754603 <[email protected]>
2026-11-16 13:25:59 +08:00
l0ng-ai 2b353dfe53 fix(mcp): let run_command return once a server prints its ready line (#3670)
run_command takes wait_for_run's pattern: the call returns (waitEnded: matched) as soon as the output matches a server's ready line, and the tool description and MCP guide tell agents to use it for servers, watchers and apps instead of a long timeout.

Refs #3646
2026-11-16 13:10:01 +08:00
l0ng-ai ead2594d72 chore(host): keep Host's JDK methods ahead of the tests module (#3669)
Clippy's items_after_test_module failed ide-host with -D warnings.
2026-11-16 13:03:05 +08:00
l0ng-ai 2cb573d5ad feat(cucumber): navigate between feature steps and step definitions (#3668)
Go to Declaration on a .feature step opens the matching JavaScript / TypeScript step definitions (@cucumber/cucumber, playwright-bdd); on a definition's pattern it lists the feature steps using it. Cucumber expressions and regular expressions match; Scenario Outline steps use their first example's values. A cheap backend scan (cucumber_sources) feeds a UI index kept until a feature or script file changes.

Refs #797
2026-11-16 13:01:44 +08:00
l0ng-ai 0360690c6a fix(database): read PostgreSQL catalogs of openGauss and older servers (#3667)
Expanding or opening a table on openGauss / GaussDB failed with "syntax error at or near \".\"": the index and foreign key queries used JOIN LATERAL / WITH ORDINALITY, which their PostgreSQL 9.2 grammar lacks. They now pair key columns by subscript (generate_series). Completion (attidentity) and routines (prokind) rerun with the older catalog's columns when the server rejects them.

Fixes #3637
2026-11-16 12:48:22 +08:00
l0ng-ai f179c970ba feat(python): Extract Method, Inline and Introduce Parameter through pylsp-rope (#3665)
pylsp with pylsp-rope runs next to the Python type checker for refactorings only (features = code-action, code-action-kinds = refactor, every pylsp plugin off): Extract Method, Inline, Introduce Parameter and module-level Introduce Constant in Python files, with rope's "including similar statements" as the all-occurrences choice. pylsp-rope is a managed companion tool, not offered for install when missing; .ropeproject is in the default ignored names.

Refs #901
2026-11-16 12:39:35 +08:00
l0ng-ai 45d34ac638 fix(editor): keep indent guides in the indentation with a proportional font (#3634)
Guides were placed at multiples of ch (the width of "0"), while indentation is made of spaces, which are narrower in a proportional font, so guides drifted into the code the deeper the block. The guides plugin now measures the editor font's space width (--openidea-space) and places guides, and the indent of code lens rows, by it. Monospace fonts render as before.
2026-11-16 12:28:53 +08:00
LU XIANGRUIтаwildcatDownstairs 7709897dbb fix(project): ask about trust before opening the project window (#3663)
Opening an untrusted project in a new window created the window first and asked inside it, where the splash gave way after its 4 s limit to the Welcome screen under the question.

Entry points that may create a window (Open…, Open in New Window, recent projects, dropped folders, clone, plugin requests) now ask in the current window first and create the window only after Trust or Preview; Don't Open creates none. A launch without an originating window (openidea <path>, Dock drop) keeps the splash up under the dialog until the answer. WSL folders are still asked about by their remote window.

Closes #3648

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 12:26:51 +08:00
LU XIANGRUIтаwildcatDownstairs da3b00518f fix(editor): take a hidden tab's tooltips off the page with its view (#3662)
A slow Go to Implementation left its "Finding navigation target…" hint on the page after the target opened in another tab. Editor tooltips are parented to document.body, outside the view, so hiding a tab left any open tooltip (hint, hover, completion) behind, and the pending-hint cleanup skipped detached views.

Each tab now has its own tooltip layer that leaves and returns with its view, and hint cleanup and timeouts also run on hidden views.

Closes #3647

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 12:24:53 +08:00
l0ng-ai 87e4dcf42b feat(agents): toggle sending the current file and selection as IDE context (#3664)
A toolbar button in the agent composer turns IDE context on or off (on by default, remembered). While on, each message carries the focused editor's file, or its selected lines as a line-range mention, unless the draft already references that file.

Closes #3633
2026-11-16 12:22:56 +08:00
l0ng-ai c860649b13 test(app): mock invoke for the system notification in the update checks (#3661)
Balloons are mirrored to a system notification since #3606, which calls invoke; the update-check test's @tauri-apps/api/core mock had none, so 28 cases failed on main.
2026-11-16 12:13:33 +08:00
LU XIANGRUIтаwildcatDownstairs 07afe43d0d feat(settings): import keymaps, terminal font, tabs and indents and more editor options from JetBrains (#3650)
Import Settings from a JetBrains IDE now also brings over the keymaps (the IDE's active one becomes current), the terminal font, Tabs and Indents of the current code style scheme, console soft wrap and about 45 more EditorSettings / CodeInsightSettings options. The IDEA keymap parser moves to src/platform so the import can use it, and now accepts the lower-case key names IDEA writes in user keymaps (every non-letter shortcut of a user keymap was dropped before, also in Settings › Keymap › Import).

Closes #3649

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 12:12:21 +08:00
Muuтаmuutot 8ca2e089a3 fix(vcs): highlight diff viewers with the editor's syntax and semantic colours (#3653)
Diff viewers used a trimmed highlight style (14 tag groups), loaded languages straight from @codemirror/language-data (missing the editor's own modes, tag patches and the data-language attribute that language-scoped colour schemes key on), and had no semantic-token layer. They now use the editor's highlight style and language pipeline, and panes showing an open document get semantic highlighting.

Co-authored-by: muutot <[email protected]>
2026-11-16 12:10:24 +08:00
terwerтаterwer 41a8fbc591 fix(agents): read Codex session metadata from rollout payloads (#3659)
Current Codex rollouts start with a top-level session_meta record whose id and cwd live in payload; the scanner read them from the outer object and silently skipped every such session in the external-session import list. Read the payload, keeping the nested and unwrapped forms.

Closes #3655

Co-authored-by: terwer <[email protected]>
2026-11-16 12:07:54 +08:00
LU XIANGRUIтаwildcatDownstairs 3a0536eafc fix(menu): keep the menu usable while a Settings window is in front (#3657)
On macOS the backend treated the Settings window as modal and dropped every menu item except Quit, Settings, Project Structure and New Projects Settings, while still showing them enabled. Items chosen with Settings in front now run in its project window, which is brought forward; once what the action opened closes (or right away if it opened nothing) Settings comes back to the front. The project window pushes its menu enablement once on blur, so editor-only items grey out, and enablement pushed by other windows no longer overrides the front window's.

Closes #3625

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 12:07:09 +08:00
kevinh 9cbdde526b fix(vcs): update and roll back a project whose submodules changed (#3656)
git status lists submodules at another commit or with changes inside among the superproject's changes, but git stash leaves them in place, so the stash added no entry and Update Project (merge, rebase, checkout, reset) failed with "could not save the local changes". A stash that adds no entry now means there was nothing to put aside. Rollback of a submodule entry, or of a folder containing one, now runs git restore --recurse-submodules --worktree: the submodule goes back to the recorded commit with its tracked files restored; untracked files are kept.

Closes #3632

Co-authored-by: kevinh458 <[email protected]>
2026-11-16 12:02:43 +08:00
l0ng-ai 2878eb8d87 feat(sdk): add a JDK from disk in Project Structure › SDKs (#3660)
The SDKs list offered only Download JDK…. The toolbar's + now also has Add JDK from Disk…: the picked folder is checked to be a JDK home and kept in the global languages.java.addedJdks, which detection lists from then on, so it appears in every JDK picker. − removes a JDK added this way.

Closes #3628
2026-11-16 12:00:30 +08:00
l0ng-ai 2e764d74f8 fix(debugger): end a program suspended at a breakpoint at once on Stop (#3658)
For adapters without a terminate request (Delve, java-debug), Stop sent SIGTERM and waited up to 10 s. A program suspended in the debugger cannot act on SIGTERM (on macOS not even SIGKILL while debugserver holds it), so Stop sat in "stopping" for the full wait. When the session is suspended, Stop now kills the program's tree, sends disconnect with terminateDebuggee so the adapter ends it, and skips the wait for shutdown output. A running program still gets SIGTERM first.

Fixes #3623
2026-11-16 11:48:55 +08:00
l0ng-ai 92dd70f08b fix(tools): install debugpy when the project's Python has no pip (#3654)
debugpy's private copy was made with python -m pip of the selected interpreter; a uv-made virtualenv has no pip, so the install failed with "No module named pip". The copy is a universal wheel: when the interpreter has no pip, pip runs through uv tool run pip, or another Python on PATH that has it.

Fixes #3619
2026-11-16 11:25:25 +08:00
l0ng-ai 484bbfc704 fix(ui): paint tree row tints as full-width bands (#3652)
File colours, excluded folders and data source colours were painted as the row's own background: inset from the tree's edges, rounded per row, or dropped under hover and selection, so a run of tinted rows read as a ragged stack. The tint is now a full-width band under the row; hover and selection stay rounded on top. Excluded folders and data source colours share the rowTint path.

Fixes #3616
2026-11-16 11:16:55 +08:00
Deng Liuтаdengliu 0b097808f1 fix(agents): increase process-run step indentation and align running tool icons (#3636)
Expanded process runs and turn folds read nearly flat: the guide line sat left of the summary chevron, nested chevrons indented by only a few pixels, and tool rows without output yet had no chevron slot, so their icon jumped right once output arrived. The guide now drops from the parent chevron's centre, tool calls after a thought indent under it, expanded output indents with its row, and output-less tool rows reserve the chevron's width.

Co-authored-by: dengliu <[email protected]>
2026-11-16 11:10:18 +08:00
LU XIANGRUIтаwildcatDownstairs 6cc4b3779c fix(settings): import the JetBrains line height from the font's own height (#3640)
The imported line height was font size × LINE_SPACING and was only written when the export had LINE_SPACING, so tall fonts came out cramped and the default spacing (left out of the export) never applied. It is now the font's measured height (ascent + descent, rounded up per side) × LINE_SPACING (1.2 when absent), written whenever the export sets a font, size or spacing; size × 1.2 is the fallback when the font cannot be measured.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 11:08:13 +08:00
Muuтаmuutot 7d9efa1997 fix(plugins): deliver the post-install settings event to a freshly installed plugin (#3642)
The UI posts a synthetic settings-changed right after an install so event-driven plugins get a first delivery, but changed_settings() took its first snapshot on that call and reported an empty diff, so the event was dropped and the plugin stayed inactive until something else happened in the window. With no snapshot yet for a (window, plugin), it now hands over the current keys; later calls still report only the diff.

Co-authored-by: muutot <[email protected]>
2026-11-16 11:07:37 +08:00
GuoYuтаguoyucode af2e45883d fix(lsp): give a project attached inside the root its own language server (#3643)
Since attached projects inside the root were left out of the content roots (the index already walks them), the language-server manager routed their files to the outer project's server, whose workspace does not contain them (rust-analyzer: "file is not included in any crate"). The manager now gets the content roots plus the projects attached inside the root; index roots are unchanged.

Co-authored-by: guoyucode <[email protected]>
2026-11-16 11:04:29 +08:00
acaoтаamphetamlne 17e11b7904 fix(lsp): bound and cancel Go module deprecation queries (#3333)
The go.mod deprecation query (go list -m -u) could wait indefinitely on a proxy or toolchain download, and superseded checks kept running. Bound it to 60 s and 8 MiB of stdout; a new check of the same document, closing it, revoking execution permission or shutting down cancels it. A supervisor task kills and reaps the process tree even if the caller is dropped; failed or cancelled checks publish nothing.

Co-authored-by: amphetamlne <[email protected]>
2026-11-16 11:01:05 +08:00
acaoтаamphetamlne 22aa1edd61 fix(editor): discard obsolete inlay hint responses (#3253)
Inlay hint requests only checked whether the document had changed, so an older response (e.g. for the previous viewport) could replace newer hints, or restore hints after they were disabled. A refresh or destroy now bumps a generation; work that is no longer wanted is skipped after document sync, before applying results and before marking the server unavailable.

Co-authored-by: amphetamlne <[email protected]>
2026-11-16 10:59:48 +08:00
acaoтаamphetamlne 07c862c785 fix(workspace): detect marked environments before directory-name skips (#3241)
Root detection skipped dot-prefixed and conventional directory names (.venv, venv, .conda) before checking the pyvenv.cfg / conda-meta markers, so those environments were never recorded as excluded roots and their packages could reach the index and VFS walk. Check the markers first; the name-based skip still stops traversal.

Co-authored-by: amphetamlne <[email protected]>
2026-11-16 10:58:53 +08:00
l0ng-ai b60dad7076 feat(languages): Gherkin feature files (#3645)
.feature files are recognised as Gherkin: syntax colours for keywords in every Gherkin language, tags, tables, doc strings and outline placeholders; line comments, two-space indentation, a file icon, and folding of each section, step argument and doc string by indentation.

Part of #797
2026-11-16 10:56:23 +08:00
l0ng-ai 148e45745a feat(database): compare the structure of two schemas (#3644)
Compare Structure picks a source and a target schema, reads their tables with columns, indexes and foreign keys, and shows the differences as a tree (only in source, only in target, different), hiding identical items on request. Checked differences become the migration script that makes the target match the source in the target dialect; changes a dialect cannot express are left as comments. The script is copied or opened in a console of the target; nothing is run.

Closes #2694
2026-11-16 10:52:21 +08:00
l0ng-ai 3287061ea1 feat(database): SQL in MyBatis mapper XML (#3641)
The statements of <select>, <insert>, <update>, <delete> and <sql> in a MyBatis mapper are highlighted as SQL in the data source dialect and get completion, unresolved table/column inspections, Go to Declaration and Quick Documentation against the data source of the file SQL resolution scope (or the only data source). The SQL tools read the mapper with everything but the statements blanked out, so offsets stay the file own; parameters, entities, CDATA, selectKey, comments and the dynamic tags where/set/trim/foreach are read the way MyBatis builds the SQL.

Closes #2457
2026-11-16 10:44:48 +08:00
l0ng-ai 223beeb374 chore(debugger): drop an unused re-export of openAttachPopup (#3639)
pnpm knip failed on main: actions.ts re-exported openAttachPopup, which every caller imports from ./attachPopup directly.
2026-11-16 10:39:30 +08:00
l0ng-ai 8b9ad2e9d1 feat(database): SQL resolution scopes (#3638)
Settings › Languages & Frameworks › SQL Resolution Scopes maps project folders and files to a data source and schema (project settings, database.resolutionScopes). SQL files in a mapped folder resolve against its data source for completion, inspections, navigation and the console toolbar, unless another data source is picked in the toolbar; the deepest row wins and the Project row applies elsewhere. Contributed settings pages can start on the project scope (defaultScope).

Part of #2457
2026-11-16 10:38:58 +08:00
l0ng-ai a5306bade3 feat(database): show query results in the editor under their statements (#3635)
The database console toolbar gets an In-Editor Results toggle (also the db.toggleInEditorResults action, saved as database.inEditorResults). While it is on, each result set of a run shows in the editor under the statement that produced it, with the result tab grid, toolbar, paging, editing and export, and a close button instead of Pin. Running a statement again replaces its result; deleting the statement drops it. Results follow edits of the text, keep their place when the console is reopened and can be resized by dragging their bottom edge. With the toggle off, results go to the Services view as before.

Closes #2956
2026-11-16 10:30:55 +08:00
itcodesтаsliencio aa8822d9a3 feat(debugger): attach to a running Unity Editor (#2919)
Unity projects get a debug-only "Unity Editor" run configuration, selected by default. Debug opens a picker of local Unity Editor processes with the current project first; Run > Attach to Unity Process is also available. The tool installer fetches the pinned Unity Debugger 3.0.1 adapter with SHA-256 verification, and the session reports ready once the Mono runtime is up. A missing Mono executable on macOS and Linux is reported in the picker.

Refs #1436

Co-authored-by: sliencio <[email protected]>
2026-11-16 10:16:50 +08:00
l0ng-ai 5fca9c9ed0 docs(readme): rename the WeChat group QR image so the new code shows up 2026-11-16 10:11:00 +08:00
Gabriel Gondim 83805734bf feat(notifications): system notifications for balloons while OpenIDEA is in the background (#3606)
Settings › Appearance & Behavior › Notifications › Enable system notifications (global, on by default): a balloon shown while no OpenIDEA window is focused also goes to the OS notification centre with the same title and text, in the UI language; clicking it focuses the window that raised it. Agents emit an Attention event (finished / needs input / failed, de-duplicated) that raises the usual in-IDE notification, so they reach the OS through the same path. Adds tauri-plugin-notification.

Closes #3531

Co-authored-by: GGVidal <[email protected]>
2026-11-16 10:09:54 +08:00
l0ng-ai 0b3d1d67d9 docs(readme): update the WeChat group QR code 2026-11-16 10:08:39 +08:00
l0ng-ai 53a26b95a4 feat(build): read Eclipse projects without a build tool (#3630)
Eclipse projects without Maven or Gradle: .classpath source folders become Source / Test roots and its output folder is excluded; builds use the .classpath libraries and the web content folder (WST component or a conventional folder holding WEB-INF/web.xml) as the Web facet when none is configured; a web project with no artifacts gets <name>:war exploded for Build Artifacts and Tomcat.

Part of #3571
2026-11-16 10:02:16 +08:00
l0ng-ai efa4fb3b43 feat(build): Build Artifacts and Tomcat deployment for projects without a build tool (#3629)
Build Artifacts on a Java project without Maven or Gradle compiles the production classes with javac and lays out each Project Structure artifact: exploded WAR (web root, WEB-INF/classes, WEB-INF/lib), WAR packed from it, or JAR with a manifest (Main-Class, Class-Path) and its libraries next to it. Layouts are rebuilt from scratch and refuse an output folder holding their inputs. The WAR artifacts are offered to Tomcat run configurations; Build before launch packs the WAR in the IDE and records it for deployment.

Part of #3571, closes #2875
2026-11-16 09:54:52 +08:00
l0ng-ai 6df0087038 feat(build): build Java projects without a build tool from their Project Structure (#3627)
Build Project / Rebuild Project on a Java project without Maven or Gradle now compiles with javac from the Project Structure: source roots to <compiler output>/production/<module> (out by default) against the project libraries, module library dependencies and the Web facet's WEB-INF/lib; resources copied next to the classes; tests to the test output with the production classes. JDK: module or project SDK, else an installed JDK for the language level (--release from JDK 9, -source/-target before). Rebuild cleans first. BuildStep can carry in-IDE actions (clean, copy resources); BuildSystem gains javac.

Part of #3571
2026-11-16 09:47:30 +08:00
l0ng-ai bedd9d2fc9 feat(appearance): scopes and file colors for the project view and editor tabs (#3624)
Settings › Appearance & Behavior gets Scopes (named file sets as file:pattern expressions with ||, && and !, optionally limited to a module) and File Colors (a background colour per scope, first match wins, in the project view and on editor tabs; on by default with Tests green and Non-Project Files yellow). The project view's context menu gets File Color for a file or folder, kept as a scope of that path first in the project's File Colors, with Clear File Color.

Closes #3183
2026-11-16 09:36:14 +08:00
Vadim LazukтаInf1mum 696abb08d8 feat(whats-new): show the release notes in the UI language when the update manifest has them (#3567)
The update manifest can carry translated notes as notes.<lang> (for example notes.zh-CN). app_release_notes returns every language it finds, keyed by base language code. What's New shows the UI language's notes and falls back to English. Notes recorded at install stay English and are replaced by the manifest's translation when one exists.

Refs #3525

Co-authored-by: Inf1mum <[email protected]>
2026-11-16 09:34:42 +08:00
l0ng-ai f99ae11c01 feat(release): Chinese update notes from a 中文 section of the release (#3622)
The update manifest's notes come from the release body. A "## 中文" section added at the end of the draft before publishing is now published as notes.zh-CN, and the English notes leave it out. HTML comments, such as the generated-notes marker, are dropped from both.

Refs #3525
2026-11-16 09:28:50 +08:00
Gabriel Gondim b0fbc5a76c feat(mcp): run HTTP Client requests from .http files as built-in tools (#3609)
Adds two built-in MCP tools on top of ide_http. http_list_requests lists the requests in a project .http / .rest file (read-only). http_run_request runs one by index with an optional environment. It needs a trusted project and asks first; the confirmation shows the resolved URL and header names, not their values. The result has status, timing and a body truncated to 8 KiB. Request headers and body are not returned, and URLs in transport errors are redacted. The run is added to the HTTP history.

Refs #3390

Co-authored-by: GGVidal <[email protected]>
2026-11-16 09:26:11 +08:00
l0ng-ai 273564687e ci: split E2E into two parallel shards (#3620)
The E2E job reached its 30-minute limit before finishing (453 of 491 tests, none failed), so whole runs were cancelled. Two Playwright shards (about 250 tests each) run in parallel, each with its own report artifact.

Fixes #3605
2026-11-16 09:23:54 +08:00
l0ng-ai 5436b7202d feat(vcs): show every file of a change in one scrollable diff (#3617)
The diff viewer's settings menu gets Show All Files in One Diff View (off by default). With it on, a diff of a file of a change opens one Combined Changes Diff tab: a block per file under a sticky header, each diff sized to its content and loaded as it nears the viewport, with collapse, open-in-own-tab, file navigation, a shared side-by-side/unified switch and a way back to one tab per file. Blocks reuse DiffEditor in a new fit mode.

Closes #3375
2026-11-16 09:12:11 +08:00
l0ng-ai 9fdb067ec5 feat(vcs): Git staging area mode for the Commit tool window (#3615)
Settings › Version Control › Git › Enable staging area (off by default, non-modal commit interface only) makes the Commit tool window work on the Git index: Staged / Unstaged / Unversioned Files without change lists or inclusion checkboxes, a Stage or Unstage button on each row and group, and a commit of exactly what is staged; with nothing staged, Commit All commits every tracked change. The inclusion is derived from the status, so the commit pipeline is unchanged; the diff's per-block checkboxes are off in this mode.

Closes #2513
2026-11-16 09:01:45 +08:00
Deng Liuтаdengliu c8112f9010 fix(index): prevent Rayon/RwLock deadlock between streaming scans and queries (#3613)
Searching files, folders or symbols while a streaming scan indexed a project of more than 2,048 files could freeze the app for good. Queries hold IndexData::read while scanning on the global Rayon pool; the scan parsed on that same pool, took IndexData::read inside parse_found and published (IndexData::write, writer-preferring) mid-pass, so every worker could block on the lock or on the bounded channel while the query waited for a worker.

- parse_found no longer locks: the previous content hash is captured during classification, and unchanged-content metadata is refreshed inside publish.
- Background indexing and snapshot hydration run on a dedicated INDEX_POOL.
- find_files, find_dirs and find_symbols are async commands on the blocking pool, off the main thread.

Adds a test with concurrent queries across a 4,600-file scan and an unchanged-content rescan.

Co-authored-by: dengliu <[email protected]>
2026-11-16 08:42:32 +08:00
l0ng-ai 0d376cae44 fix(editor): choosers focus their rows, not the pin button, when they open (#3614)
The list popup behind Go to Declaration and the other choosers gave the initial focus to the header's pin button, so arrow keys didn't move through the rows and Enter pinned the results. List takes an autoFocus prop marking it as the popup's initial focus; the list popup sets it. Other popups with a List and header buttons already focus their search field or list.
2026-11-16 08:32:14 +08:00
NealimeKennaтаNealimeKenna b5c86bc064 feat(agents): link symbols named in inline code of agent replies (#3611)
Inline code in an agent reply that names a symbol (FooView, load(), has_header, Config.load, lib.rs::has_header, a.ts#load) now opens its definition, as file paths already did. Keywords, literals and text with spaces or shell syntax are never looked up. Names are looked up once a reply's text has settled and the spans are on screen, in one request through the new find_symbols_named command (exact matches inside the task's project, one walk over the index), and cached per name and folder. A task in a worktree resolves to the same file under its own folder. With several definitions, a file named in the same reply wins, then the task's folder; otherwise clicking opens Go to Declaration's chooser via the new optional EditorService.chooseDeclaration.

Closes #3585

Co-authored-by: NealimeKenna <[email protected]>
2026-11-16 08:29:51 +08:00
Deng Liuтаdengliu 78e169f820 fix(agents): scale Markdown list gutter in em so zoomed list markers don't clip (#3607)
The list gutter in agent replies was a fixed 20px and markers sat 6px left of it without nowrap, so zoomed-in or two-digit ordered markers (10.) were cut at the row's left edge once content-visibility painted the row clipped, or wrapped under overflow-wrap: anywhere. The indent, marker gap and task-list pull-back are now in em (wider for ordered lists and for lists of 100+ items) and markers don't wrap. Adds an e2e case with zoomed single-, two-digit, bullet and task-list markers in measured rows.

Co-authored-by: dengliu <[email protected]>
2026-11-16 08:25:08 +08:00
SunZhiQiang 601f1ee10a fix(agents): retry a failed provider probe instead of caching it (#3612)
A failed provider probe was remembered like a successful one, so a transient startup failure (the CLI updating itself, a busy machine, an initialize timeout) kept showing on the new-task page. Only a successful probe is cached now; a failed one is retried on the next call. Capabilities seeded from the cache are unchanged, since a failed probe carried only defaults.

Co-authored-by: panda-student <[email protected]>
2026-11-16 08:24:13 +08:00
Sameh Elhawaryтаsamehelhawary ea65b8c074 fix(php): only a RequestFailed error is Phoxite's refusal of a refactoring (#3610)
The Phoxite hierarchy adapter treated every server error except ContentModified as the user-facing refusal of a position, so an internal server error read like the user's mistake. Phoxite refuses with LSP RequestFailed (-32803); only that code now becomes invalid input, and other errors go through rpc_err naming the server. Adds ide_jsonrpc::codes::REQUEST_FAILED; the mock test uses -32803 and covers an internal error.

Co-authored-by: samehelhawary <[email protected]>
2026-11-16 08:23:29 +08:00
Deng Liuтаdengliu 10ddb4aa89 feat(agents): per-tab font zoom in Agent chat (#3602)
Increase/Decrease/Reset Font Size and Ctrl/Cmd+mouse wheel (when enabled) zoom the focused Agent chat tab, New Task tab or docked Agent tool window on its own (-6..+36 px): prose, code, reference chips, tool cards, prompts, the composer, Mermaid diagrams and images scale together, and off-screen virtualized rows are re-measured. Reset Font Size resets only the focused Agent surface. svgSize moves to src/ui, shared by the Markdown viewer and agents.

Co-authored-by: dengliu <[email protected]>
2026-11-16 06:46:13 +08:00
Deng Liuтаdengliu 1259423fdc feat(editor): font zoom changes the active editor by default, with an Active/All editors setting (#3604)
Increase/Decrease Font Size, Reset Font Size and Ctrl/Cmd+mouse wheel apply to the active editor (or Markdown preview) by default. Settings > Editor > General > Mouse Control gets an Active editor / All editors choice beside "Change font size with Ctrl/Command+Mouse Wheel" (editor.general.wheelZoomScope); All editors keeps the behaviour from #2488. Reset Font Size resets the active editor; Reset Font Size in All Editors (editor.resetFontSizeAll) stays in the View menu.

Co-authored-by: dengliu <[email protected]>
2026-11-16 06:44:30 +08:00
Sameh Elhawaryтаsamehelhawary 3fed53ced7 feat(php): Pull Members Up and Push Members Down with Phoxite (#3603)
When a server of the document advertises experimental.phoxite.refactor, Pull Members Up / Push Members Down send Phoxite's phoxite/refactor/hierarchyMembers and phoxite/refactor/hierarchy requests; the existing dialog, Problems Detected step and edit application are reused. A refused position becomes invalid input, as the JDT extension's refusal does. PHP joins the hierarchy refactoring languages in Refactor This.

Co-authored-by: samehelhawary <[email protected]>
2026-11-16 06:42:59 +08:00
Sameh Elhawaryтаsamehelhawary ad236cf1a1 feat(plugins): route a server's client commands to a plugin (serverCommands, API 1.9) (#3597)
A language server's code lens, code action or inlay hint can carry a command it leaves to the client. `[[contributes.serverCommands]]` (API 1.9, needs `lsp:<server>`) routes such a command, when no server of the document lists it in `executeCommandProvider`, to the plugin's own command with the arguments as JSON. The first loaded plugin keeps a claimed server + command; the host logs the conflict once. Routed from lsp_execute_command, lsp_apply_code_action and lsp_execute_code_action; a code action's command is matched against its own server's claims only.

Part of #3542.

Co-authored-by: samehelhawary <[email protected]>
2026-11-16 05:32:06 +08:00
l0ng-ai 3b06fc037d test(index): wait for the snapshot instead of a fixed 150 ms
The warm-start snapshot is written on the worker's next round after a short delay; the test polls for it instead of sleeping 150 ms, which loaded CI runners didn't always cover.
2026-11-16 05:21:23 +08:00
l0ng-ai 6d70458e22 fix(rust): colour self as a keyword (#3600)
rust-analyzer's selfKeyword token and @lezer/rust's self tag were painted with Python's self-parameter colour; both now take the keyword colour, as RustRover colours the self parameter by default.
2026-11-16 05:11:06 +08:00
l0ng-ai bbd7c36c40 feat(hierarchy): pin Hierarchy tabs; a new hierarchy replaces the selected unpinned one (#3599)
Call and type hierarchies open in content tabs. A new hierarchy takes the place of the selected tab unless it is pinned, then it opens in its own tab. Tabs are pinned from the shared content tab menu or the pin in place of the close button; a tab shown again keeps its tree and expanded nodes.
2026-11-16 05:09:20 +08:00
l0ng-ai e586923308 test: fix five Windows-only test failures (#3596)
jdtls handle with the jar's portable path; plugin fuel test with headroom for Windows activation and a per-step workload so the refill is still required; cpuprofile test with a platform absolute path; bare python as the saved command on Windows; worktree checkout compared with git's path.
2026-11-16 04:39:58 +08:00
l0ng-ai 2ddc849b88 fix(run): runs started together get their own tabs (#3595)
Rerun Failed Tests for several Go packages and compound configurations start runs concurrently. Each run picked a finished tab before awaiting the editor save and took it only afterwards, so two runs could pick the same tab: one replaced the other and its process never started. A tab a starting run is about to take, or was asked to reuse, is now held until it is taken.

Also fixes the agent model e2e helper: a model row's name now includes its Configure button, so the option is matched by its leading name.
2026-11-16 04:26:13 +08:00
Mr0Bread 41951e2895 refactor(platform): move choosePath out of settings (#3594)
choosePath, a thin wrapper over the platform file/folder dialog, lived in features/settings/languages/api.ts, so vcs/RevisionBrowser imported the settings feature to open a folder picker. It moves to platform/choosePath.ts unchanged (the dialog module still loads lazily). No behaviour change.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-16 04:15:46 +08:00
Sameh Elhawaryтаsamehelhawary feb261d172 feat(plugins): requests from a plugin to a running language server (API 1.9) (#3588)
Adds the language-servers import (request / notify, JSON strings, a borrow<project> handle) and the lsp:<server> capability, one grant per server name, high risk, API 1.9. Only the server's own namespace passes: initialize, initialized, shutdown, exit, $/ methods and every LSP namespace (textDocument, workspace, window, …) are refused, in the plugin host and again in LspManager. server is the name of a [[language-servers]] entry matched against what runs for the project; a server that isn't running is not-found and nothing is started. Requests honour the invocation's cancellation and I/O time budget, need a trusted project, and are limited to 256 bytes of method and 1 MiB of params. SDK helpers and mock support, a fixture plugin for the grant checks, docs, and rebuilt components.

Part of #3542

Co-authored-by: samehelhawary <[email protected]>
2026-11-16 03:47:57 +08:00
Mr0Bread 3d4a1fd387 refactor(ui): move iconNode out of editor/lsp (#3593)
iconNode only depends on ui/icons but lived in editor/lsp/iconMarkup.ts, so agents, database, debugger and viewers imported editor internals to draw an icon. It moves to ui/iconNode.ts. No behaviour change.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-16 03:33:25 +08:00
Mr0Bread 88e4b8f79b refactor(ui): stop ui and platform importing upward (#3591)
platform/filePresentation and platform/projectType imported the icon set from ui/, and ui/logColors imported LEVELS from editor/core/cm/log. filePresentation and projectType move to ui/, and the log level vocabulary moves to platform/logLevels, imported by both the log language and ui/logColors. No behaviour change.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-16 03:32:43 +08:00
Sameh Elhawaryтаsamehelhawary 3c9ac70cdf docs: format the Turkish README (#3592)
oxfmt --check failed on README.tr.md (added in #3519), stopping the Frontend CI job at format:check. Only the benchmark table's column alignment changes.

Co-authored-by: samehelhawary <[email protected]>
2026-11-16 03:31:42 +08:00
Vadim LazukтаInf1mum cc72161f92 feat(settings): point at community themes and notify one-dark users (#3574)
Appearance gets a Get more themes link beside the Theme selector that opens Settings › Plugins on the marketplace's themes (plugins#themes; pages read the target through SettingsPageFocusContext). Installs whose settings file still names the removed one-dark theme get a one-time notice that One Dark is now provided by the One Dark Pro plugin, with Install while it isn't installed; settings_removed_theme reports the raw id a settings file names before it is mapped to its stand-in.

Closes #3284

Co-authored-by: Inf1mum <[email protected]>
2026-11-16 03:31:23 +08:00
Mr0Bread 485638cba5 fix(agent): keep a model's effort levels when an idle task's settings change (#3590)
With no session running, switching a task's model drops its effort option until an agent reports the new model's levels. Changing another setting, or picking the same model again, then saved that effort-less copy as the model's levels, erasing them until a session reported them again; apply_late_choices could do the same after a model switch whose reply had no configOptions. A model's levels are now saved from the task's own copy only while it still holds per-model options.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-16 03:25:44 +08:00
Akbar Husain e968801415 feat(templates): live, surround, postfix and file templates for Zig (#3586)
Adds Zig to the template sets: 19 live templates (functions, main, test, struct / enum / union, if / while / for with captures, defer, try / catch, switch, std.debug.print), 9 surrounders, 11 postfix templates plus .not with a Zig tab in Settings, and a Zig File new-file template (empty, main, test, struct) with the Zig Test Function fragment. if / while conditions are parenthesised as Zig requires, and ! negation is offered as in the other brace languages.

Co-authored-by: akbar1214 <[email protected]>
2026-11-16 02:39:41 +08:00
Deng Liuтаdengliu 7b6962001b feat(agents): two-page model picker with pinned models, segmented effort, Reset and ACP cost badges (#3583)
The composer model picker becomes a two-page popover for every agent: page 1 lists models with search, a Pinned section, usage multiplier and description, and a summary bar for the active model; page 2 configures a model with Back, Reset to defaults, Pin, a segmented effort control and the cost category / multiplier from ACP _meta (copilotPriceCategory, copilotUsage) where present. Option defaults are kept across same-model updates for Reset. A contextTier / context_tier option is handled as per-model like effort. Agents with no effort, model options or cost metadata keep the plain select.

Co-authored-by: dengliu <[email protected]>
2026-11-16 02:07:32 +08:00
l0ng-ai 8535fb7645 fix(agent): show an agent's form fields in its schema's order (#3584)
serde_json's Value keeps object keys sorted, so elicitation/create forms
listed their fields alphabetically. JSON-RPC handlers can now read the
request as received (Handler::on_request_raw), and the form takes its field
order from requestedSchema.properties there. The ACP dialect wrapper
forwards the raw request.
2026-11-16 01:47:38 +08:00
l0ng-ai 89eacbe640 fix(agent): offer the effort levels a session reports for ACP models discovery didn't read (#3582)
ACP discovery opens one session and knows only that session's model's
effort levels. Once discovery succeeded, session reports no longer reached
the New Task catalog, so other models of the agent showed no effort choice.
A session on another listed model now records that model's levels in the
project's catalog (never the discovered model's), and a later discovery
keeps them while the model is still listed.
2026-11-16 01:23:42 +08:00
Mr0Bread c67b336a8a feat(agent): answer ACP form elicitation (#3580)
The ACP client advertises elicitation.form and answers elicitation/create: the request's restricted JSON Schema becomes form fields (text, number, integer, boolean, single and multiple choice, with titles, descriptions, defaults, required and bounds), shown in the question card above the composer. Submit replies accept with typed values, Decline replies decline, Cancel or Escape replies cancel; the conversation records the answers. Nested objects and URL mode are refused with INVALID_PARAMS. Bypassing approvals never answers a form.

Part of #3536

Co-authored-by: Mr0Bread <[email protected]>
2026-11-16 01:11:16 +08:00
Akbar Husain 90cc707d00 feat(zig): Settings page and detection for the Zig toolchain (#3578)
Adds Settings › Languages & Frameworks › Zig for languages.zig.zig (used by the Zig External Libraries), on the shared SDK row: Auto = zig on PATH, Detect again, Browse. ide-sdk gains SdkKind::Zig, detecting PATH installs (shims skipped), Homebrew, zvm and mise / asdf installs; the stored path is the directory holding zig, with the version from zig version.

Co-authored-by: akbar1214 <[email protected]>
2026-11-16 01:05:20 +08:00
Mr0Bread 779080781b fix(agent): keep each ACP model's own effort levels (#3577)
ACP discovery opens one session and reads its thought_level option, which describes that session's model only, but recorded it under every model value. Agents whose models offer different effort lists (e.g. OMP's Copilot gpt-4o: off/auto) showed levels the agent rejects. Discovery now records the levels for the session's model only.

Part of #3536

Co-authored-by: Mr0Bread <[email protected]>
2026-11-16 01:00:29 +08:00
Bbu Gulli Annтаctro15547 ccf87e2476 fix(macos): support macOS 12 again (#3576)
Lowers the minimum macOS version to 12.0 and the WebKit floor to Safari 15.4: Vite targets safari15.4, check-webkit enforces the 15.4 floor and rejects Array toSorted/toReversed/toSpliced, showPicker and Intl.supportedValuesOf in startup chunks, the boot outdated check tests structuredClone, the Database view drops toReversed, and the install docs list macOS 12. Container-query layouts degrade on macOS 12.

Fixes #3413

Co-authored-by: ctro15547 <[email protected]>
2026-11-16 00:58:42 +08:00
l0ng-ai 76f0b3fc63 feat(project-view): Open in Right Split (⇧Enter) (#3579)
The Project view opened a file in the current pane whatever the modifier and had no way to open one in a split. Open in Right Split opens the selected files in the pane to the right: ⇧Enter in the IntelliJ keymaps, ⌘Enter / Ctrl+Enter in the VS Code ones, and in the context menu before Open In (External Libraries too). On a folder ⇧Enter keeps expanding it.

Closes #3549
2026-11-16 00:55:52 +08:00
l0ng-ai a5c14a4c21 fix(notebook): Vim u and Ctrl-R undo and redo in notebook cells (#3575)
Notebook cells keep no CodeMirror history (edits share the notebook's backend history), so Vim's u / Ctrl-R did nothing there. An editor can provide externalHistory; notebook cells provide the session's, and the Vim engine sends undo / redo to it.
2026-11-16 00:11:43 +08:00
Akbar Husain cf444a31f7 perf(index): allocation-free hump scoring and byte-scan name boosts (#3573)
hump_bonus walks the candidate's chars once with a cursor into the sorted, deduplicated match indices instead of collecting a Vec<char> per ranked survivor, and name_boost finds the extension dot with a byte scan. Results are unchanged; find_symbols/OCo goes from 3.71 ms to 3.36 ms in the index bench.

Co-authored-by: akbar1214 <[email protected]>
2026-11-16 00:05:57 +08:00
Mr0Bread c3763fb806 feat(agent): steer agents that advertise _session/steering (#3568)
Messages typed while a task is running join the running turn for agents that advertise the _session/steering extension (_meta.steering.supported in the initialize response, as OMP does), not only those advertising _meta.openidea.steer. An outcome other than injected (promptRequired, failed) queues the message for the next turn.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-16 00:01:30 +08:00
Mr0Bread 9a518e734b refactor(styles): put gap on the spacing scale (#3562)
Extends the 4px-grid spacing scale with --space-0-5 (2px), --space-1 (4px) and --space-1-5 (6px) and replaces the literal 2/4/6/8/12/16px gap, row-gap and column-gap values with the tokens; computed values are unchanged. src/styles/spacingScale.test.ts flags an on-scale literal gap.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-15 23:59:47 +08:00
Mr0Bread 2913c12a19 chore(styles): remove CSS module classes no component reads (#3560)
35 CSS-module classes in 10 modules were defined but never read (no styles.x use, no composes, no dynamic access in their importers): leftovers of removed UI such as the settings code-preview block, the GitHub tool window's layout helpers and SDK tree rows.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-15 23:58:00 +08:00
Mr0Bread 3044518b88 fix(styles): restore CSS classes components still reference (#3559)
Components read CSS-module classes no module defined, which are undefined at runtime. The archived-task banner in agent sessions (.banner, .bannerText, .bannerSpacer, dropped in #2083) and the Create Patch directory row (.cloneDirRow, .cloneDirInput, dropped in #866) are restored; references to classes that never existed are removed. src/styles/cssModules.test.ts lists any styles.x the imported module lacks.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-15 23:56:20 +08:00
Vadim LazukтаInf1mum 778472854e fix(markdown): keep the Preview only scroll position when switching tabs back (#3569)
Tab switches unmount the preview, and its saved offset was applied once at remount, before images and diagrams had drawn. A restore that clamped to the short document is applied again on each settle until it fits or the reader scrolls; the clamped write no longer replaces the saved offset. The preview opts out of scroll anchoring, which in WebView2 kept a later block in view while images above it loaded.

Fixes #3537

Co-authored-by: Inf1mum <[email protected]>
2026-11-15 23:54:36 +08:00
l0ng-ai 1679d61a6a fix(services): list the SSH configurations in the Docker connection dialog (#3570)
SshConfigSelect reads the settings window's staged ssh.configs unless given a list, and that list is empty outside the settings window, so the Docker connection dialog offered only None. The dialog now passes the live list; the None choice gets its Chinese text.

Closes #3535
2026-11-15 23:51:21 +08:00
l0ng-ai 937008a6fe fix(lsp): highlight a library class the Kotlin server shows as Java as Java (#3565)
A virtual .class document has no language by its name, so it took its server's first language: the Kotlin language server's Java stubs of jar classes were highlighted as Kotlin and their Java keywords stayed uncoloured. A .class stub whose package or import line ends with ';' is now Java (virtual_doc::is_java_class_stub).
2026-11-15 23:40:00 +08:00
l0ng-ai dc3d2050cb fix(editor): colour this and super as keywords in Java, JavaScript, TypeScript and C++ (#3564)
The Lezer grammars tag `this` as `self`, which the colour scheme paints with Python's self-parameter colour, and @lezer/javascript tags `super` as an atom. JAVA_TAGS (also used by JSP), JS_TAGS and a new C++ entry restyle them as keywords. Python's `self` is unchanged.
2026-11-15 23:37:06 +08:00
Mr0Bread 732baf8f1e fix(styles): use defined tokens where CSS read --bg-subtle, --bg-toolbar and --fg-primary (#3550)
Three custom properties were read without a fallback and declared nowhere, so they resolved to their initial values: no background on the Working Status and Command Permissions rows, none on the console Find button (its icon sat over console text), and an inherited hover colour. They now use --bg-hover, --bg-elev and --fg-strong; a dead var(--bg) fallback in Run.module.css is dropped. A test lists any var(--x) without a fallback whose --x is declared nowhere.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-15 23:31:12 +08:00
Mansur Akhmadiтаmansur-akhmadi 9b6e5a5a62 feat(vcs): copy a file's link on its Git remote from Copy Path/Reference… (#3553)
Copy Path/Reference… gains a <hosting> Link item (GitHub Link, GitLab Link, Bitbucket Link) that copies the page Open In › <hosting> opens; in the editor the link covers the selected lines (#L2-L3 / #L2-3 / #lines-2:3). A copyPath menu id lets features add items to the chooser, so editor/core and project-tree stay free of Git code.

Closes #3552

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-15 23:29:54 +08:00
l0ng-ai 8c2c701517 feat(keymap): list Cut, Copy, Paste, Undo, Redo and Select All in Settings › Keymap (#3563)
The Edit actions are hidden from Search Everywhere, and the Keymap page skipped hidden actions with no preset shortcut, so they could not get a second key (Ctrl+Shift+C / V / X for Vim users). A keymap flag on an action keeps it listed; the settings window's action list (describeActions) carries it too.
2026-11-15 23:25:59 +08:00
l0ng-ai aeb689c632 test(app): the command-line diff opens with Swap Sides (#3557)
#3540 made the command-line diff swappable; the launch tests in windows.test.ts still expected the diff data without the flag.
2026-11-15 23:17:53 +08:00
l0ng-ai 80c25be389 fix(keymap): list the data editor actions in the VS Code preset (#3556)
The VS Code preset must name every IntelliJ action id; #3551 added the db.* data editor actions to the IntelliJ presets only, failing keymap.test.ts on main.
2026-11-15 23:16:27 +08:00
Sameh Elhawaryтаsamehelhawary acea7e6235 feat(php): Phoxite as a selectable PHP language server (#3541)
languages/php.toml gains a phoxite entry (phoxite-lsp over stdio), a fallback listed after phpactor; Intelephense stays the default and users pick Phoxite under Language Servers. ide-tools installs it from the samehelhawary/phoxite GitHub releases (a binary per platform with a .sha256 beside it). A server entry can now name the servers it replaces: those stay away while it serves the file (Phoxite replaces laravel-lsp, which it covers), including when the replacing fallback takes over after a server gives up.

Co-authored-by: samehelhawary <[email protected]>
2026-11-15 23:14:32 +08:00
l0ng-ai 25197b3215 fix(vcs): show a committed directory symlink's target in revision diffs (#3554)
Revision content was decoded with the working file's encoding, read whenever the path existed. For a symlink to a folder that path is a directory, so loading failed and the Git Log diff showed '<path> is a directory'. The working file is now consulted only when it is a regular file; otherwise the encoding is detected from the revision's blob.

Closes #3528
2026-11-15 23:11:50 +08:00
Vadim LazukтаInf1mum 55786a7030 fix(vcs): the Git Log rename label names the original directory (#3546)
The changed-file label trimmed a rename's old path to its base name, so a move between directories looked like a rename in place. A shared renameFrom() now says 'renamed from <name>' within one directory and 'moved from <old path relative to the new directory>' otherwise, as IDEA does; Git Log and the GitHub create / pull request change trees use it.

Closes #3529

Co-authored-by: Inf1mum <[email protected]>
2026-11-15 23:09:13 +08:00
Vadim LazukтаInf1mum b7adbbb17c fix(project): mark symlinks with a link arrow in the tree (#3547)
Directory and file symlinks used the same icons as real folders and files. The Project view now overlays IDEA's link arrow (expui nodes/symlink) on every entry the listing reports as a symlink; the model already carried the flag, so no extra stat calls.

Closes #3527

Co-authored-by: Inf1mum <[email protected]>
2026-11-15 23:06:39 +08:00
l0ng-ai d1290c76ea feat(database): data editor row and toolbar commands as actions (#3551)
Reload Page, First / Previous / Next / Last Page, Add Row, Export Data, Delete Rows, Restore Rows, Edit Cell and the cell copy commands were menu items or toolbar buttons only. They are now db.* actions supplied by the table editor and the console result grid through their focus handle, so they appear in Find Action and take Keymap shortcuts; menus and buttons run the same actions. DataGrip's defaults bind Reload Page, Previous / Next Page and Add Row, and Delete Rows on Windows and Linux.

Closes #3506
2026-11-15 23:03:35 +08:00
l0ng-ai 0febd3e170 fix(editor): Sort Lines orders by character code (#3548)
Sort Lines used a locale-aware collator, which interleaves upper- and lowercase letters. It now compares UTF-16 code units, the order IDEA's Sort Lines uses (String.compareTo) and LC_ALL=C sort gives.

Closes #3516
2026-11-15 22:47:11 +08:00
815 змінених файлів з 37574 додано та 3227 видалено

No files matched your search

+7
Переглянути файл
@@ -0,0 +1,7 @@
# Link debug builds for the oldest system we support, so Launch Services
# accepts the bundle on macOS 11. Without this a newer SDK leaves
# LC_BUILD_VERSION.minos at 12.0 and the app is refused (-10825) before main
# can load a newer WebKit. An explicitly exported MACOSX_DEPLOYMENT_TARGET
# still wins: this is only the default for local builds and CI.
[env]
MACOSX_DEPLOYMENT_TARGET = "11.0"
Бінарний файл не відображається.

Після

Ширина:  |  Висота:  |  Розмір: 160 KiB

Бінарний файл не відображається.

До

Ширина:  |  Висота:  |  Розмір: 86 KiB

+7 -3
Переглянути файл
@@ -208,11 +208,15 @@ jobs:
- run: pnpm build
e2e:
name: E2E
name: E2E (${{ matrix.shard }}/2)
needs: changes
if: needs.changes.outputs.frontend == 'true'
timeout-minutes: 30
runs-on: ubuntu-24.04
strategy:
fail-fast: false
matrix:
shard: [1, 2]
# Browsers and their system libraries are preinstalled; keep the tag in step with @playwright/test.
container: mcr.microsoft.com/playwright:v1.64.1-noble
steps:
@@ -222,12 +226,12 @@ jobs:
- uses: actions/setup-node@v5
with: { node-version: 22, cache: pnpm }
- run: pnpm install --frozen-lockfile
- run: pnpm e2e
- run: pnpm e2e --shard=${{ matrix.shard }}/2
env:
HOME: /root
- uses: actions/upload-artifact@v6
if: failure()
with:
name: playwright-report
name: playwright-report-${{ matrix.shard }}
path: playwright-report/
retention-days: 7
+29 -9
Переглянути файл
@@ -262,26 +262,46 @@ jobs:
}
// The update's notes: the release body without its Download section. That
// section only matters on the release page, and What's new follows it.
// A translated section, "## 中文" added at the end of the draft before it is
// published (it runs to the next heading of its level, or the end), becomes
// `notes.zh-CN`: What's new shows it in that UI language and falls back to
// `notes`, the English rest of the body. HTML comments are dropped.
const { data: release } = await github.rest.repos.getRelease({ owner, repo, release_id });
const withoutDownloadSection = (body) => {
const kept = [];
const languages = { "中文": "zh-CN" };
const notesByLanguage = (body) => {
const parts = { "": [] };
let lang = "";
let langLevel = 0;
let skip = 0;
for (const line of body.split(/\r?\n/)) {
for (const line of body.replace(/<!--[\s\S]*?-->/g, "").split(/\r?\n/)) {
const heading = /^(#{1,6})\s+(.*)$/.exec(line);
if (heading) {
const level = heading[1].length;
if (!skip && level <= 3 && /^download$/i.test(heading[2].trim())) {
const title = heading[2].trim();
if (skip && level <= skip) skip = 0;
if (lang && level <= langLevel) lang = "";
if (!skip && level <= 3 && /^download$/i.test(title)) {
skip = level;
continue;
}
if (skip && level <= skip) skip = 0;
if (!skip && !lang && level <= 2 && languages[title]) {
lang = languages[title];
langLevel = level;
parts[lang] ??= [];
continue;
}
}
if (!skip) kept.push(line);
if (!skip) parts[lang].push(line);
}
return kept.join("\n").trim();
return Object.fromEntries(Object.entries(parts).map(([key, lines]) => [key, lines.join("\n").trim()]));
};
const { "": notes, ...translated } = notesByLanguage(String(release.body ?? ""));
const translations = Object.fromEntries(
Object.entries(translated).filter(([, text]) => text).map(([lang, text]) => [`notes.${lang}`, text]),
);
const manifest = {
version: tag.replace(/^v/, ""), notes, ...translations, pub_date: new Date().toISOString(), platforms,
};
const notes = withoutDownloadSection(String(release.body ?? ""));
const manifest = { version: tag.replace(/^v/, ""), notes, pub_date: new Date().toISOString(), platforms };
const old = assets.find((a) => a.name === "latest.json");
if (old) await github.rest.repos.deleteReleaseAsset({ owner, repo, asset_id: old.id });
await github.rest.repos.uploadReleaseAsset({
+1
Переглянути файл
@@ -42,6 +42,7 @@ Visual style: dark, low-contrast greys, one cool accent
shortcuts live in `src/platform/keymaps/`.
- Styling: CSS Modules + tokens only (no hex literals in components). Inline SVG
icons from `src/ui/icons.tsx`, never emoji. Real `<button>`/`<input>`; `aria-label` on icon buttons.
`gap` uses the `--space-*` scale (`src/styles/tokens.css`, 4px grid) where a value is on it.
- User-visible text goes through the text catalog: add every new string to both
`src/platform/locales/text/en.json` and `zh.json` (`textCatalog.test.ts` enforces it).
Other locales may lack entries; their UI shows the English text until a translator adds it.
Створено
+131 -6
Переглянути файл
@@ -199,7 +199,7 @@ dependencies = [
"wayland-backend",
"wayland-client",
"wayland-protocols",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -5722,6 +5722,20 @@ dependencies = [
"serde_repr",
]
[[package]]
name = "mac-notification-sys"
version = "0.6.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fd604973958ddcc11b561193c0fb96ba146506ef2f231ef2e7c35fd2cbc9beca"
dependencies = [
"cc",
"log",
"objc2 0.6.5",
"objc2-foundation 0.3.2",
"time",
"uuid",
]
[[package]]
name = "mach2"
version = "0.6.0"
@@ -5994,6 +6008,20 @@ dependencies = [
"windows-sys 0.60.2",
]
[[package]]
name = "notify-rust"
version = "4.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57da5b5d3b7809bf71858da5a2818c3404ca4688c02c8abecdda0fcdec235df3"
dependencies = [
"futures-lite",
"log",
"mac-notification-sys",
"serde",
"tauri-winrt-notification",
"zbus 6.3.0",
]
[[package]]
name = "notify-types"
version = "2.1.0"
@@ -6666,6 +6694,7 @@ dependencies = [
"tauri-build",
"tauri-plugin-dialog",
"tauri-plugin-mcp-bridge",
"tauri-plugin-notification",
"tauri-plugin-opener",
"tauri-plugin-single-instance",
"tauri-plugin-updater",
@@ -8153,7 +8182,7 @@ dependencies = [
"once_cell",
"serde",
"sha2 0.11.1",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -9429,6 +9458,26 @@ dependencies = [
"windows-core",
]
[[package]]
name = "tauri-plugin-notification"
version = "2.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14a226bfb8189ec4ab2c1936e66330ad06c44d9f6c54a674338208491dee177f"
dependencies = [
"log",
"notify-rust",
"rand 0.10.3",
"serde",
"serde_json",
"serde_repr",
"tauri",
"tauri-plugin",
"thiserror 2.0.21",
"time",
"url",
"zbus 5.19.0",
]
[[package]]
name = "tauri-plugin-opener"
version = "2.7.2"
@@ -9448,7 +9497,7 @@ dependencies = [
"thiserror 2.0.21",
"url",
"windows",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -9464,7 +9513,7 @@ dependencies = [
"tokio",
"tracing",
"windows-sys 0.61.2",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -9647,6 +9696,17 @@ dependencies = [
"toml 1.1.8+spec-1.1.0",
]
[[package]]
name = "tauri-winrt-notification"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f37a6c354fd28fc9e322ed9bd47e3959576dad28c9d58ea1cf888cce1c7ccb36"
dependencies = [
"thiserror 2.0.21",
"windows",
"windows-version",
]
[[package]]
name = "tempfile"
version = "3.27.0"
@@ -12137,11 +12197,38 @@ dependencies = [
"uuid",
"windows-sys 0.61.2",
"winnow 1.0.4",
"zbus_macros",
"zbus_macros 5.19.0",
"zbus_names",
"zvariant",
]
[[package]]
name = "zbus"
version = "6.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6b4aae740b23927ceabed962431abab2cdefb9f7f885e5bbab062da09bf580e4"
dependencies = [
"async-trait",
"bitflags 2.13.2",
"endi",
"futures-core",
"hex",
"libc",
"ordered-stream",
"rustix",
"serde",
"serde_repr",
"socket2",
"uds_windows",
"uuid",
"windows-sys 0.61.2",
"winnow 1.0.4",
"zbus_macros 6.3.0",
"zbus_utils",
"zcheapstr",
"zruntime",
]
[[package]]
name = "zbus-secret-service-keyring-store"
version = "1.0.1"
@@ -12150,7 +12237,7 @@ checksum = "74801d001b9e7729adb4f1825b67b398185fed424749aa3d8bacf70417137d9a"
dependencies = [
"keyring-core",
"secret-service",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -12168,6 +12255,18 @@ dependencies = [
"zvariant_utils",
]
[[package]]
name = "zbus_macros"
version = "6.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37c9dd4beaf145c16fcb2902862f50da86e54aed13dd368ddf64a1d17e6b8529"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.9",
"zbus_utils",
]
[[package]]
name = "zbus_names"
version = "4.3.5"
@@ -12179,6 +12278,19 @@ dependencies = [
"zvariant",
]
[[package]]
name = "zbus_utils"
version = "6.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "af55e52da295311b368c45bcae221f020e28e97a2420360170ce389218e76ec7"
dependencies = [
"proc-macro2",
"quote",
"serde",
"syn 3.0.9",
"winnow 1.0.4",
]
[[package]]
name = "zcheapstr"
version = "1.1.0"
@@ -12335,6 +12447,19 @@ dependencies = [
"simd-adler32",
]
[[package]]
name = "zruntime"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ce6a55d4f521760475a30f7b96779508fe8c40dc834478709454dd1d5f0ebc72"
dependencies = [
"futures-core",
"futures-io",
"rustix",
"socket2",
"windows-sys 0.61.2",
]
[[package]]
name = "zune-core"
version = "0.5.3"
+1 -1
Переглянути файл
@@ -68,7 +68,7 @@ the [official plugins](plugins/official). The plugin API is still a preview.
- [Discord](https://discord.gg/2Zy4yn7gP) — questions, feedback and release news.
- WeChat group — scan to join:
<img src=".github/assets/wechat-group.png" alt="WeChat group QR code" width="200">
<img src=".github/assets/wechat-group-3.png" alt="WeChat group QR code" width="200">
- Contributing: see [CONTRIBUTING.md](CONTRIBUTING.md) and the [contributor docs](https://openidea.sh/en/contribute/setup).
+9 -9
Переглянути файл
@@ -38,14 +38,14 @@ Editör, kod analizi, hata ayıklayıcı (debugger), Git, terminal, veritabanı
[freqtrade](https://github.com/freqtrade/freqtrade) projesini (Python, ~770 dosya)
önbellekler hazırken açma, 5 çalıştırmanın ortancası:
| | OpenIDEA | IntelliJ IDEA 2026.2.3 |
| ---------------------------------- | --------------------- | ---------------------- |
| Projeyle pencerenin açılması | **0,9 sn** | 3,1 sn |
| Hazır (CPU sakinleşti) | **1,1 sn** | 13,2 sn |
| Bellek (USS, tüm işlemler) | **169 MB** | 2011 MB |
| Hazır olana kadar CPU süresi | **2,4 sn** | 47,9 sn |
| Boştayken CPU | Bir çekirdeğin **%4**'ü | Bir çekirdeğin %7'si |
| Kapanma | **0,3 sn** | 5,9 sn |
| | OpenIDEA | IntelliJ IDEA 2026.2.3 |
| ---------------------------- | ----------------------- | ---------------------- |
| Projeyle pencerenin açılması | **0,9 sn** | 3,1 sn |
| Hazır (CPU sakinleşti) | **1,1 sn** | 13,2 sn |
| Bellek (USS, tüm işlemler) | **169 MB** | 2011 MB |
| Hazır olana kadar CPU süresi | **2,4 sn** | 47,9 sn |
| Boştayken CPU | Bir çekirdeğin **%4**'ü | Bir çekirdeğin %7'si |
| Kapanma | **0,3 sn** | 5,9 sn |
`main` dalından derlenmiş bir OpenIDEA sürümü ve varsayılan ayar ve eklentilerle IDEA;
Windows 11, 32 çekirdekli AMD, 62 GB RAM.
@@ -68,7 +68,7 @@ Eklentileri Ayarlar › Eklentiler (Settings › Plugins) bölümünden kur ya d
- [Discord](https://discord.gg/2Zy4yn7gP): sorular, geri bildirim ve sürüm haberleri.
- WeChat grubu, katılmak için kodu okut:
<img src=".github/assets/wechat-group.png" alt="WeChat grubu QR kodu" width="200">
<img src=".github/assets/wechat-group-3.png" alt="WeChat grubu QR kodu" width="200">
- Katkıda bulunmak için: [CONTRIBUTING.md](CONTRIBUTING.md) ve [katkıcı belgeleri](https://openidea.sh/en/contribute/setup).
+1 -1
Переглянути файл
@@ -66,7 +66,7 @@ WebAssembly 组件运行;主题、图标主题和语言无需编写代码。
- [Discord](https://discord.gg/2Zy4yn7gP):提问、反馈和版本发布消息。
- 微信群,扫码加入:
<img src=".github/assets/wechat-group.png" alt="微信群二维码" width="200">
<img src=".github/assets/wechat-group-3.png" alt="微信群二维码" width="200">
- 参与贡献:参见 [CONTRIBUTING.md](CONTRIBUTING.md) 和[贡献者文档](https://openidea.sh/zh/contribute/setup)。
+14 -17
Переглянути файл
@@ -10,12 +10,14 @@ use crate::provider::ProviderSpec;
use crate::{Shared, client_info};
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::collections::BTreeMap;
use std::sync::Arc;
use std::time::Duration;
const DISCOVER_TIMEOUT: Duration = if cfg!(test) { Duration::from_secs(3) } else { Duration::from_secs(120) };
/// Opens `session/new`, reads `configOptions`, and records per-model `thought_level` choices.
/// Opens `session/new`, reads `configOptions`, and records the `thought_level` choices of the
/// session's model: they describe that model only, and other models may offer different ones.
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec) -> Result<Discovered, String> {
let prefer_stored = crate::provider::prefer_stored_copilot_auth();
match run_once(shared, spec, prefer_stored).await {
@@ -62,21 +64,17 @@ async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool
.map_err(|e| e.to_string())?;
let mut options = config::options_of(&new);
config::add_client_options(&launch.id, &mut options);
let model_option = options.iter().find(|o| o.category.as_deref() == Some("model"));
let effort = levels_for_model_from_slice(&options);
let levels: Vec<(String, Vec<AgentConfigOption>)> = match (model_option, effort) {
(Some(model), Some(effort)) if !model.values.is_empty() => {
model.values.iter().map(|v| (v.value.clone(), effort.clone())).collect()
}
(Some(model), Some(effort)) => model.current.clone().map(|m| vec![(m, effort)]).unwrap_or_default(),
_ => Vec::new(),
let model = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.clone());
let levels = match (model, levels_for_model_from_slice(&options)) {
(Some(model), Some(effort)) => BTreeMap::from([(model, effort)]),
_ => BTreeMap::new(),
};
let commands = updates
.commands
.lock()
.clone()
.or_else(|| new.get("availableCommands").map(|_| config::commands_of(&new, &launch.id)));
Ok::<_, String>(Discovered { config: options, commands, levels: levels.into_iter().collect() })
Ok::<_, String>(Discovered { config: options, commands, levels })
};
let result = tokio::time::timeout(DISCOVER_TIMEOUT, work).await;
peer.kill();
@@ -108,18 +106,17 @@ impl ide_jsonrpc::Handler for DiscoveryUpdates {
}
}
fn is_thought_level(o: &AgentConfigOption) -> bool {
o.category.as_deref() == Some("thought_level")
|| matches!(o.id.as_str(), "effort" | "reasoning_effort" | "thinking" | "reasoning")
}
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option<Vec<AgentConfigOption>> {
let levels: Vec<_> = options
.iter()
.filter(|o| is_thought_level(o))
.filter(|o| config::is_per_model_option(o))
.cloned()
.map(|mut o| {
if o.category.as_deref() != Some("thought_level") {
if config::is_context_option(&o.id) {
if o.category.is_none() {
o.category = Some("model_config".into());
}
} else if o.category.as_deref() != Some("thought_level") {
o.category = Some("thought_level".into());
}
o
+1
Переглянути файл
@@ -155,6 +155,7 @@ async fn a_task_runs_on_a_v2_agent_and_resumes_its_session() {
config: vec![AgentConfigChoice { id: "model".into(), value: "haiku".into() }],
isolation: Isolation::Local,
base: None,
..Default::default()
})
.await
.unwrap();
+11
Переглянути файл
@@ -17,6 +17,8 @@
pub(crate) mod discover;
mod normalize;
pub(crate) use normalize::base64 as normalize_base64;
use ide_jsonrpc::{Handler, Peer, RpcError, codes};
use normalize::Normalizer;
use parking_lot::Mutex;
@@ -58,6 +60,8 @@ fn client_capabilities() -> Value {
"terminal": false,
// Subagents as sessions of their own (ACP subagents RFD; v2 baseline).
"subagents": {},
// Forms the agent asks the user to fill in (`elicitation/create`); not URL mode.
"elicitation": { "form": {} },
// Cursor exposes model parameters (e.g. Composer `fast`) as separate config options
// only when the client advertises this flag (undocumented Cursor ACP extension).
"_meta": { "parameterizedModelPicker": true },
@@ -320,6 +324,13 @@ impl Handler for Dialect {
}
self.inner.on_request(method, params)
}
fn on_request_raw(&self, method: &str, params: Value, raw: &[u8]) -> Result<Value, (i64, String, Option<Value>)> {
if self.v2() && method == "session/request_permission" {
return self.on_request_with_data(method, params);
}
self.inner.on_request_raw(method, params, raw)
}
}
/// A v2 permission request with the v1 `toolCall` (its subject's, titled with the request's title).
+5 -1
Переглянути файл
@@ -97,10 +97,13 @@ fn the_negotiating_request_carries_both_versions() {
p["clientCapabilities"]["_meta"]["parameterizedModelPicker"], true,
"Cursor and similar agents need parameterized model options (e.g. fast on/off)"
);
// Forms only: URL mode would open pages the agent names.
assert_eq!(p["clientCapabilities"]["elicitation"], json!({ "form": {} }));
// What we sent in the capture is what claude-agent-acp negotiated v2 and v1 from.
let sent = frames(TURN, "out")[0]["params"]["clientCapabilities"].clone();
let mut expected = sent;
expected["_meta"] = p["clientCapabilities"]["_meta"].clone();
expected["elicitation"] = p["clientCapabilities"]["elicitation"].clone();
assert_eq!(expected, p["clientCapabilities"]);
}
@@ -168,7 +171,8 @@ async fn discovery_reads_effort_and_fast_from_session_new_then_stops_the_agent()
let fast = cursor.config.iter().find(|o| o.id == "fast").expect("fast option");
assert_eq!(fast.category.as_deref(), Some("model_config"));
assert_eq!(fast.current.as_deref(), Some("false"));
assert!(cursor.thought_levels.contains_key("m1") && cursor.thought_levels.contains_key("m2"));
// The effort option belongs to the session's model; m2 may offer other levels.
assert_eq!(cursor.thought_levels.keys().collect::<Vec<_>>(), ["m1"]);
assert!(cursor.thought_levels["m1"].iter().any(|o| o.category.as_deref() == Some("thought_level")));
}
+99 -1
Переглянути файл
@@ -56,6 +56,16 @@ pub(crate) struct CatalogData {
pub refreshed_at_ms: Option<f64>,
}
impl CatalogData {
fn model_option(&self) -> Option<&AgentConfigOption> {
self.config.iter().find(|o| o.category.as_deref() == Some("model"))
}
fn lists(&self, model: &str) -> bool {
self.model_option().is_some_and(|o| o.values.iter().any(|v| v.value == model))
}
}
#[derive(Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct SavedCatalog {
@@ -99,6 +109,7 @@ impl LaunchContext {
provider::Driver::Acp => b"acp",
provider::Driver::Codex => b"codex",
provider::Driver::Claude => b"claude",
provider::Driver::Copilot => b"copilot",
},
);
field(&mut hash, self.spec.command.as_bytes());
@@ -193,6 +204,14 @@ impl AgentCatalogs {
.unwrap_or_else(|| Self::fallback(shared, provider))
}
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
let key = Self::key(shared, provider);
let mut state = self.state.lock();
if state.entries.get(&key).is_some_and(|e| e.flight.is_none()) {
state.entries.remove(&key);
}
}
fn snapshot(&self, shared: &Shared, provider: &str, entry: &Entry) -> AgentModelCatalog {
let catalog = entry.catalog.clone().unwrap_or_else(|| Self::fallback(shared, provider));
AgentModelCatalog {
@@ -329,11 +348,17 @@ impl AgentCatalogs {
Ok(found) => {
let mut cache = shared.known.lock();
let known = cache.entry(key.2.clone()).or_default();
let catalog = CatalogData {
let mut catalog = CatalogData {
config: found.config,
thought_levels: found.levels,
refreshed_at_ms: Some(self.epoch_ms()),
};
// Efforts sessions reported for models discovery doesn't read stay while listed.
for (model, levels) in entry.catalog.take().map(|old| old.thought_levels).unwrap_or_default() {
if catalog.lists(&model) && !catalog.thought_levels.contains_key(&model) {
catalog.thought_levels.insert(model, levels);
}
}
known.config = catalog.config.clone();
known.thought_levels = catalog.thought_levels.clone();
if let Some(commands) = found.commands {
@@ -366,6 +391,42 @@ impl AgentCatalogs {
}
}
/// Records the efforts a session reported for a listed `model` other than the one discovery
/// read: ACP discovery opens one session, so it knows only that model's efforts.
pub(crate) fn learn_levels(&self, shared: &Shared, provider: &str, model: &str, levels: Vec<AgentConfigOption>) {
let lacks = |catalog: &CatalogData| {
catalog.lists(model)
&& catalog.model_option().and_then(|o| o.current.as_deref()) != Some(model)
&& catalog.thought_levels.get(model) != Some(&levels)
};
let key = Self::key(shared, provider);
let mut state = self.state.lock();
let mut learned = false;
if let Some(catalog) = state.entries.get_mut(&key).and_then(|e| e.catalog.as_mut()).filter(|c| lacks(c)) {
catalog.thought_levels.insert(model.to_owned(), levels.clone());
learned = true;
}
let mut cache = shared.known.lock();
if let Some(saved) = cache
.get_mut(provider)
.and_then(|known| known.catalogs.get_mut(&shared.root_key()))
.filter(|saved| lacks(&saved.catalog))
{
saved.catalog.thought_levels.insert(model.to_owned(), levels);
learned = true;
}
if !learned {
return;
}
shared.persist_known(&cache);
drop(cache);
let snapshot = state.entries.get(&key).map(|entry| self.snapshot(shared, provider, entry));
drop(state);
if let Some(snapshot) = snapshot {
self.broadcast(shared, &snapshot);
}
}
fn subscribers(&self, shared: &Shared) -> Vec<Arc<Shared>> {
self.state
.lock()
@@ -420,6 +481,43 @@ async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<
.collect(),
})
}
provider::Driver::Copilot => {
if shared.uses_copilot_acp_fallback(&spec) {
let acp_spec = native::copilot::acp_fallback_spec(&spec);
return acp::discover::run(shared, &acp_spec).await;
}
match native::copilot::discover(spec.clone(), shared.paths.project_root.clone()).await {
Ok(found) => Ok(Discovered {
commands: Some(config::commands_of(
&serde_json::json!({ "availableCommands": found.commands }),
&spec.id,
)),
config: config::options_of(&serde_json::json!({ "configOptions": found.options })),
levels: found
.per_model
.into_iter()
.map(|(model, opts)| {
let parsed = if opts.is_empty() {
Vec::new()
} else {
config::options_of(&serde_json::json!({ "configOptions": opts }))
};
(model, parsed)
})
.collect(),
}),
Err(err) if err.allow_acp_fallback => {
tracing::warn!(
"Copilot headless catalog discovery failed ({}); falling back to `copilot --acp`",
err.message
);
shared.mark_copilot_acp_fallback(&spec);
let acp_spec = native::copilot::acp_fallback_spec(&spec);
acp::discover::run(shared, &acp_spec).await
}
Err(err) => Err(err.message),
}
}
}
}
+38 -1
Переглянути файл
@@ -199,7 +199,8 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
pending.reply.send(Ok(response(&["retained", "new"], &["medium"]))).unwrap();
let fresh = completed(&mut events).await;
assert_eq!(model_values(&fresh), ["retained", "new"]);
assert_eq!(fresh.thought_levels.keys().map(String::as_str).collect::<Vec<_>>(), ["new", "retained"]);
// The session's efforts describe its own model, not "new".
assert_eq!(fresh.thought_levels.keys().map(String::as_str).collect::<Vec<_>>(), ["retained"]);
assert_eq!(fresh.thought_levels["retained"][0].values[0].value, "medium");
assert!(fresh.refreshed_at_ms.is_some() && fresh.retry_at_ms.is_some());
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
@@ -220,6 +221,42 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
assert!(!tmp.path().join("store").exists(), "refresh never creates tasks");
}
#[tokio::test]
async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::new();
let catalogs = Arc::new(AgentCatalogs::default());
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Ok(response(&["first", "second"], &["low", "high"]))).unwrap();
completed(&mut events).await;
// A session on "second" reports its own efforts; one on a model the catalog lacks, or on
// "first" with other efforts, changes nothing.
let second = config::options_of(&response(&["second"], &["off", "auto"]));
manager.shared.remember(PROVIDER, Some(&second), None, Some("second"));
manager.shared.remember(PROVIDER, Some(&config::options_of(&response(&["gone"], &["x"]))), None, Some("gone"));
manager.shared.remember(PROVIDER, Some(&config::options_of(&response(&["first"], &["max"]))), None, Some("first"));
let efforts = |catalog: &AgentModelCatalog, model: &str| -> Vec<String> {
catalog.thought_levels[model][0].values.iter().map(|v| v.value.clone()).collect()
};
let catalog = manager.refresh_models(PROVIDER, false).unwrap();
assert_eq!(catalog.thought_levels.keys().map(String::as_str).collect::<Vec<_>>(), ["first", "second"]);
assert_eq!(efforts(&catalog, "first"), ["low", "high"]);
assert_eq!(efforts(&catalog, "second"), ["off", "auto"]);
let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false).unwrap();
assert_eq!(efforts(&restored, "second"), ["off", "auto"], "persisted with the project's catalog");
// Discovery again reads "first" only; "second" keeps what its session reported.
advance(&catalogs, 60);
while events.try_recv().is_ok() {}
manager.refresh_models(PROVIDER, true).unwrap();
harness.next().await.reply.send(Ok(response(&["first", "second"], &["medium"]))).unwrap();
let fresh = completed(&mut events).await;
assert_eq!(efforts(&fresh, "first"), ["medium"]);
assert_eq!(efforts(&fresh, "second"), ["off", "auto"]);
}
#[tokio::test]
async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
let tmp = tempfile::tempdir().unwrap();
+112 -12
Переглянути файл
@@ -3,7 +3,7 @@
use crate::model::{
AgentCommand, AgentCommandSource, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit,
AgentUsage,
AgentModelPricing, AgentUsage,
};
use serde_json::{Value, json};
@@ -20,17 +20,24 @@ pub(crate) fn add_client_options(provider: &str, config: &mut Vec<AgentConfigOpt
description: Some("Tool approvals for this Cursor conversation".into()),
category: Some("approval".into()),
current: Some("ask".into()),
default_value: Some("ask".into()),
via: AgentConfigVia::Option,
values: vec![
AgentConfigValue {
value: "ask".into(),
name: "Ask for approval".into(),
description: Some("Show permission requests from Cursor".into()),
cost_category: None,
usage_multiplier: None,
pricing: None,
},
AgentConfigValue {
value: "bypass".into(),
name: "Bypass approvals".into(),
description: Some("Automatically approve tool requests in this conversation".into()),
cost_category: None,
usage_multiplier: None,
pricing: None,
},
],
});
@@ -118,6 +125,18 @@ pub(crate) fn options_of(result: &Value) -> Vec<AgentConfigOption> {
out
}
pub(crate) fn is_context_option(id: &str) -> bool {
matches!(id, "context_tier" | "contextTier")
}
/// Whether an option's available values and default belong to the selected model
/// (`thought_level` and model context-tier options) rather than the provider as a whole.
pub(crate) fn is_per_model_option(o: &AgentConfigOption) -> bool {
matches!(o.category.as_deref(), Some("thought_level" | "context_tier"))
|| matches!(o.id.as_str(), "effort" | "reasoning_effort" | "thinking" | "reasoning")
|| is_context_option(&o.id)
}
/// A `configOptions` array; only select options are kept (the UI shows them as dropdowns).
pub(crate) fn parse_options(options: &Value) -> Vec<AgentConfigOption> {
let Some(list) = options.as_array() else { return Vec::new() };
@@ -133,6 +152,8 @@ pub(crate) fn parse_options(options: &Value) -> Vec<AgentConfigOption> {
None => values.extend(value_of(v)),
}
}
let current = str_of(o, "currentValue");
let default_value = str_of(o, "defaultValue").or_else(|| current.clone());
Some(AgentConfigOption {
name: str_of(o, "name").unwrap_or_else(|| id.clone()),
description: str_of(o, "description"),
@@ -143,9 +164,10 @@ pub(crate) fn parse_options(options: &Value) -> Vec<AgentConfigOption> {
matches!(id.as_str(), "effort" | "reasoning_effort" | "thinking" | "reasoning")
.then(|| "thought_level".into())
})
.or_else(|| matches!(id.as_str(), "fast").then(|| "model_config".into()))
.or_else(|| (id == "fast" || is_context_option(&id)).then(|| "model_config".into()))
}),
current: str_of(o, "currentValue"),
current,
default_value,
values,
via: AgentConfigVia::Option,
id,
@@ -155,9 +177,24 @@ pub(crate) fn parse_options(options: &Value) -> Vec<AgentConfigOption> {
}
/// A `config_option_update`: its options replace the config-option ones; `modes` / `models`
/// stand-ins stay.
/// stand-ins stay, and initial `default_value`s survive same-model option edits for Reset.
pub(crate) fn merge_update(config: &mut Vec<AgentConfigOption>, options: &Value) {
let fresh = parse_options(options);
let mut fresh = parse_options(options);
let old_model = config.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.as_deref());
let new_model = fresh.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.as_deref());
let same_model = old_model == new_model;
for f in &mut fresh {
if f.default_value == f.current
&& (same_model || !is_per_model_option(f))
&& let Some(prev_default) = config
.iter()
.find(|p| p.id == f.id)
.and_then(|p| p.default_value.as_ref())
.filter(|def| f.values.iter().any(|v| v.value == **def))
{
f.default_value = Some(prev_default.clone());
}
}
let covered = |o: &AgentConfigOption| fresh.iter().any(|f| f.category.is_some() && f.category == o.category);
config.retain(|o| o.id == CURSOR_APPROVAL || (o.via != AgentConfigVia::Option && !covered(o)));
let legacy = std::mem::take(config);
@@ -251,16 +288,21 @@ fn legacy(
Some(AgentConfigValue {
name: str_of(m, "name").unwrap_or_else(|| value.clone()),
description: str_of(m, "description"),
cost_category: None,
usage_multiplier: None,
pricing: pricing_of(m),
value,
})
})
.collect();
let current = str_of(v, current);
AgentConfigOption {
id: id.to_owned(),
name: name.to_owned(),
description: None,
category: Some(id.to_owned()),
current: str_of(v, current),
default_value: current.clone(),
current,
values,
via,
}
@@ -268,13 +310,35 @@ fn legacy(
fn value_of(v: &Value) -> Option<AgentConfigValue> {
let value = v.get("value")?.as_str()?.to_owned();
let meta = v.get("_meta");
let cost_category = meta
.and_then(|m| m.get("copilotPriceCategory").or_else(|| m.get("priceCategory")))
.and_then(Value::as_str)
.map(|s| s.trim().to_ascii_lowercase())
.filter(|s| !s.is_empty());
let usage_multiplier = meta
.and_then(|m| m.get("copilotUsage").or_else(|| m.get("usageMultiplier")))
.and_then(Value::as_str)
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned);
Some(AgentConfigValue {
name: str_of(v, "name").unwrap_or_else(|| value.clone()),
description: str_of(v, "description"),
cost_category,
usage_multiplier,
pricing: pricing_of(v),
value,
})
}
fn pricing_of(v: &Value) -> Option<Box<AgentModelPricing>> {
v.pointer("/_meta/pricing")
.or_else(|| v.get("pricing"))
.and_then(|p| serde_json::from_value(p.clone()).ok())
.map(Box::new)
}
fn str_of(v: &Value, key: &str) -> Option<String> {
v.get(key).and_then(Value::as_str).map(str::to_owned)
}
@@ -402,17 +466,53 @@ mod tests {
#[test]
fn effort_and_fast_categories_are_inferred_from_ids() {
let c = options_of(&json!({
let mut c = options_of(&json!({
"configOptions": [
{"id": "effort", "type": "select", "currentValue": "high",
"options": [{"value": "low"}, {"value": "high"}]},
{"id": "model", "type": "select", "currentValue": "gemini-4-carbon",
"options": [{"value": "gemini-4-carbon", "name": "Gemini 4 Carbon",
"description": "Powerful · Medium cost",
"_meta": {"copilotPriceCategory": "Medium", "copilotUsage": "1x"}}]},
{"id": "effort", "type": "select", "currentValue": "medium",
"options": [{"value": "low"}, {"value": "medium"}, {"value": "high"}]},
{"id": "contextTier", "type": "select", "currentValue": "default",
"options": [{"value": "default", "name": "200K"}, {"value": "long_context", "name": "1M"}]},
{"id": "fast", "type": "select", "currentValue": "false",
"options": [{"value": "false", "name": "Off"}, {"value": "true", "name": "On"}]}
]
}));
assert_eq!(c.len(), 2);
assert_eq!(c[0].category.as_deref(), Some("thought_level"));
assert_eq!(c[1].category.as_deref(), Some("model_config"));
assert_eq!(c.len(), 4);
assert_eq!(c[0].values[0].cost_category.as_deref(), Some("medium"));
assert_eq!(c[0].values[0].usage_multiplier.as_deref(), Some("1x"));
assert_eq!(c[1].category.as_deref(), Some("thought_level"));
assert_eq!(c[1].default_value.as_deref(), Some("medium"));
assert_eq!(c[2].category.as_deref(), Some("model_config"));
assert!(is_per_model_option(&c[1]) && is_per_model_option(&c[2]) && !is_per_model_option(&c[3]));
// Editing effort on the same model preserves its initial `default_value` for Reset.
merge_update(
&mut c,
&json!([
{"id": "model", "type": "select", "currentValue": "gemini-4-carbon",
"options": [{"value": "gemini-4-carbon"}]},
{"id": "effort", "type": "select", "currentValue": "high",
"options": [{"value": "low"}, {"value": "medium"}, {"value": "high"}]}
]),
);
let effort = c.iter().find(|o| o.id == "effort").unwrap();
assert_eq!((effort.current.as_deref(), effort.default_value.as_deref()), (Some("high"), Some("medium")));
// Switching models refreshes per-model `default_value` to the new model's default.
merge_update(
&mut c,
&json!([
{"id": "model", "type": "select", "currentValue": "gpt-6-sol",
"options": [{"value": "gemini-4-carbon"}, {"value": "gpt-6-sol"}]},
{"id": "effort", "type": "select", "currentValue": "low",
"options": [{"value": "low"}, {"value": "medium"}, {"value": "high"}]}
]),
);
let effort = c.iter().find(|o| o.id == "effort").unwrap();
assert_eq!((effort.current.as_deref(), effort.default_value.as_deref()), (Some("low"), Some("low")));
}
#[test]
+305
Переглянути файл
@@ -0,0 +1,305 @@
//! ACP elicitation in form mode: the agent's restricted JSON Schema as form fields, and the
//! user's answer as the `elicitation/create` response.
use crate::model::{AgentForm, AgentFormField, AgentFormFieldKind, AgentFormOption, AgentPermissionOption};
use serde::Deserialize;
use serde::de::{Deserializer, IgnoredAny, MapAccess, Visitor};
use serde_json::{Map, Value, json};
/// The reply that declines the form; a JSON object of field name to values accepts it, and
/// anything else cancels it.
const DECLINE: &str = "decline";
/// The form `elicitation/create` asks for; `Err` when it asks for something else.
pub(crate) fn form_of(params: &Value) -> Result<AgentForm, String> {
if params.get("mode").and_then(Value::as_str) != Some("form") {
return Err("only form elicitation is supported".to_owned());
}
let schema = params.get("requestedSchema").ok_or("requestedSchema is missing")?;
let required: Vec<&str> = schema
.get("required")
.and_then(Value::as_array)
.map(|names| names.iter().filter_map(Value::as_str).collect())
.unwrap_or_default();
let properties = schema.get("properties").and_then(Value::as_object).ok_or("requestedSchema has no properties")?;
let fields = properties
.iter()
.map(|(name, property)| field(name, property, required.contains(&name.as_str())))
.collect::<Result<_, _>>()?;
Ok(AgentForm { fields })
}
/// Orders the fields as the request's schema lists them: `Value` keeps object keys sorted, and
/// the agent's order is the one its form reads in.
pub(crate) fn in_schema_order(form: &mut AgentForm, raw: &[u8]) {
#[derive(Deserialize)]
struct Request {
params: Params,
}
#[derive(Deserialize)]
struct Params {
#[serde(rename = "requestedSchema")]
schema: Schema,
}
#[derive(Deserialize)]
struct Schema {
properties: Keys,
}
struct Keys(Vec<String>);
impl<'de> Deserialize<'de> for Keys {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
struct Visit;
impl<'de> Visitor<'de> for Visit {
type Value = Keys;
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
f.write_str("an object")
}
fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Keys, A::Error> {
let mut keys = Vec::new();
while let Some((key, IgnoredAny)) = map.next_entry::<String, IgnoredAny>()? {
keys.push(key);
}
Ok(Keys(keys))
}
}
deserializer.deserialize_map(Visit)
}
}
let Ok(request) = serde_json::from_slice::<Request>(raw) else { return };
let order = request.params.schema.properties.0;
form.fields.sort_by_key(|field| order.iter().position(|name| *name == field.name).unwrap_or(usize::MAX));
}
fn field(name: &str, property: &Value, required: bool) -> Result<AgentFormField, String> {
let text = |key: &str| property.get(key).and_then(Value::as_str).unwrap_or_default().trim().to_owned();
let number = |key: &str| property.get(key).and_then(Value::as_f64);
let unsupported = || format!("field {name} has an unsupported schema");
let (kind, options, min, max) = match property.get("type").and_then(Value::as_str) {
Some("string") => match choices(property) {
Some(options) => (AgentFormFieldKind::Choice, options, None, None),
None => (AgentFormFieldKind::Text, Vec::new(), number("minLength"), number("maxLength")),
},
Some("number") => (AgentFormFieldKind::Number, Vec::new(), number("minimum"), number("maximum")),
Some("integer") => (AgentFormFieldKind::Integer, Vec::new(), number("minimum"), number("maximum")),
Some("boolean") => (AgentFormFieldKind::Boolean, Vec::new(), None, None),
Some("array") => {
let options = property.get("items").and_then(choices).ok_or_else(unsupported)?;
(AgentFormFieldKind::Choices, options, number("minItems"), number("maxItems"))
}
_ => return Err(unsupported()),
};
let default = match property.get("default") {
Some(Value::Array(values)) => values.iter().filter_map(scalar).collect(),
Some(value) => scalar(value).into_iter().collect(),
None => Vec::new(),
};
let title = text("title");
Ok(AgentFormField {
name: name.to_owned(),
title: if title.is_empty() { name.to_owned() } else { title },
description: text("description"),
required,
kind,
options,
default,
min,
max,
})
}
/// The values of a choice: `enum` (titled by the legacy `enumNames`), or `oneOf` / `anyOf`
/// of `{ const, title }`.
fn choices(schema: &Value) -> Option<Vec<AgentFormOption>> {
let option = |value: &str, label: Option<&str>, description: Option<&str>| AgentFormOption {
value: value.to_owned(),
label: label.filter(|l| !l.trim().is_empty()).unwrap_or(value).to_owned(),
description: description.unwrap_or_default().trim().to_owned(),
};
if let Some(values) = schema.get("enum").and_then(Value::as_array) {
let names = schema.get("enumNames").and_then(Value::as_array);
return Some(
values
.iter()
.enumerate()
.filter_map(|(i, value)| {
Some(option(value.as_str()?, names.and_then(|n| n.get(i)).and_then(Value::as_str), None))
})
.collect(),
);
}
let listed = schema.get("oneOf").or_else(|| schema.get("anyOf"))?.as_array()?;
Some(
listed
.iter()
.filter_map(|o| {
let text = |key: &str| o.get(key).and_then(Value::as_str);
Some(option(text("const")?, text("title"), text("description")))
})
.collect(),
)
}
fn scalar(value: &Value) -> Option<String> {
match value {
Value::String(text) => Some(text.clone()),
Value::Number(number) => Some(number.to_string()),
Value::Bool(flag) => Some(flag.to_string()),
_ => None,
}
}
/// A form is submitted from its own card; this option only names a declined form.
pub(crate) fn options() -> Vec<AgentPermissionOption> {
vec![AgentPermissionOption { id: DECLINE.to_owned(), name: "Decline".to_owned(), kind: "reject_once".to_owned() }]
}
/// The `elicitation/create` response to the user's `reply`, and what the conversation
/// records as chosen.
pub(crate) fn answer(form: &AgentForm, reply: Option<&str>) -> (Value, String) {
let values = match reply {
Some(DECLINE) => return (json!({ "action": "decline" }), "Decline".to_owned()),
Some(reply) => serde_json::from_str::<Map<String, Value>>(reply).ok(),
None => None,
};
let Some(values) = values else { return (json!({ "action": "cancel" }), "Cancelled".to_owned()) };
let mut content = Map::new();
let mut shown = Vec::new();
for field in &form.fields {
let given: Vec<&str> = match values.get(&field.name) {
Some(Value::Array(items)) => items.iter().filter_map(Value::as_str).collect(),
Some(Value::String(item)) => vec![item.as_str()],
_ => Vec::new(),
};
let given: Vec<&str> = given.into_iter().map(str::trim).filter(|v| !v.is_empty()).collect();
let Some(&first) = given.first() else { continue };
let value = match field.kind {
AgentFormFieldKind::Text | AgentFormFieldKind::Choice => json!(first),
AgentFormFieldKind::Number => match first.parse::<f64>() {
Ok(number) => json!(number),
Err(_) => continue,
},
AgentFormFieldKind::Integer => match first.parse::<i64>() {
Ok(number) => json!(number),
Err(_) => continue,
},
AgentFormFieldKind::Boolean => json!(first == "true"),
AgentFormFieldKind::Choices => json!(given),
};
let label = |value: &str| {
field.options.iter().find(|o| o.value == value).map_or_else(|| value.to_owned(), |o| o.label.clone())
};
let text = match field.kind {
AgentFormFieldKind::Boolean => (if first == "true" { "yes" } else { "no" }).to_owned(),
AgentFormFieldKind::Choices => given.iter().map(|v| label(v)).collect::<Vec<_>>().join(", "),
_ => label(first),
};
shown.push(format!("{}: {text}", field.title));
content.insert(field.name.clone(), value);
}
let chosen = if shown.is_empty() { "Submitted".to_owned() } else { shown.join("; ") };
(json!({ "action": "accept", "content": content }), chosen)
}
#[cfg(test)]
mod tests {
use super::*;
/// The form OMP's `ask` tool sends: a choice with a recommended default, then an
/// optional typed answer beside it.
fn ask() -> Value {
json!({
"sessionId": "s", "mode": "form", "message": "Which database?",
"requestedSchema": { "type": "object", "properties": {
"q0": { "type": "string", "title": "Which database?", "description": "Storage",
"oneOf": [{ "const": "pg", "title": "Postgres", "description": "Relational" },
{ "const": "sqlite", "title": "SQLite" }],
"default": "pg" },
"q0__other": { "type": "string", "title": "Other (type your own)" }
} }
})
}
#[test]
fn fields_follow_the_schema_order() {
let raw = br#"{ "jsonrpc": "2.0", "id": 3, "method": "elicitation/create", "params": { "mode": "form",
"requestedSchema": { "type": "object", "properties": {
"strategy": { "type": "string" }, "tests": { "type": "boolean" }, "note": { "type": "string" }
} } } }"#;
let params = serde_json::from_slice::<Value>(raw).unwrap()["params"].take();
let mut form = form_of(&params).unwrap();
in_schema_order(&mut form, raw);
assert_eq!(form.fields.iter().map(|f| f.name.as_str()).collect::<Vec<_>>(), ["strategy", "tests", "note"]);
}
#[test]
fn reads_choices_and_text_fields() {
let form = form_of(&ask()).unwrap();
let [choice, other] = form.fields.as_slice() else { panic!("{form:?}") };
assert_eq!((choice.name.as_str(), choice.kind, choice.required), ("q0", AgentFormFieldKind::Choice, false));
assert_eq!(choice.options[0].label, "Postgres");
assert_eq!(choice.options[0].description, "Relational");
assert_eq!(choice.default, ["pg"]);
assert_eq!((other.kind, other.title.as_str()), (AgentFormFieldKind::Text, "Other (type your own)"));
}
#[test]
fn reads_every_restricted_schema_kind() {
let form = form_of(&json!({ "mode": "form", "requestedSchema": {
"type": "object", "required": ["count"],
"properties": {
"count": { "type": "integer", "minimum": 1, "maximum": 5 },
"ratio": { "type": "number" },
"ok": { "type": "boolean", "default": true },
"size": { "type": "string", "enum": ["s", "l"], "enumNames": ["Small", "Large"] },
"tags": { "type": "array", "items": { "anyOf": [{ "const": "a" }, { "const": "b" }] },
"default": ["b"], "maxItems": 2 }
}
} }))
.unwrap();
let field = |name: &str| form.fields.iter().find(|f| f.name == name).unwrap();
use AgentFormFieldKind::*;
let kinds: Vec<_> = ["count", "ratio", "ok", "size", "tags"].map(|name| field(name).kind).into();
assert_eq!(kinds, [Integer, Number, Boolean, Choice, Choices]);
assert!(field("count").required && !field("ratio").required);
assert_eq!((field("count").min, field("count").max), (Some(1.0), Some(5.0)));
assert_eq!(field("ok").default, ["true"]);
assert_eq!(field("size").options[1].label, "Large");
assert_eq!((field("tags").default.as_slice(), field("tags").max), (["b".to_owned()].as_slice(), Some(2.0)));
}
#[test]
fn url_mode_and_unsupported_fields_are_refused() {
assert!(form_of(&json!({ "mode": "url", "url": "https://example.com" })).is_err());
let nested = json!({ "mode": "form", "requestedSchema": { "type": "object", "properties": {
"address": { "type": "object" }
} } });
assert!(form_of(&nested).is_err());
}
#[test]
fn an_answer_is_typed_by_its_field() {
let form = form_of(&json!({ "mode": "form", "requestedSchema": { "type": "object", "properties": {
"count": { "type": "integer" },
"ok": { "type": "boolean" },
"size": { "type": "string", "oneOf": [{ "const": "s", "title": "Small" }] },
"tags": { "type": "array", "items": { "enum": ["a", "b"] } },
"note": { "type": "string" }
} } }))
.unwrap();
let reply = json!({ "count": ["3"], "ok": ["false"], "size": ["s"], "tags": ["a", "b"], "note": [" "] });
let (response, chosen) = answer(&form, Some(&reply.to_string()));
assert_eq!(
response,
json!({ "action": "accept", "content": { "count": 3, "ok": false, "size": "s", "tags": ["a", "b"] } })
);
assert_eq!(chosen, "count: 3; ok: no; size: Small; tags: a, b");
}
#[test]
fn declining_and_dismissing_send_no_content() {
let form = form_of(&ask()).unwrap();
assert_eq!(answer(&form, Some(DECLINE)), (json!({ "action": "decline" }), "Decline".to_owned()));
assert_eq!(answer(&form, None).0, json!({ "action": "cancel" }));
assert_eq!(answer(&form, Some("cancel")).0, json!({ "action": "cancel" }));
}
}
+20 -5
Переглянути файл
@@ -134,7 +134,10 @@ fn codex_meta(line: &serde_json::Value) -> Option<(String, Option<String>)> {
let payload =
line.get("payload").filter(|p| p.get("type").and_then(serde_json::Value::as_str) == Some("session_meta"));
let inner = payload.and_then(|p| p.get("payload")).or_else(|| {
line.get("type").and_then(serde_json::Value::as_str).filter(|t| *t == "session_meta").and(Some(line))
line.get("type")
.and_then(serde_json::Value::as_str)
.filter(|t| *t == "session_meta")
.map(|_| line.get("payload").unwrap_or(line))
})?;
let id = inner.get("id").and_then(serde_json::Value::as_str)?.to_owned();
let cwd = inner.get("cwd").and_then(serde_json::Value::as_str).map(str::to_owned);
@@ -293,16 +296,28 @@ mod tests {
assert_eq!(sessions[0].title, "hello there");
}
#[test]
fn codex_meta_accepts_current_and_legacy_shapes() {
let meta = json!({"id": "thread-1", "cwd": "/work/app"});
for line in [
json!({"type": "session_meta", "payload": meta}),
json!({"payload": {"type": "session_meta", "payload": meta}}),
json!({"type": "session_meta", "id": "thread-1", "cwd": "/work/app"}),
] {
assert_eq!(codex_meta(&line), Some(("thread-1".to_owned(), Some("/work/app".to_owned()))));
}
}
#[test]
fn lists_codex_rollouts_with_meta() {
let tmp = tempfile::tempdir().unwrap();
write(
&tmp.path().join("sessions/2026/01/02/rollout-01.jsonl"),
&[
json!({"timestamp": "t", "payload": {"type": "session_meta",
"payload": {"id": "thread-1", "cwd": "/work/app"}}}),
json!({"timestamp": "t", "payload": {"type": "user_message",
"payload": {"message": "add tests"}}}),
json!({"timestamp": "t", "type": "session_meta",
"payload": {"id": "thread-1", "cwd": "/work/app"}}),
json!({"timestamp": "t", "type": "event_msg",
"payload": {"type": "user_message", "message": "add tests"}}),
],
);
write(&tmp.path().join("sessions/notes.jsonl"), &[json!({"nope": true})]);
+506 -100
Переглянути файл
@@ -11,6 +11,7 @@ mod acp;
mod catalogs;
mod config;
mod conversation;
mod elicitation;
mod external;
pub mod mcp;
mod model;
@@ -120,6 +121,13 @@ type Connector = Arc<
/// Returns the configured MCP servers (User and Workspace) for this project.
pub type McpServersFn = dyn Fn() -> Vec<McpServer> + Send + Sync;
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
struct CopilotBinaryKey {
command: String,
modified: Option<std::time::SystemTime>,
len: Option<u64>,
}
struct Shared {
paths: AgentPaths,
runtime: tokio::runtime::Handle,
@@ -131,9 +139,13 @@ struct Shared {
providers: RwLock<Vec<provider::ProviderSpec>>,
/// Last probe of each provider.
probes: Mutex<HashMap<String, AgentProbe>>,
/// Copilot CLI installs where `--headless` failed and fell back to `--acp`.
copilot_acp_fallback: Mutex<HashSet<CopilotBinaryKey>>,
/// [`IDLE_RELEASE`], in milliseconds (shorter in tests).
idle_release_ms: AtomicU64,
mcp_servers_hook: RwLock<Option<Arc<McpServersFn>>>,
/// Monotonic id for [`AgentEvent::Attention`] episodes.
attention_seq: AtomicU64,
}
/// What an agent offered in its last session, for the New Task page.
@@ -166,6 +178,29 @@ impl Shared {
self.paths.env_secrets.as_deref()
}
fn copilot_binary_key(&self, spec: &provider::ProviderSpec) -> CopilotBinaryKey {
let resolved = spec.clone().resolve_for_launch(&self.paths.project_root);
let executable = dunce::canonicalize(&resolved.command).unwrap_or_else(|_| PathBuf::from(&resolved.command));
let metadata = std::fs::metadata(&executable).ok();
CopilotBinaryKey {
command: executable.to_string_lossy().into_owned(),
modified: metadata.as_ref().and_then(|m| m.modified().ok()),
len: metadata.as_ref().map(std::fs::Metadata::len),
}
}
pub(crate) fn uses_copilot_acp_fallback(&self, spec: &provider::ProviderSpec) -> bool {
let key = self.copilot_binary_key(spec);
self.copilot_acp_fallback.lock().contains(&key)
}
pub(crate) fn mark_copilot_acp_fallback(&self, spec: &provider::ProviderSpec) {
let key = self.copilot_binary_key(spec);
if self.copilot_acp_fallback.lock().insert(key) {
self.paths.catalogs.evict_if_idle(self, &spec.id);
}
}
fn emit(&self, event: AgentEvent) {
let sink = self.sink.read().clone();
if let Some(sink) = sink {
@@ -173,10 +208,19 @@ impl Shared {
}
}
fn mcp_servers_for_session(&self, provider: &str, init: &acp::Negotiated) -> Vec<Value> {
let mut servers = mcp_servers_for(init.mcp_stdio(), &self.paths.project_root);
fn mcp_servers_for_session(
&self,
provider: &str,
init: &acp::Negotiated,
overrides: &BTreeMap<String, bool>,
) -> Vec<Value> {
let mut servers = if overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false) {
Vec::new()
} else {
mcp_servers_for(init.mcp_stdio(), &self.paths.project_root)
};
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
servers.extend(mcp::acp_mcp_servers(&configured, provider, init));
servers.extend(mcp::acp_mcp_servers(&configured, provider, init, overrides));
servers
}
@@ -187,7 +231,7 @@ impl Shared {
fn config_for_new_task(&self, mut config: Vec<AgentConfigOption>, provider: &str) -> Vec<AgentConfigOption> {
// Model-specific options are offered separately, never as provider-wide defaults.
config.retain(|o| o.category.as_deref() != Some("thought_level"));
config.retain(|o| !config::is_per_model_option(o));
config::add_client_options(provider, &mut config);
let hook = self.new_task_approvals.read().clone();
if hook.is_some_and(|ask| ask() == ide_core::settings::NewTaskApprovals::Ask) {
@@ -223,6 +267,7 @@ impl Shared {
commands: Option<&[AgentCommand]>,
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;
@@ -232,8 +277,7 @@ impl Shared {
&& let Some(config) = config.filter(|c| !c.is_empty())
{
if let Some(model) = model {
let levels: Vec<_> =
config.iter().filter(|o| o.category.as_deref() == Some("thought_level")).cloned().collect();
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;
@@ -244,6 +288,11 @@ impl Shared {
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)| {
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)
{
@@ -254,6 +303,9 @@ impl Shared {
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 changed {
self.emit(AgentEvent::Providers);
}
@@ -329,6 +381,8 @@ struct TaskState {
/// A running agent and its session.
#[derive(Clone)]
struct Live {
provider: String,
driver: provider::Driver,
sign_in_message: String,
peer: acp::Conn,
session: String,
@@ -364,6 +418,8 @@ struct Task {
/// Bumped when the agent's last background task finishes: an idle release scheduled
/// before that is void, the usual delay starts over from the report.
idle_epoch: AtomicU64,
/// Turned on when per-session MCP overrides changed while a turn was busy; dropped once idle.
mcp_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)>>,
@@ -389,6 +445,7 @@ impl AgentManager {
}
provider::Driver::Codex => native::codex::connect(spec, cwd, client, on_stderr),
provider::Driver::Claude => native::claude::connect(spec, cwd, client, on_stderr),
provider::Driver::Copilot => native::copilot::connect(spec, cwd, client, on_stderr),
});
Self::with_connector(paths, runtime, connector)
}
@@ -406,8 +463,10 @@ impl AgentManager {
known,
providers,
probes: Mutex::new(HashMap::new()),
copilot_acp_fallback: Mutex::new(HashSet::new()),
idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),
mcp_servers_hook: RwLock::new(None),
attention_seq: AtomicU64::new(0),
});
shared.paths.catalogs.subscribe(&shared);
let mut tasks = HashMap::new();
@@ -538,6 +597,7 @@ impl AgentManager {
let specs = provider::load(self.shared.paths.custom_agents_dir.as_deref(), self.shared.env_secrets());
*self.shared.providers.write() = specs;
self.shared.probes.lock().clear();
self.shared.copilot_acp_fallback.lock().clear();
self.shared.emit(AgentEvent::Providers);
}
@@ -675,6 +735,7 @@ impl AgentManager {
resets_ms: None,
retry: None,
background: Box::default(),
mcp_overrides: BTreeMap::new(),
};
let handle = self.register(TaskFile {
task: task.clone(),
@@ -766,6 +827,7 @@ impl AgentManager {
resets_ms: None,
retry: None,
background: Box::default(),
mcp_overrides: req.mcp_overrides,
};
let handle = self.register(TaskFile {
task: task.clone(),
@@ -867,6 +929,7 @@ impl AgentManager {
resets_ms: None,
retry: None,
background: Box::default(),
mcp_overrides: req.mcp_overrides,
config,
};
let handle = self.register(TaskFile {
@@ -1000,8 +1063,11 @@ impl AgentManager {
task.emit_task();
let live = task.live.lock().clone().filter(|l| !l.peer.is_closed());
let mut model_options =
target.category.as_deref() != Some("model") || previous.as_deref() == Some(value.as_str());
// The task's copy holds its model's per-model options unless a model switch the agent
// never reported dropped them: caching that copy would erase the model's known levels.
let mut model_options = (target.category.as_deref() != Some("model")
|| previous.as_deref() == Some(value.as_str()))
&& task.state.lock().task.config.iter().any(config::is_per_model_option);
if let Some(live) = live.filter(|_| option != config::CURSOR_APPROVAL) {
let (method, mut params) = config::set_request(&target, &value);
params["sessionId"] = json!(live.session);
@@ -1032,12 +1098,13 @@ impl AgentManager {
{
let mut s = task.state.lock();
if !model_options {
s.task.config.retain(|o| o.category.as_deref() != Some("thought_level"));
s.task.config.retain(|o| !config::is_per_model_option(o));
}
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
o.current = Some(value);
}
s.task.model = model_of(&s.task.config).or(s.task.model.take());
sync_usage_context_size(&mut s.task);
let provider = s.task.provider.clone();
let config = s.task.config.clone();
let model = s.task.model.clone().filter(|_| model_options);
@@ -1064,9 +1131,11 @@ 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 = source.state.lock().task.cwd.0.clone();
let provider_id = source.state.lock().task.provider.clone();
let mcp_servers = source.shared.mcp_servers_for_session(&provider_id, &live.init);
let (cwd, provider_id, mcp_overrides) = {
let s = source.state.lock();
(s.task.cwd.0.clone(), s.task.provider.clone(), s.task.mcp_overrides.clone())
};
let mcp_servers = source.shared.mcp_servers_for_session(&provider_id, &live.init, &mcp_overrides);
let cwd_s = dunce::canonicalize(&cwd).unwrap_or(cwd).to_string_lossy().into_owned();
let reply: Value = live
.peer
@@ -1192,17 +1261,38 @@ impl AgentManager {
}
/// What `provider` reports about itself, from `initialize` alone: no session is opened,
/// so no MCP server, hook or sign-in runs. Remembered until `refresh`.
/// so no MCP server, hook or sign-in runs. A successful answer is remembered until
/// `refresh`; a failed one is not, so a transient startup failure (a CLI updating itself,
/// a busy machine) is retried on the next call instead of being shown for the rest of
/// the session.
pub async fn probe(&self, provider: &str, refresh: bool) -> IdeResult<AgentProbe> {
if !refresh && let Some(p) = self.shared.probes.lock().get(provider) {
return Ok(p.clone());
}
let spec = self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?;
let raw_spec =
self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?;
let can_fallback =
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
let mut active_spec = if raw_spec.driver == provider::Driver::Copilot && !can_fallback {
native::copilot::acp_fallback_spec(&raw_spec)
} else {
raw_spec.clone()
};
let reply = match self.probe_once(&active_spec).await {
Ok(reply) => Ok(reply),
Err((err, allow_fallback)) if can_fallback && allow_fallback => {
tracing::warn!("Copilot headless probe failed ({err}); falling back to `copilot --acp`");
self.shared.mark_copilot_acp_fallback(&raw_spec);
active_spec = native::copilot::acp_fallback_spec(&raw_spec);
self.probe_once(&active_spec).await.map_err(|(e, _)| e)
}
Err((err, _)) => Err(err),
};
let mut probe = AgentProbe {
provider: spec.id.clone(),
provider: active_spec.id.clone(),
name: None,
version: None,
protocol: match spec.driver {
protocol: match active_spec.driver {
provider::Driver::Acp => "ACP".into(),
_ => "native".into(),
},
@@ -1210,31 +1300,6 @@ impl AgentManager {
auth_methods: Vec::new(),
error: None,
};
let stderr: Arc<Mutex<Vec<String>>> = Arc::default();
let lines = stderr.clone();
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(move |l| lines.lock().push(l));
let started = (self.shared.connector)(
&spec,
&self.shared.paths.project_root,
Arc::new(ide_jsonrpc::NoopHandler),
on_stderr,
);
let reply = match started {
Err(e) => Err(format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command)),
Ok(peer) => {
let params = acp::initialize_params(&client_info());
let r = tokio::time::timeout(PROBE_TIMEOUT, peer.request::<_, Value>("initialize", params, None)).await;
peer.kill();
match r {
Ok(Ok(v)) => Ok(v),
Ok(Err(e)) => Err(match stderr.lock().last() {
Some(line) => format!("{e}: {line}"),
None => e.to_string(),
}),
Err(_) => Err("the agent did not answer".into()),
}
}
};
match reply {
Ok(reply) => {
let init = acp::Negotiated::from_initialize(&reply);
@@ -1242,7 +1307,7 @@ impl AgentManager {
let text = |k: &str| info.get(k).and_then(Value::as_str).map(str::to_owned);
probe.name = text("title").or_else(|| text("name"));
probe.version = text("version");
if spec.driver == provider::Driver::Acp {
if active_spec.driver == provider::Driver::Acp {
probe.protocol = format!("ACP v{}", init.generation);
}
probe.capabilities = capabilities_of(&init).0;
@@ -1254,10 +1319,48 @@ impl AgentManager {
}
Err(e) => probe.error = Some(e),
}
self.shared.probes.lock().insert(spec.id, probe.clone());
if probe.error.is_none() {
self.shared.probes.lock().insert(active_spec.id, probe.clone());
}
Ok(probe)
}
async fn probe_once(&self, spec: &provider::ProviderSpec) -> Result<Value, (String, bool)> {
let stderr: Arc<Mutex<Vec<String>>> = Arc::default();
let lines = stderr.clone();
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(move |l| lines.lock().push(l));
let started = (self.shared.connector)(
spec,
&self.shared.paths.project_root,
Arc::new(ide_jsonrpc::NoopHandler),
on_stderr,
);
match started {
Err(e) => Err((
format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command),
!native::copilot::is_missing_binary_error(&e),
)),
Ok(peer) => {
let params = acp::initialize_params(&client_info());
let r = tokio::time::timeout(PROBE_TIMEOUT, peer.request::<_, Value>("initialize", params, None)).await;
peer.kill();
match r {
Ok(Ok(v)) => Ok(v),
Ok(Err(e)) => {
let is_auth =
matches!(&e, RpcError::Server { code, message, .. } if acp::auth_required(*code, message));
let msg = match stderr.lock().last() {
Some(line) => format!("{e}: {line}"),
None => e.to_string(),
};
Err((msg, !is_auth))
}
Err(_) => Err(("the agent did not answer".into(), true)),
}
}
}
}
/// Stops the current turn (`session/cancel`); pending permission requests are cancelled.
/// Queued messages stay queued. With `subagent`, stops only that subagent's work.
pub fn cancel(&self, id: &str, subagent: Option<String>) -> IdeResult<()> {
@@ -1516,6 +1619,43 @@ impl AgentManager {
.await
}
/// Updates per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
/// When the task is idle and holds a resumable live session without running background tasks,
/// stops the idle process so the next turn reloads the session with the updated MCP servers;
/// when busy, schedules the reload for as soon as the turn finishes.
pub fn set_mcp_overrides(&self, id: &str, overrides: BTreeMap<String, bool>) -> IdeResult<AgentTask> {
let task = self.task(id)?;
let cleaned: BTreeMap<String, bool> = overrides
.into_iter()
.filter_map(|(k, v)| {
let k = k.trim();
(!k.is_empty()).then(|| (k.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.mcp_overrides != cleaned;
if changed {
s.task.mcp_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.mcp_reload_pending.store(true, Ordering::Release);
} else {
task.recycle_resumable_session();
}
}
Ok(out)
}
/// Stops every agent (project closed).
pub fn shutdown(&self) {
for task in self.tasks.read().values() {
@@ -1560,6 +1700,7 @@ impl Task {
turn_started: AtomicBool::new(false),
turns: AtomicU64::new(0),
idle_epoch: AtomicU64::new(0),
mcp_reload_pending: AtomicBool::new(false),
config_sent: Mutex::new(HashSet::new()),
dirty: Mutex::new(BTreeSet::new()),
streamed: Mutex::new(HashMap::new()),
@@ -1617,7 +1758,7 @@ impl Task {
fn emit_task(&self) {
let task = self.state.lock().task.clone();
self.shared.emit(AgentEvent::Task { task });
self.shared.emit(AgentEvent::Task { task: Box::new(task) });
}
/// Shows (or clears) the agent's pending retry; emitted only when it changes.
@@ -1678,6 +1819,28 @@ impl Task {
self.emit_task();
}
fn emit_attention(&self, reason: AgentAttentionReason) {
let n = self.shared.attention_seq.fetch_add(1, Ordering::Relaxed);
let tag = match reason {
AgentAttentionReason::Finished => "finished",
AgentAttentionReason::Input => "input",
AgentAttentionReason::Failed => "failed",
};
self.shared.emit(AgentEvent::Attention {
task: self.id.clone(),
event_id: format!("{}:{tag}:{n}", self.id),
reason,
});
}
/// After NeedsInput + optional auto-approve: notify only when the user must still answer.
fn emit_attention_if_input_pending(&self) {
let waiting = !self.permissions.lock().is_empty() && self.state.lock().task.status == AgentStatus::NeedsInput;
if waiting {
self.emit_attention(AgentAttentionReason::Input);
}
}
fn persist(&self) {
// Held from snapshot to rename, so saves land in order and none follows a delete.
let deleted = self.deleted.lock();
@@ -1780,8 +1943,17 @@ impl Task {
}
match (next, result) {
(Some(queued), _) => prompt = queued.prompt,
(None, Ok(_)) => {
(None, Ok(stop)) => {
self.set_status(AgentStatus::Ready, None);
if stop != "cancelled" {
self.emit_attention(AgentAttentionReason::Finished);
}
if self.mcp_reload_pending.swap(false, Ordering::AcqRel)
&& self.state.lock().background_tasks.is_empty()
{
self.recycle_resumable_session();
return;
}
return self.release_when_idle();
}
(None, Err(failure)) => return self.fail(failure),
@@ -1789,6 +1961,20 @@ impl Task {
}
}
/// Drops an idle resumable live session so the next turn reloads it with fresh MCP servers.
fn recycle_resumable_session(&self) {
self.mcp_reload_pending.store(false, Ordering::Release);
let live = {
let mut live = self.live.lock();
if live.as_ref().is_some_and(|l| l.resumable && !l.peer.is_closed()) { live.take() } else { None }
};
if let Some(live) = live {
tracing::debug!("agent task {}: restarting idle resumable session for MCP override update", self.id);
live.peer.kill();
self.clear_shown_background();
}
}
/// Stops the agent's process once the task has stayed idle for [`IDLE_RELEASE`], so
/// finished tasks don't keep an agent (and what it started) running. Only an agent that
/// reloads its session: the next message starts it again with the conversation intact.
@@ -1852,6 +2038,7 @@ impl Task {
}
None => self.set_status(AgentStatus::Failed, Some(failure.message)),
}
self.emit_attention(AgentAttentionReason::Failed);
}
/// Adds `prompt` to the running turn when the agent takes that; gives it back otherwise.
@@ -1861,12 +2048,24 @@ impl Task {
let s = self.state.lock();
s.busy && s.task.status == AgentStatus::Running
};
let Some(live) = live.filter(|l| running && (prompt.images.is_empty() || l.capabilities.images)) else {
let Some((live, method)) = live
.filter(|l| running && (prompt.images.is_empty() || l.capabilities.images))
.and_then(|l| steer_method(&l.init).map(|m| (l, m)))
else {
return Err(prompt);
};
let content = self.content(&live, &prompt).await;
let sent: Result<Value, RpcError> =
live.peer.request("_openidea/steer", json!({ "sessionId": live.session, "prompt": content }), None).await;
live.peer.request(method, json!({ "sessionId": live.session, "prompt": content }), None).await;
// `_session/steering` answers with an outcome: only `injected` joined the turn
// (`promptRequired`: no turn is running any more).
let sent = match sent {
Ok(reply) => match reply.get("outcome").and_then(Value::as_str) {
None | Some("injected") => Ok(()),
Some(outcome) => Err(reply.get("reason").and_then(Value::as_str).unwrap_or(outcome).to_owned()),
},
Err(e) => Err(e.to_string()),
};
if let Err(e) = sent {
// The turn ended meanwhile: the message waits for the next one instead.
tracing::debug!("agent task {}: steering failed: {e}", self.id);
@@ -1911,7 +2110,7 @@ impl Task {
// Launching the agent can take a while (`npx` fetches its adapter on first use).
let starting = self.live.lock().as_ref().is_none_or(|l| l.peer.is_closed());
self.set_status(if starting { AgentStatus::Starting } else { AgentStatus::Running }, None);
let live = self.ensure_session().await.map_err(Failure::from)?;
let mut live = self.ensure_session().await.map_err(Failure::from)?;
// Stopped while the agent started: the prompt is never sent.
if self.cancel_pending.load(Ordering::Acquire) {
return Ok("cancelled".into());
@@ -1933,9 +2132,34 @@ impl Task {
None => prompt.clone(),
}
};
let content = self.content(&live, &prompt).await;
let result: Result<Value, RpcError> =
let mut content = self.content(&live, &prompt).await;
let mut result: Result<Value, RpcError> =
live.peer.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None).await;
if live.driver == provider::Driver::Copilot
&& !self.turn_started.load(Ordering::Acquire)
&& let Err(RpcError::Server { code, ref message, .. }) = result
&& is_headless_protocol_error(code)
&& !acp::auth_required(code, message)
{
tracing::warn!(
"agent task {}: Copilot headless prompt failed ({message}); falling back to `copilot --acp`",
self.id
);
if let Some(raw_spec) = self.shared.spec(&live.provider) {
self.shared.mark_copilot_acp_fallback(&raw_spec);
}
live.peer.kill();
*self.live.lock() = None;
live = self.ensure_session().await.map_err(Failure::from)?;
if !prompt.images.is_empty() && !live.capabilities.images {
return Err(Failure::from("This agent can't read images.".to_owned()));
}
content = self.content(&live, &prompt).await;
result = live
.peer
.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None)
.await;
}
match result {
Ok(v) => Ok(v.get("stopReason").and_then(Value::as_str).unwrap_or("end_turn").to_owned()),
Err(e) => Err(self.failure(e)),
@@ -2015,11 +2239,43 @@ impl Task {
let s = self.state.lock();
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone())
};
let spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
let launch_cwd = cwd.clone();
let raw_spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
let can_fallback =
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
let primary_spec = if raw_spec.driver == provider::Driver::Copilot && !can_fallback {
native::copilot::acp_fallback_spec(&raw_spec)
} else {
raw_spec.clone()
};
let live = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone()).await {
Ok(live) => live,
Err(err) if can_fallback && err.allow_acp_fallback => {
tracing::warn!(
"agent task {}: Copilot headless session setup failed ({}); falling back to `copilot --acp`",
self.id,
err.message
);
self.shared.mark_copilot_acp_fallback(&raw_spec);
let acp_spec = native::copilot::acp_fallback_spec(&raw_spec);
self.open_session(&provider_id, acp_spec, &cwd, saved).await.map_err(|e| e.message)?
}
Err(err) => return Err(err.message),
};
*self.live.lock() = Some(live.clone());
Ok(live)
}
async fn open_session(
self: &Arc<Self>,
provider_id: &str,
spec: provider::ProviderSpec,
cwd: &Path,
saved: Option<String>,
) -> Result<Live, SessionOpenError> {
let launch_cwd = cwd.to_path_buf();
let spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
.await
.map_err(|e| e.to_string())?;
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?;
self.stderr.lock().clear();
self.config_sent.lock().clear();
let weak = Arc::downgrade(self);
@@ -2034,17 +2290,25 @@ impl Task {
});
// Speaks ACP v1 or v2, whichever the agent chooses; the task sees v1 either way.
let client = acp::Dialect::wrap(Arc::new(Client { task: Arc::downgrade(self) }));
let peer = (self.shared.connector)(&spec, &cwd, client.clone(), on_stderr)
.map(|peer| acp::Conn::new(peer, client))
.map_err(|e| format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command))?;
let raw_peer =
(self.shared.connector)(&spec, cwd, client.clone(), on_stderr).map_err(|e| SessionOpenError {
message: format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command),
allow_acp_fallback: !native::copilot::is_missing_binary_error(&e),
})?;
let mut stop_on_err = KillOnDrop(Some(raw_peer.clone()));
let peer = acp::Conn::new(raw_peer, client);
let init = peer.initialize(&client_info()).await.map_err(|e| self.describe(e))?;
let init = peer.initialize(&client_info()).await.map_err(|e| {
let is_auth = matches!(&e, RpcError::Server { code, message, .. } if acp::auth_required(*code, message));
SessionOpenError { message: self.describe(e), allow_acp_fallback: !is_auth }
})?;
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_servers = self.shared.mcp_servers_for_session(&provider_id, &init);
let mcp_overrides = self.state.lock().task.mcp_overrides.clone();
let mcp_servers = self.shared.mcp_servers_for_session(provider_id, &init, &mcp_overrides);
// Agents that compare canonical paths fail in a symlinked directory (macOS `/tmp`).
let cwd_s = dunce::canonicalize(&cwd).unwrap_or(cwd).to_string_lossy().into_owned();
let cwd_s = dunce::canonicalize(cwd).unwrap_or_else(|_| cwd.to_path_buf()).to_string_lossy().into_owned();
let mut tried_auth = false;
let mut session = None;
@@ -2064,11 +2328,20 @@ impl Task {
Some(s) => s,
None => {
let params = json!({ "cwd": &cwd_s, "mcpServers": &mcp_servers });
let v = self
.request_with_auth(&peer, &init, &mut tried_auth, "session/new", params)
.await
.map_err(|e| self.sign_in_error(&e, Some(&sign_in_message)).unwrap_or_else(|| self.describe(e)))?;
let id = v.get("sessionId").and_then(Value::as_str).ok_or("the agent returned no session")?.to_owned();
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 },
None => SessionOpenError { message: self.describe(e), allow_acp_fallback: true },
},
)?;
let id = v
.get("sessionId")
.and_then(Value::as_str)
.ok_or_else(|| SessionOpenError {
message: "the agent returned no session".into(),
allow_acp_fallback: true,
})?
.to_owned();
(id, v)
}
};
@@ -2091,17 +2364,17 @@ impl Task {
let reported = config::options_of(&result);
let known = !reported.is_empty();
if known {
self.shared.remember(&provider_id, Some(&reported), None, model_of(&reported).as_deref());
self.shared.remember(provider_id, Some(&reported), None, model_of(&reported).as_deref());
}
let (mut options, mut wanted) = {
let s = self.state.lock();
(if known { reported } else { s.task.config.clone() }, s.wanted.clone())
};
config::add_client_options(&provider_id, &mut options);
// Changing model can replace the effort choices; validate those only afterwards.
wanted.sort_by_key(|c| match options.iter().find(|o| o.id == c.id).and_then(|o| o.category.as_deref()) {
Some("model") => 0,
Some("thought_level") => 2,
config::add_client_options(provider_id, &mut options);
// Changing model can replace the effort / context-tier choices; validate those only afterwards.
wanted.sort_by_key(|c| match options.iter().find(|o| o.id == c.id) {
Some(o) if o.category.as_deref() == Some("model") => 0,
Some(o) if config::is_per_model_option(o) => 2,
_ => 1,
});
let mut model_options = known;
@@ -2114,7 +2387,7 @@ impl Task {
}
continue;
}
if o.category.as_deref() == Some("thought_level") && !model_options {
if config::is_per_model_option(&o) && !model_options {
continue;
}
let already = known && o.current.as_deref() == Some(choice.value.as_str());
@@ -2131,7 +2404,7 @@ impl Task {
model_options = true;
} else if o.category.as_deref() == Some("model") {
if o.current.as_deref() != Some(choice.value.as_str()) {
options.retain(|o| o.category.as_deref() != Some("thought_level"));
options.retain(|o| !config::is_per_model_option(o));
}
model_options = false;
}
@@ -2143,7 +2416,7 @@ impl Task {
}
}
let model = model_of(&options).filter(|_| model_options);
self.shared.remember(&provider_id, Some(&options), None, model.as_deref());
self.shared.remember(provider_id, Some(&options), None, model.as_deref());
{
let mut s = self.state.lock();
s.task.model = model_of(&options).or(s.task.model.take());
@@ -2156,10 +2429,18 @@ impl Task {
}
self.persist();
self.emit_task();
let live =
Live { sign_in_message, peer, session: session_id, capabilities, embedded, resumable: can_load, init };
*self.live.lock() = Some(live.clone());
Ok(live)
stop_on_err.0 = None;
Ok(Live {
provider: provider_id.to_owned(),
driver: spec.driver,
sign_in_message,
peer,
session: session_id,
capabilities,
embedded,
resumable: can_load,
init,
})
}
/// Sends the user's choices that the session offers only now: an option advertised
@@ -2195,14 +2476,18 @@ impl Task {
if let Some(fresh) = reply.get("configOptions") {
config::merge_update(&mut s.task.config, fresh);
} else if option.category.as_deref() == Some("model") {
s.task.config.retain(|o| o.category.as_deref() != Some("thought_level"));
s.task.config.retain(|o| !config::is_per_model_option(o));
}
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option.id) {
o.current = Some(value);
}
s.task.model = model_of(&s.task.config).or(s.task.model.take());
sync_usage_context_size(&mut s.task);
// As in `set_config`: a copy without per-model options can't vouch for them.
let model = s.task.model.clone().filter(|_| {
reply.get("configOptions").is_some() || option.category.as_deref() != Some("model")
reply.get("configOptions").is_some()
|| (option.category.as_deref() != Some("model")
&& s.task.config.iter().any(config::is_per_model_option))
});
let (provider, options) = (s.task.provider.clone(), s.task.config.clone());
drop(s);
@@ -2366,12 +2651,7 @@ impl Task {
// first question says what it wants, as the Claude Code adapter titles its own.
let title =
if by_index { questions.first().map(|question| question.question.clone()).unwrap_or(title) } else { title };
// A subagent's request is answered in the task's conversation, named after the subagent.
let session = params.get("sessionId").and_then(Value::as_str);
let title = match session.and_then(|s| self.state.lock().conversation.label(s)) {
Some(label) => format!("{label}: {title}"),
None => title,
};
let title = self.labelled(params, title);
let options: Vec<AgentPermissionOption> = params
.get("options")
.and_then(Value::as_array)
@@ -2403,6 +2683,7 @@ impl Task {
command: None,
options,
questions: Vec::new(),
form: None,
chosen: Some("Denied: side conversations are read-only".to_owned()),
});
return match reject {
@@ -2429,6 +2710,7 @@ impl Task {
command: shown.clone(),
options,
questions: Vec::new(),
form: None,
chosen: Some(format!("Blocked by policy ({pattern})")),
});
return match reject {
@@ -2449,6 +2731,7 @@ impl Task {
command: shown.clone(),
options,
questions: Vec::new(),
form: None,
chosen: Some(format!("{} (whitelisted)", allow.name)),
});
return json!({ "outcome": { "outcome": "selected", "optionId": allow.id } });
@@ -2464,11 +2747,13 @@ impl Task {
command: shown,
options: options.clone(),
questions,
form: None,
chosen: None,
});
self.permissions.lock().insert(id, tx);
self.set_status(AgentStatus::NeedsInput, None);
self.approve_pending();
self.emit_attention_if_input_pending();
let answer = rx.recv().ok().flatten();
let answers = answer
@@ -2490,17 +2775,7 @@ impl Task {
.and_then(|reply| options.iter().find(|option| &option.id == reply))
.map_or_else(|| "Cancelled".to_owned(), |option| option.name.clone()),
};
{
let mut s = self.state.lock();
if let Some(AgentEntry::Permission { chosen, .. }) = s.conversation.main.entries.get_mut(entry) {
*chosen = Some(name);
}
}
self.mark_dirty([(None, entry)]);
let still_asking = !self.permissions.lock().is_empty();
if !still_asking && self.state.lock().task.status == AgentStatus::NeedsInput {
self.set_status(AgentStatus::Running, None);
}
self.settle(entry, name);
// An agent that answers by index reads the answers beside the outcome, keyed by
// question index, with its Submit option chosen; anything less cancels the request.
if by_index {
@@ -2532,6 +2807,58 @@ impl Task {
}
}
/// A request from a subagent is answered in the task's conversation, named after the subagent.
fn labelled(&self, params: &Value, title: String) -> String {
let session = params.get("sessionId").and_then(Value::as_str);
match session.and_then(|s| self.state.lock().conversation.label(s)) {
Some(label) => format!("{label}: {title}"),
None => title,
}
}
/// An agent's form (`elicitation/create`): asked in the conversation like a permission
/// request, and answered with its values, declined or cancelled. Blocks like `ask_permission`.
fn elicit(self: &Arc<Self>, params: &Value, raw: Option<&[u8]>) -> Result<Value, String> {
let mut form = elicitation::form_of(params)?;
if let Some(raw) = raw {
elicitation::in_schema_order(&mut form, raw);
}
let id = self.next_permission.fetch_add(1, Ordering::Relaxed);
let message = params.get("message").and_then(Value::as_str).unwrap_or_default().trim().to_owned();
let (tx, rx) = std::sync::mpsc::channel();
let entry = self.push_entry(AgentEntry::Permission {
id,
title: self.labelled(params, message),
command: None,
options: elicitation::options(),
questions: Vec::new(),
form: Some(form.clone()),
chosen: None,
});
self.permissions.lock().insert(id, tx);
self.set_status(AgentStatus::NeedsInput, None);
self.emit_attention_if_input_pending();
let reply = rx.recv().ok().flatten();
let (response, chosen) = elicitation::answer(&form, reply.as_deref());
self.settle(entry, chosen);
Ok(response)
}
/// Records the answer to the request at `entry`; the turn runs on once nothing else waits.
fn settle(self: &Arc<Self>, entry: usize, chosen: String) {
{
let mut s = self.state.lock();
if let Some(AgentEntry::Permission { chosen: answer, .. }) = s.conversation.main.entries.get_mut(entry) {
*answer = Some(chosen);
}
}
self.mark_dirty([(None, entry)]);
let still_asking = !self.permissions.lock().is_empty();
if !still_asking && self.state.lock().task.status == AgentStatus::NeedsInput {
self.set_status(AgentStatus::Running, None);
}
}
fn approve_pending(&self) {
let s = self.state.lock();
if self.cancel_pending.load(Ordering::Acquire) || !config::bypass_approvals(&s.task.config) {
@@ -2596,9 +2923,18 @@ impl Handler for Client {
let task = self.task.upgrade().ok_or((codes::INTERNAL_ERROR, "task closed".to_owned()))?;
match method {
"session/request_permission" => Ok(task.ask_permission(&params)),
"elicitation/create" => task.elicit(&params, None).map_err(|e| (codes::INVALID_PARAMS, e)),
_ => Err((codes::METHOD_NOT_FOUND, format!("unsupported method {method}"))),
}
}
fn on_request_raw(&self, method: &str, params: Value, raw: &[u8]) -> Result<Value, (i64, String, Option<Value>)> {
if method != "elicitation/create" {
return self.on_request_with_data(method, params);
}
let task = self.task.upgrade().ok_or((codes::INTERNAL_ERROR, "task closed".to_owned(), None))?;
task.elicit(&params, Some(raw)).map_err(|e| (codes::INVALID_PARAMS, e, None))
}
}
/// The prompt trimmed, or `None` when there is nothing to send.
@@ -2786,9 +3122,13 @@ fn embeddable(path: &Path) -> Option<String> {
/// A task file from before a field existed, with that field's empty value.
fn upgrade(mut file: Value) -> Value {
if let Some(task) = file.get_mut("task").and_then(Value::as_object_mut) {
for (key, empty) in
[("config", json!([])), ("commands", json!([])), ("usage", Value::Null), ("queue", json!([]))]
{
for (key, empty) in [
("config", json!([])),
("commands", json!([])),
("usage", Value::Null),
("queue", json!([])),
("mcpOverrides", json!({})),
] {
task.entry(key).or_insert(empty);
}
}
@@ -2865,13 +3205,27 @@ fn shown_background(tasks: &[Value], known: &[AgentBackgroundTask]) -> Vec<Agent
.collect()
}
/// The method that adds a message to the running turn: OpenIDEA's own, or the
/// `_session/steering` extension an agent advertises in the response's top-level `_meta`
/// (OMP).
fn steer_method(init: &acp::Negotiated) -> Option<&'static str> {
let supported = |v: Option<&Value>| v.and_then(Value::as_bool) == Some(true);
if supported(init.meta("/openidea/steer")) {
Some("_openidea/steer")
} else if supported(init.meta.as_ref().and_then(|m| m.pointer("/steering/supported"))) {
Some("_session/steering")
} else {
None
}
}
fn capabilities_of(init: &acp::Negotiated) -> (AgentCapabilities, bool) {
let meta = |p: &str| init.meta(p).and_then(Value::as_bool) == Some(true);
let capabilities = AgentCapabilities {
images: init.prompt("image"),
fork: init.session("fork"),
rollback: meta("/openidea/rollback"),
steer: meta("/openidea/steer"),
steer: steer_method(init).is_some(),
background_tasks: meta("/openidea/backgroundTasks"),
read_only: false,
};
@@ -3079,3 +3433,55 @@ fn entry_event(
}
}
}
struct SessionOpenError {
message: String,
allow_acp_fallback: bool,
}
struct KillOnDrop(Option<Peer>);
impl Drop for KillOnDrop {
fn drop(&mut self) {
if let Some(peer) = self.0.take() {
peer.kill();
}
}
}
fn is_headless_protocol_error(code: i64) -> bool {
matches!(
code,
ide_jsonrpc::codes::PARSE_ERROR
| ide_jsonrpc::codes::INVALID_REQUEST
| ide_jsonrpc::codes::METHOD_NOT_FOUND
| ide_jsonrpc::codes::INVALID_PARAMS
)
}
/// Keeps `task.usage.size` aligned with the active model and `context_tier` when pricing
/// metadata reports the selected tier's token limit.
fn sync_usage_context_size(task: &mut AgentTask) {
let Some(usage) = task.usage.as_mut() else { return };
let Some(model_opt) = task.config.iter().find(|o| o.category.as_deref() == Some("model")) else { return };
let Some(model_id) = model_opt.current.as_deref() else { return };
let Some(pricing) = model_opt.values.iter().find(|v| v.value == model_id).and_then(|v| v.pricing.as_deref()) else {
return;
};
let tier = task
.config
.iter()
.find(|o| config::is_context_option(&o.id))
.and_then(|o| o.current.as_deref())
.unwrap_or("default");
if let Some(tokens) = pricing
.tiers
.get(tier)
.or_else(|| pricing.tiers.get("default"))
.or_else(|| pricing.tiers.get("long_context"))
.and_then(|t| t.context_tokens)
.filter(|&n| n > 0)
{
usage.size = tokens;
}
}
+822 -64
Переглянути файл
@@ -1,13 +1,24 @@
//! Model Context Protocol (MCP) server configurations stored in OpenIDEA's own settings
//! (global `settings.toml` and project `.openidea/settings.toml`), passed to ACP agents in
//! `session/new`, `session/load`, and `session/fork`, plus one-way import from `.mcp.json` /
//! `.vscode/mcp.json`.
//! `session/new`, `session/load`, and `session/fork`, plus discovery and one-way import from
//! external CLI and workspace MCP configuration files.
use crate::acp::Negotiated;
use crate::{AgentMcpServer, McpKeyValue, McpScope, McpServer, McpServerInput, McpTransport};
use crate::{
AgentMcpServer, McpDiscoveredServer, McpExternalSource, McpImportSelection, McpKeyValue, McpProbeResult, McpScope,
McpServer, McpServerInput, McpToolSummary, McpTransport,
};
use ide_core::IpcPath;
use serde_json::{Value, json};
use std::collections::{BTreeMap, HashSet};
use std::path::Path;
use std::path::{Path, PathBuf};
use std::time::{Duration, Instant};
/// Reserved server name for OpenIDEA's built-in IDE MCP server in per-session overrides.
pub const BUILTIN_MCP_NAME: &str = "openidea";
const PROBE_TIMEOUT: Duration = Duration::from_secs(12);
const PROBE_PROTOCOL_VERSION: &str = "2024-11-05";
/// Stable ID for a server in a given scope (`"user::<name>"` or `"workspace::<name>"`).
pub fn server_id(scope: McpScope, name: &str) -> String {
@@ -56,6 +67,7 @@ fn to_mcp_server(scope: McpScope, name: &str, cfg: &AgentMcpServer) -> McpServer
url: cfg.url.clone(),
headers: cfg.headers.iter().map(|(k, v)| McpKeyValue { name: k.clone(), value: v.clone() }).collect(),
agents: cfg.agents.clone(),
unapproved: false,
}
}
@@ -75,8 +87,15 @@ fn matches_agent(agents: &[String], provider: &str) -> bool {
}
/// Builds the ACP `mcpServers` array for `session/new`, `session/load`, and `session/fork`.
/// Workspace entries take precedence over User entries with the same name.
pub(crate) fn acp_mcp_servers(all: &[McpServer], provider: &str, init: &Negotiated) -> Vec<Value> {
/// Workspace entries take precedence over User entries with the same name. Per-session
/// `overrides` (`server_name` -> `enabled`) can enable a disabled server or disable an enabled one
/// for this session only.
pub(crate) fn acp_mcp_servers(
all: &[McpServer],
provider: &str,
init: &Negotiated,
overrides: &BTreeMap<String, bool>,
) -> Vec<Value> {
let supports_stdio = init.mcp_stdio();
let supports_http = init.mcp("http");
let supports_sse = init.mcp("sse");
@@ -87,7 +106,16 @@ pub(crate) fn acp_mcp_servers(all: &[McpServer], provider: &str, init: &Negotiat
all.iter().filter(|s| s.scope == McpScope::Workspace).chain(all.iter().filter(|s| s.scope == McpScope::User));
for srv in ordered {
if !srv.enabled || !matches_agent(&srv.agents, provider) || !seen.insert(srv.name.clone()) {
if srv.unapproved {
continue;
}
let explicit = overrides.get(&srv.name).copied();
let active = explicit.unwrap_or(srv.enabled);
if !active || !seen.insert(srv.name.clone()) {
continue;
}
// An explicit per-session enable (`Some(true)`) overrides the server's default agent filter.
if explicit != Some(true) && !matches_agent(&srv.agents, provider) {
continue;
}
match srv.transport {
@@ -276,6 +304,306 @@ pub fn apply_import(workspace: &mut BTreeMap<String, AgentMcpServer>, workspace_
added
}
/// Parses a raw MCP JSON snippet pasted by the user and merges its servers into `user` or
/// `workspace`. Supports `{"mcpServers": {...}}`, `{"servers": {...}}`, top-level server maps
/// (`{"my-server": {"command": ...}}`), and single-server objects when `fallback_name` is given.
pub fn apply_save_json(
user: &mut BTreeMap<String, AgentMcpServer>,
workspace: &mut BTreeMap<String, AgentMcpServer>,
has_workspace: bool,
scope: McpScope,
raw_json: &str,
fallback_name: Option<&str>,
agents: Vec<String>,
) -> Result<Vec<String>, String> {
if scope == McpScope::Workspace && !has_workspace {
return Err("Open a project to configure workspace MCP servers".into());
}
let parsed = parse_mcp_json_text(raw_json, fallback_name)?;
if parsed.is_empty() {
return Err("No valid MCP servers found in JSON".into());
}
let normalized_agents = normalize_agents_list(agents);
let target = match scope {
McpScope::User => user,
McpScope::Workspace => workspace,
};
let mut saved_names = Vec::with_capacity(parsed.len());
for (name, mut srv) in parsed {
if srv.agents.is_empty() && !normalized_agents.is_empty() {
srv.agents = normalized_agents.clone();
}
saved_names.push(name.clone());
target.insert(name, srv);
}
Ok(saved_names)
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum SourceFormat {
Jsonc,
CodexToml,
}
#[derive(Clone)]
struct SourceSpec {
id: &'static str,
label: &'static str,
path: PathBuf,
format: SourceFormat,
suggested_scope: McpScope,
native_provider: Option<&'static str>,
claude_project_lookup: bool,
}
fn external_source_specs(home_dir: Option<&Path>, workspace_root: Option<&Path>) -> Vec<SourceSpec> {
let mut specs = Vec::new();
if let Some(root) = workspace_root {
specs.push(SourceSpec {
id: "workspace-mcp",
label: "Project (.mcp.json)",
path: root.join(".mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: Some("claude"),
claude_project_lookup: false,
});
specs.push(SourceSpec {
id: "vscode-mcp",
label: "VS Code (.vscode/mcp.json)",
path: root.join(".vscode").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: None,
claude_project_lookup: false,
});
specs.push(SourceSpec {
id: "cursor-project",
label: "Cursor Project (.cursor/mcp.json)",
path: root.join(".cursor").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: Some("cursor"),
claude_project_lookup: false,
});
specs.push(SourceSpec {
id: "codex-project",
label: "Codex Project (.codex/config.toml)",
path: root.join(".codex").join("config.toml"),
format: SourceFormat::CodexToml,
suggested_scope: McpScope::Workspace,
native_provider: Some("codex"),
claude_project_lookup: false,
});
specs.push(SourceSpec {
id: "gemini-project",
label: "Gemini Project (.gemini/settings.json)",
path: root.join(".gemini").join("settings.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: Some("gemini"),
claude_project_lookup: false,
});
}
if let Some(home) = home_dir {
specs.push(SourceSpec {
id: "copilot-cli",
label: "GitHub Copilot CLI",
path: home.join(".copilot").join("mcp-config.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("copilot"),
claude_project_lookup: false,
});
specs.push(SourceSpec {
id: "claude-code",
label: "Claude Code",
path: home.join(".claude.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("claude"),
claude_project_lookup: true,
});
specs.push(SourceSpec {
id: "codex",
label: "Codex",
path: home.join(".codex").join("config.toml"),
format: SourceFormat::CodexToml,
suggested_scope: McpScope::User,
native_provider: Some("codex"),
claude_project_lookup: false,
});
specs.push(SourceSpec {
id: "cursor",
label: "Cursor",
path: home.join(".cursor").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("cursor"),
claude_project_lookup: false,
});
specs.push(SourceSpec {
id: "gemini",
label: "Gemini CLI",
path: home.join(".gemini").join("settings.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("gemini"),
claude_project_lookup: false,
});
specs.push(SourceSpec {
id: "jetbrains-air",
label: "JetBrains Air",
path: home.join(".jetbrains").join("mcp").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: None,
claude_project_lookup: false,
});
specs.push(SourceSpec {
id: "copilot-intellij",
label: "GitHub Copilot (JetBrains)",
path: home.join(".config").join("github-copilot").join("intellij").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: None,
claude_project_lookup: false,
});
}
specs
}
fn read_source_servers(spec: &SourceSpec, workspace_root: Option<&Path>) -> BTreeMap<String, AgentMcpServer> {
let Ok(text) = std::fs::read_to_string(&spec.path) else {
return BTreeMap::new();
};
if spec.format == SourceFormat::CodexToml {
return parse_codex_toml_servers(&text);
}
let Ok(root) = parse_jsonc_value(&text) else {
return BTreeMap::new();
};
let mut servers = extract_servers_from_root(&root, None);
if spec.claude_project_lookup
&& let Some(ws) = workspace_root
&& let Some(projects) = root.get("projects").and_then(Value::as_object)
{
let ws_canon = dunce::canonicalize(ws).unwrap_or_else(|_| ws.to_path_buf());
for (proj_key, proj_val) in projects {
let matches = Path::new(proj_key) == ws || dunce::canonicalize(proj_key).is_ok_and(|c| c == ws_canon);
if matches {
for (name, srv) in extract_servers_from_root(proj_val, None) {
servers.insert(name, srv);
}
}
}
}
servers
}
fn parse_codex_toml_servers(text: &str) -> BTreeMap<String, AgentMcpServer> {
let Ok(doc) = toml::from_str::<toml::Value>(text) else {
return BTreeMap::new();
};
let Ok(json_doc) = serde_json::to_value(doc) else {
return BTreeMap::new();
};
let Some(table) = json_doc.get("mcp_servers").or_else(|| json_doc.get("mcpServers")).and_then(Value::as_object)
else {
return BTreeMap::new();
};
let mut out = BTreeMap::new();
for (name, raw) in table {
let name = name.trim();
let Some(mut obj) = raw.as_object().cloned().filter(|_| !name.is_empty()) else {
continue;
};
if !obj.contains_key("headers")
&& let Some(http_headers) = obj.remove("http_headers")
{
obj.insert("headers".to_owned(), http_headers);
}
if let Some(srv) = parse_one_server_def(&obj) {
out.insert(name.to_owned(), srv);
}
}
out
}
/// Discovers external MCP configuration files on disk (without exposing secret values).
pub fn discover_external_sources(home_dir: Option<&Path>, workspace_root: Option<&Path>) -> Vec<McpExternalSource> {
let mut out = Vec::new();
for spec in external_source_specs(home_dir, workspace_root) {
let map = read_source_servers(&spec, workspace_root);
if map.is_empty() {
continue;
}
let servers = map
.into_iter()
.map(|(name, cfg)| McpDiscoveredServer {
name,
transport: cfg.transport,
enabled: cfg.enabled,
command: cfg.command,
args: cfg.args,
url: cfg.url,
env_keys: cfg.env.into_keys().collect(),
header_keys: cfg.headers.into_keys().collect(),
})
.collect();
out.push(McpExternalSource {
id: spec.id.to_owned(),
label: spec.label.to_owned(),
path: IpcPath(spec.path),
suggested_scope: spec.suggested_scope,
native_provider: spec.native_provider.map(str::to_owned),
servers,
});
}
out
}
/// Imports selected `(source_id, name)` entries from discovered external MCP config files into
/// `user` or `workspace` without modifying the external files. Returns imported server names.
pub fn apply_import_selected(
user: &mut BTreeMap<String, AgentMcpServer>,
workspace: &mut BTreeMap<String, AgentMcpServer>,
home_dir: Option<&Path>,
workspace_root: Option<&Path>,
scope: McpScope,
selections: &[McpImportSelection],
overwrite: bool,
) -> Result<Vec<String>, String> {
if scope == McpScope::Workspace && workspace_root.is_none() {
return Err("Open a project to import workspace MCP servers".into());
}
let specs = external_source_specs(home_dir, workspace_root);
let mut by_source: BTreeMap<&str, BTreeMap<String, AgentMcpServer>> = BTreeMap::new();
for spec in &specs {
if selections.iter().any(|s| s.source_id == spec.id) {
by_source.insert(spec.id, read_source_servers(spec, workspace_root));
}
}
let target = match scope {
McpScope::User => user,
McpScope::Workspace => workspace,
};
let mut imported = Vec::new();
for sel in selections {
let Some(source_map) = by_source.get(sel.source_id.as_str()) else {
continue;
};
let Some(srv) = source_map.get(&sel.name) else {
continue;
};
if overwrite || !target.contains_key(&sel.name) {
target.insert(sel.name.clone(), srv.clone());
imported.push(sel.name.clone());
}
}
Ok(imported)
}
fn normalize_agents_list(agents: Vec<String>) -> Vec<String> {
let mut out = Vec::new();
for a in agents {
@@ -287,73 +615,376 @@ fn normalize_agents_list(agents: Vec<String>) -> Vec<String> {
out
}
fn read_external_file(path: &Path) -> BTreeMap<String, AgentMcpServer> {
let Ok(bytes) = std::fs::read(path) else {
return BTreeMap::new();
};
let Ok(root) = serde_json::from_slice::<Value>(&bytes) else {
return BTreeMap::new();
};
let Some(servers_obj) = root.get("mcpServers").or_else(|| root.get("servers")).and_then(Value::as_object) else {
return BTreeMap::new();
/// Strips `//` line comments, `/* ... */` block comments, and trailing commas before `}` or `]`
/// outside JSON string literals so JSONC config files parse cleanly with `serde_json`.
pub(crate) fn strip_jsonc(input: &str) -> String {
let bytes = input.as_bytes();
let mut out = String::with_capacity(input.len());
let mut i = 0;
let mut in_str = false;
while i < bytes.len() {
if in_str {
let ch = input[i..].chars().next().unwrap();
out.push(ch);
i += ch.len_utf8();
if ch == '\\' && i < bytes.len() {
let next = input[i..].chars().next().unwrap();
out.push(next);
i += next.len_utf8();
} else if ch == '"' {
in_str = false;
}
continue;
}
if bytes[i] == b'"' {
in_str = true;
out.push('"');
i += 1;
continue;
}
if bytes[i] == b'/' && i + 1 < bytes.len() && bytes[i + 1] == b'/' {
i += 2;
while i < bytes.len() && bytes[i] != b'\n' {
i += 1;
}
continue;
}
if bytes[i] == b'/' && i + 1 < bytes.len() && bytes[i + 1] == b'*' {
i += 2;
while i + 1 < bytes.len() && !(bytes[i] == b'*' && bytes[i + 1] == b'/') {
if bytes[i] == b'\n' {
out.push('\n');
i += 1;
} else {
let ch = input[i..].chars().next().unwrap();
i += ch.len_utf8();
}
}
i = (i + 2).min(bytes.len());
continue;
}
let ch = input[i..].chars().next().unwrap();
out.push(ch);
i += ch.len_utf8();
}
remove_trailing_commas(&out)
}
fn remove_trailing_commas(input: &str) -> String {
let bytes = input.as_bytes();
let mut out = String::with_capacity(input.len());
let mut i = 0;
let mut in_str = false;
while i < bytes.len() {
if in_str {
let ch = input[i..].chars().next().unwrap();
out.push(ch);
i += ch.len_utf8();
if ch == '\\' && i < bytes.len() {
let next = input[i..].chars().next().unwrap();
out.push(next);
i += next.len_utf8();
} else if ch == '"' {
in_str = false;
}
continue;
}
if bytes[i] == b'"' {
in_str = true;
out.push('"');
i += 1;
continue;
}
if bytes[i] == b',' {
let mut j = i + 1;
while j < bytes.len() && bytes[j].is_ascii_whitespace() {
j += 1;
}
if j < bytes.len() && (bytes[j] == b'}' || bytes[j] == b']') {
i += 1;
continue;
}
}
let ch = input[i..].chars().next().unwrap();
out.push(ch);
i += ch.len_utf8();
}
out
}
fn parse_jsonc_value(raw: &str) -> Result<Value, String> {
let trimmed = raw.trim().trim_start_matches('\u{feff}');
serde_json::from_str::<Value>(trimmed)
.or_else(|_| serde_json::from_str::<Value>(&strip_jsonc(trimmed)))
.map_err(|e| format!("Invalid JSON: {e}"))
}
pub fn parse_mcp_json_text(raw: &str, fallback_name: Option<&str>) -> Result<BTreeMap<String, AgentMcpServer>, String> {
let root = parse_jsonc_value(raw)?;
Ok(extract_servers_from_root(&root, fallback_name))
}
fn is_server_def_object(obj: &serde_json::Map<String, Value>) -> bool {
obj.get("command").and_then(Value::as_str).is_some_and(|s| !s.trim().is_empty())
|| obj.get("url").and_then(Value::as_str).is_some_and(|s| !s.trim().is_empty())
|| obj.get("serverUrl").and_then(Value::as_str).is_some_and(|s| !s.trim().is_empty())
}
fn parse_one_server_def(obj: &serde_json::Map<String, Value>) -> Option<AgentMcpServer> {
let disabled = obj.get("disabled").and_then(Value::as_bool).unwrap_or(false)
|| obj.get("enabled").and_then(Value::as_bool) == Some(false);
let type_str = obj.get("type").and_then(Value::as_str).unwrap_or_default().to_ascii_lowercase();
let url = obj
.get("url")
.or_else(|| obj.get("serverUrl"))
.and_then(Value::as_str)
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned);
let command =
obj.get("command").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned);
let transport = match type_str.as_str() {
"sse" => McpTransport::Sse,
"http" | "streamable-http" | "streamable_http" => McpTransport::Http,
"stdio" | "local" => McpTransport::Stdio,
_ if url.is_some() && command.is_none() => McpTransport::Http,
_ => McpTransport::Stdio,
};
match transport {
McpTransport::Stdio => command.as_ref()?,
McpTransport::Http | McpTransport::Sse => url.as_ref()?,
};
let args = obj
.get("args")
.and_then(Value::as_array)
.map(|arr| arr.iter().filter_map(|v| v.as_str().map(str::to_owned)).collect())
.unwrap_or_default();
let agents = obj
.get("agents")
.and_then(Value::as_array)
.map(|arr| normalize_agents_list(arr.iter().filter_map(|v| v.as_str().map(str::to_owned)).collect()))
.unwrap_or_default();
Some(AgentMcpServer {
transport,
enabled: !disabled,
command,
args,
env: parse_key_values_map(obj.get("env")),
url,
headers: parse_key_values_map(obj.get("headers")),
agents,
})
}
fn extract_servers_from_root(root: &Value, fallback_name: Option<&str>) -> BTreeMap<String, AgentMcpServer> {
let mut out = BTreeMap::new();
for (name, def) in servers_obj {
let name = name.trim();
let Some(obj) = def.as_object().filter(|_| !name.is_empty()) else {
continue;
};
let disabled = obj.get("disabled").and_then(Value::as_bool).unwrap_or(false)
|| obj.get("enabled").and_then(Value::as_bool) == Some(false);
let type_str = obj.get("type").and_then(Value::as_str).unwrap_or_default().to_ascii_lowercase();
let url = obj
.get("url")
.or_else(|| obj.get("serverUrl"))
let Some(root_obj) = root.as_object() else {
return out;
};
// Single server definition object pasted directly (`{"command": "npx", ...}`).
if is_server_def_object(root_obj) {
let name = root_obj
.get("name")
.and_then(Value::as_str)
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned);
let command =
obj.get("command").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned);
let transport = match type_str.as_str() {
"sse" => McpTransport::Sse,
"http" | "streamable-http" | "streamable_http" => McpTransport::Http,
"stdio" | "local" => McpTransport::Stdio,
_ if url.is_some() && command.is_none() => McpTransport::Http,
_ => McpTransport::Stdio,
};
match transport {
McpTransport::Stdio if command.is_none() => continue,
McpTransport::Http | McpTransport::Sse if url.is_none() => continue,
_ => {}
.or_else(|| fallback_name.map(str::trim).filter(|s| !s.is_empty()));
if let (Some(name), Some(srv)) = (name, parse_one_server_def(root_obj)) {
out.insert(name.to_owned(), srv);
}
return out;
}
let args = obj
.get("args")
.and_then(Value::as_array)
.map(|arr| arr.iter().filter_map(|v| v.as_str().map(str::to_owned)).collect())
.unwrap_or_default();
let servers_obj =
root_obj.get("mcpServers").or_else(|| root_obj.get("servers")).and_then(Value::as_object).unwrap_or(root_obj);
out.insert(
name.to_owned(),
AgentMcpServer {
transport,
enabled: !disabled,
command,
args,
env: parse_key_values_map(obj.get("env")),
url,
headers: parse_key_values_map(obj.get("headers")),
agents: Vec::new(),
},
);
for (name, def) in servers_obj {
let name = name.trim();
if name.is_empty() || matches!(name, "$schema" | "inputs" | "version") {
continue;
}
let Some(obj) = def.as_object() else {
continue;
};
if !is_server_def_object(obj) {
continue;
}
if let Some(srv) = parse_one_server_def(obj) {
out.insert(name.to_owned(), srv);
}
}
out
}
fn read_external_file(path: &Path) -> BTreeMap<String, AgentMcpServer> {
let Ok(text) = std::fs::read_to_string(path) else {
return BTreeMap::new();
};
let Ok(root) = parse_jsonc_value(&text) else {
return BTreeMap::new();
};
extract_servers_from_root(&root, None)
}
/// Probes a stdio MCP server by launching its command, performing the MCP `initialize` handshake,
/// and requesting `tools/list`. For HTTP/SSE servers, use `ide-host`'s HTTP probe helper.
pub async fn probe_stdio_server(server: &AgentMcpServer, cwd: &Path) -> McpProbeResult {
let started = Instant::now();
let elapsed_ms = || u32::try_from(started.elapsed().as_millis()).unwrap_or(u32::MAX);
let Some(raw_cmd) = server.command.as_deref().map(str::trim).filter(|s| !s.is_empty()) else {
return McpProbeResult {
ok: false,
server_name: None,
server_version: None,
protocol_version: None,
tools: Vec::new(),
duration_ms: elapsed_ms(),
error: Some("Command is empty".into()),
};
};
let mut env: Vec<(String, String)> = ide_core::process::shell_env()
.map(|(k, v)| (k.to_string_lossy().into_owned(), v.to_string_lossy().into_owned()))
.collect();
for (k, v) in &server.env {
if let Some((_, existing)) = env.iter_mut().find(|(ek, _)| ek == k) {
*existing = v.clone();
} else {
env.push((k.clone(), v.clone()));
}
}
let search_path = env
.iter()
.find(|(k, _)| k.eq_ignore_ascii_case("PATH"))
.map(|(_, v)| std::ffi::OsString::from(v))
.or_else(|| ide_core::process::host_var_os("PATH"))
.unwrap_or_default();
let program = ide_core::process::find_executable(raw_cmd, &search_path)
.map(|p| p.to_string_lossy().into_owned())
.unwrap_or_else(|| raw_cmd.to_owned());
let stderr_lines = std::sync::Arc::new(parking_lot::Mutex::new(Vec::<String>::new()));
let stderr_capture = stderr_lines.clone();
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(move |line| {
let mut guard = stderr_capture.lock();
if guard.len() < 12 && !line.trim().is_empty() {
guard.push(line);
}
});
let peer = match ide_jsonrpc::Peer::spawn_framed(
&program,
&server.args,
cwd,
&env,
std::sync::Arc::new(ide_jsonrpc::NoopHandler),
on_stderr,
ide_jsonrpc::Framing::Lines,
) {
Ok(peer) => peer,
Err(e) => {
return McpProbeResult {
ok: false,
server_name: None,
server_version: None,
protocol_version: None,
tools: Vec::new(),
duration_ms: elapsed_ms(),
error: Some(format!("Failed to launch `{raw_cmd}`: {e}")),
};
}
};
let outcome = tokio::time::timeout(PROBE_TIMEOUT, async {
let init: Value = peer
.request(
"initialize",
json!({
"protocolVersion": PROBE_PROTOCOL_VERSION,
"capabilities": {},
"clientInfo": crate::client_info(),
}),
None,
)
.await
.map_err(|e| e.to_string())?;
let _ = peer.notify("notifications/initialized", json!({}));
let tools_reply: Value = peer.request("tools/list", json!({}), None).await.unwrap_or_else(|_| json!({}));
Ok::<(Value, Value), String>((init, tools_reply))
})
.await;
peer.kill();
match outcome {
Ok(Ok((init, tools_reply))) => parse_probe_payloads(&init, &tools_reply, elapsed_ms()),
Ok(Err(err)) => {
let tail = stderr_lines.lock().join("\n");
let error = if tail.is_empty() { err } else { format!("{err}\n{tail}") };
McpProbeResult {
ok: false,
server_name: None,
server_version: None,
protocol_version: None,
tools: Vec::new(),
duration_ms: elapsed_ms(),
error: Some(error),
}
}
Err(_) => {
let tail = stderr_lines.lock().join("\n");
let error = if tail.is_empty() {
format!("Timed out after {}s waiting for MCP handshake", PROBE_TIMEOUT.as_secs())
} else {
format!("Timed out after {}s waiting for MCP handshake:\n{tail}", PROBE_TIMEOUT.as_secs())
};
McpProbeResult {
ok: false,
server_name: None,
server_version: None,
protocol_version: None,
tools: Vec::new(),
duration_ms: elapsed_ms(),
error: Some(error),
}
}
}
}
pub fn parse_probe_payloads(init: &Value, tools_reply: &Value, duration_ms: u32) -> McpProbeResult {
let server_name = init.pointer("/serverInfo/name").and_then(Value::as_str).map(str::to_owned);
let server_version = init.pointer("/serverInfo/version").and_then(Value::as_str).map(str::to_owned);
let protocol_version = init.get("protocolVersion").and_then(Value::as_str).map(str::to_owned);
let tools = tools_reply
.get("tools")
.and_then(Value::as_array)
.map(|arr| {
arr.iter()
.filter_map(|t| {
let name = t.get("name")?.as_str()?.trim();
if name.is_empty() {
return None;
}
let description = t
.get("description")
.and_then(Value::as_str)
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned);
Some(McpToolSummary { name: name.to_owned(), description })
})
.collect()
})
.unwrap_or_default();
McpProbeResult { ok: true, server_name, server_version, protocol_version, tools, duration_ms, error: None }
}
fn parse_key_values_map(val: Option<&Value>) -> BTreeMap<String, String> {
match val {
Some(Value::Object(map)) => map
@@ -457,22 +1088,29 @@ mod tests {
let init_http = Negotiated::from_initialize(&json!({
"agentCapabilities": { "mcpCapabilities": { "http": true, "sse": false } }
}));
let claude_servers = acp_mcp_servers(&list, "claude-acp", &init_http);
let empty_overrides = BTreeMap::new();
let claude_servers = acp_mcp_servers(&list, "claude-acp", &init_http, &empty_overrides);
assert_eq!(claude_servers.len(), 2);
assert_eq!(claude_servers[0]["name"], "shared");
assert_eq!(claude_servers[0]["args"], json!(["-y", "workspace-pkg"]));
assert_eq!(claude_servers[1]["name"], "claude-http");
assert_eq!(claude_servers[1]["type"], "http");
let codex_servers = acp_mcp_servers(&list, "codex", &init_http);
let codex_servers = acp_mcp_servers(&list, "codex", &init_http, &empty_overrides);
assert_eq!(codex_servers.len(), 1);
assert_eq!(codex_servers[0]["name"], "shared");
// Per-session overrides can disable an enabled server or enable an agent-scoped server.
let overrides = BTreeMap::from([("shared".to_owned(), false), ("claude-http".to_owned(), true)]);
let codex_overridden = acp_mcp_servers(&list, "codex", &init_http, &overrides);
assert_eq!(codex_overridden.len(), 1);
assert_eq!(codex_overridden[0]["name"], "claude-http");
// Disable workspace `shared` and remove user `claude-http`.
apply_set_enabled(&mut user, &mut workspace, "workspace::shared", false).unwrap();
apply_remove(&mut user, &mut workspace, "user::claude-http").unwrap();
let list = servers_from_settings(&user, &workspace);
let after = acp_mcp_servers(&list, "claude", &init_http);
let after = acp_mcp_servers(&list, "claude", &init_http, &empty_overrides);
assert_eq!(after.len(), 1);
assert_eq!(after[0]["args"], json!(["-y", "user-pkg"]));
}
@@ -504,4 +1142,124 @@ mod tests {
assert_eq!(std::fs::read_to_string(&mcp_json).unwrap(), raw_mcp);
assert_eq!(std::fs::read_to_string(&vscode_mcp).unwrap(), raw_vscode);
}
#[test]
fn discovers_cli_sources_top_level_maps_and_jsonc_and_imports_selected() {
let tmp = tempfile::tempdir().unwrap();
let home = tmp.path().join("home");
let proj = tmp.path().join("project");
std::fs::create_dir_all(home.join(".copilot")).unwrap();
std::fs::create_dir_all(home.join(".codex")).unwrap();
std::fs::create_dir_all(home.join(".gemini")).unwrap();
std::fs::create_dir_all(home.join(".jetbrains").join("mcp")).unwrap();
std::fs::create_dir_all(home.join(".config").join("github-copilot").join("intellij")).unwrap();
std::fs::create_dir_all(&proj).unwrap();
std::fs::write(
home.join(".copilot").join("mcp-config.json"),
r#"{"mcpServers":{"github":{"type":"http","url":"https://api.githubcopilot.com/mcp/","headers":{"Authorization":"Bearer tok"}},"slack":{"type":"local","command":"npx","args":["-y","slack-mcp"],"env":{"SLACK_TOKEN":"xoxb"}}}}"#,
)
.unwrap();
// Codex `~/.codex/config.toml` `[mcp_servers]` format.
std::fs::write(
home.join(".codex").join("config.toml"),
"[mcp_servers.postgres]\ncommand = \"npx\"\nargs = [\"-y\", \"@modelcontextprotocol/server-postgres\"]\n\n[mcp_servers.remote_api]\nurl = \"https://mcp.example.com/sse\"\ntype = \"sse\"\nhttp_headers = { Authorization = \"Bearer codex-tok\" }\n",
)
.unwrap();
// Gemini `~/.gemini/settings.json` with unrelated top-level settings alongside `mcpServers`.
std::fs::write(
home.join(".gemini").join("settings.json"),
r#"{"theme":"Default","mcpServers":{"fetch":{"command":"uvx","args":["mcp-server-fetch"]}}}"#,
)
.unwrap();
// JetBrains Air top-level server map (not nested under `mcpServers`).
std::fs::write(
home.join(".jetbrains").join("mcp").join("mcp.json"),
r#"{"linear":{"type":"stdio","command":"npx","args":["-y","mcp-remote","https://mcp.linear.app/mcp"]}}"#,
)
.unwrap();
// JSONC comments + trailing commas.
std::fs::write(
home.join(".config").join("github-copilot").join("intellij").join("mcp.json"),
"// comment with https://url/inside\n{\n /* block comment */\n \"servers\": {\n \"docs\": { \"command\": \"uvx\", \"args\": [\"docs-mcp\",], },\n },\n}\n",
)
.unwrap();
let sources = discover_external_sources(Some(&home), Some(&proj));
assert_eq!(sources.len(), 5);
let copilot = sources.iter().find(|s| s.id == "copilot-cli").unwrap();
assert_eq!(copilot.native_provider.as_deref(), Some("copilot"));
assert_eq!(copilot.servers.len(), 2);
let gh_srv = copilot.servers.iter().find(|s| s.name == "github").unwrap();
assert_eq!(gh_srv.header_keys, vec!["Authorization".to_string()]);
let codex = sources.iter().find(|s| s.id == "codex").unwrap();
assert_eq!(codex.native_provider.as_deref(), Some("codex"));
assert_eq!(codex.servers.len(), 2);
let gemini = sources.iter().find(|s| s.id == "gemini").unwrap();
assert_eq!(gemini.servers[0].name, "fetch");
let air = sources.iter().find(|s| s.id == "jetbrains-air").unwrap();
assert_eq!(air.servers[0].name, "linear");
let ij = sources.iter().find(|s| s.id == "copilot-intellij").unwrap();
assert_eq!(ij.servers[0].name, "docs");
let mut user = BTreeMap::new();
let mut workspace = BTreeMap::new();
let imported = apply_import_selected(
&mut user,
&mut workspace,
Some(&home),
Some(&proj),
McpScope::User,
&[
McpImportSelection { source_id: "copilot-cli".into(), name: "github".into() },
McpImportSelection { source_id: "jetbrains-air".into(), name: "linear".into() },
],
false,
)
.unwrap();
assert_eq!(imported, vec!["github".to_string(), "linear".to_string()]);
assert_eq!(user["github"].headers.get("Authorization").map(String::as_str), Some("Bearer tok"));
assert_eq!(user["linear"].command.as_deref(), Some("npx"));
}
#[test]
fn apply_save_json_accepts_mcp_servers_map_and_single_server_object() {
let mut user = BTreeMap::new();
let mut workspace = BTreeMap::new();
let names = apply_save_json(
&mut user,
&mut workspace,
true,
McpScope::User,
r#"{"mcpServers":{"playwright":{"command":"npx","args":["@playwright/mcp@latest"]}}}"#,
None,
vec!["copilot".into(), "claude".into()],
)
.unwrap();
assert_eq!(names, vec!["playwright".to_string()]);
assert_eq!(user["playwright"].agents, vec!["copilot".to_string(), "claude".to_string()]);
let single = apply_save_json(
&mut user,
&mut workspace,
true,
McpScope::Workspace,
r#"{"type":"sse","serverUrl":"https://sse.example.com/events"}"#,
Some("events-sse"),
Vec::new(),
)
.unwrap();
assert_eq!(single, vec!["events-sse".to_string()]);
assert_eq!(workspace["events-sse"].transport, McpTransport::Sse);
assert_eq!(workspace["events-sse"].url.as_deref(), Some("https://sse.example.com/events"));
}
}
+198 -3
Переглянути файл
@@ -5,6 +5,15 @@ use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::BTreeMap;
/// Why a task needs the user's attention (native / in-app notify).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AgentAttentionReason {
Finished,
Input,
Failed,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AgentStatus {
@@ -41,12 +50,13 @@ pub struct AgentCapabilities {
pub read_only: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum Isolation {
/// A new git worktree on its own branch.
Worktree,
/// The project's own checkout.
#[default]
Local,
}
@@ -98,6 +108,9 @@ pub struct AgentTask {
// Boxed so that `AgentEvent::Task` stays within clippy's `large_enum_variant` bound on Windows.
#[serde(default)]
pub background: Box<Vec<AgentBackgroundTask>>,
/// 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>,
}
/// A task the agent runs in the background while the conversation goes on.
@@ -123,6 +136,40 @@ pub struct AgentRetry {
pub error: Option<String>,
}
/// Token pricing (Credits per 1M tokens) and context window capacity for one tier.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentTokenPricing {
pub input: f64,
pub output: f64,
#[serde(default)]
#[specta(optional)]
pub cache_read: Option<f64>,
#[serde(default)]
#[specta(optional)]
pub cache_write: Option<f64>,
#[serde(default)]
#[specta(optional)]
pub context_tokens: Option<u32>,
}
/// Pricing and context-tier metadata attached to a model [`AgentConfigValue`].
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentModelPricing {
/// `"low"`, `"medium"`, `"high"`, or `"very_high"`.
#[serde(default)]
#[specta(optional)]
pub cost_tier: Option<String>,
/// Request-based billing multiplier (e.g. `1.0`, `0.33`, `3.0`), when applicable.
#[serde(default)]
#[specta(optional)]
pub multiplier: Option<f64>,
/// Token pricing keyed by context tier (`"default"`, `"long_context"`).
#[serde(default)]
pub tiers: BTreeMap<String, AgentTokenPricing>,
}
/// One value of a select-type session setting.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -130,6 +177,18 @@ pub struct AgentConfigValue {
pub value: String,
pub name: String,
pub description: Option<String>,
/// Relative cost category from ACP `_meta` (`copilotPriceCategory`, e.g. `low`, `medium`, `high`, `very_high`).
#[serde(default)]
#[specta(optional)]
pub cost_category: Option<String>,
/// Usage multiplier from ACP `_meta` (`copilotUsage`, e.g. `1x`, `0x`, `3x`).
#[serde(default)]
#[specta(optional)]
pub usage_multiplier: Option<String>,
/// Detailed per-tier token pricing from `_meta.pricing` when available.
#[serde(default)]
#[specta(optional)]
pub pricing: Option<Box<AgentModelPricing>>,
}
/// How a setting is changed.
@@ -155,6 +214,10 @@ pub struct AgentConfigOption {
/// ACP category: `model`, `mode`, `thought_level`, or agent-specific.
pub category: Option<String>,
pub current: Option<String>,
/// Initial default value reported by the agent, preserved across session updates for Reset.
#[serde(default)]
#[specta(optional)]
pub default_value: Option<String>,
pub values: Vec<AgentConfigValue>,
pub via: AgentConfigVia,
}
@@ -316,6 +379,59 @@ pub struct AgentQuestionOption {
pub preview: Option<String>,
}
/// A form the agent asks the user to fill in (ACP `elicitation/create`, form mode).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentForm {
pub fields: Vec<AgentFormField>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentFormField {
/// The property name the answer is keyed by.
pub name: String,
pub title: String,
#[serde(default)]
pub description: String,
#[serde(default)]
pub required: bool,
pub kind: AgentFormFieldKind,
/// The choices of a `choice` or `choices` field.
#[serde(default)]
pub options: Vec<AgentFormOption>,
/// The initial answer: option values, a text, a number, or `true` / `false`.
#[serde(default)]
pub default: Vec<String>,
/// Bounds: the number of a `number` / `integer`, the length of a `text`, the count of `choices`.
#[serde(default)]
pub min: Option<f64>,
#[serde(default)]
pub max: Option<f64>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AgentFormFieldKind {
Text,
Number,
Integer,
Boolean,
/// One of `options`.
Choice,
/// Any of `options`.
Choices,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentFormOption {
pub value: String,
pub label: String,
#[serde(default)]
pub description: String,
}
/// One item of a task's conversation.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(tag = "type", rename_all = "camelCase", rename_all_fields = "camelCase")]
@@ -396,6 +512,10 @@ pub enum AgentEntry {
/// of question to answer instead of an option.
#[serde(default)]
questions: Vec<AgentQuestion>,
/// Set when the agent asks for a form (ACP elicitation); answered with a JSON object of
/// field name to its values, `decline`, or nothing to cancel.
#[serde(default)]
form: Option<AgentForm>,
/// Name of the chosen option, or `None` while pending. Cancelled requests read "Cancelled".
chosen: Option<String>,
},
@@ -476,7 +596,7 @@ pub struct AgentProbe {
pub error: Option<String>,
}
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct NewAgentTask {
/// Validated by the host; defaults to the window project root.
@@ -489,6 +609,9 @@ pub struct NewAgentTask {
pub isolation: Isolation,
/// Branch to start the worktree from; the current branch when `None`.
pub base: Option<String>,
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
#[serde(default)]
pub mcp_overrides: BTreeMap<String, bool>,
}
/// A file the task changed: against [`AgentTask::base_commit`], or against `HEAD` in the
@@ -560,7 +683,7 @@ pub struct AgentModelCatalog {
pub enum AgentEvent {
/// A task was created or its metadata changed.
Task {
task: AgentTask,
task: Box<AgentTask>,
},
Removed {
id: String,
@@ -597,6 +720,12 @@ pub enum AgentEvent {
},
/// The installed or configured agent providers changed.
Providers,
/// The task needs attention once (finished turn, explicit input, or failure).
Attention {
task: String,
event_id: String,
reason: AgentAttentionReason,
},
}
pub use ide_core::settings::{AgentMcpServer, McpTransport};
@@ -634,6 +763,9 @@ pub struct McpServer {
/// Agent provider ids this server is enabled for; empty means enabled for all agents.
#[serde(default)]
pub agents: Vec<String>,
/// True when this Workspace server was added outside OpenIDEA and has not been approved yet.
#[serde(default)]
pub unapproved: bool,
}
/// Payload for creating or updating a user or workspace MCP server.
@@ -666,6 +798,69 @@ fn default_true() -> bool {
true
}
/// 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")]
pub struct McpExternalSource {
/// Stable source identifier (e.g. `"copilot-cli"`, `"jetbrains-air"`, `"claude-code"`, `"cursor"`, `"workspace-mcp"`, `"vscode-mcp"`).
pub id: String,
/// Human-readable source label (e.g. `"GitHub Copilot CLI"`).
pub label: String,
/// Absolute path of the discovered configuration file.
pub path: IpcPath,
/// Suggested target scope when importing this source into OpenIDEA settings.
pub suggested_scope: McpScope,
/// Agent provider ID this external CLI reads natively (`Some("copilot")`, `Some("claude")`, `Some("cursor")`, or `None`).
pub native_provider: Option<String>,
/// Servers found inside this external configuration file (values omitted for safety; imported directly on the host).
pub servers: Vec<McpDiscoveredServer>,
}
/// Summary of one server discovered inside an external MCP configuration file.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpDiscoveredServer {
pub name: String,
pub transport: McpTransport,
pub enabled: bool,
pub command: Option<String>,
pub args: Vec<String>,
pub url: Option<String>,
/// Environment variable names declared on this server (values stay on the host).
pub env_keys: Vec<String>,
/// HTTP header names declared on this server (values stay on the host).
pub header_keys: Vec<String>,
}
/// Selection of one server from an external MCP configuration source to import.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpImportSelection {
pub source_id: String,
pub name: String,
}
/// One tool advertised by an MCP server during `tools/list`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpToolSummary {
pub name: String,
pub description: Option<String>,
}
/// Result of testing/probing an MCP server (`initialize` + `tools/list`).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpProbeResult {
pub ok: bool,
pub server_name: Option<String>,
pub server_version: Option<String>,
pub protocol_version: Option<String>,
pub tools: Vec<McpToolSummary>,
pub duration_ms: u32,
pub error: Option<String>,
}
/// Payload for creating a custom ACP agent (always the ACP driver); the id
/// becomes the `<config>/agents/<id>.toml` file name.
#[derive(Clone, Debug, Deserialize, Type)]
File diff suppressed because it is too large. Load diff
+841
Переглянути файл
@@ -0,0 +1,841 @@
//! Model catalog, effort levels, context-window tiers, and token pricing from
//! `copilot --headless --stdio` (`models.list` + `models.listTokenPriceUnits`).
use crate::model::{AgentModelPricing, AgentTokenPricing};
use serde_json::{Value, json};
use std::collections::{BTreeMap, HashMap};
pub(super) const MODEL: &str = "model";
pub(super) const EFFORT: &str = "reasoning_effort";
pub(super) const CONTEXT_TIER: &str = "context_tier";
pub(super) const MODE: &str = "mode";
pub(super) const ALLOW_ALL: &str = "allow_all";
const BATCH_TOKENS: f64 = 1_000_000.0;
const NANO_AIU_PER_CREDIT: f64 = 1_000_000_000.0;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Mode {
Agent,
Plan,
Autopilot,
}
impl Mode {
pub const ALL: [Mode; 3] = [Mode::Agent, Mode::Plan, Mode::Autopilot];
pub fn id(self) -> &'static str {
match self {
Mode::Agent => "agent",
Mode::Plan => "plan",
Mode::Autopilot => "autopilot",
}
}
pub fn wire(self) -> &'static str {
match self {
Mode::Agent => "interactive",
Mode::Plan => "plan",
Mode::Autopilot => "autopilot",
}
}
pub fn name(self) -> &'static str {
match self {
Mode::Agent => "Agent",
Mode::Plan => "Plan",
Mode::Autopilot => "Autopilot",
}
}
pub fn description(self) -> &'static str {
match self {
Mode::Agent => "Default agent mode for conversational interactions",
Mode::Plan => "Plan mode for creating and executing multi-step plans",
Mode::Autopilot => "Autonomous mode that enables allow-all and runs until task completion",
}
}
pub fn parse(value: &str) -> Option<Mode> {
let short = value.rsplit(['#', '/']).next().unwrap_or(value);
match short {
"agent" | "interactive" => Some(Mode::Agent),
"plan" => Some(Mode::Plan),
"autopilot" => Some(Mode::Autopilot),
_ => None,
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub(super) struct ContextTierChoice {
pub id: &'static str,
pub label: String,
pub tokens: u32,
pub description: &'static str,
}
#[derive(Clone, Debug, PartialEq)]
pub(super) struct ModelEntry {
pub id: String,
pub name: String,
pub description: Option<String>,
pub is_default: bool,
pub default_effort: Option<String>,
pub efforts: Vec<String>,
pub context_tiers: Vec<ContextTierChoice>,
pub default_context_tokens: Option<u32>,
pub max_context_tokens: Option<u32>,
pub pricing: Option<AgentModelPricing>,
}
impl ModelEntry {
/// Copilot's default reasoning effort for this model: user setting (`effortLevel`) when
/// supported, otherwise the model's `defaultReasoningEffort`, `"medium"`, or first listed.
pub fn default_effort<'a>(&'a self, user_default: Option<&str>) -> Option<&'a str> {
if let Some(wanted) = user_default
&& let Some(found) = self.efforts.iter().find(|e| e.as_str() == wanted)
{
return Some(found.as_str());
}
if let Some(model_def) = self.default_effort.as_deref()
&& let Some(found) = self.efforts.iter().find(|e| e.as_str() == model_def)
{
return Some(found.as_str());
}
self.efforts.iter().find(|e| e.as_str() == "medium").or_else(|| self.efforts.first()).map(String::as_str)
}
/// Copilot's default context-window tier for this model: user setting (`contextTier`) when
/// supported, otherwise `"default"` (`200K`), or first listed.
pub fn default_context_tier(&self, user_default: Option<&str>) -> Option<&'static str> {
if let Some(wanted) = user_default
&& let Some(found) = self.context_tiers.iter().find(|t| t.id == wanted)
{
return Some(found.id);
}
self.context_tiers.iter().find(|t| t.id == "default").or_else(|| self.context_tiers.first()).map(|t| t.id)
}
/// Active context window capacity in tokens for `tier`.
pub fn context_tokens(&self, tier: Option<&str>) -> Option<u32> {
if let Some(tier) = tier
&& let Some(found) = self.context_tiers.iter().find(|t| t.id == tier)
{
return Some(found.tokens);
}
self.context_tiers
.iter()
.find(|t| t.id == "default")
.or_else(|| self.context_tiers.first())
.map(|t| t.tokens)
.or(self.default_context_tokens)
.or(self.max_context_tokens)
}
}
/// Copilot's own configured defaults from `user.settings.get` (`~/.copilot/config.json`)
/// and optional CLI launch flags (`--model`, `--effort`, `--context`, `--allow-all`).
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub(super) struct UserDefaults {
pub model: Option<String>,
pub effort: Option<String>,
pub context_tier: Option<String>,
pub mode: Option<Mode>,
pub allow_all: Option<bool>,
}
impl UserDefaults {
pub fn from_rpc_and_args(settings_rpc: Option<&Value>, args: &[String]) -> Self {
let mut out = Self::default();
if let Some(res) = settings_rpc {
out.model = setting_str(res, "model");
out.effort = setting_str(res, "effortLevel").or_else(|| setting_str(res, "reasoningEffort"));
out.context_tier = setting_str(res, "contextTier");
out.mode = setting_str(res, "defaultMode").and_then(|m| Mode::parse(&m));
out.allow_all = setting_str(res, "defaultPermissionMode").and_then(|p| match p.as_str() {
"allow-all" | "allow_all" | "bypass" | "autopilot" => Some(true),
"manual" => Some(false),
_ => None,
});
}
let mut iter = args.iter().peekable();
while let Some(arg) = iter.next() {
let s = arg.as_str();
if s == "--allow-all" || s == "--yolo" {
out.allow_all = Some(true);
} else if let Some(v) = flag_val(s, "--model", &mut iter) {
out.model = Some(v);
} else if let Some(v) =
flag_val(s, "--effort", &mut iter).or_else(|| flag_val(s, "--reasoning-effort", &mut iter))
{
out.effort = Some(v);
} else if let Some(v) = flag_val(s, "--context", &mut iter) {
out.context_tier = Some(v);
}
}
out
}
}
fn setting_str(res: &Value, key: &str) -> Option<String> {
let settings = res.get("settings");
let raw = settings
.and_then(|s| s.get(key))
.and_then(|entry| entry.get("value").or(Some(entry)))
.or_else(|| res.get(key))?;
raw.as_str().map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned)
}
fn flag_val<'a>(
arg: &'a str,
flag: &str,
iter: &mut std::iter::Peekable<std::slice::Iter<'a, String>>,
) -> Option<String> {
if arg == flag {
return iter.next().map(|v| v.trim()).filter(|v| !v.is_empty()).map(str::to_owned);
}
let prefix = format!("{flag}=");
arg.strip_prefix(&prefix).map(str::trim).filter(|v| !v.is_empty()).map(str::to_owned)
}
#[derive(Clone, Debug, PartialEq)]
pub(super) struct Settings {
pub model: String,
pub effort: Option<String>,
pub context_tier: Option<String>,
pub mode: Mode,
pub allow_all: bool,
defaults: UserDefaults,
/// Explicit per-session user overrides; `None` means track Copilot's default for each model.
explicit_effort: Option<String>,
explicit_context_tier: Option<String>,
}
impl Settings {
pub fn new(models: &[ModelEntry], defaults: &UserDefaults) -> Self {
let model = defaults
.model
.as_deref()
.filter(|id| models.iter().any(|m| m.id == *id))
.or_else(|| models.iter().find(|m| m.is_default && m.id != "auto").map(|m| m.id.as_str()))
.or_else(|| models.iter().find(|m| m.id != "auto").map(|m| m.id.as_str()))
.or_else(|| models.first().map(|m| m.id.as_str()))
.unwrap_or("auto")
.to_owned();
let mode = defaults.mode.unwrap_or(Mode::Agent);
let allow_all = defaults.allow_all.unwrap_or(false) || mode == Mode::Autopilot;
let mut s = Self {
model,
effort: None,
context_tier: None,
mode,
allow_all,
defaults: defaults.clone(),
explicit_effort: None,
explicit_context_tier: None,
};
s.fit_to_model(models);
s
}
pub fn fit_to_model(&mut self, models: &[ModelEntry]) {
let Some(m) = models.iter().find(|m| m.id == self.model) else {
self.effort = None;
self.context_tier = None;
return;
};
self.effort = if m.efforts.is_empty() {
None
} else if let Some(wanted) = self.explicit_effort.as_deref().filter(|w| m.efforts.iter().any(|e| e == *w)) {
Some(wanted.to_owned())
} else {
m.default_effort(self.defaults.effort.as_deref()).map(str::to_owned)
};
self.context_tier = if m.context_tiers.is_empty() {
None
} else if let Some(wanted) =
self.explicit_context_tier.as_deref().filter(|w| m.context_tiers.iter().any(|t| t.id == *w))
{
Some(wanted.to_owned())
} else {
m.default_context_tier(self.defaults.context_tier.as_deref()).map(str::to_owned)
};
}
pub fn set(&mut self, models: &[ModelEntry], option: &str, value: &str) -> Result<(), String> {
match option {
MODEL => {
if !models.is_empty() && !models.iter().any(|m| m.id == value) && value != self.model {
return Err(format!("unknown model {value}"));
}
self.model = value.to_owned();
self.fit_to_model(models);
}
EFFORT => {
let m = models.iter().find(|m| m.id == self.model);
if !m.is_some_and(|m| m.efforts.iter().any(|e| e == value)) {
return Err(format!("{} has no reasoning effort {value}", self.model));
}
self.effort = Some(value.to_owned());
self.explicit_effort = Some(value.to_owned());
}
CONTEXT_TIER => {
let m = models.iter().find(|m| m.id == self.model);
if !m.is_some_and(|m| m.context_tiers.iter().any(|t| t.id == value)) {
return Err(format!("{} has no context tier {value}", self.model));
}
self.context_tier = Some(value.to_owned());
self.explicit_context_tier = Some(value.to_owned());
}
MODE => {
let mode = Mode::parse(value).ok_or_else(|| format!("unknown mode {value}"))?;
self.mode = mode;
if mode == Mode::Autopilot {
self.allow_all = true;
}
}
ALLOW_ALL => match value {
"on" | "true" => self.allow_all = true,
"off" | "false" => self.allow_all = false,
_ => return Err(format!("unknown allow_all value {value}")),
},
_ => return Err(format!("unknown setting {option}")),
}
Ok(())
}
pub fn active_context_tokens(&self, models: &[ModelEntry]) -> Option<u32> {
models.iter().find(|m| m.id == self.model).and_then(|m| m.context_tokens(self.context_tier.as_deref()))
}
}
/// Parses `models.list` + optional `models.listTokenPriceUnits` into catalog entries,
/// prepending `"auto"` when not already in the list.
pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<ModelEntry> {
let units = parse_price_units(price_units);
let raw = list
.get("models")
.or_else(|| list.get("data"))
.and_then(Value::as_array)
.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() {
out.push(ModelEntry {
id: "auto".into(),
name: "Auto".into(),
description: Some("Let Copilot pick the best model".into()),
is_default: false,
default_effort: None,
efforts: Vec::new(),
context_tiers: Vec::new(),
default_context_tokens: None,
max_context_tokens: None,
pricing: None,
});
}
for m in raw {
if let Some(entry) = parse_model(m, &units) {
out.push(entry);
}
}
out
}
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)
|| m.get("modelPickerEnabled").and_then(Value::as_bool) == Some(false)
{
return None;
}
let name = str_of(m, "name")
.or_else(|| str_of(m, "label"))
.or_else(|| str_of(m, "displayName"))
.filter(|s| !s.is_empty())
.unwrap_or(&id)
.to_owned();
let mut efforts = parse_efforts(m);
efforts.sort_by_key(|e| effort_rank(e));
efforts.dedup();
let limits = m.pointer("/capabilities/limits");
let max_prompt =
limits.and_then(|l| u32_of(l, "max_prompt_tokens").or_else(|| u32_of(l, "maxPromptTokens"))).filter(|&n| n > 0);
let max_window = limits
.and_then(|l| u32_of(l, "max_context_window_tokens").or_else(|| u32_of(l, "maxContextWindowTokens")))
.filter(|&n| n > 0);
let billing = m.get("billing");
let multiplier = billing.and_then(|b| f64_of(b, "multiplier"));
let raw_category = str_of(m, "modelPickerPriceCategory")
.or_else(|| str_of(m, "model_picker_price_category"))
.or_else(|| str_of(m, "priceCategory"))
.or_else(|| str_of(m, "price_category"))
.or_else(|| billing.and_then(|b| str_of(b, "priceCategory").or_else(|| str_of(b, "price_category"))));
let mut cost_tier = raw_category.and_then(normalize_cost_tier).map(str::to_owned);
let token_prices = billing.and_then(|b| b.get("token_prices").or_else(|| b.get("tokenPrices")));
let unit = units.get(&id).copied().unwrap_or(PriceUnit::Credits);
let (mut tiers, default_max, long_max) = parse_token_prices(token_prices, max_prompt, max_window, unit);
let mut context_tiers = Vec::new();
if let (Some(def_tokens), Some(long_tokens)) = (default_max, long_max)
&& def_tokens < long_tokens
{
context_tiers.push(ContextTierChoice {
id: "default",
label: format_tokens(def_tokens),
tokens: def_tokens,
description: "Default recommended context size",
});
context_tiers.push(ContextTierChoice {
id: "long_context",
label: format_tokens(long_tokens),
tokens: long_tokens,
description: "Maximum context window for longer sessions",
});
}
if cost_tier.is_none()
&& let Some(def) = tiers.get("default")
{
cost_tier = Some(infer_cost_tier(def.output).to_owned());
}
if let Some(def_tokens) = default_max.or(max_window).or(max_prompt)
&& let Some(def) = tiers.get_mut("default")
&& def.context_tokens.is_none()
{
def.context_tokens = Some(def_tokens);
}
if let Some(long_tokens) = long_max
&& let Some(long) = tiers.get_mut("long_context")
{
long.context_tokens = Some(long_tokens);
}
let pricing = (!tiers.is_empty() || cost_tier.is_some() || multiplier.is_some()).then_some(AgentModelPricing {
cost_tier,
multiplier,
tiers,
});
let description = multiplier
.map(|mul| {
let clean = round6(mul);
if (clean - clean.round()).abs() < 1e-6 {
format!("{}x", clean.round() as i64)
} else {
format!("{clean}x")
}
})
.or_else(|| str_of(m, "description").filter(|d| !d.is_empty() && *d != name).map(str::to_owned))
.or_else(|| (id == "auto").then(|| "Let Copilot pick the best model".to_owned()));
let is_default = m
.get("is_chat_default")
.or_else(|| m.get("isChatDefault"))
.or_else(|| m.get("isDefault"))
.and_then(Value::as_bool)
.unwrap_or(false);
let default_effort = str_of(m, "defaultReasoningEffort")
.or_else(|| str_of(m, "default_reasoning_effort"))
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned);
Some(ModelEntry {
id,
name,
description,
is_default,
default_effort,
efforts,
context_tiers,
default_context_tokens: default_max.or(max_window).or(max_prompt),
max_context_tokens: long_max.or(default_max).or(max_window).or(max_prompt),
pricing,
})
}
fn parse_efforts(m: &Value) -> Vec<String> {
let arr = m
.get("supportedReasoningEfforts")
.or_else(|| m.get("supported_reasoning_efforts"))
.or_else(|| m.pointer("/capabilities/supports/reasoning_effort"))
.or_else(|| m.pointer("/capabilities/supports/reasoningEffort"));
arr.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|v| v.as_str().filter(|s| !s.is_empty()).map(str::to_owned))
.collect()
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum PriceUnit {
Credits,
NanoAiu,
}
fn parse_price_units(raw: Option<&Value>) -> HashMap<String, PriceUnit> {
let mut out = HashMap::new();
let Some(raw) = raw else { return out };
let unit_of = |s: &str| {
if s.eq_ignore_ascii_case("nano_aiu") || s.eq_ignore_ascii_case("nanoaiu") || s.contains("nano") {
Some(PriceUnit::NanoAiu)
} else if s.to_ascii_lowercase().contains("credit") || s.eq_ignore_ascii_case("aic") {
Some(PriceUnit::Credits)
} else {
None
}
};
if let Some(map) =
raw.get("units").or_else(|| raw.get("priceUnits")).or_else(|| raw.get("models")).and_then(Value::as_object)
{
for (k, v) in map {
let u = v
.as_str()
.and_then(unit_of)
.or_else(|| v.get("unit").or_else(|| v.get("priceUnit")).and_then(Value::as_str).and_then(unit_of));
if let Some(u) = u {
out.insert(k.clone(), u);
}
}
}
for key in ["units", "priceUnits", "models"] {
if let Some(arr) = raw.get(key).and_then(Value::as_array) {
for item in arr {
let id = str_of(item, "modelId").or_else(|| str_of(item, "id"));
let u = str_of(item, "unit").or_else(|| str_of(item, "priceUnit")).and_then(unit_of);
if let (Some(id), Some(u)) = (id, u) {
out.insert(id.to_owned(), u);
}
}
}
}
out
}
fn parse_token_prices(
tp: Option<&Value>,
max_prompt: Option<u32>,
max_window: Option<u32>,
unit: PriceUnit,
) -> (BTreeMap<String, AgentTokenPricing>, Option<u32>, Option<u32>) {
let mut tiers = BTreeMap::new();
let Some(tp) = tp else {
return (tiers, None, max_window.or(max_prompt));
};
let batch =
f64_of(tp, "batch_size").or_else(|| f64_of(tp, "batchSize")).filter(|&b| b > 0.0).unwrap_or(BATCH_TOKENS);
let batch_scale = BATCH_TOKENS / batch;
let unit_scale = match unit {
PriceUnit::Credits => 1.0,
PriceUnit::NanoAiu => 1.0 / NANO_AIU_PER_CREDIT,
};
let scale = batch_scale * unit_scale;
let parse_tier = |node: &Value| -> Option<(AgentTokenPricing, Option<u32>)> {
let input = f64_of(node, "input_price").or_else(|| f64_of(node, "inputPrice"))?;
let output = f64_of(node, "output_price").or_else(|| f64_of(node, "outputPrice"))?;
// Guard against raw nano-AIU numbers even if `listTokenPriceUnits` was unavailable.
let effective = if unit == PriceUnit::Credits && (input >= 10_000_000.0 || output >= 10_000_000.0) {
scale / NANO_AIU_PER_CREDIT
} else {
scale
};
let cache_read = f64_of(node, "cache_read_price")
.or_else(|| f64_of(node, "cacheReadPrice"))
.or_else(|| f64_of(node, "cache_price"))
.or_else(|| f64_of(node, "cachePrice"))
.map(|v| round6(v * effective));
let cache_write = f64_of(node, "cache_write_price")
.or_else(|| f64_of(node, "cacheWritePrice"))
.map(|v| round6(v * effective));
let ctx = u32_of(node, "max_prompt_tokens")
.or_else(|| u32_of(node, "maxPromptTokens"))
.or_else(|| u32_of(node, "context_max"))
.or_else(|| u32_of(node, "contextMax"))
.filter(|&n| n > 0);
Some((
AgentTokenPricing {
input: round6(input * effective),
output: round6(output * effective),
cache_read,
cache_write,
context_tokens: ctx,
},
ctx,
))
};
// Both CAPI `/models` (`token_prices.default` + `token_prices.long_context`) and
// `copilot --headless` `models.list` (top-level `tokenPrices` + `tokenPrices.longContext`)
// share the same per-tier fields.
let def_node = tp.get("default").unwrap_or(tp);
let mut def_max = None;
if let Some((def_pricing, ctx)) = parse_tier(def_node) {
def_max = ctx;
tiers.insert("default".into(), def_pricing);
}
let long_node = tp.get("longContext").or_else(|| tp.get("long_context"));
let mut long_max = None;
if let Some(long_node) = long_node
&& let Some((mut long_pricing, ctx)) = parse_tier(long_node)
{
// Use the full context window capacity (`1_000_000`) when available so models whose
// `max_prompt_tokens` deduct `max_output_tokens` (e.g. `872_000` = `1M - 128K` on
// GPT-6 Sol, `936_000` = `1M - 64K` on Gemini 4 Carbon) display cleanly as `1M`.
let cap = match (ctx, max_window) {
(Some(c), Some(w)) if w >= c => Some(w),
(Some(c), _) => Some(c),
(None, w) => w.or(max_prompt),
};
long_max = cap;
long_pricing.context_tokens = cap;
tiers.insert("long_context".into(), long_pricing);
} else if let (Some(d), Some(p)) = (def_max, max_prompt)
&& d < p
&& let Some(def) = tiers.get("default").cloned()
{
let cap = max_window.filter(|&w| w >= p).unwrap_or(p);
long_max = Some(cap);
tiers.insert("long_context".into(), AgentTokenPricing { context_tokens: Some(cap), ..def });
}
(tiers, def_max, long_max)
}
fn normalize_cost_tier(raw: &str) -> Option<&'static str> {
match raw.trim().to_ascii_lowercase().as_str() {
"lightweight" | "low" => Some("low"),
"versatile" | "medium" | "standard" => Some("medium"),
"powerful" | "high" | "premium" => Some("high"),
"very_high" | "veryhigh" => Some("very_high"),
_ => None,
}
}
fn infer_cost_tier(output_credits_per_1m: f64) -> &'static str {
if output_credits_per_1m < 300.0 {
"low"
} else if output_credits_per_1m <= 1500.0 {
"medium"
} else {
"high"
}
}
/// Formats token capacity matching VS Code (`200000` → `"200K"`, `1000000` → `"1M"`).
pub(super) fn format_tokens(tokens: u32) -> String {
if tokens >= 1_000_000 {
let m = (f64::from(tokens) / 1_000_000.0 * 10.0).floor() / 10.0;
if (m - m.round()).abs() < 1e-6 { format!("{}M", m.round() as u32) } else { format!("{m:.1}M") }
} else if tokens > 900_000 {
"1M".into()
} else if tokens >= 1_000 {
format!("{}K", (f64::from(tokens) / 1_000.0).round() as u32)
} else {
tokens.to_string()
}
}
pub(super) fn effort_rank(effort: &str) -> u8 {
match effort {
"none" => 0,
"minimal" => 1,
"low" => 2,
"medium" => 3,
"high" => 4,
"xhigh" | "extra_high" => 5,
"max" => 6,
_ => 3,
}
}
pub(super) fn effort_label(effort: &str) -> (&'static str, &'static str) {
match effort {
"none" => ("None", "No additional reasoning; fastest responses."),
"minimal" => ("Minimal", "Least reasoning; fastest responses."),
"low" => ("Low", "Minimal reasoning before responding."),
"medium" => ("Medium", "Balanced reasoning and speed."),
"high" => ("High", "More thorough reasoning; slower responses."),
"xhigh" => ("Extra High", "Extensive reasoning for the hardest problems."),
"max" => ("Max", "Maximum reasoning; slowest but most thorough."),
_ => ("Default", ""),
}
}
/// ACP `configOptions` for the active session settings.
pub(super) fn config_options(models: &[ModelEntry], s: &Settings) -> Value {
let mut model_values: Vec<Value> = models.iter().map(model_option_value).collect();
if !s.model.is_empty() && !models.iter().any(|m| m.id == s.model) {
model_values.push(json!({ "value": s.model, "name": s.model }));
}
let mut out = Vec::new();
if !model_values.is_empty() {
out.push(json!({
"id": MODEL,
"name": "Model",
"category": "model",
"type": "select",
"currentValue": s.model,
"options": model_values,
}));
}
if let Some(m) = models.iter().find(|m| m.id == s.model) {
if let (Some(opt), Some(current)) = (effort_option_for(m, s.effort.as_deref()), s.effort.as_deref()) {
let mut o = opt;
o["currentValue"] = json!(current);
out.push(o);
}
if let (Some(opt), Some(current)) =
(context_tier_option_for(m, s.context_tier.as_deref()), s.context_tier.as_deref())
{
let mut o = opt;
o["currentValue"] = json!(current);
out.push(o);
}
}
out.push(json!({
"id": MODE,
"name": "Mode",
"category": "mode",
"type": "select",
"currentValue": s.mode.id(),
"options": Mode::ALL.iter().map(|m| json!({
"value": m.id(),
"name": m.name(),
"description": m.description(),
})).collect::<Vec<_>>(),
}));
out.push(json!({
"id": ALLOW_ALL,
"name": "Allow All",
"category": "permissions",
"type": "select",
"currentValue": if s.allow_all { "on" } else { "off" },
"options": [
{ "value": "on", "name": "On", "description": "Automatically approve all tool, path, and URL requests" },
{ "value": "off", "name": "Off", "description": "Require approval for tool, path, and URL requests" },
],
}));
Value::Array(out)
}
/// Per-model options (`[reasoning_effort?, context_tier?]`) for every model in `models`,
/// each defaulted to Copilot's own defaults (respecting `user.settings.get` / CLI flags).
pub(super) fn per_model_options(models: &[ModelEntry], defaults: &UserDefaults) -> Vec<(String, Vec<Value>)> {
models
.iter()
.map(|m| {
let mut opts = Vec::new();
if let Some(effort) = effort_option_for(m, m.default_effort(defaults.effort.as_deref())) {
opts.push(effort);
}
if let Some(ctx) = context_tier_option_for(m, m.default_context_tier(defaults.context_tier.as_deref())) {
opts.push(ctx);
}
(m.id.clone(), opts)
})
.collect()
}
fn model_option_value(m: &ModelEntry) -> Value {
let mut v = json!({ "value": m.id, "name": m.name });
if let Some(d) = &m.description {
v["description"] = json!(d);
}
if let Some(pricing) = &m.pricing {
let mut meta = serde_json::Map::new();
meta.insert("pricing".into(), json!(pricing));
if let Some(cat) = &pricing.cost_tier {
meta.insert("copilotPriceCategory".into(), json!(cat));
}
v["_meta"] = Value::Object(meta);
}
v
}
fn effort_option_for(m: &ModelEntry, current: Option<&str>) -> Option<Value> {
if m.efforts.len() <= 1 && m.efforts.is_empty() {
return None;
}
let default = current.filter(|c| m.efforts.iter().any(|e| e == *c)).or_else(|| m.default_effort(None))?;
let options: Vec<Value> = m
.efforts
.iter()
.map(|e| {
let (label, desc) = effort_label(e);
let name = if label == "Default" { capitalize(e) } else { label.to_owned() };
let mut item = json!({ "value": e, "name": name });
if !desc.is_empty() {
item["description"] = json!(desc);
}
item
})
.collect();
Some(json!({
"id": EFFORT,
"name": "Effort Level",
"description": "How much reasoning the model performs before responding. Higher effort can improve quality at the cost of speed.",
"category": "thought_level",
"type": "select",
"currentValue": default,
"options": options,
}))
}
fn context_tier_option_for(m: &ModelEntry, current: Option<&str>) -> Option<Value> {
if m.context_tiers.len() < 2 {
return None;
}
let default =
current.filter(|c| m.context_tiers.iter().any(|t| t.id == *c)).or_else(|| m.default_context_tier(None))?;
let options: Vec<Value> = m
.context_tiers
.iter()
.map(|t| {
json!({
"value": t.id,
"name": t.label,
"description": t.description,
})
})
.collect();
Some(json!({
"id": CONTEXT_TIER,
"name": "Context Size",
"description": "Context window size for this model.",
"category": "model_config",
"type": "select",
"currentValue": default,
"options": options,
}))
}
fn capitalize(s: &str) -> String {
let mut chars = s.chars();
chars.next().map(|c| c.to_uppercase().chain(chars).collect()).unwrap_or_default()
}
fn round6(n: f64) -> f64 {
let r = (n * 1_000_000.0).round() / 1_000_000.0;
if r == 0.0 { 0.0 } else { r }
}
fn str_of<'a>(v: &'a Value, key: &str) -> Option<&'a str> {
v.get(key).and_then(Value::as_str)
}
fn f64_of(v: &Value, key: &str) -> Option<f64> {
v.get(key).and_then(Value::as_f64).filter(|n| n.is_finite())
}
fn u32_of(v: &Value, key: &str) -> Option<u32> {
v.get(key).and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok())
}
+540
Переглянути файл
@@ -0,0 +1,540 @@
use super::models::{self, CONTEXT_TIER, EFFORT, MODEL, Mode, Settings, UserDefaults};
use super::{acp_args, acp_fallback_spec, attach, headless_args};
use crate::config;
use crate::provider::Driver;
use ide_jsonrpc::{Framing, Handler, Peer, codes};
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::sync::{Arc, OnceLock};
fn sample_models_list() -> Value {
json!({
"models": [
{
"id": "gemini-4-carbon",
"name": "Gemini 4 Carbon",
"priceCategory": "versatile",
"supportedReasoningEfforts": ["low", "medium", "high"],
"defaultReasoningEffort": "medium",
"capabilities": {
"supports": { "vision": true, "reasoningEffort": true },
"limits": {
"max_context_window_tokens": 1_000_000,
"max_prompt_tokens": 1_000_000,
"max_output_tokens": 64_000
}
},
"billing": {
"is_premium": true,
"multiplier": 1.0,
"token_prices": {
"batch_size": 1_000_000,
"preferred_tier": "default",
"default": {
"input_price": 100.0,
"output_price": 500.0,
"cache_read_price": 10.0,
"cache_write_price": 0.0,
"max_prompt_tokens": 200_000
},
"long_context": {
"input_price": 200.0,
"output_price": 1000.0,
"cache_read_price": 10.0,
"cache_write_price": 0.0,
"max_prompt_tokens": 1_000_000
}
}
}
},
{
"id": "gpt-5.6-sol",
"name": "GPT-5.6 Sol",
"priceCategory": "powerful",
"supportedReasoningEfforts": ["none", "low", "medium", "high", "xhigh", "max"],
"defaultReasoningEffort": "medium",
"capabilities": {
"supports": { "vision": true },
"limits": {
"max_context_window_tokens": 1_000_000,
"max_prompt_tokens": 1_000_000
}
},
"billing": {
"multiplier": 2.0,
"token_prices": {
"batch_size": 1_000_000,
"default": {
"input_price": 250_000_000_000.0,
"output_price": 1_500_000_000_000.0,
"cache_read_price": 25_000_000_000.0,
"cache_write_price": 0.0,
"max_prompt_tokens": 200_000
},
"long_context": {
"input_price": 500_000_000_000.0,
"output_price": 3_000_000_000_000.0,
"cache_read_price": 50_000_000_000.0,
"cache_write_price": 0.0,
"max_prompt_tokens": 1_000_000
}
}
}
},
{
"id": "mai-experimental-internal",
"name": "MAI Experimental",
"priceCategory": "lightweight",
"supportedReasoningEfforts": ["low", "medium"],
"capabilities": {
"limits": {
"max_context_window_tokens": 131_072,
"max_prompt_tokens": 131_072
}
},
"billing": {
"multiplier": 0.33
}
}
]
})
}
fn sample_price_units() -> Value {
json!({
"units": {
"gemini-4-carbon": "ai_credits",
"gpt-5.6-sol": "nano_aiu"
}
})
}
#[test]
fn parses_tiered_context_windows_pricing_and_uses_copilots_own_defaults() {
let catalog = models::parse_catalog(&sample_models_list(), Some(&sample_price_units()));
assert_eq!(
catalog.iter().map(|m| m.id.as_str()).collect::<Vec<_>>(),
["auto", "gemini-4-carbon", "gpt-5.6-sol", "mai-experimental-internal"]
);
let gemini = catalog.iter().find(|m| m.id == "gemini-4-carbon").unwrap();
assert_eq!(gemini.default_effort(None), Some("medium"));
assert_eq!(gemini.default_context_tier(None), Some("default"));
assert_eq!(
gemini.context_tiers.iter().map(|t| (t.id, t.label.as_str(), t.tokens)).collect::<Vec<_>>(),
[("default", "200K", 200_000), ("long_context", "1M", 1_000_000)]
);
let pricing = gemini.pricing.as_ref().unwrap();
assert_eq!(pricing.cost_tier.as_deref(), Some("medium"));
let long_p = &pricing.tiers["long_context"];
assert_eq!(
(long_p.input, long_p.output, long_p.cache_read, long_p.cache_write),
(200.0, 1000.0, Some(10.0), Some(0.0))
);
let def_p = &pricing.tiers["default"];
assert_eq!((def_p.input, def_p.output), (100.0, 500.0));
// Nano-AIU conversion (10^9 nano-AIU = 1 AI Credit).
let sol = catalog.iter().find(|m| m.id == "gpt-5.6-sol").unwrap();
assert_eq!(sol.default_effort(None), Some("medium"));
assert_eq!(sol.default_context_tier(None), Some("default"));
let sol_long = &sol.pricing.as_ref().unwrap().tiers["long_context"];
assert_eq!((sol_long.input, sol_long.output, sol_long.cache_read), (500.0, 3000.0, Some(50.0)));
// Single-window model has no multi-tier `context_tier` toggle.
let mai = catalog.iter().find(|m| m.id == "mai-experimental-internal").unwrap();
assert!(mai.context_tiers.is_empty());
assert_eq!(mai.default_effort(None), Some("medium"));
// Initial settings pick Copilot's own defaults (`medium` effort + `default` 200K context).
let mut s = Settings::new(&catalog, &UserDefaults::default());
assert_eq!(s.model, "gemini-4-carbon");
assert_eq!(s.effort.as_deref(), Some("medium"));
assert_eq!(s.context_tier.as_deref(), Some("default"));
assert_eq!(s.active_context_tokens(&catalog), Some(200_000));
// Switching to GPT-5.6 Sol without an explicit override stays on Copilot's defaults (`medium` + `default`).
s.set(&catalog, MODEL, "gpt-5.6-sol").unwrap();
assert_eq!(s.effort.as_deref(), Some("medium"));
assert_eq!(s.context_tier.as_deref(), Some("default"));
// Explicit session overrides (`xhigh` + `long_context`) stick across models that support them,
// and fall back to Copilot's default when switching to a model that does not.
s.set(&catalog, EFFORT, "xhigh").unwrap();
s.set(&catalog, CONTEXT_TIER, "long_context").unwrap();
assert_eq!(s.active_context_tokens(&catalog), Some(1_000_000));
s.set(&catalog, MODEL, "mai-experimental-internal").unwrap();
assert_eq!(s.effort.as_deref(), Some("medium"));
assert_eq!(s.context_tier, None);
// User settings from `user.settings.get` (1.0.112+ `{ value, default, isDefault }` shape) and CLI flags are honored.
let rpc_settings = json!({
"settings": {
"model": { "value": "gpt-5.6-sol", "default": null, "isDefault": false },
"effortLevel": { "value": "high", "default": null, "isDefault": false },
"contextTier": { "value": "long_context", "default": null, "isDefault": false },
"defaultMode": { "value": "plan", "default": "interactive", "isDefault": false },
}
});
let user_defs = UserDefaults::from_rpc_and_args(Some(&rpc_settings), &[]);
let configured = Settings::new(&catalog, &user_defs);
assert_eq!(configured.model, "gpt-5.6-sol");
assert_eq!(configured.effort.as_deref(), Some("high"));
assert_eq!(configured.context_tier.as_deref(), Some("long_context"));
assert_eq!(configured.mode, Mode::Plan);
// Per-model discovery options preserve pricing on `model` values and emit Copilot's defaults.
let raw = models::config_options(&catalog, &Settings::new(&catalog, &UserDefaults::default()));
let parsed = config::parse_options(&raw);
let model_opt = parsed.iter().find(|o| o.id == MODEL).unwrap();
let gem_val = model_opt.values.iter().find(|v| v.value == "gemini-4-carbon").unwrap();
assert_eq!(gem_val.pricing.as_ref().unwrap().cost_tier.as_deref(), Some("medium"));
assert_eq!(parsed.iter().find(|o| o.id == EFFORT).unwrap().current.as_deref(), Some("medium"));
assert_eq!(parsed.iter().find(|o| o.id == CONTEXT_TIER).unwrap().current.as_deref(), Some("default"));
}
#[test]
fn parses_headless_sdk_models_list_flat_token_prices_and_single_tier_models() {
let sdk_list = json!({
"models": [
{ "id": "auto", "name": "Auto" },
{
"id": "gemini-4-carbon",
"name": "Gemini 4 Carbon",
"modelPickerCategory": "powerful",
"modelPickerPriceCategory": "medium",
"supportedReasoningEfforts": ["low", "medium", "high"],
"capabilities": {
"limits": {
"max_context_window_tokens": 1_000_000,
"max_output_tokens": 64_000,
"max_prompt_tokens": 936_000
}
},
"billing": {
"tokenPrices": {
"inputPrice": 200,
"outputPrice": 1000,
"cachePrice": 10,
"cacheReadPrice": 10,
"cacheWritePrice": 0,
"contextMax": 200_000,
"maxPromptTokens": 200_000,
"batchSize": 1_000_000,
"longContext": {
"inputPrice": 200,
"outputPrice": 1000,
"cachePrice": 10,
"cacheReadPrice": 10,
"cacheWritePrice": 0,
"contextMax": 936_000,
"maxPromptTokens": 936_000
}
}
}
},
{
"id": "gpt-6-sol",
"name": "GPT-6 Sol",
"modelPickerPriceCategory": "medium",
"supportedReasoningEfforts": ["none", "low", "medium", "high", "xhigh", "max"],
"capabilities": {
"limits": {
"max_context_window_tokens": 1_000_000,
"max_output_tokens": 128_000,
"max_prompt_tokens": 872_000
}
},
"billing": {
"tokenPrices": {
"inputPrice": 250,
"outputPrice": 1250,
"contextMax": 272_000,
"maxPromptTokens": 272_000,
"batchSize": 1_000_000,
"longContext": {
"inputPrice": 500,
"outputPrice": 2500,
"contextMax": 872_000,
"maxPromptTokens": 872_000
}
}
}
},
{
"id": "gpt-5.3-codex",
"name": "GPT-5.3-Codex",
"modelPickerPriceCategory": "medium",
"supportedReasoningEfforts": ["low", "medium", "high", "xhigh"],
"capabilities": {
"limits": {
"max_context_window_tokens": 400_000,
"max_output_tokens": 128_000,
"max_prompt_tokens": 272_000
}
},
"billing": {
"tokenPrices": {
"inputPrice": 150,
"outputPrice": 600,
"contextMax": 272_000,
"maxPromptTokens": 272_000,
"batchSize": 1_000_000
}
}
}
]
});
let units = json!({
"units": [
{ "modelId": "gemini-4-carbon", "unit": "ai_credits" },
{ "modelId": "gpt-6-sol", "unit": "ai_credits" },
{ "modelId": "gpt-5.3-codex", "unit": "ai_credits" }
]
});
let catalog = models::parse_catalog(&sdk_list, Some(&units));
let carbon = catalog.iter().find(|m| m.id == "gemini-4-carbon").unwrap();
assert_eq!(
carbon.context_tiers.iter().map(|t| (t.id, t.label.as_str())).collect::<Vec<_>>(),
[("default", "200K"), ("long_context", "1M")]
);
let cp = carbon.pricing.as_ref().unwrap();
assert_eq!(cp.cost_tier.as_deref(), Some("medium"));
assert_eq!((cp.tiers["long_context"].input, cp.tiers["long_context"].output), (200.0, 1000.0));
let sol = catalog.iter().find(|m| m.id == "gpt-6-sol").unwrap();
assert_eq!(
sol.context_tiers.iter().map(|t| (t.id, t.label.as_str())).collect::<Vec<_>>(),
[("default", "272K"), ("long_context", "1M")]
);
let codex = catalog.iter().find(|m| m.id == "gpt-5.3-codex").unwrap();
assert!(codex.context_tiers.is_empty(), "single-tier model must not get a synthetic long_context tier");
}
#[test]
fn headless_and_acp_args_roundtrip_while_preserving_user_flags() {
assert_eq!(headless_args(&["--acp".into()]), vec!["--headless", "--no-auto-update", "--stdio"]);
assert_eq!(
headless_args(&["--log-level".into(), "debug".into(), "--headless".into(), "--stdio".into()]),
vec!["--log-level", "debug", "--headless", "--stdio", "--no-auto-update"]
);
assert_eq!(
acp_args(&[
"--headless".into(),
"--no-auto-update".into(),
"--stdio".into(),
"--context".into(),
"long_context".into()
]),
vec!["--acp", "--context", "long_context"]
);
let spec = crate::provider::builtin_spec("copilot").unwrap();
assert_eq!(spec.driver, Driver::Copilot);
let fallback = acp_fallback_spec(&spec);
assert_eq!(fallback.driver, Driver::Acp);
assert_eq!(fallback.args, vec!["--acp"]);
}
struct FakeCopilotServer {
peer: OnceLock<Peer>,
calls: Mutex<Vec<(String, Value)>>,
}
impl Handler for FakeCopilotServer {
fn on_notification(&self, _method: &str, _params: Value) {}
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
self.calls.lock().push((method.to_owned(), params.clone()));
match method {
"connect" => Ok(json!({ "ok": true, "protocolVersion": 3, "version": "1.0.112" })),
"models.list" => Ok(sample_models_list()),
"models.listTokenPriceUnits" => Ok(sample_price_units()),
"user.settings.get" => Ok(json!({ "settings": { "model": "gemini-4-carbon" } })),
"commands.list" => Ok(json!({ "commands": [{ "name": "compact", "description": "Compact context" }] })),
"skills.discover" => Ok(json!({ "skills": [] })),
"session.create" => Ok(json!({ "sessionId": "cop-sess-1" })),
"session.model.switchTo" => Ok(json!({ "modelId": params["modelId"] })),
"session.mode.set" => Ok(json!({})),
"session.permissions.setApproveAll" => {
assert!(params.get("enabled").and_then(Value::as_bool).is_some());
Ok(json!({ "success": true }))
}
"session.send" => {
if let Some(peer) = self.peer.get().cloned() {
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
std::thread::spawn(move || {
let _ = peer.notify(
"session.event",
json!({
"sessionId": sid,
"event": {
"id": "e1",
"type": "session.usage_info",
"data": { "currentTokens": 42_000, "tokenLimit": 1_000_000 }
}
}),
);
let _ = peer.notify(
"session.event",
json!({
"sessionId": sid,
"event": {
"id": "e2",
"type": "assistant.message_delta",
"data": { "messageId": "m1", "deltaContent": "Hello from 1M context!" }
}
}),
);
let _ = peer.notify(
"session.event",
json!({
"sessionId": sid,
"event": {
"id": "e3",
"type": "session.idle",
"data": { "aborted": false, "mode": "interactive" }
}
}),
);
});
}
Ok(json!({ "messageId": "msg-1" }))
}
_ => Err((codes::METHOD_NOT_FOUND, format!("unexpected {method}"))),
}
}
}
struct CollectUpdates(Mutex<Vec<Value>>);
impl Handler for CollectUpdates {
fn on_notification(&self, method: &str, params: Value) {
if method == "session/update" {
self.0.lock().push(params["update"].clone());
}
}
fn on_request(&self, method: &str, _params: Value) -> Result<Value, (i64, String)> {
Err((codes::METHOD_NOT_FOUND, format!("unexpected {method}")))
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_turns() {
let server = Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()) });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates.clone(), move |events| {
let (a, b) = tokio::io::duplex(1 << 16);
let (ar, aw) = tokio::io::split(a);
let (br, bw) = tokio::io::split(b);
let srv_peer = Peer::connect_framed(br, bw, server_clone.clone(), Framing::ContentLength);
let _ = server_clone.peer.set(srv_peer);
Ok(Peer::connect_framed(ar, aw, events, Framing::ContentLength))
})
.unwrap();
let init: Value = client.request("initialize", json!({}), None).await.unwrap();
assert_eq!(init["agentInfo"]["version"], "1.0.112");
assert_eq!(init["agentCapabilities"]["_meta"]["openidea"]["steer"], true);
let created: Value = client.request("session/new", json!({ "cwd": "/tmp", "mcpServers": [] }), None).await.unwrap();
assert_eq!(created["sessionId"], "cop-sess-1");
// Verify `session.create` sent `"trustWorkingDirectory": "session"`, `gemini-4-carbon`,
// and Copilot's own defaults (`reasoningEffort: "medium"` and `contextTier: "default"`).
{
let calls = server.calls.lock();
let (_, create_params) = calls.iter().find(|(m, _)| m == "session.create").unwrap();
assert_eq!(create_params["trustWorkingDirectory"], "session");
assert_eq!(create_params["model"], "gemini-4-carbon");
assert_eq!(create_params["reasoningEffort"], "medium");
assert_eq!(create_params["contextTier"], "default");
}
// Switch Context Size up to 1M (`long_context`) and Effort to `high` live via `session/set_config_option`.
let _: Value = client
.request(
"session/set_config_option",
json!({
"sessionId": "cop-sess-1",
"configId": "reasoning_effort",
"value": "high"
}),
None,
)
.await
.unwrap();
let switched_1m: Value = client
.request(
"session/set_config_option",
json!({
"sessionId": "cop-sess-1",
"configId": "context_tier",
"value": "long_context"
}),
None,
)
.await
.unwrap();
let opts_1m = config::options_of(&switched_1m);
assert_eq!(opts_1m.iter().find(|o| o.id == "context_tier").unwrap().current.as_deref(), Some("long_context"));
// Run a turn and verify 1M usage_update + streamed message chunk.
let prompt_res: Value = client
.request(
"session/prompt",
json!({
"sessionId": "cop-sess-1",
"prompt": [{ "type": "text", "text": "Explain architecture" }]
}),
None,
)
.await
.unwrap();
assert_eq!(prompt_res["stopReason"], "end_turn");
{
let seen = updates.0.lock();
assert!(
seen.iter().any(|u| u["sessionUpdate"] == "usage_update" && u["size"] == 1_000_000 && u["used"] == 42_000)
);
assert!(
seen.iter().any(
|u| u["sessionUpdate"] == "agent_message_chunk" && u["content"]["text"] == "Hello from 1M context!"
)
);
}
// Switch Context Size back down to 200K (`default`) live via `session/set_config_option`.
let switched: Value = client
.request(
"session/set_config_option",
json!({
"sessionId": "cop-sess-1",
"configId": "context_tier",
"value": "default"
}),
None,
)
.await
.unwrap();
let opts = config::options_of(&switched);
assert_eq!(opts.iter().find(|o| o.id == "context_tier").unwrap().current.as_deref(), Some("default"));
{
let calls = server.calls.lock();
let (_, sw_params) = calls.iter().rfind(|(m, _)| m == "session.model.switchTo").unwrap();
assert_eq!(sw_params["modelId"], "gemini-4-carbon");
assert_eq!(sw_params["reasoningEffort"], "high");
assert_eq!(sw_params["contextTier"], "default");
}
// Switching context_tier immediately emits an updated `usage_update` with `size: 200_000`.
assert!(
updates
.0
.lock()
.iter()
.any(|u| u["sessionUpdate"] == "usage_update" && u["size"] == 200_000 && u["used"] == 42_000)
);
}
+583
Переглянути файл
@@ -0,0 +1,583 @@
//! Pure translations between Copilot headless JSON-RPC payloads (`session.event`,
//! permissions, slash commands, MCP servers) and ACP v1.
use crate::LIMITS_UPDATE;
use serde_json::{Map, Value, json};
use std::collections::{HashMap, HashSet};
use std::path::Path;
const MAX_OUTPUT: usize = 64 * 1024;
#[derive(Default)]
pub(super) struct EventTranslator {
/// Assistant message IDs that already streamed deltas, so final `assistant.message` won't duplicate them.
streamed_messages: HashSet<String>,
/// Tool call metadata captured on `tool.execution_start`, keyed by `toolCallId`.
tools: HashMap<String, ToolInfo>,
/// Subagents started in this session (`toolCallId` → subagent session id).
subagents: HashMap<String, String>,
/// Last reported prompt token count, used when updating context size.
pub last_used_tokens: Option<u32>,
}
#[derive(Clone, Debug)]
struct ToolInfo {
kind: &'static str,
title: String,
locations: Vec<Value>,
output: String,
diffs: Vec<Value>,
}
/// An ACP notification `(session_id, update)` produced from a Copilot `session.event`.
pub(super) struct Translated {
pub updates: Vec<(String, Value)>,
pub terminal: Option<TurnTerminal>,
}
#[derive(Debug, Clone, PartialEq)]
pub(super) enum TurnTerminal {
Idle { aborted: bool },
Error { message: String, data: Option<Value> },
}
impl EventTranslator {
pub fn reset_turn(&mut self) {
self.streamed_messages.clear();
}
pub fn translate(&mut self, main_session: &str, event: &Value, fallback_limit: Option<u32>) -> Translated {
let mut out = Translated { updates: Vec::new(), terminal: None };
let event_type = str_of(event, "type").unwrap_or_default();
let data = event.get("data").unwrap_or(&Value::Null);
let agent_id = str_of(event, "agentId").filter(|s| !s.is_empty());
let target_session =
agent_id.map(|id| format!("{main_session}:sub:{id}")).unwrap_or_else(|| main_session.to_owned());
match event_type {
"assistant.reasoning_delta" => {
let delta = str_of(data, "deltaContent").or_else(|| str_of(data, "content")).unwrap_or_default();
if !delta.is_empty() {
out.updates.push((
target_session,
json!({ "sessionUpdate": "agent_thought_chunk", "content": { "type": "text", "text": delta } }),
));
}
}
"assistant.message_delta" => {
if data.get("parentToolCallId").and_then(Value::as_str).is_some() && agent_id.is_none() {
return out;
}
if let Some(mid) = str_of(data, "messageId") {
self.streamed_messages.insert(mid.to_owned());
}
let delta = str_of(data, "deltaContent").unwrap_or_default();
if !delta.is_empty() {
out.updates.push((
target_session,
json!({ "sessionUpdate": "agent_message_chunk", "content": { "type": "text", "text": delta } }),
));
}
}
"assistant.message" => {
if data.get("parentToolCallId").and_then(Value::as_str).is_some() && agent_id.is_none() {
return out;
}
let already = str_of(data, "messageId").is_some_and(|mid| self.streamed_messages.contains(mid));
if !already && let Some(content) = str_of(data, "content").filter(|c| !c.is_empty()) {
out.updates.push((
target_session,
json!({ "sessionUpdate": "agent_message_chunk", "content": { "type": "text", "text": content } }),
));
}
}
"tool.execution_start" => {
let tool_name = str_of(data, "toolName").unwrap_or_default();
if matches!(tool_name, "report_intent" | "tool_search_tool" | "tool_search_tool_regex") {
return out;
}
let Some(call_id) = str_of(data, "toolCallId").filter(|s| !s.is_empty()) else { return out };
let args = data.get("arguments").unwrap_or(&Value::Null);
if tool_name == "task" && agent_id.is_none() {
let sub_id = format!("{main_session}:task:{call_id}");
self.subagents.insert(call_id.to_owned(), sub_id.clone());
let title = str_of(args, "name").or_else(|| str_of(args, "agent_type")).unwrap_or("Subagent");
let desc = str_of(args, "description");
let prompt = str_of(args, "prompt");
out.updates.push((
main_session.to_owned(),
json!({
"sessionUpdate": "subagent_update",
"subagentId": sub_id,
"title": title,
"description": desc,
"prompt": prompt,
"status": "running",
"cancellable": false,
}),
));
return out;
}
let info = describe_tool(tool_name, args);
let mut update = json!({
"sessionUpdate": "tool_call",
"toolCallId": call_id,
"title": info.title,
"kind": info.kind,
"status": "in_progress",
});
if !info.locations.is_empty() {
update["locations"] = Value::Array(info.locations.clone());
}
if !info.diffs.is_empty() {
update["content"] = Value::Array(info.diffs.clone());
}
self.tools.insert(call_id.to_owned(), info);
out.updates.push((target_session, update));
}
"tool.execution_partial_result" | "tool.shell_output" => {
let Some(call_id) = str_of(data, "toolCallId") else { return out };
let chunk = str_of(data, "partialOutput")
.or_else(|| str_of(data, "output"))
.or_else(|| str_of(data, "chunk"))
.unwrap_or_default();
if chunk.is_empty() {
return out;
}
if let Some(info) = self.tools.get_mut(call_id) {
info.output.push_str(chunk);
trim_tail(&mut info.output);
let content = tool_content(&info.output, &info.diffs);
out.updates.push((
target_session,
json!({
"sessionUpdate": "tool_call_update",
"toolCallId": call_id,
"content": content,
}),
));
}
}
"tool.execution_complete" => {
let Some(call_id) = str_of(data, "toolCallId") else { return out };
let success = data.get("success").and_then(Value::as_bool).unwrap_or(true);
let result_text = extract_tool_result_text(data);
if let Some(sub_id) = self.subagents.remove(call_id) {
out.updates.push((
main_session.to_owned(),
json!({
"sessionUpdate": "subagent_update",
"subagentId": sub_id,
"status": if success { "done" } else { "failed" },
"reply": result_text,
"error": (!success).then(|| result_text.clone()).flatten(),
}),
));
return out;
}
let Some(mut info) = self.tools.remove(call_id) else { return out };
if info.output.is_empty()
&& let Some(t) = result_text
&& info.kind != "edit"
{
info.output = t;
trim_tail(&mut info.output);
}
let mut update = json!({
"sessionUpdate": "tool_call_update",
"toolCallId": call_id,
"status": if success { "completed" } else { "failed" },
});
let content = tool_content(&info.output, &info.diffs);
if !content.is_empty() {
update["content"] = Value::Array(content);
}
out.updates.push((target_session, update));
}
"subagent.started" => {
if let Some(call_id) = str_of(data, "toolCallId") {
let sub_id = self
.subagents
.entry(call_id.to_owned())
.or_insert_with(|| format!("{main_session}:task:{call_id}"))
.clone();
let title = str_of(data, "agentDisplayName").or_else(|| str_of(data, "agentName"));
let desc = str_of(data, "agentDescription");
out.updates.push((
main_session.to_owned(),
json!({
"sessionUpdate": "subagent_update",
"subagentId": sub_id,
"title": title,
"description": desc,
"status": "running",
}),
));
}
}
"subagent.failed" => {
if let Some(call_id) = str_of(data, "toolCallId")
&& let Some(sub_id) = self.subagents.get(call_id).cloned()
{
out.updates.push((
main_session.to_owned(),
json!({
"sessionUpdate": "subagent_update",
"subagentId": sub_id,
"status": "failed",
"error": str_of(data, "error").or_else(|| str_of(data, "message")),
}),
));
}
}
"session.title_changed" => {
if let Some(title) = str_of(data, "title").map(str::trim).filter(|t| !t.is_empty()) {
out.updates.push((
main_session.to_owned(),
json!({ "sessionUpdate": "session_info_update", "title": title }),
));
}
}
"session.usage_info" => {
let used = data.get("currentTokens").and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok());
let limit = data
.get("tokenLimit")
.and_then(Value::as_u64)
.and_then(|n| u32::try_from(n).ok())
.filter(|&n| n > 0)
.or(fallback_limit);
if let (Some(used), Some(size)) = (used, limit) {
self.last_used_tokens = Some(used);
out.updates.push((
main_session.to_owned(),
json!({ "sessionUpdate": "usage_update", "used": used, "size": size }),
));
}
}
"assistant.usage" => {
if agent_id.is_none() {
let used = data.get("inputTokens").and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok());
if let (Some(used), Some(size)) = (used, fallback_limit.filter(|&s| s > 0)) {
self.last_used_tokens = Some(used);
out.updates.push((
main_session.to_owned(),
json!({ "sessionUpdate": "usage_update", "used": used, "size": size }),
));
}
}
if let Some(limits) = quota_limits(data.get("quotaSnapshots")) {
out.updates.push((main_session.to_owned(), limits));
}
}
"session.idle" if agent_id.is_none() => {
let mode = str_of(data, "mode").unwrap_or_default();
if mode != "autopilot" {
let aborted = data.get("aborted").and_then(Value::as_bool).unwrap_or(false);
out.terminal = Some(TurnTerminal::Idle { aborted });
}
}
"session.autopilot_stopped" if agent_id.is_none() => {
let reason = str_of(data, "reason").unwrap_or_default();
if reason == "error" {
out.terminal = Some(TurnTerminal::Error { message: "Autopilot request failed".into(), data: None });
} else {
out.terminal = Some(TurnTerminal::Idle { aborted: reason == "aborted" });
}
}
"session.error" if agent_id.is_none() => {
let message = str_of(data, "message").unwrap_or("Copilot reported an error.").to_owned();
out.terminal = Some(TurnTerminal::Error { message, data: Some(data.clone()) });
}
_ => {}
}
out
}
}
fn describe_tool(name: &str, args: &Value) -> ToolInfo {
let mut locations = Vec::new();
let mut diffs = Vec::new();
if let Some(p) = str_of(args, "path").or_else(|| str_of(args, "filePath")).filter(|p| !p.is_empty()) {
locations.push(json!({ "path": p }));
}
let (kind, title) = match name {
"bash" | "powershell" | "shell" => {
let cmd = str_of(args, "command").or_else(|| str_of(args, "description")).unwrap_or("Run command");
("execute", cmd.to_owned())
}
"view" | "read_file" => {
let label = str_of(args, "path")
.and_then(|p| Path::new(p).file_name().and_then(|n| n.to_str()))
.unwrap_or("Read file");
("read", format!("Read {label}"))
}
"grep" | "glob" | "semantic_search" => {
let pat = str_of(args, "pattern").or_else(|| str_of(args, "query")).unwrap_or(name);
("search", format!("Search {pat}"))
}
"edit" => {
let path = str_of(args, "path").unwrap_or_default();
let old = str_of(args, "old_str").unwrap_or_default();
let new = str_of(args, "new_str").unwrap_or_default();
if !path.is_empty() {
diffs.push(json!({ "type": "diff", "path": path, "oldText": old, "newText": new }));
}
let label = Path::new(path).file_name().and_then(|n| n.to_str()).unwrap_or("file");
("edit", format!("Edit {label}"))
}
"create" => {
let path = str_of(args, "path").unwrap_or_default();
let new = str_of(args, "file_text").unwrap_or_default();
if !path.is_empty() {
diffs.push(json!({ "type": "diff", "path": path, "oldText": "", "newText": new }));
}
let label = Path::new(path).file_name().and_then(|n| n.to_str()).unwrap_or("file");
("edit", format!("Create {label}"))
}
"web_fetch" => {
let url = str_of(args, "url").unwrap_or("URL");
("fetch", format!("Fetch {url}"))
}
_ => ("other", str_of(args, "description").unwrap_or(name).to_owned()),
};
ToolInfo { kind, title, locations, output: String::new(), diffs }
}
fn extract_tool_result_text(data: &Value) -> Option<String> {
if let Some(err) = data.pointer("/error/message").and_then(Value::as_str).filter(|s| !s.is_empty()) {
return Some(err.to_owned());
}
let result = data.get("result")?;
if let Some(s) = result.as_str() {
return (!s.is_empty()).then(|| s.to_owned());
}
str_of(result, "content")
.or_else(|| str_of(result, "detailedContent"))
.or_else(|| str_of(result, "textResultForLlm"))
.filter(|s| !s.is_empty())
.map(str::to_owned)
}
fn tool_content(output: &str, diffs: &[Value]) -> Vec<Value> {
let mut out = diffs.to_vec();
if !output.is_empty() {
out.push(json!({ "type": "content", "content": { "type": "text", "text": output } }));
}
out
}
fn quota_limits(snapshots: Option<&Value>) -> Option<Value> {
let map = snapshots?.as_object()?;
let mut limits = Vec::new();
for (window, snap) in map {
let used_pct = snap
.get("percentageUsed")
.and_then(Value::as_f64)
.or_else(|| snap.get("remainingPercentage").and_then(Value::as_f64).map(|rem| 100.0 - rem));
let Some(used_pct) = used_pct.filter(|p| p.is_finite()) else { continue };
let resets_ms = snap.get("resetsAt").and_then(Value::as_f64);
let mut entry = json!({
"window": window,
"usedPercent": used_pct.clamp(0.0, 100.0),
});
if let Some(ms) = resets_ms {
entry["resetsMs"] = json!(ms);
}
limits.push(entry);
}
(!limits.is_empty()).then(|| json!({ "sessionUpdate": LIMITS_UPDATE, "limits": limits }))
}
/// Builds an ACP `session/request_permission` payload from Copilot's `permission.requested` data.
pub(super) fn permission_request(session_id: &str, perm: &Value) -> Value {
let kind = str_of(perm, "kind").unwrap_or("other");
let tool_call_id = str_of(perm, "toolCallId").unwrap_or("permission");
let (acp_kind, title, raw_input) = match kind {
"shell" => {
let cmd = str_of(perm, "fullCommandText").or_else(|| str_of(perm, "command")).unwrap_or_default();
let title = str_of(perm, "intention")
.filter(|s| !s.is_empty())
.map(str::to_owned)
.unwrap_or_else(|| if cmd.is_empty() { "Run shell command".into() } else { format!("Run {cmd}") });
("execute", title, json!({ "command": cmd }))
}
"write" => {
let path = str_of(perm, "fileName").or_else(|| str_of(perm, "path")).unwrap_or("file");
("edit", format!("Edit {path}"), json!({ "path": path }))
}
"read" => {
let path = str_of(perm, "path").unwrap_or("file");
("read", format!("Read {path}"), json!({ "path": path }))
}
"url" => {
let url = str_of(perm, "url").unwrap_or("URL");
("fetch", format!("Allow network access to {url}"), json!({ "url": url }))
}
"mcp" => {
let server = str_of(perm, "serverName").unwrap_or("MCP");
let tool = str_of(perm, "toolName").unwrap_or("tool");
("other", format!("Run {server}: {tool}"), perm.clone())
}
_ => {
let t = str_of(perm, "intention").or_else(|| str_of(perm, "message")).unwrap_or("Allow action");
("other", t.to_owned(), perm.clone())
}
};
json!({
"sessionId": session_id,
"toolCall": {
"toolCallId": tool_call_id,
"kind": acp_kind,
"title": title,
"rawInput": raw_input,
},
"options": [
{ "optionId": "approve-once", "name": "Allow once", "kind": "allow_once" },
{ "optionId": "approved", "name": "Always allow", "kind": "allow_always" },
{ "optionId": "denied", "name": "Reject", "kind": "reject_once" },
],
})
}
/// Builds an ACP `session/request_permission` question card for Copilot's `userInput.request`.
pub(super) fn user_input_permission_request(session_id: &str, req: &Value) -> Value {
let question = str_of(req, "question").unwrap_or("Provide input");
let choices: Vec<Value> = req
.get("choices")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|c| c.as_str().map(|label| json!({ "label": label, "description": "" })))
.collect();
json!({
"sessionId": session_id,
"toolCall": {
"toolCallId": str_of(req, "toolCallId").unwrap_or("ask_user"),
"kind": "other",
"title": question,
"_meta": {
"questions": [{
"header": "Question",
"question": question,
"multiSelect": false,
"options": choices,
}]
}
},
"options": [
{ "optionId": "submit", "name": "Submit", "kind": "allow_once" },
{ "optionId": "cancel", "name": "Cancel", "kind": "reject_once" },
],
})
}
/// Converts ACP `mcpServers` array into Copilot's `mcpServers` object map.
pub(super) fn wire_mcp_servers(acp_servers: Option<&Value>) -> Option<Value> {
let list = acp_servers?.as_array()?;
let mut out = Map::new();
for item in list {
let Some(name) = str_of(item, "name").filter(|n| !n.is_empty()) else { continue };
let transport = str_of(item, "type").unwrap_or("stdio");
match transport {
"http" | "sse" => {
let Some(url) = str_of(item, "url").filter(|u| !u.is_empty()) else { continue };
let mut headers = Map::new();
for kv in item.get("headers").and_then(Value::as_array).into_iter().flatten() {
if let (Some(k), Some(v)) = (str_of(kv, "name"), str_of(kv, "value")) {
headers.insert(k.to_owned(), json!(v));
}
}
out.insert(
name.to_owned(),
json!({
"type": transport,
"url": url,
"headers": headers,
"tools": ["*"],
}),
);
}
_ => {
let Some(cmd) = str_of(item, "command").filter(|c| !c.is_empty()) else { continue };
let args: Vec<Value> = item.get("args").and_then(Value::as_array).cloned().unwrap_or_default();
let mut env = Map::new();
for kv in item.get("env").and_then(Value::as_array).into_iter().flatten() {
if let (Some(k), Some(v)) = (str_of(kv, "name"), str_of(kv, "value")) {
env.insert(k.to_owned(), json!(v));
}
}
out.insert(
name.to_owned(),
json!({
"type": "local",
"command": cmd,
"args": args,
"env": env,
"tools": ["*"],
}),
);
}
}
}
(!out.is_empty()).then_some(Value::Object(out))
}
/// Converts `commands.list` + `skills.discover` results into ACP `availableCommands`.
pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Option<&Value>) -> Vec<Value> {
let mut seen = HashSet::new();
let mut out = Vec::new();
for cmd in commands_res.and_then(|v| v.get("commands")).and_then(Value::as_array).into_iter().flatten() {
let Some(name) = str_of(cmd, "name").map(|n| n.trim_start_matches('/')).filter(|n| !n.is_empty()) else {
continue;
};
if !seen.insert(name.to_owned()) {
continue;
}
let hint = cmd.pointer("/input/hint").and_then(Value::as_str).filter(|h| !h.is_empty());
out.push(json!({
"name": name,
"description": str_of(cmd, "description").unwrap_or_default(),
"source": "command",
"input": hint.map(|h| json!({ "hint": h })),
}));
}
for skill in skills_res.and_then(|v| v.get("skills")).and_then(Value::as_array).into_iter().flatten() {
if skill.get("enabled").and_then(Value::as_bool) == Some(false)
|| skill.get("userInvocable").and_then(Value::as_bool) == Some(false)
{
continue;
}
let Some(name) = str_of(skill, "commandName")
.or_else(|| str_of(skill, "name"))
.map(|n| n.trim_start_matches('/'))
.filter(|n| !n.is_empty())
else {
continue;
};
if !seen.insert(name.to_owned()) {
continue;
}
let hint = str_of(skill, "argumentHint").filter(|h| !h.is_empty());
out.push(json!({
"name": name,
"description": str_of(skill, "description").unwrap_or_default(),
"source": "skill",
"input": hint.map(|h| json!({ "hint": h })),
}));
}
out
}
fn trim_tail(text: &mut String) {
if text.len() > MAX_OUTPUT {
let mut cut = text.len() - MAX_OUTPUT;
while !text.is_char_boundary(cut) {
cut += 1;
}
text.replace_range(..cut, "");
}
}
fn str_of<'a>(v: &'a Value, key: &str) -> Option<&'a str> {
v.get(key).and_then(Value::as_str)
}
+1
Переглянути файл
@@ -13,6 +13,7 @@
pub(crate) mod claude;
pub(crate) mod codex;
pub(crate) mod copilot;
use ide_jsonrpc::{Framing, Handler, Peer};
use std::path::{Path, PathBuf};
+27 -4
Переглянути файл
@@ -20,6 +20,8 @@ pub(crate) enum Driver {
Codex,
/// `claude` in stream-json mode.
Claude,
/// `copilot --headless --no-auto-update --stdio`.
Copilot,
}
#[derive(Clone, Debug, PartialEq)]
@@ -55,7 +57,13 @@ const BUILTIN: &[(&str, &str, Driver, &[&str], &str)] = &[
"Run `codex login` in a terminal.",
),
("gemini", "Gemini CLI", Driver::Acp, &["gemini", "--experimental-acp"], "Run `gemini` in a terminal and sign in."),
("copilot", "GitHub Copilot", Driver::Acp, &["copilot", "--acp"], "Run `copilot` in a terminal and sign in."),
(
"copilot",
"GitHub Copilot",
Driver::Copilot,
&["copilot", "--headless", "--no-auto-update", "--stdio"],
"Run `copilot` in a terminal and sign in.",
),
("cursor", "Cursor", Driver::Acp, &["cursor-agent", "acp"], "Run `cursor-agent login` in a terminal."),
("opencode", "OpenCode", Driver::Acp, &["opencode", "acp"], "Run `opencode auth login` in a terminal."),
("qwen", "Qwen Code", Driver::Acp, &["qwen", "--experimental-acp"], "Run `qwen` in a terminal and sign in."),
@@ -242,10 +250,13 @@ fn render_login_command<'a>(program: &Path, args: impl IntoIterator<Item = &'a s
}
/// Whether `id` names a built-in agent that needs no registry install (native drivers
/// and `npx -y` adapters). CLI built-ins (`copilot`, `gemini`, …) can be installed and
/// updated from the ACP Registry into `<config>/agents/<id>.toml`.
/// other than `copilot`, and `npx -y` adapters). CLI built-ins (`copilot`, `gemini`, …)
/// can be installed and updated from the ACP Registry into `<config>/agents/<id>.toml`.
pub(crate) fn is_builtin(id: &str) -> bool {
BUILTIN.iter().any(|&(bid, _, driver, cmd, _)| bid == id && (driver != Driver::Acp || cmd.first() == Some(&"npx")))
id != "copilot"
&& BUILTIN
.iter()
.any(|&(bid, _, driver, cmd, _)| bid == id && (driver != Driver::Acp || cmd.first() == Some(&"npx")))
}
/// Display name of a built-in agent, when `id` is one.
@@ -618,6 +629,10 @@ pub(crate) fn load(custom_dir: Option<&Path>, secrets: Option<&dyn EnvSecrets>)
files.sort();
for path in files {
let Some(id) = path.file_stem().and_then(|s| s.to_str()).map(str::to_owned) else { continue };
let explicit_driver = std::fs::read_to_string(&path)
.ok()
.and_then(|t| toml::from_str::<toml::Table>(&t).ok())
.is_some_and(|t| t.contains_key("driver"));
let agent = match CustomAgent::read_with(&path, &id, secrets) {
Ok(a) => a,
Err(e) => {
@@ -643,6 +658,14 @@ pub(crate) fn load(custom_dir: Option<&Path>, secrets: Option<&dyn EnvSecrets>)
match specs.iter_mut().find(|s| s.id == spec.id) {
Some(existing) => {
spec.login_hint = existing.login_hint.clone();
if !explicit_driver && existing.driver == Driver::Copilot && spec.driver == Driver::Acp {
// Registry installs (`github-copilot-cli`) record `args = ["--acp"]` with no
// `driver`; upgrade them in place to the native headless driver (which
// automatically falls back to `--acp`) while keeping the installed executable
// path and registry version tracking. Explicit `driver = "acp"` stays ACP.
spec.driver = Driver::Copilot;
spec.args = crate::native::copilot::headless_args(&spec.args);
}
if spec.source == AgentSource::Custom {
spec.source = AgentSource::Builtin;
}
+1
Переглянути файл
@@ -64,6 +64,7 @@ async fn create(mgr: &AgentManager, provider: &str, prompt: &str) -> String {
config: config(provider),
isolation: Isolation::Local,
base: None,
..Default::default()
};
mgr.create(req).await.unwrap().id
}
File diff suppressed because it is too large. Load diff
+1
Переглянути файл
@@ -441,6 +441,7 @@ mod tests {
command: None,
options: vec![],
questions: vec![],
form: None,
chosen: None,
});
assert_eq!(t.end_turn(None), vec![2, 3]);
+54 -1
Переглянути файл
@@ -7,6 +7,7 @@ mod fingerprint;
mod launch_resources;
mod parse;
mod single;
mod structure;
mod up_to_date;
pub use fingerprint::{LaunchFingerprint, launch_fingerprint, menu_fingerprint};
@@ -15,6 +16,10 @@ pub use single::{
SingleFileTarget, compile_file_plan, find_javac, javac_step, module_classpath, single_file_classpath,
single_file_target,
};
pub use structure::{
StructureJdk, StructureRoots, artifact_file, artifact_output, language_release, structure_outputs, structure_plan,
structure_war_plan, structure_web_artifacts,
};
pub use up_to_date::{menu_up_to_date, record_menu_build};
use crate::process::{self, Stream};
@@ -55,6 +60,8 @@ pub enum BuildSystem {
CMake,
#[serde(rename = "dotnet")]
Dotnet,
/// A Java project without a build tool, compiled from its Project Structure.
Javac,
}
/// One command of a build.
@@ -65,6 +72,10 @@ pub struct BuildStep {
pub cwd: PathBuf,
pub env: BTreeMap<String, String>,
format: Format,
/// Folders created before the command runs (a compiler's output).
mkdirs: Vec<PathBuf>,
/// Work done in the IDE instead of a command, with its console title.
action: Option<(structure::Action, String)>,
}
impl BuildStep {
@@ -75,16 +86,26 @@ impl BuildStep {
cwd: cwd.to_path_buf(),
env: BTreeMap::new(),
format,
mkdirs: Vec::new(),
action: None,
}
}
fn action(action: structure::Action, root: &Path) -> Self {
let title = action.display(root);
BuildStep { action: Some((action, title)), ..Self::new("", &[], root, Format::Gradle) }
}
/// A CMake configure/build invocation, parsed as compiler output in the Build view.
pub fn cmake(program: &str, args: Vec<String>, cwd: PathBuf, env: BTreeMap<String, String>) -> Self {
Self { program: program.into(), args, cwd, env, format: Format::Gcc }
Self { program: program.into(), args, cwd, env, format: Format::Gcc, mkdirs: Vec::new(), action: None }
}
/// The command line as echoed in the console.
pub fn display(&self) -> String {
if let Some((_, title)) = &self.action {
return title.clone();
}
let program = Path::new(&self.program).file_name().map_or(self.program.clone(), |n| n.to_string_lossy().into());
std::iter::once(program)
.chain(self.args.iter().map(|a| if a.contains(' ') { format!("\"{a}\"") } else { a.clone() }))
@@ -249,6 +270,8 @@ pub fn plan(
BuildSystem::TypeScript => ts_steps(&dir, kind),
BuildSystem::CMake => cmake_steps(&dir, kind, cmake.and_then(<[_]>::first)),
BuildSystem::Dotnet => dotnet_steps(&dir, kind)?,
// Never detected from a folder: it comes from the Project Structure (`structure_plan`).
BuildSystem::Javac => return Err(IdeError::invalid("no build tool to run")),
};
Ok(BuildPlan { system, title, steps })
}
@@ -650,6 +673,36 @@ pub fn run(
let command = step.display();
on_event(BuildEvent::Step { command: command.clone(), cwd: step.cwd.clone().into() });
on_event(BuildEvent::Progress { message: command.clone(), fraction: None });
if let Some((action, _)) = &step.action {
match action.run(cancel) {
Ok(text) => {
if !text.is_empty() {
on_event(BuildEvent::Output { text: format!("{text}\n"), stderr: false });
}
continue;
}
Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => return Err(e),
Err(e) => {
let m = BuildMessage {
severity: Severity::Error,
text: e.message.clone(),
path: None,
range: None,
code: None,
};
on_event(BuildEvent::Output { text: format!("{}\n", e.message), stderr: true });
on_event(BuildEvent::Message { message: m.clone() });
messages.push(m);
success = false;
break;
}
}
}
for dir in &step.mkdirs {
if let Err(e) = std::fs::create_dir_all(dir) {
tracing::debug!(dir = %dir.display(), %e, "cannot create the build output folder");
}
}
let mut parser = OutputParser::new(step.format);
let mut emit = |raws: Vec<RawMessage>, messages: &mut Vec<BuildMessage>| {
for raw in raws {
+819
Переглянути файл
@@ -0,0 +1,819 @@
//! A Java project without a build tool, built from its Project Structure: `javac` compiles
//! the source roots to the module's output folder against the project libraries and the
//! Web facet's `WEB-INF/lib`, and the resources are copied next to the classes; tests the
//! same way into the test output, which also sees the production classes.
use super::*;
use ide_core::settings::{
ArtifactConfig, ArtifactKind, DependencyScope, ModuleStructureSettings, ProjectStructureSettings,
};
use std::fs;
/// The roots of the project as the IDE resolved them (absolute folders).
#[derive(Clone, Debug, Default)]
pub struct StructureRoots {
pub sources: Vec<PathBuf>,
pub tests: Vec<PathBuf>,
pub resources: Vec<PathBuf>,
pub test_resources: Vec<PathBuf>,
pub excluded: Vec<PathBuf>,
}
/// The JDK compiling the project.
#[derive(Clone, Debug)]
pub struct StructureJdk {
pub home: PathBuf,
pub major: u32,
}
/// Where the project's classes go: `<compiler output>/production/<module>` and
/// `<compiler output>/test/<module>` (`out` by default), unless the module names its own.
pub fn structure_outputs(root: &Path, ps: &ProjectStructureSettings) -> (PathBuf, PathBuf) {
let module = root_module(root, ps);
let name = module_name(root);
let base = resolve_dir(root, &ps.compiler_output).unwrap_or_else(|| root.join("out"));
let main = module
.and_then(|m| resolve_dir(root, &m.compiler_output))
.unwrap_or_else(|| base.join("production").join(&name));
let test = module
.and_then(|m| resolve_dir(root, &m.test_compiler_output))
.unwrap_or_else(|| base.join("test").join(&name));
(main, test)
}
fn module_name(root: &Path) -> String {
root.file_name().map_or_else(|| "project".to_owned(), |n| n.to_string_lossy().into_owned())
}
fn root_module<'a>(root: &Path, ps: &'a ProjectStructureSettings) -> Option<&'a ModuleStructureSettings> {
ps.modules.get(".").or_else(|| ps.module_settings(root, root))
}
fn resolve_dir(root: &Path, value: &str) -> Option<PathBuf> {
let value = value.trim();
(!value.is_empty()).then(|| root.join(value))
}
/// `.java` files below `dir`, not inside an excluded folder or another root of `skip`.
fn java_files(dir: &Path, excluded: &[PathBuf], out: &mut Vec<PathBuf>) {
let Ok(entries) = fs::read_dir(dir) else { return };
let mut entries: Vec<_> = entries.flatten().collect();
entries.sort_by_key(|e| e.file_name());
for e in entries {
let path = e.path();
match e.file_type() {
Ok(t) if t.is_dir() => {
if !excluded.iter().any(|x| path.starts_with(x)) {
java_files(&path, excluded, out);
}
}
Ok(t) if t.is_file() && path.extension().is_some_and(|x| x == "java") => out.push(path),
_ => {}
}
}
}
/// Folders and archives of the libraries a module compiles against, for `scope`.
fn library_entries(root: &Path, ps: &ProjectStructureSettings, test: bool) -> Vec<String> {
let wanted = |scope: DependencyScope| match scope {
DependencyScope::Compile | DependencyScope::Provided => true,
DependencyScope::Test => test,
DependencyScope::Runtime => false,
};
let mut out: Vec<String> = Vec::new();
let mut add = |entry: String| {
if !out.contains(&entry) {
out.push(entry);
}
};
let module_deps = root_module(root, ps).map(|m| m.dependencies.as_slice()).unwrap_or_default();
for lib in &ps.libraries {
// A library a module dependency names takes that dependency's scope.
let scope =
module_deps.iter().find(|d| d.kind == "library" && d.target == lib.name).map_or(lib.scope, |d| d.scope);
if wanted(scope) {
for class in &lib.classes {
add(class_entry(root, class));
}
}
}
for dep in module_deps.iter().filter(|d| d.kind == "library" && wanted(d.scope)) {
if !ps.libraries.iter().any(|l| l.name == dep.target) && !dep.target.trim().is_empty() {
add(class_entry(root, &dep.target));
}
}
for facet in ps.facets.iter().filter(|f| f.kind == "web") {
let lib = web_root(root, facet).join("WEB-INF").join("lib");
if lib.is_dir() {
add(format!("{}{}*", lib.to_string_lossy(), std::path::MAIN_SEPARATOR));
}
}
out
}
/// The web resource folder of a Web facet: its own, else the folder holding `WEB-INF/web.xml`.
fn web_root(root: &Path, facet: &ide_core::settings::FacetConfig) -> PathBuf {
let dir = facet.web_root.trim();
let dir = if dir.is_empty() {
facet.descriptor.trim().replace('\\', "/").strip_suffix("/WEB-INF/web.xml").unwrap_or("").to_owned()
} else {
dir.to_owned()
};
root.join(dir)
}
/// The class archives and folders of a library path (`lib/*.jar` lists the folder's jars).
fn library_files(root: &Path, value: &str) -> Vec<PathBuf> {
let entry = class_entry(root, value);
match entry.strip_suffix('*') {
Some(dir) => {
let mut jars: Vec<PathBuf> = fs::read_dir(dir)
.map(|d| d.flatten().map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x == "jar")).collect())
.unwrap_or_default();
jars.sort();
jars
}
None => vec![PathBuf::from(entry)],
}
}
/// A classpath entry for a library path: a folder of jars (`lib/*`) stays a wildcard javac expands.
fn class_entry(root: &Path, value: &str) -> String {
let path = root.join(value.trim());
let text = path.to_string_lossy().into_owned();
if text.ends_with("/*.jar") || text.ends_with("\\*.jar") {
return text[..text.len() - 4].to_owned();
}
text
}
fn classpath(entries: &[String]) -> String {
entries.join(if cfg!(windows) { ";" } else { ":" })
}
/// `--release N` from JDK 9 on; older compilers only know `-source` / `-target`.
fn release_args(level: Option<u32>, jdk: Option<&StructureJdk>) -> Vec<String> {
let Some(level) = level else { return Vec::new() };
if jdk.is_none_or(|j| j.major >= 9) {
vec!["--release".into(), level.to_string()]
} else {
vec!["-source".into(), format!("1.{level}"), "-target".into(), format!("1.{level}")]
}
}
/// `"17"`, `"1.8"`, `"JDK_17"` → the release number.
pub fn language_release(level: &str) -> Option<u32> {
let digits = level.trim().trim_start_matches("JDK_").trim_start_matches("jdk").replace('_', ".");
let digits = digits.strip_prefix("1.").unwrap_or(&digits);
digits.split(['.', ' ']).next()?.parse().ok().filter(|n| *n > 0)
}
/// The Build / Rebuild plan of a project without a build tool, or `None` when it has no
/// Java sources under its source roots. `language_level`: the project's, unless the module
/// overrides it. Writes the javac argument files below `cache`.
pub fn structure_plan(
root: &Path,
ps: &ProjectStructureSettings,
roots: &StructureRoots,
jdk: Option<&StructureJdk>,
language_level: &str,
kind: BuildKind,
cache: &Path,
) -> IdeResult<Option<BuildPlan>> {
let mut main_sources = Vec::new();
for dir in &roots.sources {
java_files(dir, &roots.excluded, &mut main_sources);
}
let mut test_sources = Vec::new();
for dir in &roots.tests {
java_files(dir, &roots.excluded, &mut test_sources);
}
if main_sources.is_empty() && test_sources.is_empty() {
return Ok(None);
}
let (main_out, test_out) = structure_outputs(root, ps);
let module = root_module(root, ps);
let level = module
.map(|m| m.language_level.as_str())
.filter(|l| !l.trim().is_empty())
.or(Some(language_level))
.and_then(language_release);
let env: BTreeMap<String, String> = jdk
.map(|j| BTreeMap::from([("JAVA_HOME".to_owned(), j.home.to_string_lossy().into_owned())]))
.unwrap_or_default();
let javac = find_javac(&env);
let args_dir = cache.join("javac");
fs::create_dir_all(&args_dir)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", args_dir.display())))?;
let mut steps = Vec::new();
if kind == BuildKind::Rebuild {
steps.push(BuildStep::action(Action::Clean(vec![main_out.clone(), test_out.clone()]), root));
}
let main_cp = library_entries(root, ps, false);
let compile = |name: &str, sources: &[PathBuf], out: &Path, cp: &[String]| -> IdeResult<BuildStep> {
let args_file = args_dir.join(format!("{name}.args"));
// One quoted path per line: the sources outgrow a command line quickly.
let text: String = sources
.iter()
.map(|p| format!("\"{}\"\n", p.to_string_lossy().replace('\\', "\\\\").replace('"', "\\\"")))
.collect();
fs::write(&args_file, text)
.map_err(|e| IdeError::internal(format!("cannot write {} ({e})", args_file.display())))?;
let mut step = BuildStep::new(&javac, &[], root, Format::Gradle);
step.args.extend(["-encoding".into(), "UTF-8".into(), "-g".into()]);
step.args.extend(["-d".into(), out.to_string_lossy().into_owned()]);
if !cp.is_empty() {
step.args.extend(["-cp".into(), classpath(cp)]);
}
step.args.extend(release_args(level, jdk));
step.args.push(format!("@{}", args_file.to_string_lossy()));
step.env = env.clone();
step.mkdirs = vec![out.to_path_buf()];
Ok(step)
};
if !main_sources.is_empty() {
steps.push(compile("production", &main_sources, &main_out, &main_cp)?);
}
steps.push(BuildStep::action(
Action::CopyResources {
from: roots.sources.iter().chain(&roots.resources).cloned().collect(),
to: main_out.clone(),
},
root,
));
// Artifacts hold production classes only.
if !test_sources.is_empty() && kind != BuildKind::Artifacts {
let mut test_cp = vec![main_out.to_string_lossy().into_owned()];
test_cp.extend(library_entries(root, ps, true));
steps.push(compile("test", &test_sources, &test_out, &test_cp)?);
steps.push(BuildStep::action(
Action::CopyResources {
from: roots.tests.iter().chain(&roots.test_resources).cloned().collect(),
to: test_out.clone(),
},
root,
));
}
if kind == BuildKind::Artifacts {
if ps.artifacts.is_empty() {
return Err(IdeError::invalid("No artifacts are configured: add one in Project Structure › Artifacts"));
}
for artifact in &ps.artifacts {
steps.extend(artifact_steps(root, ps, artifact, &main_out, None, cache));
}
}
Ok(Some(BuildPlan { system: BuildSystem::Javac, title: module_name(root), steps }))
}
/// Where an artifact goes: its output folder, else `out/artifacts/<name>`.
pub fn artifact_output(root: &Path, artifact: &ArtifactConfig) -> PathBuf {
resolve_dir(root, &artifact.output_directory)
.unwrap_or_else(|| root.join("out").join("artifacts").join(file_name(&artifact.name)))
}
/// An artifact name as a file name (`shop:war exploded` → `shop_war_exploded`).
fn file_name(name: &str) -> String {
name.chars().map(|c| if c.is_alphanumeric() || c == '-' || c == '.' { c } else { '_' }).collect()
}
/// The archive a `jar` / `war` artifact writes (`<output>/<name>.war`), or its folder (exploded).
pub fn artifact_file(root: &Path, artifact: &ArtifactConfig) -> PathBuf {
let out = artifact_output(root, artifact);
let base = artifact.name.split(':').next().filter(|n| !n.trim().is_empty()).unwrap_or(&artifact.name);
match artifact.kind {
ArtifactKind::Jar => out.join(format!("{}.jar", file_name(base))),
ArtifactKind::War => out.join(format!("{}.war", file_name(base))),
ArtifactKind::WarExploded => out,
}
}
/// The steps laying out one artifact from the module output `classes`; `war`: write a
/// WAR there instead of the artifact's own output (an application server's deployment).
fn artifact_steps(
root: &Path,
ps: &ProjectStructureSettings,
artifact: &ArtifactConfig,
classes: &Path,
war: Option<&Path>,
cache: &Path,
) -> Vec<BuildStep> {
let libraries: Vec<PathBuf> = ps
.libraries
.iter()
.filter(|l| artifact.include_libraries.contains(&l.name))
.flat_map(|l| l.classes.iter().flat_map(|c| library_files(root, c)))
.collect();
let facet = ps
.facets
.iter()
.filter(|f| f.kind == "web")
.find(|f| f.module == artifact.module || f.module.is_empty() && artifact.module == ".")
.or_else(|| ps.facets.iter().find(|f| f.kind == "web"));
let staging = cache.join("artifacts").join(file_name(&artifact.name));
let mut steps = Vec::new();
match (artifact.kind, war) {
(ArtifactKind::Jar, None) => {
let out = artifact_output(root, artifact);
let mut manifest = String::from("Manifest-Version: 1.0\r\n");
if !artifact.main_class.trim().is_empty() {
manifest.push_str(&format!("Main-Class: {}\r\n", artifact.main_class.trim()));
}
let names: Vec<String> =
libraries.iter().filter_map(|l| l.file_name()).map(|n| n.to_string_lossy().into_owned()).collect();
if !names.is_empty() {
manifest.push_str(&format!("Class-Path: {}\r\n", names.join(" ")));
}
steps.push(BuildStep::action(
Action::Layout { into: staging.clone(), entries: vec![(classes.to_path_buf(), PathBuf::new())] },
root,
));
// The jar's Class-Path names the libraries next to it.
steps.push(BuildStep::action(
Action::Layout {
into: out.clone(),
entries: libraries.iter().map(|l| (l.clone(), file_of(l))).collect(),
},
root,
));
steps.push(BuildStep::action(
Action::Archive { from: staging, to: artifact_file(root, artifact), manifest: Some(manifest) },
root,
));
}
(kind, war) => {
let exploded = match (kind, war) {
(ArtifactKind::WarExploded, None) => artifact_output(root, artifact),
_ => staging.clone(),
};
let mut entries = Vec::new();
if let Some(facet) = facet {
entries.push((web_root(root, facet), PathBuf::new()));
}
entries.push((classes.to_path_buf(), PathBuf::from("WEB-INF/classes")));
for lib in &libraries {
entries.push((lib.clone(), Path::new("WEB-INF/lib").join(file_of(lib))));
}
steps.push(BuildStep::action(Action::Layout { into: exploded.clone(), entries }, root));
let archive = war
.map(Path::to_path_buf)
.or_else(|| (kind != ArtifactKind::WarExploded).then(|| artifact_file(root, artifact)));
if let Some(to) = archive {
steps.push(BuildStep::action(Action::Archive { from: exploded, to, manifest: None }, root));
}
}
}
steps
}
fn file_of(path: &Path) -> PathBuf {
path.file_name().map(PathBuf::from).unwrap_or_default()
}
/// The WAR artifacts of a project without a build tool: an application server deploys them.
pub fn structure_web_artifacts(ps: &ProjectStructureSettings) -> Vec<&ArtifactConfig> {
ps.artifacts.iter().filter(|a| matches!(a.kind, ArtifactKind::War | ArtifactKind::WarExploded)).collect()
}
/// A build of `artifact` into the WAR `war` (Tomcat's deployment), compiling first.
#[allow(clippy::too_many_arguments)]
pub fn structure_war_plan(
root: &Path,
ps: &ProjectStructureSettings,
roots: &StructureRoots,
jdk: Option<&StructureJdk>,
language_level: &str,
artifact: &ArtifactConfig,
war: &Path,
cache: &Path,
) -> IdeResult<BuildPlan> {
let mut plan = structure_plan(root, ps, roots, jdk, language_level, BuildKind::Build, cache)?
.unwrap_or_else(|| BuildPlan { system: BuildSystem::Javac, title: module_name(root), steps: Vec::new() });
let (main_out, _) = structure_outputs(root, ps);
// Tests are not part of a deployment.
plan.steps.retain(|s| !s.args.iter().any(|a| a.ends_with("test.args")));
plan.steps
.retain(|s| !matches!(&s.action, Some((Action::CopyResources { to, .. }, _)) if !to.starts_with(&main_out)));
plan.steps.extend(artifact_steps(root, ps, artifact, &main_out, Some(war), cache));
plan.title = artifact.name.clone();
Ok(plan)
}
/// Work a build does in the IDE itself rather than through a tool.
#[derive(Clone, Debug, PartialEq)]
pub(crate) enum Action {
/// Deletes these output folders (Rebuild).
Clean(Vec<PathBuf>),
/// Copies the files of these folders that are not Java sources into `to`, keeping their
/// relative paths; files that are already up to date are left alone.
CopyResources { from: Vec<PathBuf>, to: PathBuf },
/// Lays out an artifact in `into`: each folder's content or file goes to its relative
/// place (`""` = the top). What is no longer laid out is removed.
Layout { into: PathBuf, entries: Vec<(PathBuf, PathBuf)> },
/// Zips the folder `from` into the archive `to`, with this manifest first.
Archive { from: PathBuf, to: PathBuf, manifest: Option<String> },
}
impl Action {
pub(crate) fn display(&self, root: &Path) -> String {
let rel = |p: &Path| p.strip_prefix(root).unwrap_or(p).to_string_lossy().replace('\\', "/");
match self {
Action::Clean(dirs) => format!("Clean {}", dirs.iter().map(|d| rel(d)).collect::<Vec<_>>().join(", ")),
Action::CopyResources { to, .. } => format!("Copy resources to {}", rel(to)),
Action::Layout { into, .. } => format!("Lay out {}", rel(into)),
Action::Archive { to, .. } => format!("Pack {}", rel(to)),
}
}
/// Runs the action; the text is a summary for the console.
pub(crate) fn run(&self, cancel: &CancellationToken) -> IdeResult<String> {
match self {
Action::Clean(dirs) => {
for dir in dirs.iter().filter(|d| d.exists()) {
fs::remove_dir_all(dir)
.map_err(|e| IdeError::internal(format!("cannot delete {} ({e})", dir.display())))?;
}
Ok(String::new())
}
Action::CopyResources { from, to } => {
let mut copied = 0;
for dir in from {
copied += copy_resources(dir, dir, to, cancel)?;
}
Ok(format!("{copied} resource file(s) copied"))
}
Action::Layout { into, entries } => {
// A fresh layout: files dropped from the sources must not linger in the artifact.
if entries.iter().any(|(from, _)| from.starts_with(into)) {
return Err(IdeError::invalid(format!(
"The artifact output folder {} holds files the artifact is made of",
into.display()
)));
}
if into.exists() {
fs::remove_dir_all(into)
.map_err(|e| IdeError::internal(format!("cannot delete {} ({e})", into.display())))?;
}
let mut copied = 0;
for (from, to) in entries {
let target = into.join(to);
if from.is_dir() {
copied += copy_tree(from, &target, cancel)?;
} else if from.is_file() {
copy_file(from, &target)?;
copied += 1;
}
}
Ok(format!("{copied} file(s) laid out"))
}
Action::Archive { from, to, manifest } => {
archive(from, to, manifest.as_deref(), cancel)?;
Ok(format!("Wrote {}", to.display()))
}
}
}
}
fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
if let Some(parent) = to.parent() {
fs::create_dir_all(parent)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
}
fs::copy(from, to).map_err(|e| IdeError::internal(format!("cannot copy {} ({e})", from.display())))?;
Ok(())
}
fn copy_tree(from: &Path, to: &Path, cancel: &CancellationToken) -> IdeResult<usize> {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Ok(entries) = fs::read_dir(from) else { return Ok(0) };
let mut copied = 0;
for e in entries.flatten() {
let Ok(t) = e.file_type() else { continue };
let target = to.join(e.file_name());
if t.is_dir() {
copied += copy_tree(&e.path(), &target, cancel)?;
} else if t.is_file() {
copy_file(&e.path(), &target)?;
copied += 1;
}
}
Ok(copied)
}
fn archive(from: &Path, to: &Path, manifest: Option<&str>, cancel: &CancellationToken) -> IdeResult<()> {
use std::io::Write;
let err = |e: &dyn std::fmt::Display| IdeError::internal(format!("cannot write {} ({e})", to.display()));
if let Some(parent) = to.parent() {
fs::create_dir_all(parent).map_err(|e| err(&e))?;
}
let mut zip = zip::ZipWriter::new(fs::File::create(to).map_err(|e| err(&e))?);
let options = zip::write::SimpleFileOptions::default();
if let Some(manifest) = manifest {
zip.add_directory("META-INF/", options).map_err(|e| err(&e))?;
zip.start_file("META-INF/MANIFEST.MF", options).map_err(|e| err(&e))?;
zip.write_all(manifest.as_bytes()).map_err(|e| err(&e))?;
}
let mut stack = vec![from.to_path_buf()];
while let Some(dir) = stack.pop() {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Ok(entries) = fs::read_dir(&dir) else { continue };
let mut entries: Vec<_> = entries.flatten().collect();
entries.sort_by_key(|e| e.file_name());
for e in entries {
let path = e.path();
let name = path.strip_prefix(from).unwrap_or(&path).to_string_lossy().replace('\\', "/");
if manifest.is_some() && name.eq_ignore_ascii_case("META-INF/MANIFEST.MF") {
continue;
}
match e.file_type() {
Ok(t) if t.is_dir() => {
if !(manifest.is_some() && name == "META-INF") {
zip.add_directory(format!("{name}/"), options).map_err(|e| err(&e))?;
}
stack.push(path);
}
Ok(t) if t.is_file() => {
zip.start_file(name, options).map_err(|e| err(&e))?;
let mut file = fs::File::open(&path).map_err(|e| err(&e))?;
std::io::copy(&mut file, &mut zip).map_err(|e| err(&e))?;
}
_ => {}
}
}
}
zip.finish().map_err(|e| err(&e))?;
Ok(())
}
fn copy_resources(base: &Path, dir: &Path, to: &Path, cancel: &CancellationToken) -> IdeResult<usize> {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Ok(entries) = fs::read_dir(dir) else { return Ok(0) };
let mut copied = 0;
for e in entries.flatten() {
let path = e.path();
let Ok(t) = e.file_type() else { continue };
if t.is_dir() {
// The output folder can sit inside a source root (`src` holding `classes`).
if path != to && !path.starts_with(to) {
copied += copy_resources(base, &path, to, cancel)?;
}
continue;
}
if !t.is_file() || path.extension().is_some_and(|x| x == "java") {
continue;
}
let target = to.join(path.strip_prefix(base).unwrap_or(&path));
let newer =
match (fs::metadata(&path).and_then(|m| m.modified()), fs::metadata(&target).and_then(|m| m.modified())) {
(Ok(source), Ok(existing)) => source > existing,
_ => true,
};
if newer {
if let Some(parent) = target.parent() {
fs::create_dir_all(parent)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
}
fs::copy(&path, &target)
.map_err(|e| IdeError::internal(format!("cannot copy {} ({e})", path.display())))?;
copied += 1;
}
}
Ok(copied)
}
#[cfg(test)]
mod tests {
use super::*;
use ide_core::settings::{FacetConfig, ModuleDependency, ProjectLibrary};
fn write(path: &Path, text: &str) {
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, text).unwrap();
}
#[test]
fn reads_language_levels() {
assert_eq!(language_release("17"), Some(17));
assert_eq!(language_release("1.8"), Some(8));
assert_eq!(language_release("JDK_11"), Some(11));
assert_eq!(language_release(""), None);
}
#[test]
fn plans_javac_over_source_roots_with_libraries_and_web_lib() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("shop");
write(&root.join("src/com/a/A.java"), "package com.a; class A {}");
write(&root.join("src/com/a/app.properties"), "x=1");
write(&root.join("test/com/a/ATest.java"), "package com.a; class ATest {}");
write(&root.join("WebRoot/WEB-INF/web.xml"), "<web-app/>");
write(&root.join("WebRoot/WEB-INF/lib/x.jar"), "");
let ps = ProjectStructureSettings {
libraries: vec![
ProjectLibrary { name: "tools".into(), classes: vec!["lib/*.jar".into()], ..Default::default() },
ProjectLibrary {
name: "junit".into(),
classes: vec!["junit.jar".into()],
scope: DependencyScope::Test,
..Default::default()
},
],
facets: vec![FacetConfig {
kind: "web".into(),
module: ".".into(),
descriptor: "WebRoot/WEB-INF/web.xml".into(),
web_root: String::new(),
}],
..Default::default()
};
let roots =
StructureRoots { sources: vec![root.join("src")], tests: vec![root.join("test")], ..Default::default() };
let jdk = StructureJdk { home: PathBuf::from("/jdk"), major: 21 };
let plan = structure_plan(&root, &ps, &roots, Some(&jdk), "17", BuildKind::Rebuild, &tmp.path().join("cache"))
.unwrap()
.unwrap();
assert_eq!(plan.system, BuildSystem::Javac);
let shown: Vec<String> = plan.steps.iter().map(BuildStep::display).collect();
assert_eq!(shown[0], "Clean out/production/shop, out/test/shop");
let javac = &plan.steps[1];
let cp = |s: &BuildStep| s.args[s.args.iter().position(|a| a == "-cp").unwrap() + 1].clone();
let sep = if cfg!(windows) { ";" } else { ":" };
let main_cp = cp(javac);
let entries: Vec<&str> = main_cp.split(sep).collect();
assert_eq!(entries.len(), 2, "{main_cp}");
assert!(Path::new(entries[0]).ends_with("lib/*"));
assert!(Path::new(entries[1]).ends_with("WEB-INF/lib/*"));
assert!(javac.args.windows(2).any(|w| w == ["--release", "17"]));
let args = fs::read_to_string(tmp.path().join("cache/javac/production.args")).unwrap();
assert!(args.contains("A.java") && !args.contains("ATest.java"));
assert_eq!(shown[2], "Copy resources to out/production/shop");
let test = &plan.steps[3];
let test_cp = cp(test);
assert_eq!(Path::new(test_cp.split(sep).next().unwrap()), root.join("out/production/shop"));
assert!(test_cp.contains("junit.jar"));
}
#[test]
fn a_module_dependency_gives_its_library_a_scope_and_jdk_8_gets_source_and_target() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("p");
write(&root.join("src/A.java"), "class A {}");
let mut ps = ProjectStructureSettings {
libraries: vec![ProjectLibrary {
name: "junit".into(),
classes: vec!["junit.jar".into()],
..Default::default()
}],
compiler_output: "build/classes".into(),
..Default::default()
};
ps.modules.insert(
".".into(),
ModuleStructureSettings {
language_level: "1.8".into(),
dependencies: vec![ModuleDependency {
kind: "library".into(),
target: "junit".into(),
scope: DependencyScope::Test,
exported: false,
}],
..Default::default()
},
);
let roots = StructureRoots { sources: vec![root.join("src")], ..Default::default() };
let jdk = StructureJdk { home: PathBuf::from("/jdk8"), major: 8 };
let plan = structure_plan(&root, &ps, &roots, Some(&jdk), "21", BuildKind::Build, &tmp.path().join("c"))
.unwrap()
.unwrap();
let javac = &plan.steps[0];
assert!(!javac.args.iter().any(|a| a == "-cp"), "{:?}", javac.args);
assert!(javac.args.windows(4).any(|w| w == ["-source", "1.8", "-target", "1.8"]));
assert!(
javac.args.windows(2).any(|w| w[0] == "-d" && Path::new(&w[1]).ends_with("build/classes/production/p"))
);
}
#[test]
fn no_plan_without_java_sources() {
let tmp = tempfile::tempdir().unwrap();
let roots = StructureRoots { sources: vec![tmp.path().join("src")], ..Default::default() };
let plan =
structure_plan(tmp.path(), &Default::default(), &roots, None, "", BuildKind::Build, &tmp.path().join("c"));
assert!(plan.unwrap().is_none());
}
#[test]
fn copies_resources_but_not_sources_and_skips_up_to_date_files() {
let tmp = tempfile::tempdir().unwrap();
let src = tmp.path().join("src");
write(&src.join("a/A.java"), "class A {}");
write(&src.join("a/x.xml"), "<x/>");
let out = tmp.path().join("out");
let action = Action::CopyResources { from: vec![src], to: out.clone() };
let cancel = CancellationToken::new();
assert_eq!(action.run(&cancel).unwrap(), "1 resource file(s) copied");
assert!(out.join("a/x.xml").is_file() && !out.join("a/A.java").exists());
assert_eq!(action.run(&cancel).unwrap(), "0 resource file(s) copied");
Action::Clean(vec![out.clone()]).run(&cancel).unwrap();
assert!(!out.exists());
}
fn entries(archive: &Path) -> Vec<String> {
let mut zip = zip::ZipArchive::new(fs::File::open(archive).unwrap()).unwrap();
(0..zip.len()).map(|i| zip.by_index(i).unwrap().name().unwrap().into_owned()).collect()
}
fn run_plan(plan: &BuildPlan) {
let cancel = CancellationToken::new();
for step in &plan.steps {
if let Some((action, _)) = &step.action {
action.run(&cancel).unwrap();
}
}
}
#[test]
fn lays_out_war_jar_and_exploded_artifacts() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("shop");
write(&root.join("WebRoot/index.jsp"), "hi");
write(&root.join("WebRoot/WEB-INF/web.xml"), "<web-app/>");
write(&root.join("WebRoot/WEB-INF/lib/inside.jar"), "");
write(&root.join("lib/extra.jar"), "");
let classes = root.join("out/production/shop");
write(&classes.join("com/a/A.class"), "");
let artifact = |name: &str, kind| ArtifactConfig {
name: name.into(),
kind,
module: ".".into(),
include_libraries: vec!["extra".into()],
main_class: "com.a.A".into(),
..Default::default()
};
let ps = ProjectStructureSettings {
libraries: vec![ProjectLibrary {
name: "extra".into(),
classes: vec!["lib/*.jar".into()],
..Default::default()
}],
facets: vec![FacetConfig {
kind: "web".into(),
module: ".".into(),
descriptor: "WebRoot/WEB-INF/web.xml".into(),
web_root: String::new(),
}],
artifacts: vec![
artifact("shop:war", ArtifactKind::War),
artifact("shop:war exploded", ArtifactKind::WarExploded),
artifact("shop:jar", ArtifactKind::Jar),
],
..Default::default()
};
let cache = tmp.path().join("cache");
for a in &ps.artifacts {
let plan = BuildPlan {
system: BuildSystem::Javac,
title: String::new(),
steps: artifact_steps(&root, &ps, a, &classes, None, &cache),
};
run_plan(&plan);
}
let war = entries(&root.join("out/artifacts/shop_war/shop.war"));
for name in [
"index.jsp",
"WEB-INF/web.xml",
"WEB-INF/lib/inside.jar",
"WEB-INF/lib/extra.jar",
"WEB-INF/classes/com/a/A.class",
] {
assert!(war.iter().any(|e| e == name), "{name} in {war:?}");
}
let exploded = root.join("out/artifacts/shop_war_exploded");
assert!(exploded.join("WEB-INF/classes/com/a/A.class").is_file());
assert!(exploded.join("WEB-INF/lib/extra.jar").is_file());
let jar_dir = root.join("out/artifacts/shop_jar");
let jar = entries(&jar_dir.join("shop.jar"));
assert_eq!(jar[..2], ["META-INF/".to_owned(), "META-INF/MANIFEST.MF".to_owned()]);
assert!(jar.iter().any(|e| e == "com/a/A.class"));
assert!(jar_dir.join("extra.jar").is_file());
let mut zip = zip::ZipArchive::new(fs::File::open(jar_dir.join("shop.jar")).unwrap()).unwrap();
let mut manifest = String::new();
std::io::Read::read_to_string(&mut zip.by_name("META-INF/MANIFEST.MF").unwrap(), &mut manifest).unwrap();
assert!(manifest.contains("Main-Class: com.a.A") && manifest.contains("Class-Path: extra.jar"));
}
#[test]
fn never_lays_out_over_its_own_sources() {
let tmp = tempfile::tempdir().unwrap();
let web = tmp.path().join("WebRoot");
write(&web.join("a.jsp"), "");
let action = Action::Layout { into: tmp.path().to_path_buf(), entries: vec![(web.clone(), PathBuf::new())] };
assert!(action.run(&CancellationToken::new()).is_err());
assert!(web.join("a.jsp").is_file());
}
}
+1 -1
Переглянути файл
@@ -1463,7 +1463,7 @@ dependencies {
model.projects.push(project);
}
assert!(build_files(root, &model).contains(&root.join("included/deps.gradle")));
let model = crate::BuildModel { maven: None, gradle: vec![model] };
let model = crate::BuildModel { maven: None, gradle: vec![model], sbt: Vec::new() };
assert_eq!(crate::dependency_coordinates(root, &model)[0].artifact_id, "included");
}
+10 -5
Переглянути файл
@@ -1,4 +1,4 @@
//! Build tool models for the Maven and Gradle tool windows, and Build › Build
//! Build tool models for the Maven, Gradle and sbt tool windows, and Build › Build
//! Project ([`compile`]) for Maven, Gradle, Cargo, Go and TypeScript projects.
//!
//! [`load`] reads the project's build files (instant, no build tool involved)
@@ -13,6 +13,7 @@ pub mod kotlin_bridge;
pub mod maven;
pub mod pom_edit;
mod process;
pub mod sbt;
mod sync;
pub mod web;
mod xml;
@@ -20,6 +21,7 @@ mod xml;
pub use gradle::{GradleModel, GradleProject, GradleTask};
pub use gradle_deps::{GradleDependency, gradle_dependencies};
pub use maven::{MavenDependency, MavenModel, MavenPlugin, MavenProfile, MavenProject, Omission};
pub use sbt::{SbtBuild, SbtProject};
pub use sync::{
SyncOptions, SyncProgress, maven_profiles, save_maven_profiles, sync_gradle, sync_gradle_model, sync_maven,
};
@@ -42,6 +44,9 @@ pub struct BuildModel {
pub maven: Option<MavenModel>,
#[serde(default)]
pub gradle: Vec<GradleModel>,
/// sbt builds, read from their `build.sbt` (sbt is not started).
#[serde(default)]
pub sbt: Vec<SbtBuild>,
}
impl BuildModel {
@@ -96,7 +101,7 @@ pub fn load_linked(
g
})
.collect();
BuildModel { maven, gradle }
BuildModel { maven, gradle, sbt: sbt::load(root) }
}
/// Gradle project folders outside `root` as of the last sync (`includeFlat` siblings):
@@ -329,7 +334,7 @@ mod tests {
..Default::default()
};
let gradle = gradle::load(root).into_iter().collect();
let model = BuildModel { maven: Some(maven), gradle };
let model = BuildModel { maven: Some(maven), gradle, sbt: Vec::new() };
let names: Vec<String> = dependency_coordinates(root, &model)
.into_iter()
.map(|c| format!("{}{}:{}:{}", if c.gradle { "G " } else { "M " }, c.group_id, c.artifact_id, c.version))
@@ -348,7 +353,7 @@ mod tests {
"ext { gson = '2.8.9' }\ndependencies { implementation \"com.google.code.gson:gson:${gson}\" }\n",
)
.unwrap();
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect() };
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect(), sbt: Vec::new() };
let names: Vec<String> = dependency_coordinates(root, &model)
.into_iter()
.map(|c| format!("{}:{}:{}", c.group_id, c.artifact_id, c.version))
@@ -367,7 +372,7 @@ mod tests {
)
.unwrap();
std::fs::write(root.join("gradle.properties"), "# versions\nv = 1.2\nonlyInProperties: 2.3\n").unwrap();
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect() };
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect(), sbt: Vec::new() };
let versions: Vec<_> = dependency_coordinates(root, &model).into_iter().map(|c| c.version).collect();
assert_eq!(versions, ["1.2", "2.3"]);
}
+301
Переглянути файл
@@ -0,0 +1,301 @@
//! sbt builds for the sbt tool window: each `build.sbt` build under the project root
//! with the projects its definition declares (`lazy val core = project`,
//! `(project in file("core"))`, `Project("core", file("core"))`), read statically —
//! sbt itself is not started.
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct SbtBuild {
/// Folder of `build.sbt`, relative to the project root (`""` for the root itself).
pub dir: String,
/// The launcher: a `sbt` / `sbtx` script in the build folder, else `sbt` on `PATH`.
pub command: String,
/// `sbt.version` of `project/build.properties`.
pub version: Option<String>,
/// The root project first, then the declared projects in source order.
pub projects: Vec<SbtProject>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct SbtProject {
/// The project id tasks are scoped with (`core/compile`).
pub id: String,
/// Base folder relative to the build folder (`""` for the build's own).
pub dir: String,
/// The build's root project: its tasks run unscoped (and aggregate when sbt does).
pub root: bool,
}
/// The sbt builds under `root` (outermost `build.sbt` folders).
pub fn load(root: &Path) -> Vec<SbtBuild> {
ide_core::project_roots::discover(root, &["build.sbt"])
.into_iter()
.filter_map(|dir| {
let text = std::fs::read_to_string(dir.join("build.sbt")).ok()?;
let rel = dir.strip_prefix(root).unwrap_or(&dir).to_string_lossy().replace('\\', "/");
let name = dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| "root".to_owned());
Some(SbtBuild {
dir: rel,
command: launcher(&dir),
version: build_version(&dir),
projects: projects(&text, &name),
})
})
.collect()
}
fn launcher(dir: &Path) -> String {
for script in ["sbt", "sbtx"] {
if !cfg!(windows) && dir.join(script).is_file() {
return format!("./{script}");
}
}
if cfg!(windows) && dir.join("sbt.bat").is_file() {
return "sbt.bat".to_owned();
}
"sbt".to_owned()
}
fn build_version(dir: &Path) -> Option<String> {
let text = std::fs::read_to_string(dir.join("project/build.properties")).ok()?;
text.lines().find_map(|line| {
let (key, value) = line.split_once('=')?;
(key.trim() == "sbt.version").then(|| value.trim().to_owned())
})
}
/// `text` with comments and the contents of string literals blanked (quotes kept),
/// byte for byte, so offsets into it are offsets into `text`.
fn mask(text: &str) -> String {
let mut out = String::with_capacity(text.len());
let blank = |out: &mut String, c: char| {
if c == '\n' {
out.push('\n');
} else {
out.extend(std::iter::repeat_n(' ', c.len_utf8()));
}
};
let mut chars = text.chars().peekable();
while let Some(c) = chars.next() {
match c {
'"' => {
out.push('"');
let mut ahead = chars.clone();
if ahead.next() == Some('"') && ahead.next() == Some('"') {
// `"""…"""`: no escapes inside.
chars.next();
chars.next();
out.push_str("\"\"");
let mut quotes = 0;
for c in chars.by_ref() {
quotes = if c == '"' { quotes + 1 } else { 0 };
if quotes > 0 {
out.push('"')
} else {
blank(&mut out, c)
}
if quotes == 3 {
break;
}
}
continue;
}
while let Some(c) = chars.next() {
if c == '"' || c == '\n' {
out.push(c);
break;
}
blank(&mut out, c);
if c == '\\'
&& let Some(n) = chars.next()
{
blank(&mut out, n);
}
}
}
'/' if chars.peek() == Some(&'/') => {
blank(&mut out, c);
for c in chars.by_ref() {
blank(&mut out, c);
if c == '\n' {
break;
}
}
}
'/' if chars.peek() == Some(&'*') => {
blank(&mut out, c);
let mut prev = ' ';
for c in chars.by_ref() {
blank(&mut out, c);
if prev == '*' && c == '/' {
break;
}
prev = c;
}
}
_ => out.push(c),
}
}
out
}
fn identifier(s: &str) -> Option<(&str, &str)> {
let s = s.trim_start();
if let Some(rest) = s.strip_prefix('`') {
let end = rest.find('`')?;
return Some((&rest[..end], &rest[end + 1..]));
}
let end = s.find(|c: char| !(c.is_alphanumeric() || c == '_')).unwrap_or(s.len());
(end > 0).then(|| (&s[..end], &s[end..]))
}
/// The string literal at the start of `s` (after spaces), and the rest.
fn string_literal(s: &str) -> Option<(&str, &str)> {
let rest = s.trim_start().strip_prefix('"')?;
let end = rest.find('"')?;
Some((&rest[..end], &rest[end + 1..]))
}
/// The folder of a `file("x")` / `new File("x")` at the start of `s`.
fn file_arg(s: &str) -> Option<&str> {
let s = s.trim_start();
let s = s.strip_prefix("file").or_else(|| s.strip_prefix("new File"))?;
let s = s.trim_start().strip_prefix('(')?;
string_literal(s).map(|(dir, _)| dir)
}
fn normalize_dir(dir: &str) -> String {
let dir = dir.trim_start_matches("./").trim_end_matches('/');
if dir == "." { String::new() } else { dir.to_owned() }
}
/// What a `lazy val <id> = <rhs>` declares: a project and its base folder. `rhs` is
/// masked (see [`mask`]); `original` is the same text unmasked, for the folder names.
fn project_of(id: &str, rhs: &str, original: &str) -> Option<String> {
let at = |s: &str| original.get(rhs.len() - s.len()..).unwrap_or_default();
let rhs = rhs.trim_start().trim_start_matches('(').trim_start();
if let Some(rest) = rhs.strip_prefix("Project") {
// `Project("id", file("dir"))` / `Project(id = "x", base = file("dir"))`.
let args = rest.trim_start().strip_prefix('(')?;
let base = args.find("file(").or_else(|| args.find("new File("))?;
return file_arg(at(&args[base..])).map(normalize_dir);
}
let rest = rhs.strip_prefix("project")?;
if rest.starts_with(|c: char| c.is_alphanumeric() || c == '_') {
return None;
}
let rest = rest.trim_start();
let located = rest
.strip_prefix(".in")
.and_then(|r| r.trim_start().strip_prefix('('))
.or_else(|| rest.strip_prefix("in ").or_else(|| rest.strip_prefix("in\t")));
Some(match located.and_then(|l| file_arg(at(l))) {
Some(dir) => normalize_dir(dir),
None => id.to_owned(),
})
}
/// The projects a build definition declares; `name` is the build folder's name, the id
/// sbt gives an implicit root project.
pub fn projects(text: &str, name: &str) -> Vec<SbtProject> {
let masked = mask(text);
let mut out: Vec<SbtProject> = Vec::new();
let mut from = 0;
while let Some(found) = masked[from..].find("val ") {
let at = from + found;
from = at + 4;
if masked[..at].chars().last().is_some_and(|c| c.is_alphanumeric() || c == '_') {
continue;
}
let Some((id, tail)) = identifier(&masked[from..]) else { continue };
let Some(rhs) = tail.trim_start().strip_prefix('=') else { continue };
if rhs.starts_with('=') || rhs.starts_with('>') {
continue;
}
let Some(dir) = project_of(id, rhs, &text[masked.len() - rhs.len()..]) else { continue };
if !out.iter().any(|p| p.id == id) {
out.push(SbtProject { id: id.to_owned(), root: dir.is_empty(), dir });
}
}
match out.iter().position(|p| p.root) {
Some(i) => {
let root = out.remove(i);
out.insert(0, root);
}
None => out.insert(0, SbtProject { id: name.to_owned(), dir: String::new(), root: true }),
}
out
}
#[cfg(test)]
mod tests {
use super::*;
fn ids(text: &str) -> Vec<(String, String, bool)> {
projects(text, "shop").into_iter().map(|p| (p.id, p.dir, p.root)).collect()
}
#[test]
fn single_project_builds_have_an_implicit_root() {
assert_eq!(
ids("ThisBuild / scalaVersion := \"3.3.4\"\nname := \"shop\"\n"),
[("shop".into(), "".into(), true)]
);
}
#[test]
fn declared_projects_and_their_folders() {
let text = r#"
// lazy val commented = project
lazy val root = (project in file("."))
.aggregate(core, `web-app`, util)
.settings(name := "shop")
lazy val core = project
lazy val `web-app` = (project in file("modules/web")).dependsOn(core)
lazy val util = project.in(file("libs/util/"))
lazy val legacy = Project("legacy", file("old"))
/* lazy val hidden = project */
val description = "lazy val fake = project"
lazy val projectSettings = Seq(scalacOptions += "-deprecation")
"#;
assert_eq!(
ids(text),
[
("root".into(), "".into(), true),
("core".into(), "core".into(), false),
("web-app".into(), "modules/web".into(), false),
("util".into(), "libs/util".into(), false),
("legacy".into(), "old".into(), false),
]
);
}
#[test]
fn a_root_declared_last_is_listed_first() {
let text = "lazy val api = project\nlazy val all = (project in file(\".\")).aggregate(api)\n";
assert_eq!(ids(text), [("all".into(), "".into(), true), ("api".into(), "api".into(), false)]);
}
#[test]
fn builds_are_found_with_their_launcher_and_version() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
std::fs::create_dir_all(root.join("svc/project")).unwrap();
std::fs::create_dir_all(root.join("svc/core")).unwrap();
std::fs::write(root.join("svc/build.sbt"), "lazy val core = project\n").unwrap();
// A project's own build.sbt is part of the outer build.
std::fs::write(root.join("svc/core/build.sbt"), "libraryDependencies += \"a\" % \"b\" % \"1\"\n").unwrap();
std::fs::write(root.join("svc/project/build.properties"), "sbt.version = 1.10.7\n").unwrap();
let builds = load(root);
assert_eq!(builds.len(), 1);
let b = &builds[0];
assert_eq!((b.dir.as_str(), b.command.as_str(), b.version.as_deref()), ("svc", "sbt", Some("1.10.7")));
assert_eq!(b.projects.iter().map(|p| p.id.as_str()).collect::<Vec<_>>(), ["svc", "core"]);
}
}
+3
Переглянути файл
@@ -12,6 +12,8 @@ use std::collections::BTreeMap;
pub struct EditorGeneralSettings {
/// Change font size with ⌘ + mouse wheel.
pub wheel_zoom: bool,
/// Scope of ⌘ + mouse wheel font zoom: `active` editor | `all` editors.
pub wheel_zoom_scope: String,
pub markdown_image_folder: String,
pub markdown_image_name_pattern: String,
/// Drag-and-drop of selected text inside the editor.
@@ -37,6 +39,7 @@ impl Default for EditorGeneralSettings {
fn default() -> Self {
Self {
wheel_zoom: false,
wheel_zoom_scope: "active".into(),
markdown_image_folder: "assets".into(),
markdown_image_name_pattern: "image-{timestamp}".into(),
drag_and_drop: true,
+3 -1
Переглянути файл
@@ -14,7 +14,8 @@ pub fn inside_git_repo(dir: &Path) -> bool {
dir.ancestors().any(|d| d.join(".git").exists() || d.join(".jj").exists())
}
/// IDEA's default list, plus `.jj` and the Windows shell files.
/// IDEA's default list, plus `.jj`, rope's `.ropeproject` (pylsp-rope creates it in the
/// project root) and the Windows shell files.
pub const DEFAULT_IGNORED_NAMES: &[&str] = &[
"*.pyc",
"*.pyo",
@@ -25,6 +26,7 @@ pub const DEFAULT_IGNORED_NAMES: &[&str] = &[
".git",
".hg",
".jj",
".ropeproject",
".svn",
"CVS",
"__pycache__",
+69 -5
Переглянути файл
@@ -67,6 +67,12 @@ pub struct Settings {
pub mcp_server: McpServerSettings,
/// Tools › Agents: Command Execution Policy.
pub agent_security: AgentSecuritySettings,
/// Appearance & Behavior › Scopes: named file sets other settings refer to.
pub scopes: Vec<NamedScope>,
/// Appearance & Behavior › File Colors.
pub file_colors: FileColorSettings,
/// Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes.
pub database: DatabaseSettings,
/// Plugin settings (`[contributes.settings]`): plugin id → its values by key.
#[specta(type = BTreeMap<String, BTreeMap<String, specta_typescript::Unknown>>)]
pub plugins: BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
@@ -218,16 +224,20 @@ where
Ok(serde_json::from_value(serde_json::Value::deserialize(d)?).unwrap_or_default())
}
/// The built-in themes that were removed (#2981; the One Dark Pro plugin
/// maintains their look) and the built-in that stands in for each: read by
/// [`theme_id`], and the removal notice looks for them in settings files.
pub const REMOVED_THEMES: [(&str, &str); 2] = [("one-light", "light"), ("one-dark", "dark")];
/// A theme id, with the built-in themes that were removed read as the Islands theme of their kind.
fn theme_id<'de, D>(d: D) -> Result<String, D::Error>
where
D: serde::Deserializer<'de>,
{
let id = String::deserialize(d)?;
Ok(match id.as_str() {
"one-light" => "light".into(),
"one-dark" => "dark".into(),
_ => id,
Ok(match REMOVED_THEMES.iter().find(|(removed, _)| *removed == id.as_str()) {
Some((_, stand_in)) => (*stand_in).to_owned(),
None => id,
})
}
@@ -498,6 +508,9 @@ impl Default for Settings {
agents: AgentSettings::default(),
mcp_server: McpServerSettings::default(),
agent_security: AgentSecuritySettings::default(),
scopes: Vec::new(),
file_colors: FileColorSettings::default(),
database: DatabaseSettings::default(),
plugins: BTreeMap::new(),
}
}
@@ -508,6 +521,47 @@ fn default_keymap() -> &'static str {
if cfg!(target_os = "macos") { "intellij-macos" } else { "intellij-windows" }
}
/// A named set of files: `file:src//*.ts && !file:*.test.ts` (project-relative path patterns
/// joined with `||`, `&&`, `!` and parentheses).
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct NamedScope {
pub name: String,
pub pattern: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct FileColorSettings {
pub enabled: bool,
pub editor_tabs: bool,
pub project_view: bool,
/// Scope → colour; the first scope that holds a file gives its colour.
pub colors: Vec<FileColor>,
}
impl Default for FileColorSettings {
fn default() -> Self {
let color = |scope: &str, color: &str| FileColor { scope: scope.into(), color: color.into() };
Self {
enabled: true,
editor_tabs: true,
project_view: true,
colors: vec![color("Non-Project Files", "yellow"), color("Tests", "green")],
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct FileColor {
/// A built-in scope (`Tests`, `Production`, `Project Files`, `Non-Project Files`) or a
/// `scopes` entry, by name.
pub scope: String,
/// A palette name (`blue`, `green`, `orange`, `rose`, `violet`, `yellow`, `gray`) or `#rrggbb`.
pub color: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct CustomKeymap {
@@ -596,13 +650,20 @@ impl Default for DateFormatSettings {
pub struct NotificationSettings {
pub balloons: bool,
pub sound: bool,
/// Mirror balloon notifications to the OS when no OpenIDEA window is focused.
#[serde(default = "default_true")]
pub system_notifications: bool,
/// Group id → display; groups not listed use their default.
pub groups: BTreeMap<String, NotificationGroupSettings>,
}
fn default_true() -> bool {
true
}
impl Default for NotificationSettings {
fn default() -> Self {
Self { balloons: true, sound: false, groups: BTreeMap::new() }
Self { balloons: true, sound: false, system_notifications: true, groups: BTreeMap::new() }
}
}
@@ -1286,6 +1347,9 @@ pub struct JavaSettings {
pub jdtls_vm_args: String,
/// Share one JDT LS across builds in an ordinary project window; other windows remain separate.
pub jdtls_shared: bool,
/// JDK homes added by hand (Platform Settings › SDKs › Add JDK from Disk…), listed with the
/// detected ones.
pub added_jdks: Vec<String>,
/// Build Tools › Maven.
pub maven: MavenSettings,
/// Build Tools › Gradle.
+2
Переглянути файл
@@ -19,6 +19,7 @@ pub enum Tool {
Maven,
Gradle,
Ruby,
Zig,
}
impl Tool {
@@ -32,6 +33,7 @@ impl Tool {
Tool::Maven => &["maven"],
Tool::Gradle => &["gradle"],
Tool::Ruby => &["ruby"],
Tool::Zig => &["zig"],
}
}
}
+28
Переглянути файл
@@ -69,6 +69,9 @@ pub struct GitSettings {
pub push_dialog_only_protected: bool,
/// Stashes and shelves share one tab.
pub combine_stash_and_shelf: bool,
/// The non-modal Commit tool window works on the index: Staged / Unstaged groups,
/// stage and unstage instead of inclusion checkboxes, and no change lists.
pub staging_area: bool,
}
impl Default for GitSettings {
@@ -90,6 +93,7 @@ impl Default for GitSettings {
show_push_dialog: true,
push_dialog_only_protected: false,
combine_stash_and_shelf: false,
staging_area: false,
}
}
}
@@ -237,6 +241,30 @@ impl Default for LogLevelColors {
}
}
/// Database settings: Query Execution and SQL Resolution Scopes.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct DatabaseSettings {
/// A console's result sets show under the statements that produced them, in the editor,
/// instead of in the Services view's result tabs.
pub in_editor_results: bool,
/// Languages & Frameworks › SQL Resolution Scopes: the data source SQL in a file or folder
/// resolves against (completion, inspections, navigation), most specific path first.
pub resolution_scopes: Vec<SqlResolutionScope>,
}
/// One row of SQL Resolution Scopes.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct SqlResolutionScope {
/// Project-relative file or folder, `/`-separated; empty for the whole project.
pub path: String,
/// Data source id.
pub data_source: String,
/// Schema unqualified names resolve in; empty for the data source's default.
pub schema: String,
}
/// Build, Execution, Deployment › Console.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
+6
Переглянути файл
@@ -120,6 +120,12 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
"stdio",
"Install GDB 14 or newer (apt install gdb, dnf install gdb, brew install gdb)",
),
"unity" => cfg(
"unity-debug",
&[],
"stdio",
"Install Unity Debugger in Settings > Language Servers, or configure the unity-debug tool path",
),
"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(
+1
Переглянути файл
@@ -12,6 +12,7 @@ use std::path::Path;
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AttachKind {
Unity,
Java,
Node,
Python,
+25 -3
Переглянути файл
@@ -19,6 +19,7 @@ mod jvm_memory;
pub mod kotlin;
pub mod kotlin_lsp;
mod session;
pub mod unity;
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
use connection::{Connection, DapError};
@@ -1121,6 +1122,16 @@ impl DebugManager {
let _ = tokio::time::timeout(INIT_TIMEOUT, initialized.wait_for(|v| *v)).await;
}
if s.adapter == "unity" {
if launch_result.is_none()
&& let Some(launch) = launch.as_mut()
{
launch.await?;
launch_result = Some(());
}
unity::wait_for_threads(s).await?;
}
// A fresh adapter has no breakpoints, so a file with none enabled needs no request; the
// others go out together, as VS Code sends them, instead of one round trip per file.
let (files, idle): (Vec<_>, Vec<_>) = self
@@ -1202,6 +1213,10 @@ impl DebugManager {
if let Some(link) = s.jdwp_link.lock().as_ref() {
link.release();
}
if s.adapter == "unity" {
unity::settle_startup(s).await;
s.emit(ide_core::event::DebugEvent::Initialized);
}
Ok(())
}
@@ -1229,11 +1244,18 @@ impl DebugManager {
// rdbg's terminate exits the Ruby process without terminating its children.
let graceful =
terminate && s.request == "launch" && s.adapter != "rdbg" && s.supports("supportsTerminateRequest");
// A program suspended in the debugger cannot act on SIGTERM, and on macOS not even die of
// SIGKILL while the debugger holds it: it is killed (with what it started) and the adapter
// is told to end it. A killed program has no shutdown output to wait for.
let killed = own_terminate && !graceful && s.suspended.get();
if killed {
crate::session::signal_debuggee(s, true).await;
}
if !s.conn.is_closed() {
if graceful {
let _ = s.conn.request_timeout("terminate", json!({ "restart": false }), SHUTDOWN_TIMEOUT).await;
}
if !graceful && !own_terminate {
if !graceful && (!own_terminate || killed) {
let _ = s
.conn
.request_timeout(
@@ -1244,7 +1266,7 @@ impl DebugManager {
.await;
}
}
if own_terminate && !graceful {
if own_terminate && !graceful && !killed {
// Signal before anything else: waiting on a request the adapter may not answer
// would delay the shutdown the console is supposed to show.
crate::session::signal_debuggee(s, false).await;
@@ -1263,7 +1285,7 @@ impl DebugManager {
// lets Run start again into an occupied port, so wait for the program first — with the
// connection still open, so a second Stop can find the session and kill it.
crate::session::wait_for_debuggee(s, terminate).await;
if terminate && s.request == "launch" {
if terminate && s.request == "launch" && !killed {
// The adapter reports `terminated` only after it has drained the program's console
// (java-debug waits up to 5 s for the pump): closing before that drops the last
// shutdown lines from the console.
+15 -2
Переглянути файл
@@ -17,7 +17,7 @@ use std::process::Stdio;
use std::sync::Arc;
use std::sync::Weak;
use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
use std::time::Duration;
use std::time::{Duration, Instant};
use tokio::io::{AsyncRead, AsyncReadExt};
use tokio::process::Child;
use tokio::sync::{mpsc, watch};
@@ -116,6 +116,7 @@ pub(crate) struct Session {
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
/// Used only by a kotlin-lsp session: see [`Session::kotlin_lsp_quirks`].
pub(crate) quirks: kotlin_lsp::Quirks,
pub(crate) unity_startup_activity: Mutex<Instant>,
}
/// Which threads of the program are suspended: each from its `stopped` event until a
@@ -270,6 +271,7 @@ impl Session {
kotlin_mirror: Mutex::new(None),
jvm_memory: tokio::sync::Mutex::default(),
quirks: kotlin_lsp::Quirks::default(),
unity_startup_activity: Mutex::new(Instant::now()),
}
}
@@ -716,6 +718,15 @@ pub(crate) async fn event_loop(
}
async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut body: Value) {
if s.adapter == "unity"
&& event == "output"
&& body
.get("output")
.and_then(Value::as_str)
.is_some_and(|text| text.starts_with("Loaded assembly:") || text.starts_with("Resolved pending breakpoint"))
{
*s.unity_startup_activity.lock() = Instant::now();
}
if let Some(mirror) = s.kotlin_mirror.lock().as_ref() {
mirror.translate(&mut body);
}
@@ -724,7 +735,9 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
match event {
"initialized" => {
s.initialized.send_replace(true);
s.emit(DebugEvent::Initialized);
if s.adapter != "unity" {
s.emit(DebugEvent::Initialized);
}
}
"stopped" => {
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
+93 -2
Переглянути файл
@@ -158,6 +158,7 @@ struct Script {
/// `launch`, and a `configurationDone` sent while it runs is refused with `notStopped`.
gdb15_starts_at_launch: bool,
launch_after_configuration: bool,
empty_thread_responses: usize,
/// Requests of the adapter's own (js-debug's `setCustomBreakpoints`…) answered with an empty body.
accept: &'static [&'static str],
/// Requests of the adapter's own answered with a body and followed by events.
@@ -198,6 +199,7 @@ impl Default for Script {
close_during_startup: false,
gdb15_starts_at_launch: false,
launch_after_configuration: false,
empty_thread_responses: 0,
accept: &[],
custom: None,
}
@@ -244,6 +246,8 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
let mut held: Vec<Value> = Vec::new();
let mut stopped = false;
let mut running = false;
let mut thread_requests = 0;
let mut unity = false;
macro_rules! send {
($v:expr) => {{
let mut v: Value = $v;
@@ -268,13 +272,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
}
match msg["command"].as_str().unwrap_or_default() {
"initialize" => {
unity = msg["arguments"]["adapterID"] == "unity";
if let Some(delay) = script.delay_initialize {
tokio::time::sleep(delay).await;
}
ok!(
msg,
json!({
"supportsConfigurationDoneRequest": true,
"supportsConfigurationDoneRequest": !unity,
"supportsCompletionsRequest": true,
"supportsTerminateRequest": script.supports_terminate,
"supportsSetVariable": true,
@@ -293,8 +298,15 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
// defers it sends late).
send!(json!({"type": "event", "event": "initialized"}));
}
if unity {
send!(json!({"type": "event", "event": "initialized"}));
}
}
"launch" | "attach" => {
if unity {
ok!(msg, Value::Null);
continue;
}
if script.gdb15_starts_at_launch {
// GDB 15 starts the program here and answers `launch` right away.
running = true;
@@ -448,7 +460,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
tokio::time::sleep(Duration::from_millis(50)).await;
ok!(msg, json!({"threads": [{"id": 1, "name": "\"main\"@1"}]}));
}
"threads" => ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]})),
"threads" => {
thread_requests += 1;
if thread_requests <= script.empty_thread_responses {
ok!(msg, json!({"threads": []}));
} else {
ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]}));
}
}
"stackTrace" => ok!(
msg,
json!({"stackFrames": [
@@ -508,6 +527,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
}
}
"disconnect" => {
// Like Delve: the adapter ends the program it launched.
#[cfg(unix)]
if msg["arguments"]["terminateDebuggee"] == true
&& let Some(pid) = script.debuggee_pid
{
// SAFETY: plain syscall on the test's own child process.
unsafe { libc::kill(pid as i32, libc::SIGKILL) };
}
ok!(msg, Value::Null);
let _ = w.lock().await.shutdown().await;
break;
@@ -878,6 +905,32 @@ async fn stop_terminates_and_disconnects() {
assert!(h.manager.threads(id).await.is_err());
}
#[tokio::test]
async fn unity_attach_waits_for_mono_and_disconnects_without_terminating_editor() {
let h = harness(Script { empty_thread_responses: 2, ..Script::default() });
h.manager.set_breakpoints(PathBuf::from("/p/a.cs"), vec![bp(4)]).await.unwrap();
let start = h.start(LaunchConfig {
adapter: "unity".into(),
request: "attach".into(),
program: None,
extra_json: Some(json!({ "name": "Unity Editor (42)", "__exceptionOptions": [] }).to_string()),
..config()
});
let ready = async {
h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
let commands = h.commands();
let before_breakpoints = commands.iter().take_while(|c| *c != "setBreakpoints");
assert!(before_breakpoints.filter(|c| *c == "threads").count() >= 3);
assert!(commands.iter().any(|c| c == "setBreakpoints"));
};
let (id, ()) = tokio::join!(start, ready);
let id = id.unwrap();
assert_eq!(h.request("attach")["arguments"]["name"], "Unity Editor (42)");
h.manager.stop(id).await.unwrap();
assert!(!h.commands().iter().any(|c| c == "launch" || c == "terminate"));
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], false);
}
#[tokio::test]
async fn concurrent_sessions_are_independent() {
let h = harness(Script::default());
@@ -2274,6 +2327,44 @@ async fn stop_waits_for_the_launched_program_to_exit() {
h.wait_event(|e| matches!(e, DebugEvent::Terminated)).await;
}
/// Delve and other adapters without `terminate`: a program stopped at a breakpoint cannot
/// handle the SIGTERM Stop sends, so Stop has the adapter end it instead of waiting out the grace period.
#[cfg(unix)]
#[tokio::test]
async fn stop_kills_a_program_suspended_at_a_breakpoint_at_once() {
let mut child = std::process::Command::new("python3")
.args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(30)"])
.spawn()
.unwrap();
let pid = child.id();
let exited = Arc::new(AtomicBool::new(false));
{
let exited = exited.clone();
std::thread::spawn(move || {
let _ = child.wait();
exited.store(true, Ordering::Release);
});
}
let h = harness(Script { debuggee_pid: Some(pid), supports_terminate: false, ..Default::default() });
let id = h.start(config()).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
let session = h.manager.session(id).unwrap();
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
tokio::time::sleep(Duration::from_millis(200)).await; // let the program install its trap
let started = Instant::now();
h.manager.stop(id).await.unwrap();
let elapsed = started.elapsed();
assert!(elapsed < Duration::from_secs(3), "stop waited {elapsed:?} for a suspended program");
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], true);
let deadline = Instant::now() + Duration::from_secs(2);
while !exited.load(Ordering::Acquire) {
assert!(Instant::now() < deadline, "the suspended program was left running");
tokio::time::sleep(Duration::from_millis(10)).await;
}
}
#[cfg(unix)]
#[tokio::test]
async fn a_second_stop_kills_the_program_instead_of_waiting() {
+187
Переглянути файл
@@ -0,0 +1,187 @@
//! Lists the Unity Editors to attach to through UnityDebug's discovery (`unity-debug list`).
use crate::{
adapter,
attach::{AttachKind, AttachableProcess},
};
use ide_core::{IdeError, IdeResult};
use std::{path::PathBuf, process::Stdio, time::Duration};
/// Waits until Mono reports its threads.
pub(crate) async fn wait_for_threads(session: &crate::session::Session) -> IdeResult<()> {
tokio::time::timeout(Duration::from_secs(20), async {
loop {
let body = session.conn.request_timeout("threads", serde_json::json!({}), Duration::from_secs(5)).await?;
if body.get("threads").and_then(serde_json::Value::as_array).is_some_and(|t| !t.is_empty()) {
return Ok(());
}
tokio::time::sleep(Duration::from_millis(100)).await;
}
})
.await
.map_err(|_| {
IdeError::unavailable(
"Unity debugger did not become ready. Enable Editor Attaching and Debug Mode in Unity, then retry.",
)
})?
}
// Mono binds breakpoints asynchronously and resumes threads itself during startup: wait for that burst to end.
pub(crate) async fn settle_startup(session: &crate::session::Session) {
*session.unity_startup_activity.lock() = std::time::Instant::now();
let _ = tokio::time::timeout(Duration::from_secs(3), async {
while session.unity_startup_activity.lock().elapsed() < Duration::from_secs(1) {
tokio::time::sleep(Duration::from_millis(50)).await;
}
})
.await;
}
pub fn require_runtime(cwd: &std::path::Path) -> IdeResult<()> {
if cfg!(unix) && ide_core::tool_path::find_command("mono", &ide_core::tool_path::search_path(), cwd).is_none() {
return Err(IdeError::unavailable(
"Unity Debugger requires Mono. Install Mono, make sure mono is on PATH, then refresh the Unity process list.",
));
}
Ok(())
}
const NOT_INSTALLED: &str = "debug adapter `unity` not found. Install Unity Debugger in Settings > Language Servers or configure the unity-debug tool path";
pub async fn editors(command: Option<String>, cwd: PathBuf) -> IdeResult<Vec<AttachableProcess>> {
require_runtime(&cwd)?;
let command = command.unwrap_or_else(|| "unity-debug".into());
let lookup = command.clone();
let dir = cwd.clone();
let binary = tokio::task::spawn_blocking(move || adapter::resolve_binary(&lookup, &dir))
.await
.map_err(|e| IdeError::internal(e.to_string()))?
.ok_or_else(|| IdeError::unavailable(NOT_INSTALLED))?;
let mut cmd = tokio::process::Command::new(binary);
ide_core::process::prepare(cmd.as_std_mut());
cmd.arg("list")
.current_dir(&cwd)
.env("PATH", ide_core::tool_path::search_path())
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
let out = tokio::time::timeout(Duration::from_secs(15), cmd.output())
.await
.map_err(|_| {
IdeError::unavailable("Unity process discovery timed out. Check that Unity Editor is responsive.")
})?
.map_err(|e| IdeError::unavailable(format!("Cannot start Unity process discovery: {e}")))?;
if !out.status.success() {
return Err(IdeError::unavailable(format!(
"Unity process discovery failed: {}",
String::from_utf8_lossy(&out.stderr).trim()
)));
}
let mut rows = parse_editors(&String::from_utf8_lossy(&out.stdout));
#[cfg(windows)]
if !rows.is_empty() {
match editor_process_ids() {
Ok(editors) => rows.retain(|p| editors.contains(&p.pid)),
Err(error) => tracing::warn!(%error, "Unity process filtering failed; using adapter discovery results"),
}
}
// The Editor of the open project comes first; the user picks which one to attach to.
let path = cwd.join("Library/EditorInstance.json");
let pid = std::fs::File::open(path).ok().and_then(|file| {
use std::io::Read;
let json: serde_json::Value = serde_json::from_reader(file.take(4096)).ok()?;
json.get("process_id")?.as_u64().and_then(|n| u32::try_from(n).ok())
});
for row in &mut rows {
if Some(row.pid) == pid {
row.command_line = cwd.to_string_lossy().into_owned();
}
}
rows.sort_by_key(|p| Some(p.pid) != pid);
Ok(rows)
}
#[cfg(windows)]
fn editor_process_ids() -> IdeResult<std::collections::HashSet<u32>> {
use std::collections::HashMap;
use windows_sys::Win32::{
Foundation::{CloseHandle, INVALID_HANDLE_VALUE},
System::Diagnostics::ToolHelp::{
CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW, TH32CS_SNAPPROCESS,
},
};
let mut unity = HashMap::new();
// The adapter also finds the asset import worker processes: keep the Unity processes whose parent isn't Unity.
unsafe {
let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if snapshot == INVALID_HANDLE_VALUE {
return Err(std::io::Error::last_os_error().into());
}
let mut entry = PROCESSENTRY32W { dwSize: std::mem::size_of::<PROCESSENTRY32W>() as u32, ..std::mem::zeroed() };
let mut found = Process32FirstW(snapshot, &mut entry);
if found == 0 {
let error = std::io::Error::last_os_error();
CloseHandle(snapshot);
return Err(error.into());
}
while found != 0 {
let end = entry.szExeFile.iter().position(|c| *c == 0).unwrap_or(entry.szExeFile.len());
let name = String::from_utf16_lossy(&entry.szExeFile[..end]);
if name.eq_ignore_ascii_case("Unity.exe") {
unity.insert(entry.th32ProcessID, entry.th32ParentProcessID);
}
found = Process32NextW(snapshot, &mut entry);
}
CloseHandle(snapshot);
}
Ok(unity.iter().filter_map(|(&pid, parent)| (!unity.contains_key(parent)).then_some(pid)).collect())
}
pub fn parse_editors(output: &str) -> Vec<AttachableProcess> {
let mut editors = Vec::new();
for line in output.lines() {
let line = line.trim().trim_start_matches('\u{feff}');
if !line.starts_with("Unity Editor (") {
continue;
}
// 3.0.1 prints `Unity Editor (Unity) (123)`; later versions append the project name.
let Some((name, pid, project)) = line.match_indices(" (").find_map(|(at, _)| {
let (id, project) = line[at + 2..].split_once(')')?;
let pid = id.parse::<u32>().ok().filter(|n| *n > 0)?;
Some((&line[..at], pid, project))
}) else {
continue;
};
if editors.iter().any(|p: &AttachableProcess| p.pid == pid) {
continue;
}
editors.push(AttachableProcess {
pid,
name: "Unity Editor".into(),
command_line: if project.trim().is_empty() { name.into() } else { project.trim().into() },
kind: AttachKind::Unity,
adapter: "unity".into(),
host: None,
port: None,
});
}
editors.sort_by(|a, b| a.command_line.cmp(&b.command_line).then(a.pid.cmp(&b.pid)));
editors
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_editor_ids_and_projects_without_mistaking_players_or_logs_for_editors() {
let rows = parse_editors(
"\u{feff}Unity Editor (Unity) (42) Game (Test)\r\nUnity Editor (7) My Game\nUnity Editor (42) duplicate\nWindowsPlayer (123) Player\nUnity Hub (44)\nUnity Editor (invalid)\nUnity Editor (0)\nlog text",
);
assert_eq!(rows.len(), 2);
assert_eq!((rows[0].pid, rows[0].command_line.as_str()), (42, "Game (Test)"));
assert_eq!(rows[1].pid, 7);
assert!(rows.iter().all(|p| p.kind == AttachKind::Unity && p.adapter == "unity"));
}
}
+187
Переглянути файл
@@ -0,0 +1,187 @@
//! Attaches to a real Unity Editor, with its own temporary project and Editor instance.
//! OPENIDEA_UNITY_EDITOR=<Unity.exe> OPENIDEA_UNITY_ADAPTER=<UnityDebug.exe>
//! cargo test -p ide-dap --test unity -- --ignored --nocapture
use ide_core::{IdeEvent, SharedSink, event::DebugEvent};
use ide_dap::{Breakpoint, DebugManager, LaunchConfig, SessionOwner, StepKind};
use ide_language::LanguageRegistry;
use parking_lot::Mutex;
use std::{collections::BTreeMap, path::PathBuf, sync::Arc, time::Duration};
const SCRIPT: &str = r#"using System.IO;
using UnityEditor;
using UnityEngine;
[InitializeOnLoad]
public static class OpenIdeaAttachProbe
{
static readonly string Root = Directory.GetParent(Application.dataPath).FullName;
static OpenIdeaAttachProbe()
{
EditorApplication.update += Tick;
}
static void Tick()
{
if (EditorApplication.isCompiling || EditorApplication.isUpdating) return;
if (!File.Exists(Path.Combine(Root, "ready")))
File.WriteAllText(Path.Combine(Root, "ready"), System.Diagnostics.Process.GetCurrentProcess().Id.ToString());
if (File.Exists(Path.Combine(Root, "exit"))) { EditorApplication.Exit(0); return; }
if (!File.Exists(Path.Combine(Root, "go"))) return;
File.Delete(Path.Combine(Root, "go"));
int result = Hit(41);
File.WriteAllText(Path.Combine(Root, "done"), result.ToString());
}
static int Hit(int seed)
{
int answer = seed + 1;
return answer;
}
}
"#;
async fn stopped(events: &Mutex<Vec<IdeEvent>>, expected_reason: &str) -> i64 {
for _ in 0..600 {
if let Some(thread) = events.lock().iter().find_map(|e| match e {
IdeEvent::Debug { event: DebugEvent::Stopped { thread_id, reason, .. }, .. }
if reason == expected_reason =>
{
Some(*thread_id)
}
_ => None,
}) {
return thread;
}
tokio::time::sleep(Duration::from_millis(50)).await;
}
let events = events.lock();
panic!("No breakpoint/step event: {:?}", &events[events.len().saturating_sub(16)..]);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[ignore = "needs a licensed Unity Editor and the Unity DAP adapter"]
async fn real_editor_attach_breakpoint_step_variables_and_detach() {
let editor = std::env::var("OPENIDEA_UNITY_EDITOR").expect("OPENIDEA_UNITY_EDITOR");
let adapter = std::env::var("OPENIDEA_UNITY_ADAPTER").expect("OPENIDEA_UNITY_ADAPTER");
let target = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target").canonicalize().unwrap();
// Keep the Editor log for diagnosing a failure.
let root = tempfile::Builder::new().prefix("unity-dap-smoke-").tempdir_in(target).unwrap().keep();
let root = root.to_string_lossy().trim_start_matches(r"\\?\").replace('\\', "/");
let root = PathBuf::from(root);
std::fs::create_dir_all(root.join("Assets/Editor")).unwrap();
std::fs::create_dir(root.join("ProjectSettings")).unwrap();
std::fs::create_dir(root.join("Packages")).unwrap();
std::fs::write(
root.join("ProjectSettings/ProjectVersion.txt"),
format!(
"m_EditorVersion: {}\n",
PathBuf::from(&editor).ancestors().nth(2).and_then(|p| p.file_name()).unwrap().to_string_lossy()
),
)
.unwrap();
std::fs::write(root.join("Packages/manifest.json"), r#"{"dependencies":{}}"#).unwrap();
let source = root.join("Assets/Editor/OpenIdeaAttachProbe.cs");
std::fs::write(&source, SCRIPT).unwrap();
let mut command = tokio::process::Command::new(&editor);
ide_core::process::prepare(command.as_std_mut());
// The test project has no packages: skip the package manager.
command
.args(["-batchmode", "-nographics", "-noUpm", "-debugCodeOptimization", "-projectPath"])
.arg(&root)
.arg("-logFile")
.arg(root.join("Editor.log"))
.current_dir(&root)
.kill_on_drop(true);
let mut child = command.spawn().unwrap();
let pid = child.id().unwrap();
eprintln!("Isolated Unity pid {pid}, project {}", root.display());
for _ in 0..1200 {
if root.join("ready").exists() {
break;
}
assert!(child.try_wait().unwrap().is_none(), "Unity exited; inspect {}/Editor.log", root.display());
tokio::time::sleep(Duration::from_millis(100)).await;
}
assert!(root.join("ready").exists(), "Editor failed to load the test script");
let rows = ide_dap::unity::editors(Some(adapter.clone()), root.clone()).await.unwrap();
assert!(rows.iter().any(|p| p.pid == pid), "test Editor absent: {rows:?}");
let events: Arc<Mutex<Vec<IdeEvent>>> = Arc::default();
let saved = events.clone();
let sink: SharedSink = Arc::new(move |event| saved.lock().push(event));
let manager = DebugManager::new(Arc::new(LanguageRegistry::from_configs(Vec::new())));
let line = SCRIPT.lines().position(|l| l.contains("int answer =")).unwrap() as u32;
manager
.set_breakpoints(
source.clone(),
vec![Breakpoint { line, condition: None, hit_condition: None, log_message: None, enabled: true }],
)
.await
.unwrap();
let start = || {
manager.start_with(
LaunchConfig {
name: format!("Unity Editor ({pid})"),
adapter: "unity".into(),
request: "attach".into(),
program: None,
args: vec![],
cwd: Some(root.clone().into()),
env: BTreeMap::new(),
extra_json: Some(
serde_json::json!({ "name": format!("Unity Editor ({pid})"), "__exceptionOptions": [] })
.to_string(),
),
},
SessionOwner::new("smoke", sink.clone()),
|_| Some(adapter.clone()),
)
};
let session = start().await.unwrap();
eprintln!("Attached; breakpoint states: {:?}", manager.breakpoint_states(&source));
// Mono is ready to run once the start returns.
assert!(!manager.threads(session).await.unwrap().is_empty());
std::fs::write(root.join("go"), "").unwrap();
let thread = stopped(&events, "breakpoint").await;
let frames = manager.stack_trace(session, thread).await.unwrap();
assert!(!frames.is_empty(), "Empty breakpoint stack: {:?}", events.lock());
assert_eq!(frames[0].line, line);
let scopes = manager.scopes(session, frames[0].id).await.unwrap();
let variables = manager.variables(session, scopes[0].variables_reference).await.unwrap();
assert!(variables.iter().any(|v| v.name == "seed" && v.value == "41"), "{variables:?}");
assert_eq!(manager.evaluate(session, Some(frames[0].id), "seed + 1".into()).await.unwrap().value, "42");
events.lock().clear();
manager.step(session, thread, StepKind::Over).await.unwrap();
let thread = stopped(&events, "step").await;
let frames = manager.stack_trace(session, thread).await.unwrap();
assert!(!frames.is_empty(), "Empty step stack: {:?}", events.lock());
assert!(frames[0].line > line);
// Detaching at a breakpoint resumes the Editor.
manager.stop(session).await.unwrap();
verify_resumed(&root, &mut child).await;
// Attaching again to the same Editor hits the existing breakpoint.
std::fs::remove_file(root.join("done")).unwrap();
events.lock().clear();
let session = start().await.unwrap_or_else(|error| {
let events = events.lock();
panic!("Reattach failed: {error:?}, recent events: {:?}", &events[events.len().saturating_sub(12)..]);
});
std::fs::write(root.join("go"), "").unwrap();
let thread = stopped(&events, "breakpoint").await;
assert_eq!(manager.stack_trace(session, thread).await.unwrap()[0].line, line);
manager.stop(session).await.unwrap();
verify_resumed(&root, &mut child).await;
std::fs::write(root.join("exit"), "").unwrap();
assert!(tokio::time::timeout(Duration::from_secs(30), child.wait()).await.unwrap().unwrap().success());
eprintln!("Verified discovery, attachment, breakpoint, locals, evaluation, step, detach and reattachment");
}
async fn verify_resumed(root: &std::path::Path, child: &mut tokio::process::Child) {
let path = root.join("done");
for _ in 0..100 {
assert!(child.try_wait().unwrap().is_none(), "disconnect terminated the Unity Editor");
if std::fs::read_to_string(&path).is_ok_and(|text| text == "42") {
return;
}
tokio::time::sleep(Duration::from_millis(100)).await;
}
panic!("Unity did not complete the script after disconnect: {:?}", std::fs::read_to_string(path));
}
+13 -2
Переглянути файл
@@ -279,6 +279,18 @@ type Session = Arc<tokio::sync::Mutex<Option<Held>>>;
const MAX_META_ROWS: usize = 100_000;
/// Rows of catalog query `q`, run again as [`sql::postgres_legacy`] when a PostgreSQL server's
/// catalog lacks a column it reads (openGauss, PostgreSQL 9).
async fn catalog_rows(pool: &Pool, q: &str) -> IdeResult<Vec<Vec<Option<String>>>> {
match pool.rows(q, MAX_META_ROWS).await {
Err(e) if pool.driver() == DbDriver::Postgres => match sql::postgres_legacy(q) {
Some(legacy) => pool.rows(&legacy, MAX_META_ROWS).await.map_err(|_| e),
None => Err(e),
},
rows => rows,
}
}
fn flag(v: &Option<String>) -> bool {
matches!(v.as_deref(), Some("1" | "t" | "true" | "YES"))
}
@@ -1079,8 +1091,7 @@ impl DbManager {
let driver = pool.driver();
let mut out = SchemaObjects::default();
if let Some(q) = sql::routines(driver, schema) {
out.routines = pool
.rows(&q, MAX_META_ROWS)
out.routines = catalog_rows(&pool, &q)
.await?
.into_iter()
.filter_map(|r| {
+51 -7
Переглянути файл
@@ -219,6 +219,9 @@ pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {
}
/// Rows: `index name, unique (0/1), column` (one row per indexed column, in order).
// Key columns are paired from one series up to `max_index_keys` (the server's INDEX_MAX_KEYS, the
// most columns an index or key has): unlike a series per catalog row, it lets the planner find the
// table's rows through the catalog's index first.
pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
match driver {
@@ -236,8 +239,8 @@ pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
"SELECT i.relname, CASE WHEN ix.indisunique THEN 1 ELSE 0 END, a.attname \
FROM pg_index ix JOIN pg_class t ON t.oid = ix.indrelid JOIN pg_class i ON i.oid = ix.indexrelid \
JOIN pg_namespace n ON n.oid = t.relnamespace \
JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord) ON true \
JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum \
JOIN generate_series(0, current_setting('max_index_keys')::int - 1) AS k(ord) ON k.ord < ix.indnatts \
JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ix.indkey[k.ord] \
WHERE n.nspname = {s} AND t.relname = {t} ORDER BY i.relname, k.ord"
),
DbDriver::Mysql => format!(
@@ -284,12 +287,15 @@ pub fn completion_columns(driver: DbDriver) -> &'static str {
FROM sqlite_master m JOIN pragma_table_info(m.name) p \
WHERE m.type IN ('table', 'view') AND m.name NOT LIKE 'sqlite\\_%' ESCAPE '\\' ORDER BY m.name, p.cid"
}
// Identity columns own their sequence through an internal dependency (`attidentity` is PostgreSQL 10+).
DbDriver::Postgres => {
"SELECT n.nspname, c.relname, CASE c.relkind WHEN 'v' THEN 'view' WHEN 'm' THEN 'materialized view' ELSE 'table' END, a.attname, \
format_type(a.atttypid, a.atttypmod), CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END, \
CASE WHEN EXISTS (SELECT 1 FROM pg_index i WHERE i.indrelid = c.oid AND i.indisprimary \
AND a.attnum = ANY(i.indkey)) THEN 1 ELSE 0 END, \
CASE WHEN a.atthasdef OR a.attidentity <> '' THEN 1 ELSE 0 END \
CASE WHEN a.atthasdef OR EXISTS (SELECT 1 FROM pg_depend d WHERE d.refclassid = 'pg_class'::regclass \
AND d.refobjid = c.oid AND d.refobjsubid = a.attnum AND d.classid = 'pg_class'::regclass \
AND d.deptype = 'i') THEN 1 ELSE 0 END \
FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace JOIN pg_attribute a ON a.attrelid = c.oid \
WHERE c.relkind IN ('r', 'v', 'm', 'p', 'f') AND a.attnum > 0 AND NOT a.attisdropped \
AND n.nspname NOT IN ('pg_catalog', 'information_schema') \
@@ -363,9 +369,9 @@ pub fn foreign_keys(driver: DbDriver) -> &'static str {
FROM pg_constraint con \
JOIN pg_class sc ON sc.oid = con.conrelid JOIN pg_namespace sn ON sn.oid = sc.relnamespace \
JOIN pg_class tc ON tc.oid = con.confrelid JOIN pg_namespace tn ON tn.oid = tc.relnamespace \
CROSS JOIN LATERAL unnest(con.conkey, con.confkey) WITH ORDINALITY AS k(s, t, ord) \
JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = k.s \
JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = k.t \
JOIN generate_series(1, current_setting('max_index_keys')::int) AS k(ord) ON k.ord <= array_upper(con.conkey, 1) \
JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = con.conkey[k.ord] \
JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = con.confkey[k.ord] \
WHERE con.contype = 'f' AND sn.nspname NOT IN ('pg_catalog', 'information_schema') \
ORDER BY 1, 2, 3, k.ord LIMIT 20000"
}
@@ -408,7 +414,7 @@ pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String
"SELECT {s}, {t}, f.id, f.\"from\", {s}, f.\"table\", f.\"to\" FROM pragma_foreign_key_list({t}, {s}) f ORDER BY f.id, f.seq"
),
DbDriver::Postgres => format!(
"SELECT sn.nspname, sc.relname, con.conname, sa.attname, tn.nspname, tc.relname, ta.attname FROM pg_constraint con JOIN pg_class sc ON sc.oid = con.conrelid JOIN pg_namespace sn ON sn.oid = sc.relnamespace JOIN pg_class tc ON tc.oid = con.confrelid JOIN pg_namespace tn ON tn.oid = tc.relnamespace CROSS JOIN LATERAL unnest(con.conkey, con.confkey) WITH ORDINALITY AS k(s, t, ord) JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = k.s JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = k.t WHERE con.contype = 'f' AND sn.nspname = {s} AND sc.relname = {t} ORDER BY 3, k.ord"
"SELECT sn.nspname, sc.relname, con.conname, sa.attname, tn.nspname, tc.relname, ta.attname FROM pg_constraint con JOIN pg_class sc ON sc.oid = con.conrelid JOIN pg_namespace sn ON sn.oid = sc.relnamespace JOIN pg_class tc ON tc.oid = con.confrelid JOIN pg_namespace tn ON tn.oid = tc.relnamespace JOIN generate_series(1, current_setting('max_index_keys')::int) AS k(ord) ON k.ord <= array_upper(con.conkey, 1) JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = con.conkey[k.ord] JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = con.confkey[k.ord] WHERE con.contype = 'f' AND sn.nspname = {s} AND sc.relname = {t} ORDER BY 3, k.ord"
),
DbDriver::Mysql => format!(
"SELECT table_schema, table_name, constraint_name, column_name, referenced_table_schema, referenced_table_name, referenced_column_name FROM information_schema.key_column_usage WHERE referenced_table_name IS NOT NULL AND table_schema = {s} AND table_name = {t} ORDER BY constraint_name, ordinal_position"
@@ -671,6 +677,16 @@ pub fn sqlite_trigger_event(sql: &str) -> (String, String) {
(timing.to_owned(), event.to_ascii_lowercase())
}
/// PostgreSQL catalog query `sql` of this module for servers whose catalog predates a column
/// it reads: PostgreSQL before 11 (`prokind`), and the servers built on an older PostgreSQL
/// (openGauss, GaussDB). `None` when it reads none.
pub fn postgres_legacy(sql: &str) -> Option<String> {
let legacy = sql
.replace("CASE WHEN p.prokind = 'p' THEN 'procedure' ELSE 'function' END", "'function'")
.replace("p.prokind IN ('f', 'p')", "NOT p.proisagg AND NOT p.proiswindow");
(legacy != sql).then_some(legacy)
}
/// Rows: `name, kind (function/procedure), arguments, result` of a schema's routines (none in SQLite).
pub fn routines(driver: DbDriver, schema: &str) -> Option<String> {
let s = quote_literal(driver, schema);
@@ -1172,4 +1188,32 @@ mod tests {
assert_eq!(crate::conn::begin_statement(driver), "BEGIN");
assert_eq!(crate::plan::explain_statement(driver, "select 1;"), "EXPLAIN USING TABULAR select 1");
}
#[test]
fn postgres_catalog_queries_run_on_older_servers() {
let pg = DbDriver::Postgres;
// Neither LATERAL (9.3), WITH ORDINALITY (9.4) nor attidentity (10) in any metadata query:
// openGauss / GaussDB parse 9.2's grammar and catalog. `prokind` (11) has its legacy rerun.
let queries = [
schemas(pg, false).to_owned(),
schemas(pg, true).to_owned(),
tables(pg, "s"),
columns(pg, "s", "t"),
indexes(pg, "s", "t"),
completion_columns(pg).to_owned(),
foreign_keys(pg).to_owned(),
table_foreign_keys(pg, "s", "t"),
triggers(pg, "s", "t"),
routines(pg, "s").unwrap(),
sequences(pg, "s").unwrap(),
];
for q in queries {
let upper = q.to_uppercase();
assert!(!["LATERAL", "ORDINALITY", "ATTIDENTITY"].iter().any(|w| upper.contains(w)), "{q}");
}
assert_eq!(postgres_legacy(completion_columns(pg)), None);
let routines = postgres_legacy(&routines(pg, "s").unwrap()).unwrap();
assert!(!routines.contains("prokind") && routines.contains("NOT p.proisagg"));
assert_eq!(postgres_legacy(&indexes(pg, "s", "t")), None);
}
}
+95
Переглянути файл
@@ -133,3 +133,98 @@ async fn a_reused_physical_connection_restores_the_full_default_path() -> IdeRes
);
Ok(())
}
/// Indexes, foreign keys, routines and completion read the catalog with queries every
/// PostgreSQL-protocol server answers, back to the 9.2 core of openGauss / GaussDB (#3637).
#[tokio::test]
async fn table_details_routines_and_completion_on_older_catalogs() -> IdeResult<()> {
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let c = CancellationToken::new();
for stmt in [
"DROP SCHEMA IF EXISTS oi_meta CASCADE",
"CREATE SCHEMA oi_meta",
"CREATE TABLE oi_meta.orders (region INT, id INT, note TEXT DEFAULT 'x', PRIMARY KEY (region, id))",
"CREATE TABLE oi_meta.lines (n INT PRIMARY KEY, o_region INT, o_id INT, \
FOREIGN KEY (o_region, o_id) REFERENCES oi_meta.orders (region, id))",
"CREATE INDEX lines_order ON oi_meta.lines (o_id, o_region)",
"CREATE FUNCTION oi_meta.twice(v INT) RETURNS INT AS 'SELECT v * 2' LANGUAGE sql",
] {
db.execute("p", stmt, 10, &c).await?;
}
let details = db.table_details("p", "oi_meta", "lines").await?;
let index = details.indexes.iter().find(|i| i.name == "lines_order").expect("lines_order");
assert_eq!(index.columns, ["o_id", "o_region"]);
assert!(!index.unique);
assert_eq!(details.foreign_keys.len(), 1, "{:?}", details.foreign_keys);
assert_eq!(details.foreign_keys[0].columns, ["o_region", "o_id"]);
assert_eq!(details.foreign_keys[0].ref_columns, ["region", "id"]);
let orders = db.table_details("p", "oi_meta", "orders").await?;
let key = orders.indexes.iter().find(|i| i.unique).expect("primary key index");
assert_eq!(key.columns, ["region", "id"]);
let objects = db.schema_objects("p", "oi_meta").await?;
assert!(objects.routines.iter().any(|r| r.name == "twice"), "{:?}", objects.routines);
let completion = db.completion("p").await?;
assert!(completion.tables.iter().any(|t| t.schema == "oi_meta" && t.name == "orders"));
db.execute("p", "DROP SCHEMA oi_meta CASCADE", 10, &c).await?;
Ok(())
}
/// Opening a table pairs the columns of composite keys in order, also when a foreign key lists
/// them in another order than the key it references; its data page and DDL read the same catalog,
/// and completion tells identity columns apart in one query (#3637).
#[tokio::test]
async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let c = CancellationToken::new();
for stmt in [
"DROP SCHEMA IF EXISTS oi_keys CASCADE",
"CREATE SCHEMA oi_keys",
"CREATE TABLE oi_keys.pairs (a INT, b INT, PRIMARY KEY (b, a))",
"CREATE TABLE oi_keys.refs (id INT PRIMARY KEY, x INT, y INT, FOREIGN KEY (y, x) REFERENCES oi_keys.pairs (b, a))",
"CREATE UNIQUE INDEX refs_yx ON oi_keys.refs (y, x)",
"INSERT INTO oi_keys.pairs VALUES (1, 2)",
"INSERT INTO oi_keys.refs VALUES (7, 1, 2)",
] {
db.execute("p", stmt, 10, &c).await?;
}
let details = db.table_details("p", "oi_keys", "refs").await?;
let indexes: Vec<_> = details.indexes.iter().map(|i| (i.name.as_str(), i.unique, i.columns.join(","))).collect();
assert_eq!(indexes, [("refs_pkey", true, "id".into()), ("refs_yx", true, "y,x".into())]);
let key = |k: &ide_db::ForeignKey| (k.columns.join(","), k.ref_table.clone(), k.ref_columns.join(","));
assert_eq!(
details.foreign_keys.iter().map(key).collect::<Vec<_>>(),
[("y,x".into(), "pairs".into(), "b,a".into())]
);
let pairs = db.table_details("p", "oi_keys", "pairs").await?;
assert_eq!(pairs.indexes[0].columns, ["b", "a"]);
let page = db.table_page("p", "oi_keys", "refs", None, &[], 0, 10, &c).await?;
assert_eq!(page.result.rows.len(), 1);
// Identity columns (PostgreSQL 10+; openGauss has none) are optional in INSERT.
let identity =
db.execute("p", "CREATE TABLE oi_keys.ids (n INT GENERATED ALWAYS AS IDENTITY, v INT)", 10, &c).await;
let completion = db.completion("p").await?;
if identity.is_ok() {
let ids = completion.tables.iter().find(|t| t.schema == "oi_keys" && t.name == "ids").expect("ids");
let defaults: Vec<_> = ids.columns.iter().map(|c| (c.name.as_str(), c.has_default)).collect();
assert_eq!(defaults, [("n", true), ("v", false)]);
}
assert!(
completion.foreign_keys.iter().any(|k| k.table == "refs" && key(k).2 == "b,a"),
"{:?}",
completion.foreign_keys
);
// The other catalog reads of the tree and its DDL actions, on the same server.
assert!(db.schemas("p").await?.iter().any(|s| s == "oi_keys"));
assert_eq!(db.tables("p", "oi_keys").await?.len(), if identity.is_ok() { 3 } else { 2 });
db.execute("p", "CREATE SEQUENCE oi_keys.seq", 10, &c).await?;
let objects = db.schema_objects("p", "oi_keys").await?;
assert_eq!(objects.sequences.len(), 1);
assert!(db.ddl("p", "oi_keys", "refs").await?.contains("FOREIGN KEY"));
db.execute("p", "DROP SCHEMA oi_keys CASCADE", 10, &c).await?;
Ok(())
}
+21
Переглянути файл
@@ -48,6 +48,9 @@ pub enum Capability {
Ipc(String),
/// Run one external program. Full code execution: never fine-grained.
Process(String),
/// Send a running language server (its name in the language definition) its own
/// requests. The server reads and edits project files on the plugin's behalf.
Lsp(String),
/// Read files outside the project under one path.
FsRead(String),
/// Write files outside the project under one path.
@@ -85,6 +88,7 @@ impl Capability {
| Self::IdeCommands
| Self::Ipc(_)
| Self::Process(_)
| Self::Lsp(_)
| Self::FsRead(_)
| Self::FsWrite(_) => Risk::High,
}
@@ -126,6 +130,9 @@ impl Capability {
format!("Connect to local socket {path} — equivalent to running arbitrary code on the project machine")
}
Self::Process(bin) => format!("Run {bin} — equivalent to running arbitrary code on this machine"),
Self::Lsp(server) => {
format!("Send requests to the {server} language server, which reads and changes the project's files")
}
Self::FsRead(path) => format!("Read files under {path}, outside the project"),
Self::FsWrite(path) => format!("Change files under {path}, outside the project"),
}
@@ -249,6 +256,7 @@ impl fmt::Display for Capability {
Self::NetHttp(h) => write!(f, "net.http:{h}"),
Self::Ipc(p) => write!(f, "ipc:{p}"),
Self::Process(b) => write!(f, "process:{b}"),
Self::Lsp(s) => write!(f, "lsp:{s}"),
Self::FsRead(p) => write!(f, "fs.read:{p}"),
Self::FsWrite(p) => write!(f, "fs.write:{p}"),
}
@@ -298,6 +306,12 @@ impl FromStr for Capability {
}
Ok(Self::Process(arg.to_owned()))
}
"lsp" => {
if arg.len() > 128 || arg.chars().any(|c| c.is_whitespace() || c.is_control() || c == ':') {
return Err(format!("{s:?}: use the server's name in its language definition"));
}
Ok(Self::Lsp(arg.to_owned()))
}
"fs.read" | "fs.write" => {
if !std::path::Path::new(arg).is_absolute() && !arg.starts_with('~') {
return Err(format!("{s:?}: use an absolute path (or ~/…)"));
@@ -376,6 +390,8 @@ mod tests {
"net:crates.io",
"net:*.github.com",
"process:cargo",
"lsp:phoxite",
"lsp:rust-analyzer",
] {
assert_eq!(s.parse::<Capability>().unwrap().to_string(), s);
}
@@ -392,6 +408,9 @@ mod tests {
assert!("net:".parse::<Capability>().is_err());
assert!("net:a b".parse::<Capability>().is_err());
assert!("process:./evil".parse::<Capability>().is_err());
assert!("lsp:".parse::<Capability>().is_err());
assert!("lsp:a b".parse::<Capability>().is_err());
assert!("lsp:phoxite:phoxite/laravel".parse::<Capability>().is_err());
assert!("fs.read:rel".parse::<Capability>().is_err());
assert!("fs.write:rel".parse::<Capability>().is_err());
assert!("network".parse::<Capability>().is_err());
@@ -405,6 +424,8 @@ mod tests {
assert_eq!("clipboard".parse::<Capability>().unwrap(), Capability::Clipboard);
assert_eq!(Capability::Clipboard.risk(), Risk::Medium);
assert_eq!(Capability::Process("cargo".into()).risk(), Risk::High);
assert_eq!(Capability::Lsp("phoxite".into()).risk(), Risk::High);
assert!(!Capability::Lsp("phoxite".into()).covers(&Capability::Lsp("intelephense".into())));
assert!(Capability::Storage.auto_migrates() && !Capability::EditorWrite.auto_migrates());
}
+18
Переглянути файл
@@ -357,6 +357,9 @@ impl Manifest {
if matches!(cap, Capability::NetAsk) {
self.needs_api(&format!("capability `{cap}`"), 5)?;
}
if matches!(cap, Capability::Lsp(_)) {
self.needs_api(&format!("capability `{cap}`"), 9)?;
}
}
if let Some(dark) = &self.icon_dark {
if self.icon.is_none() {
@@ -712,6 +715,21 @@ mod tests {
}
}
#[test]
fn language_server_capabilities_need_api_1_9() {
let caps = "[capabilities]
required = [\"lsp:phoxite\"]
";
for engine in ["^1.2", "^1.8"] {
assert!(
err(&format!("{}{caps}", BASE.replace("^1.2", engine))).contains("new in plugin API 1.9"),
"{engine}"
);
}
let m = Manifest::parse(&format!("{}{caps}", BASE.replace("^1.2", "^1.9"))).unwrap();
assert_eq!(m.capabilities.required, [Capability::Lsp("phoxite".into())]);
}
#[test]
fn parses_icons() {
let m = Manifest::parse(&format!("{BASE}icon = \"icon.svg\"\nicon-dark = \"icon_dark.svg\"\n")).unwrap();
+3 -1
Переглянути файл
@@ -320,7 +320,8 @@ fn rename_failure(error: &io::Error) -> RenameFailure {
}
/// Only Windows splits these paths. Renames are cheap; cross-volume copies run in
/// the background. Consumers always use Local, even when migration fails.
/// the background. Consumers always use Local, even when migration fails. On every
/// system, tool virtual environments moved from elsewhere are dropped (#3581).
pub fn migrate(data: &Path, local: &Path) {
if cfg!(target_os = "windows") && data != local {
migrate_entries(data, local);
@@ -328,6 +329,7 @@ pub fn migrate(data: &Path, local: &Path) {
if cfg!(target_os = "windows") {
relative_tool_shims(&local.join("tools"));
}
ide_tools::drop_moved_venvs(&local.join("tools"));
}
/// Wrappers written before they named their tool relative to themselves hold its absolute
+9
Переглянути файл
@@ -190,6 +190,7 @@ impl Host {
open_locks: Default::default(),
};
host.apply_proxy();
host.apply_added_jdks();
ops::agent::move_user_mcp_values(&host);
host
}
@@ -531,6 +532,14 @@ impl Host {
}
}
impl Host {
/// Lists the JDKs added by hand (global Settings › SDKs) with the detected ones.
pub fn apply_added_jdks(&self) {
let homes = self.global_settings.effective().languages.java.added_jdks;
ide_sdk::java::set_added_jdks(homes.into_iter().map(PathBuf::from));
}
}
#[cfg(test)]
mod tests {
use super::*;
+252
Переглянути файл
@@ -0,0 +1,252 @@
//! HTTP Client tools: list and run requests from project `.http` / `.rest` files.
use crate::mcp::tool::{Call, Output, Param, ParamType, Tool};
use ide_core::{IdeError, IdeResult};
use serde_json::json;
use std::path::Path;
/// Response body characters returned at most (keeps agent context bounded).
const MAX_BODY_CHARS: usize = 8_192;
pub fn tools() -> Vec<Tool> {
vec![http_list_requests(), http_run_request()]
}
fn is_http_file(path: &Path) -> bool {
path.extension()
.and_then(|e| e.to_str())
.is_some_and(|e| e.eq_ignore_ascii_case("http") || e.eq_ignore_ascii_case("rest"))
}
async fn resolve_http_file(call: &Call, path: &str) -> IdeResult<std::path::PathBuf> {
let path = call.resolve_inside(path)?;
if !is_http_file(&path) {
return Err(IdeError::invalid("path must be a .http or .rest file"));
}
if !path.is_file() {
return Err(IdeError::not_found(format!("No such file: {}", call.display(&path))));
}
Ok(path)
}
fn http_list_requests() -> Tool {
Tool::new(
"http_list_requests",
"Lists the HTTP requests in a project `.http` or `.rest` file (IntelliJ-style HTTP Client).
Returns each request's 0-based `index`, optional `name`, `method`, URL as written (variables not substituted), and `line`.
Use `http_run_request` with the same `path` and an `index` to send one.",
|call| async move {
let path = resolve_http_file(&call, &call.str("path")?).await?;
let text = crate::ops::fs::read_text(&call.host(), call.window(), path).await?;
let requests: Vec<_> = ide_http::parse::requests(&text)
.into_iter()
.map(|b| {
json!({
"index": b.index,
"name": b.name,
"method": b.method,
"url": b.url,
"line": b.line,
})
})
.collect();
Output::json(json!({ "requests": requests }))
},
)
.param(Param::required(
"path",
ParamType::String,
"Project-relative path to a `.http` or `.rest` file",
))
.output(json!({
"type": "object",
"properties": {
"requests": {
"type": "array",
"items": {
"type": "object",
"properties": {
"index": { "type": "integer" },
"name": { "type": ["string", "null"] },
"method": { "type": "string" },
"url": { "type": "string" },
"line": { "type": "integer" },
},
"required": ["index", "method", "url", "line"],
},
},
},
"required": ["requests"],
}))
}
fn truncate_chars(text: &str, max: usize) -> (String, bool) {
let count = text.chars().count();
if count <= max {
return (text.to_owned(), false);
}
(text.chars().take(max).collect(), true)
}
/// Drop resolved URLs from transport errors so MCP JSON does not echo env-substituted targets.
fn redact_transport_error(error: Option<String>, resolved_url: &str) -> Option<String> {
let error = error?;
let mut out = error.replace(resolved_url, "<url>");
// reqwest often embeds `https://host/...` even when the primary URL string differs slightly.
out = redact_urls(&out);
Some(out)
}
fn redact_urls(s: &str) -> String {
let mut out = String::with_capacity(s.len());
let mut rest = s;
loop {
// Prefer `https://` so we don't match the `http://` prefix inside it.
let start = match (rest.find("https://"), rest.find("http://")) {
(Some(a), Some(b)) => Some(a.min(b)),
(Some(a), None) => Some(a),
(None, Some(b)) => Some(b),
(None, None) => None,
};
let Some(start) = start else {
out.push_str(rest);
break;
};
out.push_str(&rest[..start]);
out.push_str("<url>");
let after = &rest[start..];
let end = after.find(|c: char| c.is_whitespace() || c == '\'' || c == '"' || c == ')').unwrap_or(after.len());
rest = &after[end..];
}
out
}
fn http_run_request() -> Tool {
Tool::new(
"http_run_request",
"Runs one request from a project `.http` or `.rest` file by 0-based `index`, using the IDE HTTP Client
(same as Run Request in the editor). Variables resolve from `http-client.env.json` / `http-client.private.env.json`
for the optional `env` name. Asks for confirmation with the resolved URL (and header names) first.
Returns status, timing and a truncated response body — not request headers or body (those may hold secrets).
The `url` field in the result is as written in the file (unsubstituted); transport errors redact URLs.",
|call| async move {
let rel = call.str("path")?;
let path = resolve_http_file(&call, &rel).await?;
let index =
call.opt_i64("index")?.ok_or_else(|| IdeError::invalid("missing or invalid argument `index`"))?;
if index < 0 {
return Err(IdeError::invalid("index must be >= 0"));
}
let index = index as u32;
let env = call.opt_str("env")?;
let text = crate::ops::fs::read_text(&call.host(), call.window(), path.clone()).await?;
let blocks = ide_http::parse::requests(&text);
let block =
blocks.get(index as usize).ok_or_else(|| IdeError::not_found(format!("no request #{}", index + 1)))?;
let input = ide_http::RunInput {
text: &text,
index,
file: Some(&path),
root: Some(call.root()),
env: env.as_deref(),
};
// Prepare before confirm so the dialog shows the real destination (after env substitution).
let prepared = ide_http::prepare(&input)?;
let subject = prepared.name.clone().unwrap_or_else(|| format!("{} {}", prepared.method, prepared.url));
let headers: Vec<_> = prepared.headers.iter().map(|(k, _)| k.as_str()).collect();
let mut detail = format!("{} {}\nFile: {rel}\nIndex: {index}", prepared.method, prepared.url);
if let Some(env) = &env {
detail.push_str(&format!("\nEnvironment: {env}"));
}
if !headers.is_empty() {
detail.push_str(&format!("\nHeaders: {}", headers.join(", ")));
}
if prepared.body.is_some() {
detail.push_str("\nBody: present");
}
call.confirm(&subject, Some(detail)).await?;
let exchange = ide_http::run(input, &call.cancel).await?;
let history = call.project().http_history.clone();
let saved = exchange.clone();
let _ = call.host().blocking(move || history.add(&saved)).await;
let (body, body_truncated) = match exchange.response.as_ref().and_then(|r| r.body.as_deref()) {
Some(b) => {
let (t, truncated) = truncate_chars(b, MAX_BODY_CHARS);
(Some(t), truncated)
}
None => (None, false),
};
let response = exchange.response.as_ref();
Output::json(json!({
"index": index,
"name": block.name,
"method": block.method,
"url": block.url,
"status": response.map(|r| r.status),
"statusText": response.map(|r| r.status_text.clone()),
"totalMs": response.map(|r| r.total_ms).or(exchange.entry.total_ms),
"error": redact_transport_error(exchange.entry.error.clone(), &prepared.url),
"body": body,
"bodyTruncated": body_truncated,
}))
},
)
.write()
.param(Param::required("path", ParamType::String, "Project-relative path to a `.http` or `.rest` file"))
.param(Param::required("index", ParamType::Integer, "0-based request index from `http_list_requests`"))
.param(Param::optional(
"env",
ParamType::String,
"Environment name from `http-client.env.json` / `http-client.private.env.json`",
))
.output(json!({
"type": "object",
"properties": {
"index": { "type": "integer" },
"name": { "type": ["string", "null"] },
"method": { "type": "string" },
"url": { "type": "string" },
"status": { "type": ["integer", "null"] },
"statusText": { "type": ["string", "null"] },
"totalMs": { "type": ["number", "null"] },
"error": { "type": ["string", "null"] },
"body": { "type": ["string", "null"] },
"bodyTruncated": { "type": "boolean" },
},
"required": ["index", "method", "url", "bodyTruncated"],
}))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn accepts_http_and_rest_extensions() {
assert!(is_http_file(Path::new("a.http")));
assert!(is_http_file(Path::new("a.REST")));
assert!(!is_http_file(Path::new("a.txt")));
}
#[test]
fn truncates_long_bodies() {
let long = "x".repeat(MAX_BODY_CHARS + 10);
let (t, truncated) = truncate_chars(&long, MAX_BODY_CHARS);
assert!(truncated);
assert_eq!(t.chars().count(), MAX_BODY_CHARS);
assert_eq!(truncate_chars("ok", MAX_BODY_CHARS), ("ok".into(), false));
}
#[test]
fn redacts_urls_in_transport_errors() {
let url = "https://secret.example/v1?token=abc";
assert_eq!(
redact_transport_error(Some(format!("error sending request for {url}")), url).as_deref(),
Some("error sending request for <url>")
);
assert_eq!(redact_urls("fail https://a.example/x and http://b/y"), "fail <url> and <url>");
}
}
+2
Переглянути файл
@@ -7,6 +7,7 @@ pub(crate) mod run;
mod vcs;
pub use requests::Requests;
mod files;
mod http;
mod page;
mod reports;
mod search;
@@ -39,6 +40,7 @@ fn tools() -> Vec<tool::Tool> {
tools.extend(edit::tools());
tools.extend(run::tools());
tools.extend(vcs::tools());
tools.extend(http::tools());
tools
}
+13 -4
Переглянути файл
@@ -128,9 +128,11 @@ pub fn run_command() -> Tool {
&format!(
"Runs a shell command line in a new or reused tab of OpenIDEA's Run tool window, with the shell of \
Settings › Tools › Terminal. The user is asked first (unless the IDE runs tools without \
confirmation). Waits up to `timeout` milliseconds (default {RUN_TIMEOUT_MS}) for the command to finish; a command \
still running then keeps running, and `wait_for_run`, `read_run_output`, `get_run_status`, `send_run_input` and \
`stop_run` follow it up by name. Returns the tab's status (`state`: starting, running, stopping, succeeded, failed, \
confirmation). Waits up to `timeout` milliseconds (default {RUN_TIMEOUT_MS}) for the command to finish, or until its \
output matches `pattern`; a command still running then keeps running, and `wait_for_run`, `read_run_output`, \
`get_run_status`, `send_run_input` and `stop_run` follow it up by name. A server, watcher or app never finishes: to \
start one, pass `pattern` for the line it prints once ready (e.g. `Listening on|Started .* in|ready in`) rather than \
a long `timeout`, so the call returns as soon as it is up. Returns the tab's status (`state`: starting, running, stopping, succeeded, failed, \
crashed, stoppedByAgent, stoppedByUser or startFailed; `exitCode`; `crash` with the signal or exception of a crashed \
process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
),
@@ -152,6 +154,7 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
};
let env = call.args.get("envs").filter(|v| !v.is_null()).map(|_| call.str_map("envs")).transpose()?;
let deadline = deadline(&call, RUN_TIMEOUT_MS)?;
let ready = pattern(&call)?;
let host = call.host();
let runs = &host.mcp_agent_runs;
if let Some(run) = runs.get(call.root(), &name).filter(|r| r.running()) {
@@ -185,7 +188,7 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
return Err(IdeError::invalid(format!("`{name}` did not start: {error}")));
}
let from = run.process_offset();
let end = run.wait(deadline, None, from, &call.cancel).await?;
let end = run.wait(deadline, ready.as_ref(), from, &call.cancel).await?;
let mut extra = output_view(&call, &run, from)?;
extra.insert("waitEnded".into(), end.as_str().into());
result(&run, extra)
@@ -209,6 +212,12 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
ParamType::Integer,
"Milliseconds to wait for the command to finish before returning (0 returns once it started); the command \
keeps running after it",
))
.param(Param::optional(
"pattern",
ParamType::String,
"Regular expression that ends the wait when the command's output matches it: the ready line of a server or \
watcher. `waitEnded` is then `matched`",
))
.param(Param::optional("maxLinesCount", ParamType::Integer, MAX_LINES))
.param(Param::optional("truncateMode", ParamType::String, TRUNCATE_MODE))
+8 -2
Переглянути файл
@@ -748,9 +748,15 @@ async fn file_search(call: Call) -> IdeResult<Output> {
// 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();
// The project folder and the content roots outside it.
// The project folder and the content roots its walk does not cover: those outside it and
// those inside it that it skips as ignored.
let roots: Vec<PathBuf> = std::iter::once(root.clone())
.chain(call.project().content_roots().into_iter().filter(|r| relative_to_root(&root, r).is_none()))
.chain(
call.project()
.content_roots()
.into_iter()
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r)),
)
.collect();
let host = call.host();
let walk = Walk {
+297 -21
Переглянути файл
@@ -8,7 +8,8 @@ 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, McpScope, McpServer, McpServerInput, NewAgentTask,
ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput,
McpTransport, NewAgentTask,
};
use ide_core::error::ErrorKind;
use ide_core::{IdeError, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
@@ -477,19 +478,21 @@ fn persist_mcp_map(
Ok(())
}
fn update_mcp_maps<F>(host: &Host, window: &str, approve: Option<&str>, f: F) -> IdeResult<Vec<McpServer>>
fn update_mcp_maps<F>(host: &Host, window: &str, approve: &[String], f: F) -> IdeResult<Vec<McpServer>>
where
F: FnOnce(&mut McpServerMap, &mut McpServerMap, Option<&std::path::Path>) -> Result<(), String>,
F: FnOnce(&mut McpServerMap, &mut McpServerMap, Option<&std::path::Path>) -> Result<Vec<String>, String>,
{
let (mut user, mut workspace, project) = mcp_maps(host, window);
let prev_user = user.clone();
let prev_workspace = workspace.clone();
let project_root = project.as_ref().map(|p| p.root.as_path());
f(&mut user, &mut workspace, project_root).map_err(IdeError::invalid)?;
if let (Some(name), Some(p)) = (approve, &project)
&& let Some(server) = workspace.get(name)
{
host.mcp_approvals.approve(&p.root, name, server)?;
let extra_approved = f(&mut user, &mut workspace, project_root).map_err(IdeError::invalid)?;
if let Some(p) = &project {
for name in approve.iter().chain(extra_approved.iter()) {
if let Some(server) = workspace.get(name.as_str()) {
host.mcp_approvals.approve(&p.root, name, server)?;
}
}
}
if workspace != prev_workspace {
persist_mcp_map(host, project.as_ref(), McpScope::Workspace, &workspace)?;
@@ -507,11 +510,22 @@ fn listed(
user: &McpServerMap,
workspace: McpServerMap,
) -> Vec<McpServer> {
let raw_workspace = workspace.clone();
let workspace = match project {
Some(p) => host.mcp_approvals.apply(&p.root, workspace),
None => workspace,
};
ide_agent::mcp::servers_from_settings(user, &workspace)
let mut out = ide_agent::mcp::servers_from_settings(user, &workspace);
if let Some(p) = project {
for srv in &mut out {
if srv.scope == McpScope::Workspace
&& let Some(raw) = raw_workspace.get(&srv.name)
{
srv.unapproved = !host.mcp_approvals.approved(&p.root, &srv.name, raw);
}
}
}
out
}
/// The MCP servers agent sessions of the project at `root` get: the user's, values filled in, and
@@ -525,7 +539,8 @@ pub(crate) fn session_mcp_servers(
use ide_workspace::settings::SettingsScope;
let mut user = settings.layer(SettingsScope::Global).agents.mcp_servers;
fill_mcp_values(secrets, &mut user);
let workspace = approvals.apply(root, settings.layer(SettingsScope::Project).agents.mcp_servers);
let mut workspace = settings.layer(SettingsScope::Project).agents.mcp_servers;
workspace.retain(|name, srv| approvals.approved(root, name, srv));
ide_agent::mcp::servers_from_settings(&user, &workspace)
}
@@ -538,39 +553,289 @@ pub fn mcp_list(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
/// Creates or updates a User or Workspace MCP server and returns the updated list. A Workspace
/// server saved here is one the user turned on.
pub fn mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<Vec<McpServer>> {
let approve = (input.scope == McpScope::Workspace).then(|| input.name.trim().to_owned());
update_mcp_maps(host, window, approve.as_deref(), |user, workspace, project_root| {
ide_agent::mcp::apply_save(user, workspace, project_root.is_some(), input)
let approve: Vec<String> =
(input.scope == McpScope::Workspace).then(|| input.name.trim().to_owned()).into_iter().collect();
update_mcp_maps(host, window, &approve, |user, workspace, project_root| {
ide_agent::mcp::apply_save(user, workspace, project_root.is_some(), input).map(|()| Vec::new())
})
}
/// Parses and saves one or more MCP servers from a pasted JSON snippet (`{"mcpServers": {...}}` or
/// single server object). Workspace servers explicitly saved here by the user are approved.
pub fn mcp_save_json(
host: &Host,
window: &str,
scope: McpScope,
raw_json: String,
fallback_name: Option<String>,
agents: Vec<String>,
) -> IdeResult<Vec<McpServer>> {
update_mcp_maps(host, window, &[], |user, workspace, project_root| {
let saved = ide_agent::mcp::apply_save_json(
user,
workspace,
project_root.is_some(),
scope,
&raw_json,
fallback_name.as_deref(),
agents,
)?;
Ok(if scope == McpScope::Workspace { saved } else { Vec::new() })
})
}
/// Enables or disables an MCP server and returns the updated list.
pub fn mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) -> IdeResult<Vec<McpServer>> {
let approve = ide_agent::mcp::parse_server_id(&id)
let approve: Vec<String> = ide_agent::mcp::parse_server_id(&id)
.filter(|(scope, _)| enabled && *scope == McpScope::Workspace)
.map(|(_, name)| name.to_owned());
update_mcp_maps(host, window, approve.as_deref(), |user, workspace, _| {
ide_agent::mcp::apply_set_enabled(user, workspace, &id, enabled).map(|_| ())
.map(|(_, name)| name.to_owned())
.into_iter()
.collect();
update_mcp_maps(host, window, &approve, |user, workspace, _| {
ide_agent::mcp::apply_set_enabled(user, workspace, &id, enabled).map(|_| Vec::new())
})
}
/// Removes a User or Workspace MCP server and returns the updated list.
pub fn mcp_remove(host: &Host, window: &str, id: String) -> IdeResult<Vec<McpServer>> {
update_mcp_maps(host, window, None, |user, workspace, _| {
ide_agent::mcp::apply_remove(user, workspace, &id).map(|_| ())
update_mcp_maps(host, window, &[], |user, workspace, _| {
ide_agent::mcp::apply_remove(user, workspace, &id).map(|_| Vec::new())
})
}
/// Copies MCP servers from `.mcp.json` and `.vscode/mcp.json` into the workspace settings once;
/// they stay off until the user turns them on.
pub fn mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
update_mcp_maps(host, window, None, |_, workspace, project_root| {
update_mcp_maps(host, window, &[], |_, workspace, project_root| {
let root = project_root.ok_or_else(|| "Open a project to import workspace MCP servers".to_string())?;
ide_agent::mcp::apply_import(workspace, root);
Ok(())
Ok(Vec::new())
})
}
/// Discovers external MCP configuration files on disk (CLI user configs + workspace `.mcp.json`).
pub async fn mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<McpExternalSource>> {
let project_root = host.project(window).ok().filter(|p| !p.light).map(|p| p.root.clone());
let home = dirs::home_dir();
tokio::task::spawn_blocking(move || {
ide_agent::mcp::discover_external_sources(home.as_deref(), project_root.as_deref())
})
.await
.map_err(|e| IdeError::internal(e.to_string()))
}
/// Imports selected servers from discovered external MCP configuration files into User or Workspace scope.
/// Imported Workspace entries remain unapproved (disabled) until the user explicitly enables them.
pub async fn mcp_import_selected(
host: &Host,
window: &str,
scope: McpScope,
selections: Vec<McpImportSelection>,
overwrite: bool,
) -> IdeResult<Vec<McpServer>> {
let home = dirs::home_dir();
update_mcp_maps(host, window, &[], move |user, workspace, project_root| {
ide_agent::mcp::apply_import_selected(
user,
workspace,
home.as_deref(),
project_root,
scope,
&selections,
overwrite,
)?;
Ok(Vec::new())
})
}
/// Tests an MCP server by connecting (`initialize`) and listing its tools (`tools/list`).
pub async fn mcp_test(host: &Host, window: &str, id: String) -> IdeResult<McpProbeResult> {
host.require_trust(window)?;
let (user, workspace, project) = mcp_maps(host, window);
let (scope, name) = ide_agent::mcp::parse_server_id(&id)
.ok_or_else(|| IdeError::not_found(format!("MCP server `{id}` not found")))?;
let server = match scope {
McpScope::User => user.get(name),
McpScope::Workspace => workspace.get(name),
}
.cloned()
.ok_or_else(|| IdeError::not_found(format!("MCP server `{name}` not found")))?;
if scope == McpScope::Workspace {
let p = project.as_ref().ok_or_else(|| IdeError::invalid("Open a project to test workspace MCP servers"))?;
if !host.mcp_approvals.approved(&p.root, name, &server) {
return Err(IdeError::invalid("Enable this workspace MCP server first before testing it"));
}
}
let cwd = project.as_ref().map(|p| p.root.clone()).or_else(dirs::home_dir).unwrap_or_else(std::env::temp_dir);
match server.transport {
McpTransport::Stdio => Ok(ide_agent::mcp::probe_stdio_server(&server, &cwd).await),
McpTransport::Http | McpTransport::Sse => Ok(probe_http_mcp_server(&server).await),
}
}
async fn probe_http_mcp_server(server: &ide_core::settings::AgentMcpServer) -> McpProbeResult {
let started = std::time::Instant::now();
let elapsed_ms = || u32::try_from(started.elapsed().as_millis()).unwrap_or(u32::MAX);
let Some(url) = server.url.as_deref().map(str::trim).filter(|u| !u.is_empty()) else {
return McpProbeResult {
ok: false,
server_name: None,
server_version: None,
protocol_version: None,
tools: Vec::new(),
duration_ms: elapsed_ms(),
error: Some("URL is empty".into()),
};
};
let mut headers = reqwest::header::HeaderMap::new();
headers.insert(
reqwest::header::ACCEPT,
reqwest::header::HeaderValue::from_static("application/json, text/event-stream"),
);
for (k, v) in &server.headers {
if let (Ok(name), Ok(val)) =
(reqwest::header::HeaderName::from_bytes(k.as_bytes()), reqwest::header::HeaderValue::from_str(v))
{
headers.insert(name, val);
}
}
let client =
match reqwest::Client::builder().default_headers(headers).timeout(std::time::Duration::from_secs(12)).build() {
Ok(c) => c,
Err(e) => {
return McpProbeResult {
ok: false,
server_name: None,
server_version: None,
protocol_version: None,
tools: Vec::new(),
duration_ms: elapsed_ms(),
error: Some(format!("HTTP client error: {e}")),
};
}
};
let post_rpc = |session_id: Option<String>, body: serde_json::Value| {
let client = client.clone();
let url = url.to_owned();
async move {
let mut req =
client.post(&url).header(reqwest::header::CONTENT_TYPE, "application/json").body(body.to_string());
if let Some(sid) = session_id.as_deref() {
req = req.header("Mcp-Session-Id", sid);
}
let resp = req.send().await.map_err(|e| format!("Request to `{url}` failed: {e}"))?;
let status = resp.status();
let next_session =
resp.headers().get("mcp-session-id").and_then(|v| v.to_str().ok()).map(str::to_owned).or(session_id);
let text = resp.text().await.map_err(|e| format!("Failed reading response: {e}"))?;
if !status.is_success() {
let detail = text.trim();
let msg = if detail.is_empty() {
format!("HTTP {status}")
} else {
format!("HTTP {status}: {}", detail.chars().take(240).collect::<String>())
};
return Err(msg);
}
Ok((next_session, parse_mcp_http_response(&text)?))
}
};
let init_req = serde_json::json!({
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "2024-11-05",
"capabilities": {},
"clientInfo": { "name": "OpenIDEA", "version": env!("CARGO_PKG_VERSION") },
}
});
let (session_id, init_res) = match post_rpc(None, init_req).await {
Ok(v) => v,
Err(err) => {
return McpProbeResult {
ok: false,
server_name: None,
server_version: None,
protocol_version: None,
tools: Vec::new(),
duration_ms: elapsed_ms(),
error: Some(err),
};
}
};
// Best-effort `notifications/initialized` + `tools/list`.
let mut not_req = client.post(url).header(reqwest::header::CONTENT_TYPE, "application/json").body(
serde_json::json!({
"jsonrpc": "2.0",
"method": "notifications/initialized",
"params": {},
})
.to_string(),
);
if let Some(sid) = session_id.as_deref() {
not_req = not_req.header("Mcp-Session-Id", sid);
}
let _ = not_req.send().await;
let tools_res = post_rpc(
session_id,
serde_json::json!({
"jsonrpc": "2.0",
"id": 2,
"method": "tools/list",
"params": {},
}),
)
.await
.map(|(_, v)| v)
.unwrap_or_else(|_| serde_json::json!({}));
ide_agent::mcp::parse_probe_payloads(&init_res, &tools_res, elapsed_ms())
}
fn parse_mcp_http_response(body: &str) -> Result<serde_json::Value, String> {
let trimmed = body.trim();
if trimmed.is_empty() {
return Ok(serde_json::json!({}));
}
if let Ok(msg) = serde_json::from_str::<serde_json::Value>(trimmed) {
if let Some(err) = msg.get("error") {
let em = err.get("message").and_then(serde_json::Value::as_str).unwrap_or("JSON-RPC error");
return Err(em.to_owned());
}
return Ok(msg.get("result").cloned().unwrap_or(msg));
}
// Streamable HTTP SSE frames (`data: {...}`).
for line in trimmed.lines() {
if let Some(rest) = line.strip_prefix("data:")
&& let Ok(msg) = serde_json::from_str::<serde_json::Value>(rest.trim())
&& (msg.get("result").is_some() || msg.get("error").is_some())
{
if let Some(err) = msg.get("error") {
let em = err.get("message").and_then(serde_json::Value::as_str).unwrap_or("JSON-RPC error");
return Err(em.to_owned());
}
return Ok(msg.get("result").cloned().unwrap_or(msg));
}
}
Err("Unexpected non-JSON MCP response".into())
}
/// Updates per-session MCP server enable/disable overrides on task `task`.
pub fn set_mcp_overrides(
host: &Host,
window: &str,
task: String,
overrides: std::collections::BTreeMap<String, bool>,
) -> IdeResult<AgentTask> {
host.project(window)?.agents.set_mcp_overrides(&task, overrides)
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("agent_subscribe", |c| async move { subscribe(&c.host, &c.window, c.channel("onEvent")?) });
@@ -587,12 +852,23 @@ pub(crate) fn register(d: &mut Dispatcher) {
d.add("agent_registry_remove", |c| async move { registry_remove(&c.host, &c.window, c.arg("id")?).await });
d.add("agent_mcp_list", |c| async move { mcp_list(&c.host, &c.window) });
d.add("agent_mcp_save", |c| async move { mcp_save(&c.host, &c.window, c.arg("input")?) });
d.add("agent_mcp_save_json", |c| async move {
mcp_save_json(&c.host, &c.window, c.arg("scope")?, c.arg("rawJson")?, c.arg("fallbackName")?, c.arg("agents")?)
});
d.add(
"agent_mcp_set_enabled",
|c| async move { mcp_set_enabled(&c.host, &c.window, c.arg("id")?, c.arg("enabled")?) },
);
d.add("agent_mcp_remove", |c| async move { mcp_remove(&c.host, &c.window, c.arg("id")?) });
d.add("agent_mcp_import", |c| async move { mcp_import(&c.host, &c.window) });
d.add("agent_mcp_discover_sources", |c| async move { mcp_discover_sources(&c.host, &c.window).await });
d.add("agent_mcp_import_selected", |c| async move {
mcp_import_selected(&c.host, &c.window, c.arg("scope")?, c.arg("selections")?, c.arg("overwrite")?).await
});
d.add("agent_mcp_test", |c| async move { mcp_test(&c.host, &c.window, c.arg("id")?).await });
d.add("agent_set_mcp_overrides", |c| async move {
set_mcp_overrides(&c.host, &c.window, c.arg("task")?, c.arg("overrides")?)
});
d.add("agent_commands", |c| async move { commands(&c.host, &c.window, c.arg("provider")?, c.arg("task")?).await });
d.add("agent_entries", |c| async move { entries(&c.host, &c.window, c.arg("task")?, c.arg("subagent")?) });
d.add("agent_create", |c| async move { create(&c.host, &c.window, c.arg("request")?).await });
+115
Переглянути файл
@@ -0,0 +1,115 @@
//! 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
//! owns the Gherkin and step-expression parsing and the index it feeds (as for `routes`),
//! so this side stays a cheap scan.
use crate::Host;
use ide_core::IdeResult;
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
use std::sync::Mutex;
use std::sync::atomic::{AtomicUsize, Ordering};
/// Files handed out at most, and bytes in total: a test suite's features and step
/// files fit well inside these, and the UI indexes them once.
const MAX_FILES: usize = 4096;
const MAX_BYTES: usize = 64 << 20;
/// A single source bigger than this is a bundle, not a step file.
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("];
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct StepSource {
pub path: ide_core::IpcPath,
pub text: String,
/// A Gherkin `.feature` file; otherwise a script defining steps.
pub feature: bool,
}
fn is_feature(path: &Path) -> bool {
path.extension().and_then(|e| e.to_str()).is_some_and(|e| e.eq_ignore_ascii_case("feature"))
}
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")
)
}
/// 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());
let bytes = AtomicUsize::new(0);
ide_vfs::walk_files(root, excludes, |path| {
let feature = is_feature(path);
if !(feature || is_script(path)) || bytes.load(Ordering::Relaxed) >= MAX_BYTES {
return;
}
if std::fs::metadata(path).map_or(true, |m| m.len() > MAX_FILE_BYTES) {
return;
}
let Ok(text) = std::fs::read_to_string(path) else { return };
if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) {
return;
}
let Ok(mut found) = found.lock() else { return };
if found.len() >= MAX_FILES {
return;
}
bytes.fetch_add(text.len(), Ordering::Relaxed);
found.push(StepSource { path: path.to_path_buf().into(), text, feature });
});
let mut files = found.into_inner().unwrap_or_default();
files.sort_by(|a, b| a.path.cmp(&b.path));
files
}
/// 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()) {
out.extend(sources_in(&root, &excludes));
}
out.sort_by(|a, b| a.path.cmp(&b.path));
out.dedup_by(|a, b| a.path == b.path);
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn features_and_step_files_are_read_and_nothing_else() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
for dir in ["features", "steps", "src", "node_modules/@cucumber/cucumber/lib"] {
std::fs::create_dir_all(root.join(dir)).unwrap();
}
std::fs::write(root.join("features/cart.feature"), "Feature: Cart\n").unwrap();
std::fs::write(root.join("steps/cart.steps.ts"), "Given('an empty cart', () => {});").unwrap();
std::fs::write(root.join("steps/bdd.mjs"), "const { When } = createBdd();\nWhen(/^I add (\\d+)$/, f);")
.unwrap();
std::fs::write(root.join("src/app.ts"), "export const app = 1;").unwrap();
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("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!(files[0].feature && !files[1].feature);
assert!(files[3].text.contains("an empty cart"));
}
}
+86 -11
Переглянути файл
@@ -641,6 +641,82 @@ pub async fn maven_exclude_dependency(
.map_err(join_err)?
}
/// Build / Rebuild / Build Artifacts of a Java project without a build tool, from its
/// Project Structure; `None` when it has no Java sources under its source roots.
fn structure_plan(
root: &Path,
settings: &Settings,
detected: &[ide_workspace::roots::SourceFolder],
kind: BuildKind,
cache: &Path,
) -> IdeResult<Option<compile::BuildPlan>> {
let (ps, roots, jdk) = structure_inputs(root, settings, detected);
compile::structure_plan(root, &ps, &roots, jdk.as_ref(), &settings.languages.java.language_level, kind, cache)
}
/// The Project Structure, roots and JDK a build of a project without a build tool uses.
/// An Eclipse project's `.classpath` libraries and its web content folder count as if they
/// were configured, and a web project with no artifacts gets IDEA's `<name>:war exploded`.
pub(crate) fn structure_inputs(
root: &Path,
settings: &Settings,
detected: &[ide_workspace::roots::SourceFolder],
) -> (ide_core::settings::ProjectStructureSettings, compile::StructureRoots, Option<compile::StructureJdk>) {
use ide_core::settings::{ArtifactConfig, ArtifactKind, FacetConfig, ProjectLibrary};
use ide_workspace::roots::{ProjectRoots, RootKind, eclipse};
let mut ps = settings.project_structure.clone();
let mut included = Vec::new();
if let Some(cp) = eclipse::classpath(root).filter(|cp| !cp.libraries.is_empty()) {
let name = "Eclipse classpath".to_owned();
if !ps.libraries.iter().any(|l| l.name == name) {
ps.libraries.push(ProjectLibrary { name: name.clone(), classes: cp.libraries, ..Default::default() });
}
included.push(name);
}
if !ps.facets.iter().any(|f| f.kind == "web")
&& let Some(web) = eclipse::web_root(root)
{
ps.facets.push(FacetConfig {
kind: "web".into(),
module: ".".into(),
descriptor: format!("{web}/WEB-INF/web.xml"),
web_root: web,
});
if ps.artifacts.is_empty() {
let name = root.file_name().map_or_else(|| "app".into(), |n| n.to_string_lossy().into_owned());
ps.artifacts.push(ArtifactConfig {
name: format!("{name}:war exploded"),
kind: ArtifactKind::WarExploded,
module: ".".into(),
include_libraries: included,
..Default::default()
});
}
}
let roots = ProjectRoots::compute(detected.to_vec(), &ps);
let of = |kind: RootKind| roots.roots.iter().filter(|r| r.kind == kind).map(|r| root.join(&r.path)).collect();
let module = ps.module_settings(root, root);
let level = module
.map(|m| m.language_level.as_str())
.filter(|l| !l.trim().is_empty())
.unwrap_or(&settings.languages.java.language_level);
// Without a configured SDK, an installed JDK that can compile the language level.
let jdk = ide_sdk::apply::module_jdk(root, root, settings)
.or_else(|| {
let installed = ide_sdk::java::installed_jdks();
ide_sdk::java::pick_jdk(&installed, compile::language_release(level)).cloned()
})
.map(|j| compile::StructureJdk { home: j.home, major: j.major });
let roots = compile::StructureRoots {
sources: of(RootKind::Source),
tests: of(RootKind::Test),
resources: of(RootKind::Resources),
test_resources: of(RootKind::TestResources),
excluded: of(RootKind::Excluded),
};
(ps, roots, jdk)
}
fn cmake_plan(root: &Path, kind: BuildKind, configs: &[ide_run::RunConfig], id: &str) -> IdeResult<compile::BuildPlan> {
let commands = ide_run::cmake_build_configs(configs, id)?;
let title = commands.last().map(|c| c.name.clone()).unwrap_or_default();
@@ -675,6 +751,7 @@ pub async fn build_run(
let project = host.project(window)?;
let (root, cache, sink) = (project.root.clone(), project.build_cache_dir(), project.sink.clone());
let settings = project.settings.effective();
let detected = project.detected_roots.read().clone();
let config_dir = host.config_dir.clone();
let token = host.begin_project_request(window, request);
let result = tokio::task::spawn_blocking(move || {
@@ -738,17 +815,15 @@ pub async fn build_run(
plan.title = workspace.name;
plan
} else {
prepare_plan(
compile::plan(
&root,
&with_profiles(load(&root, &cache, &settings), &cache),
kind,
file.as_deref(),
settings.cmake.profiles.as_deref(),
)?,
&root,
&settings,
)
let model = with_profiles(load(&root, &cache, &settings), &cache);
match compile::plan(&root, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref()) {
Ok(plan) => prepare_plan(plan, &root, &settings),
// No build tool: a Java project builds from its Project Structure.
Err(e) if e.kind == ide_core::error::ErrorKind::NotFound => {
structure_plan(&root, &settings, &detected, kind, &cache)?.ok_or(e)?
}
Err(e) => return Err(e),
}
};
let result = compile::run(&root, &plan, &token, &|e| {
let _ = on_event.send(e);
+4
Переглянути файл
@@ -88,6 +88,10 @@ pub(super) fn load_scopes(root: &Path, scopes: &[Scope]) -> BuildModel {
}
}
combined.gradle.extend(model.gradle);
for b in model.sbt.iter_mut().filter(|_| scope.root != root) {
b.dir = absolute(&scope.root, &b.dir);
}
combined.sbt.extend(model.sbt);
}
combined
}
+45
Переглянути файл
@@ -12,6 +12,25 @@ use std::path::PathBuf;
/// Starts a session owned by this window: its events (and those of child sessions) go here only.
pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> IdeResult<DebugSessionId> {
host.require_trust(window)?;
let unity_pid = if config.adapter == "unity" {
if config.request != "attach" {
return Err(ide_core::IdeError::invalid("Unity debugging only supports attachment to a running Editor"));
}
let arguments = launch_arguments(&config)?;
let pid = arguments["name"]
.as_str()
.and_then(|name| name.strip_prefix("Unity Editor ("))
.and_then(|name| name.strip_suffix(')'))
.and_then(|pid| pid.parse::<u32>().ok());
if let Some(pid) = pid {
require_unity_editor(pid)?;
}
let cwd = config.cwd.as_ref().map(|path| path.as_ref()).unwrap_or_else(|| std::path::Path::new("."));
unity::require_runtime(cwd)?;
pid
} else {
None
};
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
if config.adapter == "debugpy"
&& config.request == "launch"
@@ -100,12 +119,26 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
let server_port = debug_server_port(&config);
let result = host.debugger.start_with(config, owner, custom).await;
flush_output();
if result.is_err()
&& let Some(pid) = unity_pid
{
require_unity_editor(pid)?;
}
if let (Ok(id), Some(port)) = (&result, server_port) {
attach_jvm_inspector(host, window, *id, port);
}
result
}
fn require_unity_editor(pid: u32) -> IdeResult<()> {
if !ide_core::process::process_alive(pid) {
return Err(ide_core::IdeError::unavailable(format!(
"Unity Editor (PID {pid}) is no longer running. Refresh the Unity process list and select a running Editor."
)));
}
Ok(())
}
/// The port of the java-debug server this machine's jdtls started; `debugServer` as `host:port`
/// names an adapter on another machine, whose jdtls is not ours to ask.
fn debug_server_port(config: &LaunchConfig) -> Option<u16> {
@@ -460,6 +493,17 @@ pub async fn debug_free_port(host: &Host, window: &str) -> IdeResult<u16> {
ide_dap::adapter::free_port().map_err(ide_core::IdeError::from)
}
pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
host.require_trust(window)?;
let project = host.project(window)?;
if ide_workspace::unity::detect(&project.root).is_none() {
return Err(ide_core::IdeError::invalid("Open a Unity project before attaching to the Editor"));
}
let command = ide_sdk::apply::tool_command(&project.root, &project.settings.effective(), "unity-debug")
.map(|p| p.to_string_lossy().into_owned());
unity::editors(command, project.root.clone()).await
}
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
pub async fn debug_listen_for_jvm(
@@ -664,6 +708,7 @@ pub(crate) fn register(d: &mut Dispatcher) {
});
d.add("debug_attachable_processes", |c| async move { debug_attachable_processes(&c.host, &c.window).await });
d.add("debug_free_port", |c| async move { debug_free_port(&c.host, &c.window).await });
d.add("debug_unity_processes", |c| async move { debug_unity_processes(&c.host, &c.window).await });
d.add("debug_listen_for_jvm", |c| async move {
debug_listen_for_jvm(&c.host, &c.window, c.arg("request")?, c.arg("host")?, c.arg("port")?).await
});
+199
Переглянути файл
@@ -1057,6 +1057,11 @@ pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action
blocking(move || apply_edit(&documents, &edit)).await?;
}
open_plugin_action_target(&action, window);
if let Some(command) = &action.command
&& let Some(result) = run_plugin_server_command(host, window, doc, None, command).await
{
return result;
}
if let Some(command) = action.command
&& !(action.edit.is_some() && is_client_follow_up(&project, doc, None, &command).await)
{
@@ -1168,6 +1173,122 @@ pub async fn lsp_hierarchy_refactor(
.await
}
/// The signature of the method at `pos`, for Change Signature.
pub async fn lsp_signature_info(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
pos: Pos,
) -> IdeResult<MethodSignature> {
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.change_signature_info(doc, pos, cancel).await;
host.end_request(request);
result
}
/// Checks changing the method at `pos` to `signature` and computes the edit without applying it.
#[allow(clippy::too_many_arguments)]
pub async fn lsp_change_signature(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
pos: Pos,
signature: MethodSignature,
delegate: bool,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
let project = host.project(window)?;
let documents = project.documents.clone();
let version = blocking(move || documents.version(doc)).await?;
let cancel = host.begin_request(request);
let result = project.lsp.change_signature(doc, pos, signature, delegate, confirmation, cancel).await;
host.end_request(request);
let mut changed = result?;
blocking(move || {
if project.documents.version(doc)? != version {
return Err(ide_core::IdeError::new(
ide_core::error::ErrorKind::OutOfSync,
"document changed while computing the refactoring; request it again",
));
}
if let Some(edit) = &mut changed.edit {
project.documents.prepare_workspace_edit(edit)?;
}
Ok(changed)
})
.await
}
fn json_argument(args: &str) -> IdeResult<serde_json::Value> {
serde_json::from_str(args).map_err(|e| IdeError::invalid(format!("invalid move arguments: {e}")))
}
fn json_strings(values: Vec<serde_json::Value>) -> Vec<String> {
values.iter().map(serde_json::Value::to_string).collect()
}
/// Where a Java Move code action of `kind` can go; `args` (JSON) carries the code action's own
/// arguments back unchanged, and each destination comes back as JSON.
pub async fn lsp_java_move_destinations(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
kind: String,
args: String,
) -> IdeResult<Vec<String>> {
let args = json_argument(&args)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.java_move_destinations(doc, kind, args, cancel).await;
host.end_request(request);
result.map(json_strings)
}
/// The project's Java source types, for moving a member or type into a class.
pub async fn lsp_java_source_types(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
project_name: Option<String>,
) -> IdeResult<Vec<String>> {
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.java_source_types(doc, project_name, cancel).await;
host.end_request(request);
result.map(json_strings)
}
/// Checks a Java move and computes its edit without applying it.
#[allow(clippy::too_many_arguments)]
pub async fn lsp_java_move(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
kind: String,
args: String,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
let args = json_argument(&args)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.java_move(doc, kind, args, confirmation, cancel).await;
host.end_request(request);
let mut moved = result?;
blocking(move || {
if let Some(edit) = &mut moved.edit {
project.documents.prepare_workspace_edit(edit)?;
}
Ok(moved)
})
.await
}
pub async fn lsp_rename(
host: &Host,
window: &str,
@@ -1608,9 +1729,47 @@ pub async fn lsp_execute_command(host: &Host, window: &str, doc: DocId, command:
return blocking(move || plugins.run_language_command(&plugin, &command_id, argument.as_deref(), invocation))
.await;
}
if let Some(result) = run_plugin_server_command(host, window, doc, None, &command).await {
return result;
}
host.project(window)?.lsp.execute_command(doc, command).await
}
/// Runs `command` through the plugin that claims it (`[[contributes.serverCommands]]`)
/// when no server of the document executes it itself: a code lens, code action or inlay
/// hint may carry a command the server leaves to the client. `None` when no plugin does.
async fn run_plugin_server_command(
host: &Host,
window: &str,
doc: DocId,
server: Option<ServerId>,
command: &Command,
) -> Option<IdeResult<()>> {
let plugins = crate::plugins::editor_plugin_host()?;
let project = host.project(window).ok()?;
if project.lsp.provides_command(doc, server, &command.command).await {
return None;
}
let (plugin, run) = plugins.server_command(&project.lsp.server_names(doc, server), &command.command)?;
let snap = match project.documents.snapshot(doc) {
Ok(snap) => snap,
Err(e) => return Some(Err(e)),
};
let invocation = ide_plugin::Invocation {
client: Some(window.into()),
workspace_root: Some(project.root.clone()),
editor: Some(ide_plugin::EditorContext {
path: snap.path.0.clone(),
language: snap.language.0,
selections: vec![],
}),
selected_paths: vec![snap.path.0],
..Default::default()
};
let arguments = serde_json::Value::Array(command.arguments.clone()).to_string();
Some(blocking(move || plugins.run_language_command(&plugin, &run, Some(&arguments), invocation)).await)
}
/// Resolves an interactive command without applying edits or executing it.
pub async fn lsp_resolve_command(
host: &Host,
@@ -1652,6 +1811,11 @@ pub async fn lsp_execute_code_action(
.await
.map_err(|e| ide_core::IdeError::internal(e.to_string()))??;
}
if let Some(command) = &action.command
&& let Some(result) = run_plugin_server_command(host, window, doc, Some(action.server), command).await
{
return result.map(|()| Vec::new());
}
match action.command {
Some(command) if edited && is_client_follow_up(&project, doc, Some(action.server), &command).await => {
Ok(Vec::new())
@@ -1848,6 +2012,41 @@ pub(crate) fn register(d: &mut Dispatcher) {
)
.await
});
d.add("lsp_signature_info", |c| async move {
lsp_signature_info(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_change_signature", |c| async move {
lsp_change_signature(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("signature")?,
c.arg("delegate")?,
c.arg("confirmation")?,
)
.await
});
d.add("lsp_java_move_destinations", |c| async move {
lsp_java_move_destinations(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("kind")?, c.arg("args")?)
.await
});
d.add("lsp_java_source_types", |c| async move {
lsp_java_source_types(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("projectName")?).await
});
d.add("lsp_java_move", |c| async move {
lsp_java_move(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("kind")?,
c.arg("args")?,
c.arg("confirmation")?,
)
.await
});
d.add("lsp_format", |c| async move {
lsp_format(&c.host, &c.window, c.arg("doc")?, c.arg("range")?, c.arg("options")?).await
});
+1
Переглянути файл
@@ -4,6 +4,7 @@
pub mod agent;
pub mod analysis;
pub mod bdd;
pub mod build;
pub mod bytes;
pub mod coverage;
+28 -9
Переглянути файл
@@ -54,8 +54,9 @@ pub fn index_file_extensions(host: &Host, window: &str) -> IdeResult<Vec<Extensi
Ok(host.project(window)?.index.file_extensions())
}
pub fn find_files(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
Ok(host.project(window)?.index.find_files(&query, limit as usize))
pub async fn find_files(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
let project = host.project(window)?;
blocking(move || Ok(project.index.find_files(&query, limit as usize))).await
}
pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeResult<Vec<IpcPath>> {
@@ -63,18 +64,33 @@ pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeRes
blocking(move || Ok(project.index.files_named(&name).into_iter().map(Into::into).collect())).await
}
pub fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
Ok(host.project(window)?.index.find_dirs(&query, limit as usize))
pub async fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
let project = host.project(window)?;
blocking(move || Ok(project.index.find_dirs(&query, limit as usize))).await
}
pub fn find_symbols(
pub async fn find_symbols(
host: &Host,
window: &str,
query: String,
filter: SymbolFilter,
limit: u32,
) -> IdeResult<Vec<SymbolMatch>> {
Ok(host.project(window)?.index.find_symbols(&query, filter, limit as usize))
let project = host.project(window)?;
blocking(move || Ok(project.index.find_symbols(&query, filter, limit as usize))).await
}
/// Index symbols named exactly one of `names` inside `within` (an agent task's folder),
/// at most `SYMBOLS_PER_NAME` each: every name an agent reply shows, in one lookup.
pub async fn find_symbols_named(
host: &Host,
window: &str,
names: Vec<String>,
within: IpcPath,
) -> IdeResult<Vec<SymbolMatch>> {
const SYMBOLS_PER_NAME: usize = 50;
let project = host.project(window)?;
blocking(move || Ok(project.index.symbols_named_any(&names, &PathBuf::from(within), SYMBOLS_PER_NAME))).await
}
pub fn mark_recent(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
@@ -318,11 +334,14 @@ pub async fn web_unresolved_references(host: &Host, window: &str, doc: DocId) ->
pub(crate) fn register(d: &mut Dispatcher) {
d.add("index_status", |c| async move { index_status(&c.host, &c.window) });
d.add("index_file_extensions", |c| async move { index_file_extensions(&c.host, &c.window) });
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
d.add("find_files_named", |c| async move { find_files_named(&c.host, &c.window, c.arg("name")?).await });
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
d.add("find_symbols", |c| async move {
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?)
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?).await
});
d.add("find_symbols_named", |c| async move {
find_symbols_named(&c.host, &c.window, c.arg("names")?, c.arg("within")?).await
});
d.add("mark_recent", |c| async move { mark_recent(&c.host, &c.window, c.arg("path")?) });
d.add("remove_recent", |c| async move { remove_recent(&c.host, &c.window, c.arg("path")?) });
+12
Переглянути файл
@@ -65,6 +65,15 @@ pub fn settings(host: &Host, window: &str) -> Settings {
})
}
/// The removed built-in theme a settings file of this window still names, if any
/// (`settings` reports its stand-in): the "provided by a plugin now" notice targets these.
pub fn settings_removed_theme(host: &Host, window: &str) -> Option<String> {
match host.project(window) {
Ok(p) => p.settings.named_removed_theme().or_else(|| host.global_settings.named_removed_theme()),
Err(_) => host.global_settings.named_removed_theme(),
}
}
pub fn roots(host: &Host, window: &str) -> IdeResult<ide_workspace::ProjectRoots> {
Ok(host.project(window)?.roots())
}
@@ -223,6 +232,9 @@ pub fn set_settings(
if key == "ssh" || key.starts_with("ssh.") {
host.ssh.set_configs(host.global_settings.effective().ssh.configs);
}
if key == "languages" || key == "languages.java" || key.starts_with("languages.java.addedJdks") {
host.apply_added_jdks();
}
if is_proxy {
host.apply_proxy();
}
+82 -2
Переглянути файл
@@ -202,12 +202,86 @@ pub async fn run_tomcat_installations(
.map_err(|e| IdeError::internal(e.to_string()))
}
/// Id prefix of a Project Structure WAR artifact (a project without a build tool).
const PROJECT_ARTIFACT: &str = "project:";
fn project_web_artifacts(ps: &ide_core::settings::ProjectStructureSettings) -> Vec<ide_build::web::WebArtifact> {
ide_build::compile::structure_web_artifacts(ps)
.into_iter()
.map(|a| ide_build::web::WebArtifact {
id: format!("{PROJECT_ARTIFACT}{}", a.name),
name: a.name.split(':').next().unwrap_or(&a.name).to_owned(),
module: if a.module == "." { String::new() } else { a.module.clone() },
tool: "project".into(),
})
.collect()
}
/// Compiles the project and packs the Project Structure artifact `name` as the WAR Tomcat
/// deploys, recorded in `base` like a build tool's archive.
fn build_project_war(
root: &std::path::Path,
settings: &ide_core::settings::Settings,
detected: &[ide_workspace::roots::SourceFolder],
name: &str,
base: &std::path::Path,
cache: &std::path::Path,
) -> IdeResult<()> {
use ide_build::compile;
let (ps, roots, jdk) = crate::ops::build::structure_inputs(root, settings, detected);
let artifact = ps
.artifacts
.iter()
.find(|a| a.name == name)
.ok_or_else(|| IdeError::invalid(format!("No artifact named {name} in Project Structure › Artifacts")))?;
let war = base.join("artifact").join(format!(
"{}.war",
name.split(':').next().unwrap_or(name).replace(|c: char| !c.is_alphanumeric() && c != '-', "_")
));
let plan = compile::structure_war_plan(
root,
&ps,
&roots,
jdk.as_ref(),
&settings.languages.java.language_level,
artifact,
&war,
cache,
)?;
let result = compile::run(root, &plan, &ide_core::CancellationToken::new(), &|_| {})?;
if !result.success {
let first = result.messages.iter().find(|m| m.severity == ide_core::Severity::Error);
let text = match first {
Some(m) => match (&m.path, m.range) {
(Some(path), Some(range)) => {
format!("{}:{}: {}", std::path::PathBuf::from(path.clone()).display(), range.start.line + 1, m.text)
}
_ => m.text.clone(),
},
None => "the build failed".into(),
};
return Err(IdeError::invalid(format!("Cannot build {name}: {text}")));
}
std::fs::create_dir_all(base)?;
std::fs::write(base.join("artifact-id.txt"), format!("{PROJECT_ARTIFACT}{name}"))?;
std::fs::write(base.join("artifact-path.txt"), war.to_string_lossy().as_bytes())?;
Ok(())
}
pub async fn run_tomcat_artifacts(host: &Host, window: &str) -> IdeResult<Vec<ide_build::web::WebArtifact>> {
host.require_trust(window)?;
let project = host.project(window)?;
tokio::task::spawn_blocking(move || {
let model = crate::ops::build::load(&project.root, &project.build_cache_dir(), &project.settings.effective());
ide_build::web::artifacts(&project.root, &model)
let settings = project.settings.effective();
let model = crate::ops::build::load(&project.root, &project.build_cache_dir(), &settings);
let mut artifacts = ide_build::web::artifacts(&project.root, &model);
// Without a build tool, the Project Structure's WAR artifacts are built by the IDE.
if model.maven.is_none() && model.gradle.is_empty() {
let detected = project.detected_roots.read().clone();
let (ps, _, _) = crate::ops::build::structure_inputs(&project.root, &settings, &detected);
artifacts.extend(project_web_artifacts(&ps));
}
artifacts
})
.await
.map_err(|e| IdeError::internal(e.to_string()))
@@ -230,6 +304,12 @@ pub async fn run_tomcat_build(host: &Host, window: &str, config: RunConfig) -> I
.or_else(|| artifacts.first().map(|a| &a.id))
.ok_or_else(|| IdeError::invalid("Choose a WAR artifact"))?;
let base = ide_run::tomcat::effective_base_dir(&project.root, &project.cache_dir, &config)?;
if let Some(name) = id.strip_prefix(PROJECT_ARTIFACT) {
let settings = project.settings.effective();
let detected = project.detected_roots.read().clone();
build_project_war(&project.root, &settings, &detected, name, &base, &project.build_cache_dir())?;
return Ok(None);
}
// "Build before launch" is skipped when the built WAR is already newer than the
// sources of every module in the build, so a repeated run does not rebuild (IDEA's
// up-to-date check) but a change in a dependency module does.
+14
Переглянути файл
@@ -37,6 +37,9 @@ pub struct ProjectInterpreter {
pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
host.require_trust(window)?;
let project = host.project(window).ok();
if kind == SdkKind::Jdk {
host.apply_added_jdks();
}
let root = project.as_ref().map(|p| p.root.clone());
// The interpreter the project uses is a choice even where detection doesn't look (a
// virtualenv in a subfolder, one picked by path), so it shows by name and version.
@@ -372,9 +375,20 @@ pub async fn sdk_python_pip(
result?
}
/// The JDK whose home is `path` (a macOS bundle too), as the SDK list shows it; `None` when
/// `path` is no JDK home (Add JDK from Disk…).
pub async fn sdk_jdk_at(path: String) -> IdeResult<Option<Sdk>> {
tokio::task::spawn_blocking(move || {
ide_sdk::java::jdk_at(std::path::Path::new(&path)).map(|j| ide_sdk::jdk_sdk(&j))
})
.await
.map_err(join_err)
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("sdk_detect", |c| async move { sdk_detect(&c.host, &c.window, c.arg("kind")?).await });
d.add("sdk_jdk_at", |c| async move { sdk_jdk_at(c.arg("path")?).await });
d.add(
"sdk_python_project_interpreters",
|c| async move { sdk_python_project_interpreters(&c.host, &c.window).await },
+6 -2
Переглянути файл
@@ -95,8 +95,12 @@ pub(crate) fn search_project(
cancel,
&|mut file| {
if dir != root {
let name = dir.file_name().unwrap_or_default().to_string_lossy();
file.rel_path = format!("{name}/{}", file.rel_path);
// A root inside the project (one its walk skips) goes by its path there.
let prefix = match dir.strip_prefix(root) {
Ok(rel) if include_root => rel.to_string_lossy().replace('\\', "/"),
_ => dir.file_name().unwrap_or_default().to_string_lossy().into_owned(),
};
file.rel_path = format!("{prefix}/{}", file.rel_path);
}
emit(file);
},
+81 -4
Переглянути файл
@@ -97,6 +97,21 @@ pub trait PluginWorkspace: Send + Sync {
fn indexed_files(&self, _root: &Path, _matches: &dyn Fn(&Path) -> bool, _limit: usize) -> Option<Vec<PathBuf>> {
None
}
/// Sends `method` to the running language server named `server` of the project at
/// `root`: a request, or with `notify` a notification (the result is null).
#[allow(clippy::too_many_arguments)]
fn lsp_request(
&self,
_root: &Path,
server: &str,
_method: &str,
_params: Option<serde_json::Value>,
_notify: bool,
_cancel: &CancellationToken,
_timeout: Duration,
) -> Result<serde_json::Value, HostError> {
Err(HostError::NotFound(format!("no language server `{server}` is running for this project")))
}
/// Current index of the project rooted at `root`; never reads disk or calls LSP.
fn symbols(
&self,
@@ -662,9 +677,14 @@ impl Shared {
}
let previous =
self.setting_snapshots.lock().insert((client.map(str::to_owned), pkg.id().into()), current.clone());
previous
.map(|old| current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect())
.unwrap_or_default()
match previous {
// First contact since the plugin loaded (fresh install, update,
// re-enable): hand over every current key, so the synthetic
// post-install `settings-changed` wakes the plugin instead of being
// dropped for having no diff yet.
None => current.into_keys().collect(),
Some(old) => current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect(),
}
}
pub fn status_snapshot(&self, client: &str) -> Vec<super::PluginStatusItem> {
@@ -2180,6 +2200,35 @@ impl HostApi for PluginApi {
)
}
fn lsp_request(
&self,
root: &Path,
server: &str,
method: &str,
params: Option<String>,
notify: bool,
cancel: &CancellationToken,
timeout: Duration,
) -> Result<String, HostError> {
self.require_api("`language-servers`", 9)?;
if !ide_lsp::plugin_method_allowed(method) {
return Err(HostError::Invalid(format!("`{method}` is not one of the server's own methods")));
}
let workspace = self
.shared
.workspace()
.ok_or_else(|| HostError::NotFound(format!("no language server `{server}` is running for this project")))?;
// The server reads and edits the project on the plugin's behalf, as a process would.
if !workspace.trusted(root) {
return Err(HostError::Denied("project is not trusted".into()));
}
let params = params
.map(|p| serde_json::from_str(&p).map_err(|e| HostError::Invalid(format!("params are not JSON: {e}"))))
.transpose()?;
let result = workspace.lsp_request(root, server, method, params, notify, cancel, timeout)?;
Ok(result.to_string())
}
fn find_files(&self, root: &Path, glob: &str, limit: usize) -> Result<Vec<String>, HostError> {
let matcher = globset::GlobBuilder::new(glob)
.literal_separator(true)
@@ -2782,7 +2831,7 @@ impl HostApi for PluginApi {
}
fn post_view_message(&self, view: &str, message: String) -> Result<(), HostError> {
let declared = [super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
let declared = super::ui_points::WEB_POINTS
.iter()
.any(|point| self.shared.ui.items(point, Some(self.id())).iter().any(|i| i.key == view));
if !declared {
@@ -3302,6 +3351,34 @@ impl PluginWorkspace for HostWorkspace {
}
}
fn lsp_request(
&self,
root: &Path,
server: &str,
method: &str,
params: Option<serde_json::Value>,
notify: bool,
cancel: &CancellationToken,
timeout: Duration,
) -> Result<serde_json::Value, HostError> {
use ide_core::error::ErrorKind;
let host = self.0.upgrade().ok_or(HostError::Cancelled)?;
let project = HostWorkspace::project_covering(self, root)
.ok_or_else(|| HostError::NotFound("the project is no longer open".into()))?;
let result = if notify {
project.lsp.server_notify(root, server, method, params).map(|()| serde_json::Value::Null)
} else {
host.runtime.block_on(project.lsp.server_request(root, server, method, params, cancel, timeout))
};
result.map_err(|e| match e.kind {
// A server that stopped while the request was on its way is as absent as one never started.
ErrorKind::NotFound | ErrorKind::Unavailable => HostError::NotFound(e.message),
ErrorKind::InvalidInput => HostError::Invalid(e.message),
ErrorKind::Cancelled => HostError::Cancelled,
_ => HostError::Failed(e.message),
})
}
fn trusted(&self, root: &Path) -> bool {
// A workspace member is as trusted as the group's project it was opened with.
HostWorkspace::project_covering(self, root).is_some_and(|p| p.is_trusted())
+29
Переглянути файл
@@ -313,6 +313,35 @@ impl PluginHost {
}
}
impl PluginHost {
/// The plugin command that runs `command`, which one of the language servers
/// `servers` handed to the client (`[[contributes.serverCommands]]`): the plugin
/// and its command id. A plugin counts while it holds `lsp:<server>`; when several
/// claim the same server and command, the first one loaded keeps it.
pub(crate) fn server_command(&self, servers: &[String], command: &str) -> Option<(String, String)> {
let mut claims = self.ui.items(super::ui_points::SERVER_COMMANDS, None).into_iter().filter_map(|item| {
let decl: super::ui_points::ServerCommandDecl = serde_json::from_value(item.decl).ok()?;
let claimed = decl.command == command && servers.contains(&decl.server);
let grant = ide_extension::Capability::Lsp(decl.server.clone());
let granted = claimed
&& self.get(&item.plugin_id).is_ok_and(|p| p.meta.lock().granted.iter().any(|g| g.covers(&grant)));
granted.then_some((item.plugin_id, decl.server, decl.run))
});
let (plugin, server, run) = claims.next()?;
for (other, _, _) in claims.filter(|(other, s, _)| *other != plugin && *s == server) {
static LOGGED: parking_lot::Mutex<std::collections::BTreeSet<(String, String, String)>> =
parking_lot::Mutex::new(std::collections::BTreeSet::new());
if LOGGED.lock().insert((other.clone(), server.clone(), command.to_owned())) {
tracing::warn!(
"plugins {plugin} and {other} both claim command `{command}` of language server {server}; \
{plugin} was loaded first and keeps it"
);
}
}
Some((plugin, run))
}
}
pub(crate) fn signature_help(h: SignatureHelp) -> ide_lsp::types::SignatureHelp {
let signatures: Vec<_> = h
.signatures
+2 -3
Переглянути файл
@@ -1489,9 +1489,8 @@ impl PluginHost {
}
fn declared_view(&self, id: &str, view: &str) -> IdeResult<()> {
let declared = [ui_points::VIEWS, ui_points::CUSTOM_EDITORS]
.iter()
.any(|point| self.ui.items(point, Some(id)).iter().any(|i| i.key == view));
let declared =
ui_points::WEB_POINTS.iter().any(|point| self.ui.items(point, Some(id)).iter().any(|i| i.key == view));
if declared { Ok(()) } else { Err(IdeError::not_found(format!("plugin {id:?} declares no view {view:?}"))) }
}
+2
Переглянути файл
@@ -89,10 +89,12 @@ pub fn register_builtin_points(
registry.register(Arc::new(UiPoint::new(p::SETTINGS, ui.clone(), p::settings)))?;
registry.register(Arc::new(UiPoint::new(p::VIEWS, ui.clone(), p::view)))?;
registry.register(Arc::new(UiPoint::new(p::CUSTOM_EDITORS, ui.clone(), p::custom_editor)))?;
registry.register(Arc::new(UiPoint::new(p::EDITOR_PANELS, ui.clone(), p::editor_panel)))?;
registry.register(Arc::new(UiPoint::new(p::MARKER_ICONS, ui.clone(), p::marker_icon)))?;
registry.register(Arc::new(UiPoint::new(p::FILE_ICONS, ui.clone(), p::file_icon)))?;
registry.register(Arc::new(UiPoint::new(p::FILE_TEMPLATES, ui.clone(), p::file_template)))?;
registry.register(Arc::new(UiPoint::new(p::COMMIT_CHECKS, ui.clone(), p::commit_check)))?;
registry.register(Arc::new(UiPoint::new(p::SERVER_COMMANDS, ui.clone(), p::server_command)))?;
registry.register(Arc::new(UiPoint::new(ide_extension::LOCALES_POINT, ui.clone(), p::locales)))?;
Ok(())
}
+121
Переглянути файл
@@ -36,6 +36,12 @@
//! layout = "tab" # or "split" / "preview": beside the text editor
//! web = "web/index.html" # a web page from the package instead of rendered content
//!
//! [[contributes.editorPanels]]
//! id = "minimap"
//! web = "web/index.html" # beside each editor group's text editor; needs `editor.read`
//! width = 110 # pixels, 40–400
//! when = "plugin.<id>.enabled" # optional
//!
//! [[contributes.fileIcons]]
//! id = "drawing"
//! patterns = ["*.excalidraw"]
@@ -46,6 +52,11 @@
//! id = "conventional"
//! title = "Conventional Commits" # Commit Options › Before Commit; `commit-checker.check` runs it
//!
//! [[contributes.serverCommands]]
//! server = "phoxite" # the language server whose results carry the command
//! command = "laravel.modelView" # a command the server leaves to the client
//! run = "model-view" # this plugin's command; needs `lsp:phoxite`
//!
//! [[contributes.fileTemplates]]
//! id = "drawing"
//! name = "Excalidraw Drawing"
@@ -68,10 +79,14 @@ pub const STATUS_BAR: &str = "statusBar";
pub const SETTINGS: &str = "settings";
pub const VIEWS: &str = "views";
pub const CUSTOM_EDITORS: &str = "customEditors";
pub const EDITOR_PANELS: &str = "editorPanels";
/// The points whose declarations can name a `web` page (served, messaged, sent view events).
pub const WEB_POINTS: [&str; 3] = [VIEWS, CUSTOM_EDITORS, EDITOR_PANELS];
pub const FILE_ICONS: &str = "fileIcons";
pub const MARKER_ICONS: &str = "markerIcons";
pub const FILE_TEMPLATES: &str = "fileTemplates";
pub const COMMIT_CHECKS: &str = "commitChecks";
pub const SERVER_COMMANDS: &str = "serverCommands";
const VIEW_ITEM_MENU: &str = "viewItem.context";
/// The toolbar above the commit message (Commit tool window and dialog).
@@ -739,6 +754,41 @@ pub(super) fn custom_editor(pkg: &Package, decl: toml::Value) -> Result<UiDecl,
Ok(out)
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
struct EditorPanelDecl {
id: String,
web: String,
width: u32,
#[serde(default, skip_serializing_if = "Option::is_none")]
when: Option<String>,
}
const EDITOR_PANEL_WIDTH: std::ops::RangeInclusive<u32> = 40..=400;
/// `[[contributes.editorPanels]]` (API 1.9): a web page at the right edge of every
/// editor group, beside its text editor. It sees each file the group shows, so it
/// needs `editor.read`.
pub(super) fn editor_panel(pkg: &Package, decl: toml::Value) -> Result<UiDecl, String> {
let d: EditorPanelDecl = decode(EDITOR_PANELS, decl)?;
pkg.manifest.needs_api(&format!("contributes.{EDITOR_PANELS}"), 9)?;
validate_item_id(&d.id, "editor panel id")?;
let what = format!("editor panel {:?}", d.id);
if !EDITOR_PANEL_WIDTH.contains(&d.width) {
return Err(format!("{what}: `width` is {}–{} pixels", EDITOR_PANEL_WIDTH.start(), EDITOR_PANEL_WIDTH.end()));
}
if let Some(when) = &d.when {
validate_when(when).map_err(|e| format!("{what}: {e}"))?;
}
if !pkg.manifest.capabilities.all().any(|c| *c == ide_extension::Capability::EditorRead) {
return Err(format!("{what}: needs the `editor.read` capability (the page sees the files editors show)"));
}
let files = super::web::web_files(pkg, &d.web, &what)?;
let mut out = UiDecl::new(d.id.clone(), d.id.clone(), json(&d)?);
out.files = files;
Ok(out)
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
struct FileIconDecl {
@@ -964,6 +1014,37 @@ pub(super) fn commit_check(pkg: &Package, decl: toml::Value) -> Result<UiDecl, S
Ok(UiDecl::new(d.id.clone(), d.title.clone(), json(&d)?))
}
/// A command a language server's code lens, code action or inlay hint carries and
/// leaves to the client, and the plugin command that runs it.
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub(super) struct ServerCommandDecl {
/// The server's name in its language definition.
pub(super) server: String,
pub(super) command: String,
/// The plugin's command (`[[contributes.commands]]`); it gets the arguments as JSON.
pub(super) run: String,
}
/// `[[contributes.serverCommands]]` (API 1.9): routes a command no server executes
/// itself to the plugin's own command.
pub(super) fn server_command(pkg: &Package, decl: toml::Value) -> Result<UiDecl, String> {
let d: ServerCommandDecl = decode(SERVER_COMMANDS, decl)?;
pkg.manifest.needs_api(&format!("contributes.{SERVER_COMMANDS}"), 9)?;
if d.command.is_empty() || d.command.len() > 256 {
return Err(format!("contributes.{SERVER_COMMANDS}: command names are 1–256 bytes"));
}
declared_command(pkg, SERVER_COMMANDS, &d.run)?;
let grant: ide_extension::Capability =
format!("lsp:{}", d.server).parse().map_err(|e| format!("contributes.{SERVER_COMMANDS}: {e}"))?;
if !pkg.manifest.capabilities.all().any(|c| *c == grant) {
return Err(format!(
"contributes.{SERVER_COMMANDS}: needs the `{grant}` capability (the command comes from that server)"
));
}
Ok(UiDecl::new(format!("{}:{}", d.server, d.command), d.command.clone(), json(&d)?))
}
const MAX_CATALOG_ENTRIES: usize = 20_000;
pub fn locale_asset(tag: &str) -> String {
@@ -1159,6 +1240,46 @@ mod tests {
}
}
#[test]
fn editor_panels_validate_api_width_when_capability_and_page() {
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/editor-panel");
let source = std::fs::read_to_string(root.join("plugin.toml")).unwrap();
let check = |source: &str| {
let manifest = ide_extension::Manifest::parse(source)?;
let decl = manifest.declarations(EDITOR_PANELS).into_iter().next().unwrap();
editor_panel(&Package::new(manifest, root.clone()), decl)
};
let valid = check(&source).unwrap();
assert_eq!(valid.key, "minimap");
assert_eq!(valid.json, serde_json::json!({ "id": "minimap", "web": "web/index.html", "width": 110 }));
assert_eq!(valid.files, [PathBuf::from("web/index.html")]);
let when = source.replace("width = 110", "width = 110\nwhen = \"plugin.editor-panel.enabled\"");
assert_eq!(check(&when).unwrap().json["when"], "plugin.editor-panel.enabled");
for width in ["40", "400"] {
assert!(check(&source.replace("width = 110", &format!("width = {width}"))).is_ok(), "{width}");
}
for (bad, error) in [
(source.replace("^1.9", "^1.8"), "1.9"),
(source.replace("width = 110", "width = 39"), "40–400"),
(source.replace("width = 110", "width = 401"), "40–400"),
(source.replace("width = 110", "width = -1"), "u32"),
(source.replace("width = 110\n", ""), "width"),
(source.replace("width = 110", "width = 110\nwhen = \"a &&\""), "when"),
(source.replace("width = 110", "width = 110\nside = \"left\""), "side"),
(source.replace(r#"required = ["editor.read"]"#, "required = []"), "editor.read"),
(source.replace("web/index.html", "index.html"), "directory of its own"),
(source.replace("web/index.html", "web/missing.html"), "no such file"),
(source.replace("web/index.html", "../web/index.html"), "web"),
(source.replace(r#"id = "minimap""#, r#"id = "Mini Map""#), "id"),
] {
let err = check(&bad).unwrap_err();
assert!(err.contains(error), "{bad}\n→ {err}");
}
// Declared as optional, the capability is still shown at install.
let optional = source.replace("required = [", "optional = [");
assert!(check(&optional).is_ok());
}
fn package_with_catalogs(files: &[(&str, &str)]) -> (tempfile::TempDir, Package) {
let dir = tempfile::tempdir().unwrap();
std::fs::create_dir(dir.path().join(LOCALES_DIR)).unwrap();
+2 -2
Переглянути файл
@@ -335,7 +335,7 @@ impl PluginHost {
/// The web roots `plugin` declares (entry directories, package-relative, `/`-terminated).
fn web_dirs(&self, plugin: &str) -> Vec<String> {
[super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
super::ui_points::WEB_POINTS
.iter()
.flat_map(|point| self.ui.items(point, Some(plugin)))
.filter_map(|item| item.decl.get("web").and_then(|w| w.as_str()).map(str::to_owned))
@@ -356,7 +356,7 @@ impl PluginHost {
if !plugin.status().is_live() {
return Err(IdeError::unavailable(format!("plugin {plugin_id:?} is not enabled")));
}
let entry = [super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
let entry = super::ui_points::WEB_POINTS
.iter()
.flat_map(|point| self.ui.items(point, Some(plugin_id)))
.find(|item| item.key == view)
+51 -7
Переглянути файл
@@ -144,7 +144,7 @@ impl Host {
let lsp = LspManager::new(root.clone(), languages.clone(), sink.clone());
crate::plugins::injections::configure_lsp(&lsp);
lsp.set_execution_allowed(trusted.load(Ordering::Acquire));
lsp.set_content_roots(extra_roots.clone());
lsp.set_content_roots(language_server_roots(&root, extra_roots.clone()));
lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
&root,
&settings.effective().languages.java.maven.linked_projects,
@@ -1224,7 +1224,7 @@ impl Project {
return;
}
let (roots, excludes) = (self.content_roots(), self.exclude_globs());
self.lsp.set_content_roots(roots.clone());
self.lsp.set_content_roots(language_server_roots(&self.root, roots.clone()));
self.lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
&self.root,
&self.settings.effective().languages.java.maven.linked_projects,
@@ -1275,7 +1275,9 @@ impl Project {
}
let defaults = self.documents.file_defaults();
let fallback = defaults.fallback_for(path);
if path.exists() {
// The working file only when it is a regular file: a path that is a directory there
// (a committed symlink to a folder, a file replaced by a folder) has only its blob.
if path.is_file() {
let loaded = ide_vfs::load_text_with_fallback(path, fallback)?;
return encoding_rs::Encoding::for_label(loaded.encoding.as_bytes())
.ok_or_else(|| ide_core::IdeError::invalid("unknown file encoding"));
@@ -1348,15 +1350,20 @@ pub(crate) fn workspace_member_roots(root: &Path) -> Vec<PathBuf> {
.unwrap_or_default()
}
/// Workspace members in manifest order, or extra Project Structure directories, Gradle
/// project folders outside the project, and directories of Maven POMs linked from
/// outside it (`build_cache` is the Gradle sync cache).
/// Workspace members in manifest order, or the attached projects outside the project and
/// those inside it that its walk skips as ignored (a git worktree under an ignored folder),
/// extra Project Structure directories, Gradle project folders outside the project, and
/// directories of Maven POMs linked from outside it (`build_cache` is the Gradle sync cache).
fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cache: &Path) -> Vec<PathBuf> {
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root) {
if workspace.is_container(root) {
return workspace.projects;
}
let mut roots = workspace.projects.into_iter().filter(|p| !p.starts_with(root)).collect::<Vec<_>>();
let mut roots = workspace
.projects
.into_iter()
.filter(|p| !p.starts_with(root) || ide_index::walk_skips(root, p))
.collect::<Vec<_>>();
for path in extra_content_roots(settings, root, build_cache) {
if !roots.contains(&path) {
roots.push(path);
@@ -1367,6 +1374,22 @@ fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cac
extra_content_roots(settings, root, build_cache)
}
/// The content roots plus the projects attached inside this one. The index covers those
/// already, but each is a project of its own (a git worktree under the project, a nested
/// Cargo workspace), so its files get a language server rooted there, not at this root.
fn language_server_roots(root: &Path, mut roots: Vec<PathBuf>) -> Vec<PathBuf> {
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root)
&& !workspace.is_container(root)
{
for path in workspace.projects {
if path != root && path.starts_with(root) && !roots.contains(&path) {
roots.push(path);
}
}
}
roots
}
/// The roots a file may navigate into: its own root (the workspace member containing it, or
/// the project root) plus that root's configured dependencies. A workspace member depends
/// only on the roots picked per member in Project Structure › Dependencies —
@@ -2161,4 +2184,25 @@ mod content_roots_tests {
let roots = content_roots(&settings, &root, &tmp.path().join("build"));
assert_eq!(roots, vec![shared, dep]);
}
#[test]
fn projects_attached_inside_the_root_get_their_own_language_server_root() {
let tmp = tempfile::tempdir().unwrap();
let ws = dunce::canonicalize(tmp.path()).unwrap();
let (root, nested, other) = (ws.join("app"), ws.join("app/.wt/feature"), ws.join("other"));
for dir in [&nested, &other] {
std::fs::create_dir_all(dir).unwrap();
}
let settings = ide_core::settings::Settings::default();
let build = ws.join("build");
assert!(super::language_server_roots(&root, content_roots(&settings, &root, &build)).is_empty());
ide_workspace::workspace::Workspace::attach(&root, "app", vec![root.clone(), nested.clone(), other.clone()])
.unwrap();
// The index walks the nested project as part of the root ...
let roots = content_roots(&settings, &root, &build);
assert_eq!(roots, vec![other.clone()]);
// ... while its files go to a language server of its own.
assert_eq!(super::language_server_roots(&root, roots), vec![other, nested]);
}
}
+1
Переглянути файл
@@ -165,6 +165,7 @@ impl Dispatcher {
})
.add("project_roots", |c| async move { ops::project::roots(&c.host, &c.window) })
.add("settings_get", |c| async move { Ok(ops::project::settings(&c.host, &c.window)) })
.add("settings_removed_theme", |c| async move { Ok(ops::project::settings_removed_theme(&c.host, &c.window)) })
.add("settings_set", |c| async move {
let key: String = c.arg("key")?;
let scope = c.arg("scope")?;
+6
Переглянути файл
@@ -408,6 +408,7 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
| "settings_export"
| "settings_get"
| "settings_get_global"
| "settings_removed_theme"
| "settings_import"
| "settings_list_jetbrains_ides"
| "settings_read_jetbrains"
@@ -499,6 +500,7 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
| "find_files_named"
| "find_dirs"
| "find_symbols"
| "find_symbols_named"
| "mark_recent"
| "remove_recent"
| "recent_files"
@@ -545,9 +547,13 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
| "agent_registry_remove"
| "agent_mcp_list"
| "agent_mcp_save"
| "agent_mcp_save_json"
| "agent_mcp_set_enabled"
| "agent_mcp_remove"
| "agent_mcp_import"
| "agent_mcp_discover_sources"
| "agent_mcp_import_selected"
| "agent_set_mcp_overrides"
| "coverage_import"
| "system_font_families"
| "user_font_data"
+98
Переглянути файл
@@ -594,6 +594,31 @@ fn agent_process(h: &Harness, name: &str) -> ide_core::RunId {
h.host.processes.list().into_iter().filter(|r| r.config_id == id && r.running).map(|r| r.id).max().unwrap()
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread")]
async fn run_command_returns_once_a_server_prints_its_ready_line() {
let h = Harness::new();
h.trust().await;
h.host.mcp_requests.set_ready("main", true);
h.host
.global_settings
.set(ide_workspace::SettingsScope::Global, "mcpServer.runWithoutConfirmation", json!(true))
.unwrap();
let _started = run_tool_window(&h);
// A server started with its ready line returns once it prints it, long before the timeout.
let started_at = std::time::Instant::now();
let up = h
.json(
"run_command",
json!({"name": "web", "command": "sleep 1; echo Listening on 8080; sleep 30", "pattern": "Listening on", "timeout": 60000}),
)
.await;
assert_eq!((up["waitEnded"].as_str(), up["state"].as_str()), (Some("matched"), Some("running")), "{up}");
assert!(up["output"].as_str().unwrap().contains("Listening on 8080"), "{up}");
assert!(started_at.elapsed() < std::time::Duration::from_secs(20), "returned after {:?}", started_at.elapsed());
h.json("stop_run", json!({"name": "web", "force": true, "timeout": 10000})).await;
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread")]
async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
@@ -697,3 +722,76 @@ async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
let interrupted = h.json("wait_for_run", json!({"name": "interrupt", "timeout": 10000})).await;
assert_eq!(interrupted["state"], "stoppedByAgent", "{interrupted}");
}
#[tokio::test(flavor = "multi_thread")]
async fn http_list_and_run_require_confirmation() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let h = Harness::new();
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
let (mut socket, _) = listener.accept().await.unwrap();
let mut buf = [0u8; 1024];
let _ = socket.read(&mut buf).await;
let body = b"{\"ok\":true}";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
body.len(),
std::str::from_utf8(body).unwrap()
);
let _ = socket.write_all(response.as_bytes()).await;
});
std::fs::write(
h.root.join("api.http"),
format!(
"### Health\nGET http://{addr}/health\nAccept: application/json\n\n### Echo\n# @name echo\nGET http://{addr}/echo\n"
),
)
.unwrap();
std::fs::write(h.root.join("http-client.env.json"), r#"{"dev":{"unused":"x"}}"#).unwrap();
let listed = h.json("http_list_requests", json!({"path": "api.http"})).await;
assert_eq!(listed["requests"].as_array().unwrap().len(), 2, "{listed}");
assert_eq!(listed["requests"][0]["index"], 0);
assert_eq!(listed["requests"][0]["name"], "Health");
assert_eq!(listed["requests"][0]["method"], "GET");
assert_eq!(listed["requests"][1]["name"], "echo");
assert!(listed["requests"][0]["url"].as_str().unwrap().contains("/health"));
// Write tool is hidden until the project is trusted.
assert!(Registry::new(h.host.clone()).tools(&h.root).unwrap().iter().all(|t| t.name != "http_run_request"));
h.trust().await;
assert!(
Registry::new(h.host.clone())
.tools(&h.root)
.unwrap()
.iter()
.any(|t| t.name == "http_run_request" && !t.read_only)
);
h.host.mcp_requests.set_ready("main", true);
let denied = h.error("http_run_request", json!({"path": "api.http", "index": 0, "env": "dev"}));
let deny = async {
let id = h.request().await;
h.host.mcp_requests.answer("main", id, false, None).unwrap();
};
let (error, ()) = tokio::join!(denied, deny);
assert!(error.contains("denied by the user"), "{error}");
h.events.lock().unwrap().clear();
let run = h.json("http_run_request", json!({"path": "api.http", "index": 0, "env": "dev"}));
let allow = async {
let id = h.request().await;
h.host.mcp_requests.answer("main", id, true, None).unwrap();
};
let (result, ()) = tokio::join!(run, allow);
assert_eq!(result["status"], 200, "{result}");
assert_eq!(result["method"], "GET");
assert!(result["body"].as_str().unwrap().contains("ok"), "{result}");
assert_eq!(result["bodyTruncated"], false);
// Secrets must not appear as request headers/body in the tool payload.
assert!(result.get("headers").is_none(), "{result}");
assert!(result.get("request").is_none(), "{result}");
}
+184
Переглянути файл
@@ -0,0 +1,184 @@
//! `[[contributes.serverCommands]]` (plugin API 1.9): a command a language server hands to the
//! client runs the plugin command that claims it. The fixture's command sends its argument
//! back to the server (`mock/ran`), through the real component runtime and `language-servers`.
use ide_host::plugins::{Consent, HostWorkspace, PluginHost, set_editor_providers};
use ide_host::{Host, HostConfig, ops};
use ide_jsonrpc::{Handler, Peer};
use ide_lsp::types::Command;
use ide_plugin::Limits;
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::{path::Path, sync::Arc, time::Duration};
const ID: &str = "test.lsp-requests";
const SECOND: &str = "test.lsp-second";
fn fixture() -> std::path::PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/lsp-requests")
}
/// The fixture under `dir` with `edit` applied to its manifest.
fn variant(dir: &Path, edit: impl Fn(&str) -> String) -> std::path::PathBuf {
fn copy(from: &Path, to: &Path) {
std::fs::create_dir_all(to).unwrap();
for entry in std::fs::read_dir(from).unwrap() {
let entry = entry.unwrap();
match entry.file_type().unwrap().is_dir() {
true if entry.file_name() != "target" => copy(&entry.path(), &to.join(entry.file_name())),
true => {}
false => drop(std::fs::copy(entry.path(), to.join(entry.file_name())).unwrap()),
}
}
}
copy(&fixture(), dir);
let manifest = dir.join("plugin.toml");
std::fs::write(&manifest, edit(&std::fs::read_to_string(&manifest).unwrap())).unwrap();
dir.to_path_buf()
}
/// A language server named `mock`: it executes `mock.own` itself and records what it gets.
#[derive(Default)]
struct Mock {
requests: Mutex<Vec<(String, Value)>>,
notifications: Mutex<Vec<(String, Value)>>,
}
impl Mock {
fn ran(&self) -> Vec<Value> {
self.notifications.lock().iter().filter(|(m, _)| m == "mock/ran").map(|(_, p)| p.clone()).collect()
}
fn executed(&self) -> Vec<Value> {
let requests = self.requests.lock();
requests.iter().filter(|(m, _)| m == "workspace/executeCommand").map(|(_, p)| p["command"].clone()).collect()
}
}
impl Handler for Mock {
fn on_notification(&self, method: &str, p: Value) {
self.notifications.lock().push((method.to_owned(), p));
}
fn on_request(&self, method: &str, p: Value) -> Result<Value, (i64, String)> {
self.requests.lock().push((method.to_owned(), p));
Ok(match method {
"initialize" => json!({ "capabilities": {
"textDocumentSync": { "openClose": true, "change": 1 },
"executeCommandProvider": { "commands": ["mock.own"] },
} }),
_ => Value::Null,
})
}
}
async fn eventually(what: &str, mut f: impl FnMut() -> bool) {
for _ in 0..500 {
if f() {
return;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
panic!("timed out waiting for {what}");
}
fn command(name: &str, arguments: Vec<Value>) -> Command {
Command { title: "Lens".into(), command: name.into(), arguments }
}
#[tokio::test(flavor = "multi_thread")]
async fn a_command_the_server_leaves_to_the_client_runs_the_plugin_that_claims_it() {
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
std::fs::create_dir(&root).unwrap();
let host = Arc::new(Host::new(HostConfig {
config_dir: tmp.path().join("config"),
data_dir: tmp.path().join("data"),
local_data_dir: tmp.path().join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(ide_core::NullSink)),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
}));
// Language servers start only in a trusted project.
host.set_project_trust(&root, true, false).await.unwrap();
host.open_project("main", &root).unwrap();
let plugins = Arc::new(
PluginHost::new(tmp.path().join("plugins"), Arc::new(|_: Option<&str>, _| {}), Limits::default()).unwrap(),
);
plugins.set_workspace(Some(Arc::new(HostWorkspace(Arc::downgrade(&host)))));
set_editor_providers(Some(&plugins));
// The manifest must hold the grant of the server whose commands it claims.
let ungranted = variant(&tmp.path().join("ungranted"), |m| m.replace("optional = [\"lsp:mock\"]", "optional = []"));
let err = plugins.install_from_dir(&ungranted, &Consent::all()).unwrap_err();
assert!(err.message.contains("needs the `lsp:mock` capability"), "{err:?}");
plugins.install_from_dir(&fixture(), &Consent::all()).unwrap();
// The server `mock` serves the project's text files.
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
let port = listener.local_addr().unwrap().port();
let mock = Arc::new(Mock::default());
let peers = Arc::new(Mutex::new(Vec::<Peer>::new()));
let (accepted, state) = (peers.clone(), mock.clone());
let server = tokio::spawn(async move {
while let Ok((stream, _)) = listener.accept().await {
let (r, w) = stream.into_split();
accepted.lock().push(Peer::connect(r, w, state.clone()));
}
});
let cfg: ide_language::LanguageServerConfig =
toml::from_str(&format!("name='mock'\ncommand='no-process-required'\nconnect='127.0.0.1:{port}'")).unwrap();
let project = host.project("main").unwrap();
project.lsp.set_servers_hook(Box::new(move |_, _| vec![cfg.clone()]));
let path = root.join("a.txt");
std::fs::write(&path, "class Post {}\n").unwrap();
let doc = ops::doc::open(&host, "main", path.clone()).await.unwrap().id;
project.lsp.did_open(
doc,
&path,
&ide_core::LanguageId::plain_text(),
0,
"class Post {}
",
);
eventually("the server to be ready", || {
project.lsp.servers().iter().any(|s| s.name == "mock" && s.status == ide_core::event::ServerStatus::Ready)
})
.await;
// A lens command the server does not execute: the plugin's command gets the arguments as JSON.
let lens = command("mock.modelView", vec![json!("App\\Models\\Post"), json!({ "line": 3 })]);
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
eventually("the plugin's command", || !mock.ran().is_empty()).await;
assert_eq!(mock.ran(), [json!(["App\\Models\\Post", { "line": 3 }])]);
assert!(mock.executed().is_empty(), "the server was not asked to execute it");
// A command in the server's `executeCommandProvider` still goes to the server.
ops::lsp::lsp_execute_command(&host, "main", doc, command("mock.own", vec![])).await.unwrap();
assert_eq!(mock.executed(), [json!("mock.own")]);
assert_eq!(mock.ran().len(), 1);
// A command nobody claims fails as before.
let err = ops::lsp::lsp_execute_command(&host, "main", doc, command("mock.unclaimed", vec![])).await.unwrap_err();
assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable, "{err:?}");
// Two plugins claim the same server and command: the first one loaded keeps it.
let second = variant(&tmp.path().join("second"), |m| m.replace(ID, SECOND));
plugins.install_from_dir(&second, &Consent::all()).unwrap();
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
eventually("the first plugin's command again", || mock.ran().len() == 2).await;
assert_eq!(plugins.info_of(SECOND).unwrap().stats.activations, 0, "the second plugin never ran");
// A claim counts only while the plugin holds the server's grant.
plugins.set_capability(ID, "lsp:mock", false).unwrap();
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
eventually("the second plugin's command", || mock.ran().len() == 3).await;
assert_eq!(plugins.info_of(SECOND).unwrap().stats.activations, 1);
plugins.set_capability(SECOND, "lsp:mock", false).unwrap();
let err = ops::lsp::lsp_execute_command(&host, "main", doc, lens).await.unwrap_err();
assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable, "{err:?}");
assert_eq!(mock.ran().len(), 3);
set_editor_providers(None);
server.abort();
}
+117 -7
Переглянути файл
@@ -31,6 +31,8 @@ struct TestWorkspace {
/// plugin → its settings as the user set them.
settings: Mutex<std::collections::BTreeMap<String, serde_json::Map<String, serde_json::Value>>>,
global_settings: Mutex<std::collections::BTreeMap<String, serde_json::Map<String, serde_json::Value>>>,
/// What plugins sent the language server `mock`: (method, params, whether a notification).
server_messages: Mutex<Vec<(String, Option<serde_json::Value>, bool)>>,
}
impl TestWorkspace {
@@ -49,6 +51,7 @@ impl TestWorkspace {
diagnostics: Mutex::default(),
settings: Mutex::default(),
global_settings: Mutex::default(),
server_messages: Mutex::default(),
})
}
@@ -176,6 +179,23 @@ impl PluginWorkspace for TestWorkspace {
fn trusted(&self, _root: &Path) -> bool {
self.trusted
}
/// One language server runs for the project, `mock`: it answers with what it was sent.
fn lsp_request(
&self,
_root: &Path,
server: &str,
method: &str,
params: Option<serde_json::Value>,
notify: bool,
_cancel: &ide_core::CancellationToken,
_timeout: Duration,
) -> Result<serde_json::Value, HostError> {
if server != "mock" {
return Err(HostError::NotFound(format!("no language server `{server}` is running for this project")));
}
self.server_messages.lock().push((method.into(), params.clone(), notify));
Ok(if notify { serde_json::Value::Null } else { serde_json::json!({ "method": method, "params": params }) })
}
fn project_windows(&self, root: &Path) -> Vec<String> {
// `main` shows the fixture project; other open roots have no window left.
if root == self.root { vec!["closing".into(), "main".into()] } else { Vec::new() }
@@ -821,10 +841,11 @@ fn a_reporting_task_outlives_its_background_budget() {
#[test]
fn background_tasks_scale_and_renew_cpu_fuel_budget() {
// Room for activation (about 3_100 on macOS, more on Windows) but not for `patient`'s
// whole run (about 9_000) without the refill on each report.
// Room for activation (about 3_100 on macOS, more on Windows). A background task gets ten
// times it (5 s / 500 ms): enough for each step of `patient` with its CPU work (32_000 to
// 80_000), not for the whole run without the refill on each report.
let f = fixture(Limits {
fuel: 6_000,
fuel: 40_000,
timeout: Duration::from_millis(500),
background: Duration::from_millis(5_000),
..Limits::default()
@@ -836,11 +857,11 @@ fn background_tasks_scale_and_renew_cpu_fuel_budget() {
// Warm up activation in its own call so `patient` starts with a fresh budget.
assert_eq!(f.run("misbehave", "echo", Some("warm")).unwrap().as_deref(), Some("warm"));
let out = f.run("misbehave", "patient", None).expect("background task succeeds").expect("output");
let out = f.run("misbehave", "patient", Some("4000")).expect("background task succeeds").expect("output");
assert_eq!(out, "still here");
let err = f.run("misbehave", "spin", None).unwrap_err();
assert!(err.contains("exceeded its CPU budget (6000 fuel per call)"), "{err}");
assert!(err.contains("exceeded its CPU budget (40000 fuel per call)"), "{err}");
}
#[test]
@@ -2606,6 +2627,7 @@ fn git_toolbox_does_not_fetch_untrusted_projects() {
diagnostics: Mutex::default(),
settings: Mutex::default(),
global_settings: Mutex::default(),
server_messages: Mutex::default(),
});
f.host.set_workspace(Some(untrusted));
let err = f.run("openidea.git-toolbox", "fetch", None).unwrap_err();
@@ -6249,10 +6271,15 @@ fn api14_settings_and_input_events_use_other_and_capture_the_editor() {
assert!(f.host.wait_events(Duration::from_secs(5)));
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
let events = received.as_array().unwrap();
assert_eq!(events.len(), 3, "{received}");
assert_eq!(events.len(), 4, "{received}");
// The first synthetic post hands over the current keys ("enabled": false);
// the second is a real diff to true. Keys come from the recomputed
// snapshot, never from the event payload ("another-plugin-key").
assert_eq!(events[0]["kind"], "settings-changed");
assert_eq!(events[0]["data"], "[\"enabled\"]");
assert_eq!(events[2]["kind"], "input-mode-changed");
assert_eq!(events[1]["kind"], "settings-changed");
assert_eq!(events[1]["data"], "[\"enabled\"]");
assert_eq!(events[3]["kind"], "input-mode-changed");
assert_eq!(events[2]["editor"][0], path);
assert_eq!(events[2]["editor"][1][0], serde_json::json!([0, 0, 0, 0]));
}
@@ -6930,3 +6957,86 @@ fn project_write_judges_a_link_by_its_target() {
assert_eq!(std::fs::read_to_string(&secret).unwrap(), "top secret", "{rel}");
}
}
/// A plugin reaches a running language server only with `lsp:<server>`, in a trusted
/// project, and only with the server's own methods (API 1.9).
#[test]
fn language_server_requests_need_the_servers_grant_and_its_own_methods() {
use serde_json::json;
let f = fixture(Limits::default());
let pkg = repo().join("crates/ide-plugin/tests/fixtures/lsp-requests");
let id = "test.lsp-requests";
let info = f.install(&pkg);
assert!(info.capabilities.iter().any(|c| c.id == "lsp:mock" && c.granted && c.risk == ide_extension::Risk::High));
// The request and its JSON params reach the server; its answer comes back as JSON.
let answer = f.run(id, "request", Some(r#"{"verb":"GET"}"#)).unwrap().unwrap();
assert_eq!(
serde_json::from_str::<serde_json::Value>(&answer).unwrap(),
json!({ "method": "mock/routes", "params": { "verb": "GET" } })
);
assert_eq!(f.run(id, "notify", None).unwrap(), None);
assert_eq!(
*f.workspace.server_messages.lock(),
[("mock/routes".to_owned(), Some(json!({ "verb": "GET" })), false), ("mock/changed".to_owned(), None, true)]
);
// Params that are not JSON and LSP's own methods stop at the host.
assert!(f.run(id, "request", Some("{")).unwrap_err().contains("params are not JSON"));
assert!(f.run(id, "standard", None).unwrap_err().contains("not one of the server's own methods"));
assert_eq!(f.workspace.server_messages.lock().len(), 2);
// The grant names one server: another one is denied, not merely absent.
let err = f.host.run_command(id, "ungranted", None, f.inv()).unwrap_err();
assert_eq!(err.kind, ErrorKind::PermissionDenied, "{err:?}");
assert!(err.message.contains("lsp:other"), "{err:?}");
// Without the grant the call is denied and nothing is sent.
f.host.set_capability(id, "lsp:mock", false).unwrap();
let err = f.host.run_command(id, "request", None, f.inv()).unwrap_err();
assert_eq!(err.kind, ErrorKind::PermissionDenied, "{err:?}");
assert!(err.message.contains("lsp:mock"), "{err:?}");
f.host.set_capability(id, "lsp:mock", true).unwrap();
f.run(id, "request", None).unwrap();
// A server acts on the project's files: not in an untrusted project.
let mut untrusted = TestWorkspace::new(&f.project);
Arc::get_mut(&mut untrusted).unwrap().trusted = false;
f.host.set_workspace(Some(untrusted.clone()));
let err = f.host.run_command(id, "request", None, f.inv()).unwrap_err();
assert_eq!(err.kind, ErrorKind::PermissionDenied, "{err:?}");
assert!(untrusted.server_messages.lock().is_empty());
assert_eq!(f.host.info_of(id).unwrap().stats.crashes, 0);
}
/// The grant is new in API 1.9: an older `engines.openidea` can't ask for it.
#[test]
fn the_language_server_grant_needs_api_1_9() {
let f = fixture(Limits::default());
let tmp = tempfile::tempdir().unwrap();
let pkg = tmp.path().join("lsp-requests");
copy_dir(&repo().join("crates/ide-plugin/tests/fixtures/lsp-requests"), &pkg);
let manifest = std::fs::read_to_string(pkg.join("plugin.toml")).unwrap();
std::fs::write(pkg.join("plugin.toml"), manifest.replace("\"^1.9\"", "\"^1.8\"")).unwrap();
let err = f.host.install_from_dir(&pkg, &Consent::all()).unwrap_err();
assert!(err.message.contains("new in plugin API 1.9"), "{err:?}");
}
/// The UI's synthetic post-install `SettingsChanged([])` reaches a plugin that
/// subscribes to `on-event:settings-changed`, though it carries no keys.
#[test]
fn a_freshly_installed_plugin_gets_the_post_install_settings_event() {
let f = fixture(Limits::default());
f.install(&sample("api14"));
use ide_plugin::WorkbenchEvent as E;
// What refreshEventKinds() posts right after commandsChanged (install).
f.host.post_events(Some("main"), vec![E::SettingsChanged(Vec::new())]);
f.host.flush_events_at(Instant::now() + Duration::from_secs(2));
assert!(f.host.wait_events(Duration::from_secs(5)));
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
let events = received.as_array().unwrap();
assert!(
events.iter().any(|e| e["kind"] == "settings-changed"),
"freshly installed plugin got no post-install event: {received}"
);
}
+18 -14
Переглянути файл
@@ -70,10 +70,14 @@ async fn open(fixture: &str) -> Opened {
}
/// Polls `check` until it holds; fails with its last answer.
async fn until<T: std::fmt::Debug>(what: &str, timeout: Duration, mut check: impl FnMut() -> Result<(), T>) {
async fn until<T: std::fmt::Debug, F, Fut>(what: &str, timeout: Duration, mut check: F)
where
F: FnMut() -> Fut,
Fut: std::future::Future<Output = Result<(), T>>,
{
let deadline = Instant::now() + timeout;
loop {
match check() {
match check().await {
Ok(()) => return,
Err(last) if Instant::now() > deadline => panic!("{what}: timed out after {timeout:?}; last: {last:?}"),
Err(_) => tokio::time::sleep(Duration::from_millis(100)).await,
@@ -82,25 +86,25 @@ async fn until<T: std::fmt::Debug>(what: &str, timeout: Duration, mut check: imp
}
impl Opened {
fn files(&self, query: &str) -> Vec<String> {
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).unwrap();
async fn files(&self, query: &str) -> Vec<String> {
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).await.unwrap();
found.into_iter().map(|f| f.rel_path).collect()
}
fn symbols(&self, query: &str, filter: SymbolFilter) -> Vec<(String, String)> {
let found = ops::nav::find_symbols(&self.host, WINDOW, query.into(), filter, 20).unwrap();
async fn symbols(&self, query: &str, filter: SymbolFilter) -> Vec<(String, String)> {
let found = ops::nav::find_symbols(&self.host, WINDOW, query.into(), filter, 20).await.unwrap();
found.into_iter().map(|s| (s.name, s.rel_path)).collect()
}
fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
let found = self.symbols(name, filter);
async fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
let found = self.symbols(name, filter).await;
if found.iter().any(|(n, f)| n == name && f == file) { Ok(()) } else { Err(found) }
}
}
async fn smoke(f: Fixture) {
let p = open(f.dir).await;
until("indexing", Duration::from_secs(30), || {
until("indexing", Duration::from_secs(30), || async {
let s = ops::nav::index_status(&p.host, WINDOW).unwrap();
if !s.indexing && s.files > 0 && s.symbols > 0 { Ok(()) } else { Err(s) }
})
@@ -115,12 +119,12 @@ async fn smoke(f: Fixture) {
);
}
let files = p.files(f.file.0);
let files = p.files(f.file.0).await;
assert!(files.iter().any(|r| r == f.file.1), "{}: files for {:?}: {files:?}", f.dir, f.file.0);
if let Err(found) = p.has_symbol(f.class.0, f.class.1, SymbolFilter::Types) {
if let Err(found) = p.has_symbol(f.class.0, f.class.1, SymbolFilter::Types).await {
panic!("{}: Go to Class {:?}: {found:?}", f.dir, f.class.0);
}
if let Err(found) = p.has_symbol(f.symbol.0, f.symbol.1, SymbolFilter::All) {
if let Err(found) = p.has_symbol(f.symbol.0, f.symbol.1, SymbolFilter::All).await {
panic!("{}: Go to Symbol {:?}: {found:?}", f.dir, f.symbol.0);
}
@@ -130,8 +134,8 @@ async fn smoke(f: Fixture) {
until("a new file's class", Duration::from_secs(20), || p.has_symbol("FreshWidget", added, SymbolFilter::Types))
.await;
std::fs::remove_file(p.root.join(added)).unwrap();
until("a deleted file's class", Duration::from_secs(20), || {
let found = p.symbols("FreshWidget", SymbolFilter::Types);
until("a deleted file's class", Duration::from_secs(20), || async {
let found = p.symbols("FreshWidget", SymbolFilter::Types).await;
if found.is_empty() { Ok(()) } else { Err(found) }
})
.await;
+46
Переглянути файл
@@ -111,3 +111,49 @@ async fn gbk_document_gutter_diff_stage_and_rollback_share_encoding() {
assert_eq!(vcs::vcs_file_at(&host, "main", utf8, None).await.unwrap().as_deref(), Some(old));
host.close_project("main");
}
/// A committed symlink to a folder (#3528): its revision is the link target, even though the
/// working path is a directory.
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_directory_symlink_revision_is_its_target() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("project");
std::fs::create_dir_all(root.join("target")).unwrap();
git(&root, &["init", "-b", "main"]);
git(&root, &["config", "user.name", "Test"]);
git(&root, &["config", "user.email", "[email protected]"]);
git(&root, &["config", "commit.gpgsign", "false"]);
std::fs::write(root.join("target/file.txt"), "example\n").unwrap();
std::os::unix::fs::symlink("target", root.join("dir-link")).unwrap();
git(&root, &["add", "."]);
git(&root, &["commit", "-m", "Add a directory symlink"]);
let host = Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("data"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(NullSink)),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
host.trust.decide(&root, true, false).unwrap();
let project = host.open_project("main", &root).unwrap();
for _ in 0..500 {
if !project.repos().is_empty() {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
let link = root.join("dir-link");
assert!(link.is_dir());
assert_eq!(
vcs::vcs_file_at(&host, "main", link.clone(), Some("HEAD".into())).await.unwrap().as_deref(),
Some("target")
);
assert_eq!(vcs::vcs_file_mode(&host, "main", link, Some("HEAD".into())).await.unwrap().as_deref(), Some("120000"));
host.close_project("main");
}
+64
Переглянути файл
@@ -105,6 +105,70 @@ async fn linked_projects_share_navigation_but_keep_files_repositories_and_run_di
host.close_project("main");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_project_attached_inside_the_root_is_searched_and_indexed_once() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("app");
// `.wt/feature` is its own repository, which the outer one ignores; `lib` is not ignored.
let (ignored, covered) = (root.join(".wt/feature"), root.join("lib"));
for dir in [&root, &ignored, &covered] {
std::fs::create_dir_all(dir).unwrap();
}
for repo in [&root, &ignored] {
assert!(std::process::Command::new("git").args(["init", "-q"]).current_dir(repo).status().unwrap().success());
}
std::fs::write(root.join(".git/info/exclude"), "/.wt/\n").unwrap();
std::fs::write(root.join("main.txt"), "needle\n").unwrap();
std::fs::write(ignored.join("feature.txt"), "needle\n").unwrap();
std::fs::write(covered.join("lib.txt"), "needle\n").unwrap();
let host = Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("data"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(NullSink)),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
for dir in [&root, &ignored, &covered] {
host.trust.decide(dir, true, false).unwrap();
}
let project = host.open_project("main", &root).unwrap();
ops::project::attach_workspace(&host, "main", &ignored).unwrap();
ops::project::attach_workspace(&host, "main", &covered).unwrap();
assert_eq!(project.content_roots(), vec![ignored.clone()], "the root's walk covers `lib`");
assert!(project.index.wait_idle(Duration::from_secs(10)));
let files = project.index.find_files(".txt", 100);
let mut indexed = files.iter().map(|f| f.rel_path.clone()).collect::<Vec<_>>();
indexed.sort();
assert_eq!(indexed, [".wt/feature/feature.txt", "lib/lib.txt", "main.txt"]);
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();
ops::search::start(
&host,
"main",
RequestId::next(),
query,
Arc::new(move |event| {
if let ops::search::SearchEvent::File { file } = event {
out.lock().unwrap().push(file.rel_path);
}
}),
)
.await
.unwrap();
let mut found = hits.lock().unwrap().clone();
found.sort();
assert_eq!(found, [".wt/feature/feature.txt", "lib/lib.txt", "main.txt"]);
host.close_project("main");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn python_effective_interpreter_falls_back_to_the_primary_project() {
let temp = tempfile::tempdir().unwrap();
+10 -2
Переглянути файл
@@ -646,8 +646,16 @@ impl IndexData {
}
}
pub(crate) fn record_of(&self, path: &Path) -> Option<FileRecord> {
self.get(path).map(|e| self.record(e))
/// Refreshes on-disk metadata of an unchanged-content file in place and
/// returns its persisted record.
pub(crate) fn refresh_metadata(&mut self, path: &Path, mtime: u64, size: u64, ignored: bool) -> Option<FileRecord> {
let slot = *self.by_path.get(path)?;
let e = self.files[slot as usize].as_mut()?;
e.mtime = mtime;
e.size = size;
e.ignored = ignored;
let e = self.files[slot as usize].as_ref()?;
Some(self.record(e))
}
/// The symbols of one file, in declaration order.
+67 -9
Переглянути файл
@@ -52,6 +52,29 @@ fn root_ignores(root: &Path) -> Gitignore {
gi.build().unwrap_or_else(|_| Gitignore::empty())
}
/// Whether walking `root` leaves out `dir`, a folder below it: `dir` or a folder between
/// them is ignored (`.gitignore`, `.ignore`, `info/exclude`, the global excludes). Such a
/// folder can be a root of its own, with its own rules, without its files being walked twice.
pub fn walk_skips(root: &Path, dir: &Path) -> bool {
if dir == root || !dir.starts_with(root) || !dir.is_dir() {
return false;
}
let target = dir.to_path_buf();
let walker = WalkBuilder::new(root)
.hidden(false)
.parents(true)
.ignore(true)
.git_ignore(true)
.git_global(true)
.git_exclude(true)
.require_git(ide_core::ignored::inside_git_repo(root))
.follow_links(false)
// Only the folders on the way down to `dir`.
.filter_entry(move |e| target.starts_with(e.path()))
.build();
!walker.flatten().any(|e| e.path() == dir)
}
fn rel_string(rel: &Path) -> String {
let mut out = String::new();
for c in rel.components() {
@@ -115,12 +138,18 @@ impl PathFilter {
let mut extra: Vec<ExtraRoot> = Vec::new();
for r in &extra_roots.folders {
let path = dunce::canonicalize(r).unwrap_or_else(|_| r.clone());
let nested = (extra_roots.include_root && (path.starts_with(root) || root.starts_with(&path)))
// A folder inside the root is a root of its own only when the root's walk skips it.
let inside = path.starts_with(root) && !walk_skips(root, &path);
let nested = (extra_roots.include_root && (inside || root.starts_with(&path)))
|| extra.iter().any(|e| path.starts_with(&e.path) || e.path.starts_with(&path));
if nested || !path.is_dir() {
continue;
}
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
// Inside the root it goes by its path there, elsewhere by its folder name.
let name = match path.strip_prefix(root) {
Ok(rel) if extra_roots.include_root => rel_string(rel),
_ => path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),
};
extra.push(ExtraRoot { gitignore: root_ignores(&path), name, path });
}
Self {
@@ -176,13 +205,11 @@ impl PathFilter {
/// The root containing `path`, its display prefix (`None` for the project root) and ignore rules.
fn base_of(&self, path: &Path) -> Option<(&Path, Option<&str>, &Gitignore)> {
if self.include_root && path.starts_with(&self.root) {
return Some((&self.root, None, &self.gitignore));
// An extra root inside the project root wins: its own rules apply below it.
if let Some(e) = self.extra.iter().find(|e| path.starts_with(&e.path)) {
return Some((e.path.as_path(), Some(e.name.as_str()), &e.gitignore));
}
self.extra
.iter()
.find(|e| path.starts_with(&e.path))
.map(|e| (e.path.as_path(), Some(e.name.as_str()), &e.gitignore))
(self.include_root && path.starts_with(&self.root)).then_some((self.root.as_path(), None, &self.gitignore))
}
/// Whether `path` is (at or) below one of the roots.
@@ -207,7 +234,7 @@ impl PathFilter {
/// Key of `path` in the persistent store: only files below the project root
/// are persisted (extra content roots are rescanned when the project opens).
pub(crate) fn store_key(&self, path: &Path) -> Option<String> {
if !self.include_root {
if !self.include_root || self.extra.iter().any(|e| path.starts_with(&e.path)) {
return None;
}
let rel = rel_string(path.strip_prefix(&self.root).ok()?);
@@ -537,4 +564,35 @@ src/local/
assert!(filter.same_config(&vec![shared.clone(), root.join("src")].into(), &["target".into()]));
assert!(!filter.same_config(&vec![shared].into(), &["target".into()]));
}
#[test]
fn an_ignored_folder_inside_the_root_is_a_root_with_its_own_rules() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
let nested = root.join(".wt/feature");
for f in ["src/a.rs", "lib/d.rs", ".wt/feature/src/b.rs", ".wt/feature/out/c.rs"] {
touch(&root, f);
}
// A git worktree kept inside the repository it belongs to, which ignores it.
std::fs::create_dir_all(root.join(".git/info")).unwrap();
std::fs::write(root.join(".git/info/exclude"), "/.wt/\n").unwrap();
std::fs::write(nested.join(".git"), "gitdir: ../../.git/worktrees/feature\n").unwrap();
std::fs::write(nested.join(".gitignore"), "out/\n").unwrap();
assert!(walk_skips(&root, &nested));
assert!(!walk_skips(&root, &root.join("lib")));
let filter = PathFilter::new(&root, &vec![nested.clone(), root.join("lib")].into(), &[]);
assert_eq!(filter.roots().count(), 2, "a folder the root's walk covers is not a root of its own");
let mut found: Vec<String> = filter
.roots()
.flat_map(|r| filter.walk(r, &AtomicBool::new(false)))
.filter_map(|f| filter.rel(&f.path))
.collect();
found.sort();
assert_eq!(found, [".wt/feature/.gitignore", ".wt/feature/src/b.rs", "lib/d.rs", "src/a.rs"]);
assert_eq!(filter.store_key(&nested.join("src/b.rs")), None, "extra roots are not persisted");
assert!(!filter.is_excluded(&nested.join("src/new.rs"), false));
assert!(filter.is_excluded(&nested.join("out/new.rs"), false));
assert!(filter.is_excluded(&root.join(".wt/other/x.rs"), false));
}
}
+6
Переглянути файл
@@ -21,6 +21,7 @@ mod matching;
mod store;
mod worker;
pub use filter::walk_skips;
pub use worker::MAX_SYMBOL_FILE;
use worker::{Job, MAX_RECENT, Shared};
@@ -323,6 +324,11 @@ impl ProjectIndex {
matching::symbols_named_within(&self.shared.data.read(), name, kind, roots, limit)
}
/// Symbols named exactly one of `names` whose file is inside `root`, at most `limit` per name.
pub fn symbols_named_any(&self, names: &[String], root: &Path, limit: usize) -> Vec<SymbolMatch> {
matching::symbols_named_any(&self.shared.data.read(), names, root, limit)
}
/// Incrementally re-indexes changed paths (called from the vfs watcher).
/// Cheap: the work is queued for the indexing thread.
pub fn update(&self, changed: &[PathBuf], removed: &[PathBuf]) {
+60 -11
Переглянути файл
@@ -78,8 +78,8 @@ impl Needle {
let mut b = 0;
if n.eq_ignore_ascii_case(q) {
b += EXACT;
} else if let Some(dot) = name.find('.')
&& name.as_bytes()[..dot].eq_ignore_ascii_case(q)
} else if let Some(dot) = n.iter().position(|&b| b == b'.')
&& n[..dot].eq_ignore_ascii_case(q)
{
b += EXACT_STEM;
} else if n.len() >= q.len() && n[..q.len()].eq_ignore_ascii_case(q) {
@@ -97,17 +97,31 @@ fn hump_bonus(s: &str, indices: &[u32]) -> u32 {
if indices.is_empty() {
return 0;
}
let chars: Vec<char> = s.chars().collect();
let is_start = |i: usize| {
if i == 0 {
return true;
// One pass over `s`: `indices` is sorted, and whether position `i` is a
// word start only needs the char before it, so no `Vec<char>` is collected.
let is_start = |prev: Option<char>, c: char| match prev {
None => true,
Some(p) => {
!p.is_alphanumeric()
|| (p.is_lowercase() && c.is_uppercase())
|| (!p.is_ascii_digit() && c.is_ascii_digit())
}
let (p, c) = (chars[i - 1], chars[i]);
!p.is_alphanumeric() || (p.is_lowercase() && c.is_uppercase()) || (!p.is_ascii_digit() && c.is_ascii_digit())
};
let humps = indices.iter().filter(|&&i| (i as usize) < chars.len() && is_start(i as usize)).count() as u32;
let first = if is_start(indices[0] as usize) { FIRST_AT_START } else { 0 };
humps * HUMP + first
let (mut humps, mut next, mut first_start) = (0u32, 0usize, false);
let (mut prev, mut at) = (None, 0u32);
for c in s.chars() {
if next < indices.len() && indices[next] == at {
let started = is_start(prev, c);
humps += u32::from(started);
if next == 0 {
first_start = started;
}
next += 1;
}
prev = Some(c);
at += 1;
}
humps * HUMP + u32::from(first_start) * FIRST_AT_START
}
#[derive(Clone, Copy)]
@@ -618,6 +632,41 @@ pub(crate) fn symbols_named_within(
out
}
/// Symbols named exactly one of `names` whose file is inside `root`, at most `limit` per
/// name, by path then position: one walk over the index for every name an agent reply shows.
pub(crate) fn symbols_named_any(data: &IndexData, names: &[String], root: &Path, limit: usize) -> Vec<SymbolMatch> {
let wanted: Vec<(u64, &str)> = names.iter().map(|name| (char_mask(name), name.as_str())).collect();
let syms = &data.syms;
let mut out: Vec<SymbolMatch> = data
.files
.iter()
.flatten()
.filter(|entry| entry.path.starts_with(root))
.flat_map(|entry| {
(entry.sym_start..entry.sym_start + entry.sym_len)
.filter(|&at| wanted.iter().any(|&(mask, name)| syms.mask(at) == mask && syms.name(at) == name))
.map(move |at| SymbolMatch {
name: syms.name(at).to_string(),
kind: syms.kind(at),
container: syms.container(at).map(str::to_owned),
path: entry.path.clone().into(),
rel_path: entry.rel.to_string(),
range: syms.range(at),
score: 0,
indices: Vec::new(),
})
})
.collect();
out.sort_by(|left, right| left.rel_path.cmp(&right.rel_path).then_with(|| left.range.cmp(&right.range)));
let mut kept: HashMap<String, usize> = HashMap::new();
out.retain(|symbol| {
let count = kept.entry(symbol.name.clone()).or_default();
*count += 1;
*count <= limit
});
out
}
#[cfg(test)]
mod tests {
use super::*;
+107 -2
Переглянути файл
@@ -549,6 +549,24 @@ fn symbols_named_within_keeps_out_of_root_matches_from_evicting_a_root() {
assert!(idx.symbols_named_within("Decoder", None, &[f.root.join("none")], 3).is_empty());
}
#[test]
fn symbols_named_any_answers_every_name_inside_the_root_in_one_walk() {
let fixture = Fixture::new(&[
("app/a.rs", "struct Config;\nfn load() {}\nfn load_all() {}\n"),
("app/b.rs", "fn load() {}\nfn load() {}\n"),
("other/c.rs", "struct Config;\n"),
]);
let idx = fixture.open();
let names = ["Config".to_string(), "load".to_string(), "missing".to_string()];
let found: Vec<(String, String)> = idx
.symbols_named_any(&names, &fixture.root.join("app"), 2)
.into_iter()
.map(|symbol| (symbol.name, symbol.rel_path))
.collect();
let expected = [("Config", "app/a.rs"), ("load", "app/a.rs"), ("load", "app/b.rs")];
assert_eq!(found, expected.map(|(name, path)| (name.to_string(), path.to_string())));
}
#[test]
fn content_roots_and_excludes_change_without_reopening() {
let fx = Fixture::new(&[("src/main.rs", "fn alpha() {}\n"), ("src/gen/out.rs", "fn generated() {}\n")]);
@@ -779,8 +797,13 @@ fn incremental_changes_refresh_the_warm_start_snapshot() {
let changed = f.write("src/a.rs", "fn renamed() {}\n");
idx.update(&[changed], &[]);
assert!(idx.wait_idle(WAIT));
std::thread::sleep(Duration::from_millis(150));
assert!(f.cache.join("index.snapshot").exists(), "a watcher update must regenerate the snapshot");
// The snapshot is written after a short delay, on the worker's next round.
let snapshot = f.cache.join("index.snapshot");
let deadline = std::time::Instant::now() + WAIT;
while !snapshot.exists() && std::time::Instant::now() < deadline {
std::thread::sleep(Duration::from_millis(20));
}
assert!(snapshot.exists(), "a watcher update must regenerate the snapshot");
}
#[test]
@@ -962,3 +985,85 @@ fn warm_start_sees_edits_deletions_and_renames_made_while_closed() {
assert_eq!(idx.status().files, 3);
assert_eq!(symbols(&idx, "zzzz", SymbolFilter::All), ["zzzz"]);
}
#[test]
fn queries_during_streaming_scan_do_not_deadlock() {
// More than `2 * SCAN_BATCH` (4,096) files so a scan both flushes mid-pass
// (`publish` -> `data.write()`) and fills the bounded parse channel while
// concurrent queries hold `data.read()` and dispatch onto Rayon.
const FILES: usize = 4_600;
let f = Fixture::new(&[]);
for m in 0..32 {
std::fs::create_dir_all(f.root.join(format!("mod{m}"))).unwrap();
}
for i in 0..FILES {
std::fs::write(
f.root.join(format!("mod{}/File{i}.rs", i % 32)),
format!("pub struct Type{i};\npub fn sym{i}() {{}}\n"),
)
.unwrap();
}
let (done_tx, done_rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
let languages = Arc::new(LanguageRegistry::load(None).unwrap());
let syntax = Arc::new(Syntax::new());
let stop = Arc::new(std::sync::atomic::AtomicBool::new(false));
let idx =
ProjectIndex::open(&f.root, &f.cache, Vec::new(), vec![], languages, syntax, Arc::new(NullSink)).unwrap();
let readers: Vec<_> = (0..4usize)
.map(|r| {
let idx = idx.clone();
let stop = stop.clone();
std::thread::spawn(move || {
let mut n = r;
while !stop.load(Ordering::Relaxed) {
match n % 3 {
0 => {
let _ = idx.find_files("File1", 20);
}
1 => {
let _ = idx.find_dirs("mod", 20);
}
_ => {
let _ = idx.find_symbols("sym1", SymbolFilter::All, 20);
}
}
n = n.wrapping_add(1);
}
})
})
.collect();
assert!(idx.wait_idle(WAIT), "initial streaming scan did not finish");
let parsed_before = idx.shared.parsed.load(Ordering::SeqCst);
assert_eq!(parsed_before, FILES);
// Touch every file without changing its contents so `parse_found` takes
// the `Extracted::Unchanged` path across multiple `SCAN_BATCH` flushes.
let bumped = std::fs::FileTimes::new().set_modified(std::time::SystemTime::now() + Duration::from_secs(10));
for i in 0..FILES {
let path = f.root.join(format!("mod{}/File{i}.rs", i % 32));
std::fs::File::options().write(true).open(path).unwrap().set_times(bumped).unwrap();
}
idx.shared.enqueue(Job::Rescan);
assert!(idx.wait_idle(WAIT), "rescan of unchanged-content files did not finish");
assert_eq!(idx.shared.parsed.load(Ordering::SeqCst), parsed_before, "unchanged content is not re-parsed");
assert_eq!(symbols(&idx, "sym4599", SymbolFilter::All), ["sym4599"]);
stop.store(true, Ordering::Relaxed);
for h in readers {
h.join().unwrap();
}
assert_eq!(idx.status().files, FILES as u32);
drop(idx);
let reopened = f.open();
assert_eq!(reopened.shared.parsed.load(Ordering::SeqCst), 0);
assert_eq!(symbols(&reopened, "sym4599", SymbolFilter::All), ["sym4599"]);
let _ = done_tx.send(());
});
done_rx.recv_timeout(Duration::from_secs(60)).expect("concurrent index queries deadlocked with streaming scan");
}
+146 -81
Переглянути файл
@@ -11,9 +11,21 @@ use rayon::prelude::*;
use std::collections::{HashMap, HashSet, VecDeque};
use std::io::Read;
use std::path::{Path, PathBuf};
use std::sync::LazyLock;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::{Duration, Instant, SystemTime};
/// Dedicated pool for background indexing and snapshot hydration: queries hold
/// `IndexData::read` while scanning on the global Rayon pool, so indexing work
/// (which may block on channel backpressure while the index thread waits for
/// `IndexData::write`) must never compete for the same workers.
static INDEX_POOL: LazyLock<rayon::ThreadPool> = LazyLock::new(|| {
rayon::ThreadPoolBuilder::new()
.thread_name(|i| format!("openidea-index-{i}"))
.build()
.expect("cannot build index thread pool")
});
/// Files larger than this are listed but not parsed for symbols.
pub const MAX_SYMBOL_FILE: u64 = 2 * 1024 * 1024;
const CHUNK: usize = 512;
@@ -254,17 +266,19 @@ impl Shared {
}
}
let build_started = Instant::now();
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = (0..snapshot.len())
.into_par_iter()
.map(|i| {
let path = root.join(snapshot.rel(i));
let meta = std::fs::symlink_metadata(&path).ok()?;
if !meta.is_file() || mtime_of(&meta) != snapshot.mtime(i) || meta.len() != snapshot.size(i) {
return None;
}
Some(snapshot.entry(i, root))
})
.collect();
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = INDEX_POOL.install(|| {
(0..snapshot.len())
.into_par_iter()
.map(|i| {
let path = root.join(snapshot.rel(i));
let meta = std::fs::symlink_metadata(&path).ok()?;
if !meta.is_file() || mtime_of(&meta) != snapshot.mtime(i) || meta.len() != snapshot.size(i) {
return None;
}
Some(snapshot.entry(i, root))
})
.collect()
});
let built = build_started.elapsed();
if entries.iter().any(Option::is_none) {
return false;
@@ -333,17 +347,19 @@ impl Shared {
let started = Instant::now();
match store.load_snapshot() {
Some(snapshot) => {
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = (0..snapshot.len())
.into_par_iter()
.filter_map(|i| {
let rel = snapshot.rel(i);
if !safe_rel(rel) {
return None;
}
let path = root.join(rel);
seen.contains(path.as_path()).then(|| snapshot.entry(i, &root))
})
.collect();
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = INDEX_POOL.install(|| {
(0..snapshot.len())
.into_par_iter()
.filter_map(|i| {
let rel = snapshot.rel(i);
if !safe_rel(rel) {
return None;
}
let path = root.join(rel);
seen.contains(path.as_path()).then(|| snapshot.entry(i, &root))
})
.collect()
});
let mut d = self.data.write();
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
d.reserve(entries.len(), symbols, 0);
@@ -363,16 +379,18 @@ impl Shared {
Ok(records) => {
// Fallback for an index that changed since the snapshot: redb
// records are decoded one file at a time and filtered by the walk.
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = records
.into_par_iter()
.filter(|(rel, _)| {
safe_rel(rel) && {
let path = root.join(rel);
seen.contains(path.as_path())
}
})
.map(|(rel, rec)| FileEntry::new(root.join(&rel), rel, rec))
.collect();
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = INDEX_POOL.install(|| {
records
.into_par_iter()
.filter(|(rel, _)| {
safe_rel(rel) && {
let path = root.join(rel);
seen.contains(path.as_path())
}
})
.map(|(rel, rec)| FileEntry::new(root.join(&rel), rel, rec))
.collect()
});
let mut d = self.data.write();
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
d.reserve(entries.len(), symbols, 0);
@@ -446,10 +464,11 @@ impl Shared {
}
let classify_started = Instant::now();
let seen: HashSet<&Path> = found.iter().map(|f| f.path.as_path()).collect();
let (todo, stale): (Vec<&Found>, Vec<PathBuf>) = {
let (todo, stale) = {
let d = self.data.read();
let todo = found.iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect();
let stale = d
let todo: Vec<(&Found, Option<ContentHash>)> =
found.iter().filter_map(|f| prev_hash_if_stale(&d, f).map(|h| (f, h))).collect();
let stale: Vec<PathBuf> = d
.paths()
.filter(|p| dirs.is_none_or(|dirs| dirs.iter().any(|dir| p.starts_with(dir))))
.filter(|p| !seen.contains(p.as_path()))
@@ -470,7 +489,7 @@ impl Shared {
let total = todo.len();
let mut laps = ChunkLaps::default();
{
// One streaming parallel pass: parse on the rayon pool without
// One streaming parallel pass: parse on `INDEX_POOL` without
// per-chunk joins (a straggler file at a join's tail idles every
// other core), while parsed files flow to this thread to be
// inserted and persisted in batches. `filter` moves into the
@@ -485,12 +504,14 @@ impl Shared {
let pass_started = Instant::now();
std::thread::scope(|scope| -> () {
scope.spawn(move || {
todo.par_iter().for_each(|f| {
if cancelled.load(Ordering::Relaxed) {
return;
}
let Some(out) = self.parse_found(f, &filter, false) else { return };
let _ = tx.send(out);
INDEX_POOL.install(|| {
todo.par_iter().for_each(|&(f, prev_hash)| {
if cancelled.load(Ordering::Relaxed) {
return;
}
let Some(out) = self.parse_found(f, prev_hash, &filter) else { return };
let _ = tx.send(out);
});
});
// `tx` drops here: the consumer's loop ends with the channel.
});
@@ -570,13 +591,13 @@ impl Shared {
}
/// Extracts records in parallel, then publishes them to memory and disk.
/// `force` re-parses files whose content is unchanged (their language changed).
fn index_files<'a>(&self, files: impl Iterator<Item = &'a Found>, force: bool) -> ChunkLaps {
fn index_files(&self, files: &[(Found, Option<ContentHash>)]) -> ChunkLaps {
let mut laps = ChunkLaps::default();
let files: Vec<&Found> = files.collect();
let filter = self.filter();
let started = Instant::now();
let extracted: Vec<ParsedFile> = files.par_iter().filter_map(|f| self.parse_found(f, &filter, force)).collect();
let extracted: Vec<ParsedFile> = INDEX_POOL.install(|| {
files.par_iter().filter_map(|(f, prev_hash)| self.parse_found(f, *prev_hash, &filter)).collect()
});
laps.extract = started.elapsed();
if extracted.is_empty() {
return laps;
@@ -585,49 +606,69 @@ impl Shared {
laps
}
/// Reads and parses one file (parallel-safe), serializing its record for
/// the cache alongside the parse. `None` when the file is outside the
/// scope or the scan was cancelled.
fn parse_found(&self, f: &Found, filter: &std::sync::Arc<PathFilter>, force: bool) -> Option<ParsedFile> {
/// Reads and parses one file on `INDEX_POOL` without locking `self.data`,
/// serializing new records for the cache alongside the parse. `None` when
/// the file is outside the scope or the scan was cancelled.
fn parse_found(
&self,
f: &Found,
prev_hash: Option<ContentHash>,
filter: &std::sync::Arc<PathFilter>,
) -> Option<ParsedFile> {
if self.is_cancelled() {
return None;
}
let rel = filter.rel(&f.path)?;
let prev_hash = if force { None } else { self.data.read().get(&f.path).map(|e| e.hash) };
let rec = match self.extract(f, prev_hash) {
Extracted::Unchanged => {
// Same content, new mtime: keep the symbols, refresh metadata.
let mut rec = self.data.read().record_of(&f.path)?;
rec.mtime = f.mtime;
rec.size = f.size;
rec.ignored = f.ignored;
rec
}
Extracted::New(rec) => rec,
};
let key = filter.store_key(&f.path);
let bytes = postcard::to_allocvec(&rec).ok();
Some(ParsedFile { rel, rec, key, bytes, path: f.path.clone() })
let outcome = match self.extract(f, prev_hash) {
Extracted::Unchanged => ParsedOutcome::Unchanged { mtime: f.mtime, size: f.size, ignored: f.ignored },
Extracted::New(rec) => {
let bytes = key.as_ref().and_then(|_| postcard::to_allocvec(&rec).ok());
ParsedOutcome::New { rec, bytes }
}
};
Some(ParsedFile { rel, key, outcome, path: f.path.clone() })
}
/// Inserts a parsed batch into the in-memory index and persists the records.
fn publish(&self, batch: impl Iterator<Item = ParsedFile>) -> ChunkLaps {
let mut laps = ChunkLaps::default();
let started = Instant::now();
let mut entries: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
let mut inserts: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
let mut refreshes: Vec<MetadataRefresh> = Vec::new();
let mut puts: Vec<(String, Vec<u8>)> = Vec::new();
for out in batch {
let ParsedFile { rel, rec, key, bytes, path } = out;
if let (Some(key), Some(bytes)) = (key, bytes) {
puts.push((key, bytes));
let ParsedFile { rel, key, outcome, path } = out;
match outcome {
ParsedOutcome::New { rec, bytes } => {
if let (Some(key), Some(bytes)) = (key, bytes) {
puts.push((key, bytes));
}
inserts.push(FileEntry::new(path, rel, rec));
}
ParsedOutcome::Unchanged { mtime, size, ignored } => {
refreshes.push(MetadataRefresh { path, key, mtime, size, ignored });
}
}
entries.push(FileEntry::new(path, rel, rec));
}
let mut refreshed_records: Vec<(String, FileRecord)> = Vec::new();
{
let mut d = self.data.write();
for (e, symbols) in entries {
for (e, symbols) in inserts {
d.insert(e, symbols);
}
for r in refreshes {
if let Some(rec) = d.refresh_metadata(&r.path, r.mtime, r.size, r.ignored)
&& let Some(key) = r.key
{
refreshed_records.push((key, rec));
}
}
}
for (key, rec) in refreshed_records {
if let Ok(bytes) = postcard::to_allocvec(&rec) {
puts.push((key, bytes));
}
}
laps.insert = started.elapsed();
let started = Instant::now();
@@ -818,9 +859,9 @@ impl Shared {
for (dir, wanted) in by_dir {
files.extend(filter.list_dir(&dir).into_iter().filter(|f| wanted.contains(&f.path)));
}
let files: Vec<Found> = {
let files: Vec<(Found, Option<ContentHash>)> = {
let d = self.data.read();
files.into_iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect()
files.into_iter().filter_map(|f| prev_hash_if_stale(&d, &f).map(|h| (f, h))).collect()
};
if !files.is_empty() {
touched = true;
@@ -828,17 +869,17 @@ impl Shared {
if self.is_cancelled() {
return;
}
self.index_files(chunk.iter(), false);
self.index_files(chunk);
}
}
for before in reparse {
let affected: Vec<Found> = {
let affected: Vec<(Found, Option<ContentHash>)> = {
let d = self.data.read();
d.paths()
.filter(|p| before.detect(p, None) != self.languages.detect(p, None))
.filter_map(|p| {
let e = d.get(p)?;
Some(Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored })
Some((Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored }, None))
})
.collect()
};
@@ -848,7 +889,7 @@ impl Shared {
if self.is_cancelled() {
return;
}
self.index_files(chunk.iter(), true);
self.index_files(chunk);
}
}
}
@@ -866,6 +907,18 @@ impl Shared {
}
}
type ContentHash = [u8; 32];
/// `Some(prev_hash)` when `f` is missing or stale in `d` (`None` inner hash when
/// the file must be parsed fresh); `None` when `d` is already current for `f`.
fn prev_hash_if_stale(d: &IndexData, f: &Found) -> Option<Option<ContentHash>> {
match d.get(&f.path) {
None => Some(None),
Some(e) if e.stale_for(f) => Some((!e.ignored).then_some(e.hash)),
Some(_) => None,
}
}
/// The first line, capped at 256 bytes (for shebang / `<?xml` detection).
fn first_line(text: &str) -> &str {
let line = text.lines().next().unwrap_or_default();
@@ -898,14 +951,26 @@ impl ChunkLaps {
}
}
/// One file parsed off the index thread: its record ready to publish, already
/// serialized for the cache (in parallel with the parse).
struct MetadataRefresh {
path: PathBuf,
key: Option<String>,
mtime: u64,
size: u64,
ignored: bool,
}
enum ParsedOutcome {
Unchanged { mtime: u64, size: u64, ignored: bool },
New { rec: FileRecord, bytes: Option<Vec<u8>> },
}
/// One file parsed off the index thread: its outcome ready to publish, with new
/// records already serialized for the cache in parallel with the parse.
struct ParsedFile {
rel: String,
rec: FileRecord,
/// Cache key and postcard bytes; `None` when outside the persisted root.
/// Cache key; `None` when outside the persisted root.
key: Option<String>,
bytes: Option<Vec<u8>>,
outcome: ParsedOutcome,
path: PathBuf,
}
+24 -8
Переглянути файл
@@ -194,6 +194,9 @@ pub mod codes {
pub const METHOD_NOT_FOUND: i64 = -32601;
pub const INVALID_PARAMS: i64 = -32602;
pub const INTERNAL_ERROR: i64 = -32603;
/// LSP `RequestFailed`: the request was understood and could not be carried out; the
/// message says why.
pub const REQUEST_FAILED: i64 = -32803;
/// LSP `ServerCancelled`.
pub const SERVER_CANCELLED: i64 = -32802;
/// LSP `ContentModified`.
@@ -215,12 +218,18 @@ pub trait Handler: Send + Sync + 'static {
/// Respond to a server→client request (e.g. `workspace/configuration`).
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)>;
/// [`on_request`](Self::on_request) for handlers whose errors carry `data`. This is the
/// one the connection calls.
/// [`on_request`](Self::on_request) for handlers whose errors carry `data`.
fn on_request_with_data(&self, method: &str, params: Value) -> Result<Value, (i64, String, Option<Value>)> {
self.on_request(method, params).map_err(|(code, message)| (code, message, None))
}
/// [`on_request_with_data`](Self::on_request_with_data) with the request as received, for
/// handlers that need what `Value` drops, such as the order of an object's keys. This is the
/// one the connection calls.
fn on_request_raw(&self, method: &str, params: Value, _raw: &[u8]) -> Result<Value, (i64, String, Option<Value>)> {
self.on_request_with_data(method, params)
}
/// Called once the response to a `method` request is queued: what it sends follows the response.
fn after_response(&self, _method: &str) {}
@@ -577,8 +586,8 @@ impl Peer {
tracing::error!("jsonrpc notification handler panicked on {method}");
}
}
Incoming::Request(id, method, params) => {
runtime.spawn(handle_request(inner.clone(), handler.clone(), id, method, params));
Incoming::Request(id, method, params, raw) => {
runtime.spawn(handle_request(inner.clone(), handler.clone(), id, method, params, raw));
}
Incoming::Response(tx, result) => {
let _ = tx.send(result);
@@ -761,14 +770,21 @@ fn parse_id(id: &Value) -> Option<i64> {
enum Incoming {
Notification(String, Value),
Request(Value, String, Value),
Request(Value, String, Value, Arc<[u8]>),
Response(oneshot::Sender<Result<Value, RpcError>>, Result<Value, RpcError>),
}
async fn handle_request(inner: Arc<Inner>, handler: Arc<dyn Handler>, id: Value, method: String, params: Value) {
async fn handle_request(
inner: Arc<Inner>,
handler: Arc<dyn Handler>,
id: Value,
method: String,
params: Value,
raw: Arc<[u8]>,
) {
let m = method.clone();
let h = handler.clone();
let result = tokio::task::spawn_blocking(move || h.on_request_with_data(&m, params)).await;
let result = tokio::task::spawn_blocking(move || h.on_request_raw(&m, params, &raw)).await;
let reply = match result {
Ok(Ok(result)) => json!({ "jsonrpc": "2.0", "id": id, "result": result }),
Ok(Err((code, message, data))) => {
@@ -808,7 +824,7 @@ fn dispatch(inner: &Arc<Inner>, handler: &dyn Handler, notif_tx: &std::sync::mps
let params = obj.remove("params").unwrap_or(Value::Null);
match id {
Some(id) if !id.is_null() => {
let _ = notif_tx.send(Incoming::Request(id, method, params));
let _ = notif_tx.send(Incoming::Request(id, method, params, Arc::from(body)));
}
_ => {
let _ = notif_tx.send(Incoming::Notification(method, params));
+5
Переглянути файл
@@ -170,6 +170,11 @@ pub struct LanguageServerConfig {
/// basedpyright): only used while none of those is installed.
#[serde(default)]
pub fallback: bool,
/// Names of servers listed after this one that it makes redundant (a PHP server
/// with its own Laravel support replaces `laravel-lsp`): they aren't used while
/// this one serves the file.
#[serde(default)]
pub replaces: Vec<String>,
/// What the server is used for (`completion`, `code-action`, `diagnostics`,
/// … `FEATURES` in `ide-lsp/src/caps.rs`); empty means everything. The other
/// capabilities it announces are ignored, so a refactoring-only server next
+39 -3
Переглянути файл
@@ -33,6 +33,7 @@ const BUILTIN: &[(&str, &str)] = &[
("gdscript", include_str!("../../../languages/gdscript.toml")),
("gdshader", include_str!("../../../languages/gdshader.toml")),
("go", include_str!("../../../languages/go.toml")),
("gherkin", include_str!("../../../languages/gherkin.toml")),
("gomod", include_str!("../../../languages/gomod.toml")),
("gowork", include_str!("../../../languages/gowork.toml")),
("godot-resource", include_str!("../../../languages/godot-resource.toml")),
@@ -626,6 +627,7 @@ mod tests {
"Vue",
"Angular Template",
"Angular TypeScript",
"Thymeleaf",
"ERB",
"JSP",
"Astro",
@@ -678,7 +680,7 @@ mod tests {
let got: Vec<(&str, bool)> = cfg
.language_servers
.iter()
.filter(|s| !s.require_root_marker)
.filter(|s| !s.require_root_marker && s.features.is_empty())
.map(|s| (s.name.as_str(), s.fallback))
.collect();
let expected: Vec<(&str, bool)> = servers.iter().enumerate().map(|(i, name)| (*name, i > 0)).collect();
@@ -758,7 +760,10 @@ mod tests {
let cfg = reg.get(&LanguageId::new("php")).unwrap();
let names: Vec<&str> = cfg.language_servers.iter().map(|s| s.name.as_str()).collect();
// After the fallback: hover, rename and symbols stay with Intelephense.
assert_eq!(names, ["intelephense", "phpactor", "laravel-lsp"]);
assert_eq!(names, ["intelephense", "phpactor", "phoxite", "laravel-lsp"]);
// Phoxite answers the Laravel strings itself.
let phoxite = cfg.language_servers.iter().find(|s| s.name == "phoxite").unwrap();
assert!(phoxite.fallback && phoxite.replaces == ["laravel-lsp"]);
let lsp = cfg.language_servers.iter().find(|s| s.name == "laravel-lsp").unwrap();
assert_eq!(lsp.command.as_str(), "laravel-lsp");
// Its `lsp` command takes no options and speaks over stdio; `--stdio` stops it at startup.
@@ -775,13 +780,26 @@ mod tests {
assert_eq!(served("lib/src/Parser.php"), None);
}
#[test]
fn pylsp_adds_only_rope_refactorings_to_python() {
let reg = reg();
let cfg = reg.get(&LanguageId::new("python")).unwrap();
let pylsp = cfg.language_servers.iter().find(|s| s.name == "pylsp").unwrap();
assert!(!pylsp.fallback && !pylsp.require_root_marker);
assert_eq!(pylsp.features, ["code-action"]);
assert_eq!(pylsp.code_action_kinds, ["refactor"]);
let plugins = pylsp.initialization_options.as_ref().unwrap()["pylsp"]["plugins"].as_table().unwrap();
assert_eq!(plugins["jedi_completion"]["enabled"].as_bool(), Some(false));
assert!(plugins.values().all(|p| p["enabled"].as_bool() == Some(false)));
}
#[test]
fn ruff_serves_python_files_only_below_its_config() {
let reg = reg();
let cfg = reg.get(&LanguageId::new("python")).unwrap();
let names: Vec<&str> = cfg.language_servers.iter().map(|s| s.name.as_str()).collect();
// After the fallbacks: hover, rename and symbols stay with the type checker.
assert_eq!(names, ["basedpyright", "pyright", "ty", "pyrefly", "ruff"]);
assert_eq!(names, ["basedpyright", "pyright", "ty", "pyrefly", "ruff", "pylsp"]);
let ruff = cfg.language_servers.iter().find(|s| s.name == "ruff").unwrap();
assert_eq!((ruff.command.as_str(), ruff.args.as_slice()), ("ruff", ["server".to_string()].as_slice()));
assert!(ruff.require_root_marker && !ruff.fallback);
@@ -823,6 +841,23 @@ mod tests {
assert!(!reg.is_framework_marker(&root.join("apps/admin/package.json")));
}
#[test]
fn spring_template_folders_make_html_thymeleaf() {
let reg = reg();
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
let mode = |file: &str| reg.framework_ui_mode(&LanguageId::new("html"), &root.join(file), Some(root));
std::fs::create_dir_all(root.join("web/src/main/resources/templates/fragments")).unwrap();
std::fs::create_dir_all(root.join("docs")).unwrap();
for file in
["web/src/main/resources/templates/index.html", "web/src/main/resources/templates/fragments/nav.html"]
{
assert_eq!(mode(file).as_deref(), Some("Thymeleaf"), "{file}");
}
assert_eq!(mode("docs/index.html"), None);
assert!(reg.is_framework_marker(&root.join("web/src/main/resources/templates")));
}
#[test]
fn django_projects_make_html_in_templates_folders_templates() {
let reg = reg();
@@ -1054,6 +1089,7 @@ mod tests {
("CMakeLists.txt", "cmake"),
("api.proto", "proto"),
("schema.graphql", "graphql"),
("checkout.feature", "gherkin"),
("schema.prisma", "prisma"),
("main.tf", "terraform"),
("prod.tfvars", "terraform-vars"),
+370 -18
Переглянути файл
@@ -6,11 +6,15 @@
use crate::LspManager;
use crate::server::Server;
use ide_core::{DocId, Pos, Range};
use ide_core::{CancellationToken, DocId, Pos, Range};
use serde::Deserialize;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::Arc;
use std::sync::atomic::Ordering;
use std::time::Duration;
use tokio::io::AsyncReadExt;
pub(crate) const CHECK_UPGRADES: &str = "gopls.check_upgrades";
/// gopls answers code lenses once it has loaded the module.
@@ -18,6 +22,43 @@ const ATTEMPTS: u32 = 10;
const RETRY: Duration = Duration::from_secs(2);
/// Producer of the deprecation diagnostics (one full set per go.mod).
const DEPRECATIONS: &str = "go-mod-deprecations";
// This optional background check must not wait indefinitely on a proxy or toolchain download.
const QUERY_TIMEOUT: Duration = Duration::from_secs(60);
const OUTPUT_LIMIT: u64 = 8 * 1024 * 1024;
#[derive(Default)]
pub(crate) struct Queries {
generation: u64,
running: HashMap<DocId, (u64, CancellationToken)>,
}
impl Queries {
fn begin(&mut self, doc: DocId) -> (u64, CancellationToken) {
self.cancel(doc);
self.generation += 1;
let cancel = CancellationToken::new();
self.running.insert(doc, (self.generation, cancel.clone()));
(self.generation, cancel)
}
fn finish(&mut self, doc: DocId, generation: u64) {
if self.running.get(&doc).is_some_and(|(current, _)| *current == generation) {
self.running.remove(&doc);
}
}
pub(crate) fn cancel(&mut self, doc: DocId) {
if let Some((_, cancel)) = self.running.remove(&doc) {
cancel.cancel();
}
}
pub(crate) fn cancel_all(&mut self) {
for (_, (_, cancel)) in self.running.drain() {
cancel.cancel();
}
}
}
fn is_go_mod(path: &Path) -> bool {
path.file_name().is_some_and(|n| n == "go.mod")
@@ -66,6 +107,15 @@ impl LspManager {
}
async fn report_deprecated_modules(&self, doc: DocId, server: &Server) {
let (generation, cancel) = self.go_mod_queries.lock().begin(doc);
self.report_deprecated_modules_query(doc, server, &cancel).await;
self.go_mod_queries.lock().finish(doc, generation);
}
async fn report_deprecated_modules_query(&self, doc: DocId, server: &Server, cancel: &CancellationToken) {
if self.shutting_down.load(Ordering::Acquire) || !self.execution_allowed.load(Ordering::Acquire) {
return;
}
let Some((path, text)) = self.docs.lock().get(&doc).map(|d| (d.path.clone(), d.text.as_str().to_owned()))
else {
return;
@@ -78,10 +128,9 @@ impl LspManager {
let search = crate::launch::server_search_path(&config);
let Some(dir) = path.parent().map(Path::to_path_buf) else { return };
let modules: Vec<String> = required.iter().map(|r| r.path.clone()).collect();
let listed = tokio::task::spawn_blocking(move || list_deprecations(&dir, &search, &modules)).await;
let Ok(Some(deprecated)) = listed else { return };
let Some(deprecated) = list_deprecations(&dir, &search, &modules, cancel).await else { return };
// The document changed meanwhile: its own save runs again.
if self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
if cancel.is_cancelled() || self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
return;
}
let items = required
@@ -157,22 +206,100 @@ struct ListedModule {
}
/// `(module, message)` of each deprecated module in `modules`; `None` when `go` failed.
fn list_deprecations(dir: &Path, search: &std::ffi::OsStr, modules: &[String]) -> Option<Vec<(String, String)>> {
let go: PathBuf = ide_core::tool_path::find_command("go", search, dir)?;
let output = ide_core::process::prepare(&mut std::process::Command::new(go))
.args(["list", "-m", "-u", "-e", "-json"])
.args(modules)
.current_dir(dir)
.env("PATH", search)
.stdin(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.output()
.ok()?;
if output.stdout.is_empty() {
tracing::debug!("go list -m -u in {}: {}", dir.display(), output.status);
async fn list_deprecations(
dir: &Path,
search: &std::ffi::OsStr,
modules: &[String],
cancel: &CancellationToken,
) -> Option<Vec<(String, String)>> {
let (dir, search, modules) = (dir.to_path_buf(), search.to_owned(), modules.to_vec());
let command = tokio::task::spawn_blocking(move || {
let go: PathBuf = ide_core::tool_path::find_command("go", &search, &dir)?;
let mut command = Command::new(go);
command.args(["list", "-m", "-u", "-e", "-json"]).args(modules).current_dir(dir).env("PATH", search);
Some(command)
})
.await
.ok()??;
let output = run_query(command, cancel, QUERY_TIMEOUT).await?;
if output.is_empty() {
return None;
}
Some(parse_deprecations(&output.stdout))
tokio::task::spawn_blocking(move || parse_deprecations(&output)).await.ok()
}
async fn run_query(command: Command, cancel: &CancellationToken, timeout: Duration) -> Option<Vec<u8>> {
let cancel = cancel.child_token();
let _cancel_on_drop = cancel.clone().drop_guard();
// The supervisor owns cleanup even if the caller's future is dropped.
tokio::spawn(async move { supervise_query(command, &cancel, timeout).await }).await.ok().flatten()
}
async fn supervise_query(mut command: Command, cancel: &CancellationToken, timeout: Duration) -> Option<Vec<u8>> {
if cancel.is_cancelled() {
return None;
}
ide_core::process::prepare(&mut command);
ide_core::process::own_group(&mut command);
command.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
let mut command = tokio::process::Command::from(command);
command.kill_on_drop(true);
let mut child = command.spawn().ok()?;
#[cfg(windows)]
let job = child.id().and_then(ide_core::process::Job::for_pid);
let stdout = child.stdout.take()?;
let mut reader = tokio::spawn(async move {
let mut output = Vec::new();
stdout.take(OUTPUT_LIMIT + 1).read_to_end(&mut output).await.ok()?;
if output.len() as u64 > OUTPUT_LIMIT {
tracing::debug!("go module query exceeded stdout budget");
return None;
}
Some(output)
});
let deadline = tokio::time::sleep(timeout);
tokio::pin!(deadline);
// Drain before reaping: if a descendant holds stdout open, the root's id
// still belongs to this child when cancellation kills its process tree.
let output = tokio::select! {
biased;
() = cancel.cancelled() => None,
() = &mut deadline => {
tracing::debug!("go module query timed out");
None
},
result = &mut reader => result.ok().flatten(),
};
if let Some(bytes) = output {
let status = tokio::select! {
biased;
() = cancel.cancelled() => None,
() = &mut deadline => {
tracing::debug!("go module query timed out");
None
},
status = child.wait() => Some(status),
};
if let Some(status) = status {
return status.ok().map(|_| bytes);
}
}
// The root is still unreaped here, so its process/group id cannot be reused.
if let Some(pid) = child.id() {
let _ = tokio::task::spawn_blocking(move || {
#[cfg(windows)]
if let Some(job) = job {
job.terminate();
return;
}
ide_core::process::kill_tree_of(pid);
})
.await;
}
let _ = child.start_kill();
let _ = child.wait().await;
reader.abort();
None
}
fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
@@ -187,6 +314,231 @@ fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
mod tests {
use super::*;
#[test]
fn queries_cancel_only_the_superseded_document() {
let mut queries = Queries::default();
let (first, old) = queries.begin(DocId(1));
let (_, other) = queries.begin(DocId(2));
let (second, new) = queries.begin(DocId(1));
assert!(old.is_cancelled());
assert!(!other.is_cancelled());
assert!(!new.is_cancelled());
queries.finish(DocId(1), first);
assert_eq!(queries.running.len(), 2);
queries.finish(DocId(1), second);
assert_eq!(queries.running.len(), 1);
queries.cancel_all();
assert!(other.is_cancelled());
assert!(queries.running.is_empty());
}
#[test]
fn closing_one_document_does_not_cancel_another() {
let mut queries = Queries::default();
let (_, closed) = queries.begin(DocId(1));
let (_, other) = queries.begin(DocId(2));
queries.cancel(DocId(1));
assert!(closed.is_cancelled());
assert!(!other.is_cancelled());
assert_eq!(queries.running.len(), 1);
}
#[cfg(unix)]
fn shell(script: &str) -> Command {
let mut command = Command::new("sh");
command.args(["-c", script]);
command
}
#[cfg(target_os = "linux")]
async fn assert_stopped(pid: u32) {
tokio::time::timeout(Duration::from_secs(5), async {
while let Ok(stat) = std::fs::read_to_string(format!("/proc/{pid}/stat")) {
if stat.rsplit_once(") ").unwrap().1.split_whitespace().next() == Some("Z") {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
}
#[cfg(unix)]
#[tokio::test]
async fn cancelled_query_never_spawns() {
let dir = tempfile::tempdir().unwrap();
let cancel = CancellationToken::new();
cancel.cancel();
let mut command = shell("touch started");
command.current_dir(dir.path());
assert!(run_query(command, &cancel, Duration::from_secs(5)).await.is_none());
assert!(!dir.path().join("started").exists());
}
#[cfg(unix)]
#[tokio::test]
async fn queries_keep_working_directories_and_environments_separate() {
let a = tempfile::tempdir().unwrap();
let b = tempfile::tempdir().unwrap();
std::fs::write(a.path().join("value"), "directory-a").unwrap();
std::fs::write(b.path().join("value"), "directory-b").unwrap();
let mut ca = shell("printf '%s:' \"$QUERY_VALUE\"; cat value");
ca.current_dir(a.path()).env("QUERY_VALUE", "env-a");
let mut cb = shell("printf '%s:' \"$QUERY_VALUE\"; cat value");
cb.current_dir(b.path()).env("QUERY_VALUE", "env-b");
let cancel = CancellationToken::new();
let (a, b) = tokio::join!(
run_query(ca, &cancel, Duration::from_secs(5)),
run_query(cb, &cancel, Duration::from_secs(5)),
);
assert_eq!(a.unwrap(), b"env-a:directory-a");
assert_eq!(b.unwrap(), b"env-b:directory-b");
}
#[cfg(unix)]
#[tokio::test]
async fn timeout_kills_and_reaps_the_query() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("echo $$ > pid; exec sleep 2");
command.current_dir(dir.path());
let output = run_query(command, &CancellationToken::new(), Duration::from_secs(1)).await;
assert!(output.is_none());
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap().trim().parse().unwrap();
assert!(!ide_core::process::process_alive(pid));
}
#[cfg(unix)]
#[tokio::test]
async fn cancellation_kills_the_running_query_and_its_child() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("sleep 30 & echo $$ $! > pids; wait");
command.current_dir(dir.path());
let cancel = CancellationToken::new();
let token = cancel.clone();
let task = tokio::spawn(async move { run_query(command, &token, Duration::from_secs(10)).await });
let pids = dir.path().join("pids");
tokio::time::timeout(Duration::from_secs(5), async {
while !std::fs::read_to_string(&pids).is_ok_and(|s| s.split_whitespace().count() == 2) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let text = std::fs::read_to_string(pids).unwrap();
let pids: Vec<u32> = text.split_whitespace().map(|p| p.parse().unwrap()).collect();
cancel.cancel();
assert!(task.await.unwrap().is_none());
assert!(!ide_core::process::process_alive(pids[0]));
// An orphaned child may remain a zombie until the host's init reaps it.
#[cfg(target_os = "linux")]
assert_stopped(pids[1]).await;
#[cfg(not(target_os = "linux"))]
tokio::time::timeout(Duration::from_secs(5), async {
while ide_core::process::process_alive(pids[1]) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
}
#[cfg(unix)]
#[tokio::test]
async fn dropping_the_caller_still_reaps_its_query() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("sleep 30 & echo $$ $! > pid; wait");
command.current_dir(dir.path());
let task =
tokio::spawn(async move { run_query(command, &CancellationToken::new(), Duration::from_secs(10)).await });
let file = dir.path().join("pid");
tokio::time::timeout(Duration::from_secs(5), async {
while !std::fs::read_to_string(&file).is_ok_and(|s| s.split_whitespace().count() == 2) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let text = std::fs::read_to_string(file).unwrap();
let pids: Vec<u32> = text.split_whitespace().map(|p| p.parse().unwrap()).collect();
let pid = pids[0];
task.abort();
let _ = task.await;
tokio::time::timeout(Duration::from_secs(5), async {
while ide_core::process::process_alive(pid) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
#[cfg(target_os = "linux")]
assert_stopped(pids[1]).await;
#[cfg(not(target_os = "linux"))]
tokio::time::timeout(Duration::from_secs(5), async {
while ide_core::process::process_alive(pids[1]) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
}
#[cfg(target_os = "linux")]
#[tokio::test]
async fn timeout_cleans_up_a_child_holding_stdout_after_root_exit() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("sleep 30 & echo $! > pid; exit 0");
command.current_dir(dir.path());
assert!(run_query(command, &CancellationToken::new(), Duration::from_secs(1)).await.is_none());
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap();
assert_stopped(pid.trim().parse().unwrap()).await;
}
#[cfg(unix)]
#[tokio::test]
async fn output_at_the_limit_is_not_truncated() {
let output = run_query(shell("head -c 8388608 /dev/zero"), &CancellationToken::new(), Duration::from_secs(5))
.await
.unwrap();
assert_eq!(output.len() as u64, OUTPUT_LIMIT);
}
#[cfg(unix)]
#[tokio::test]
async fn oversized_output_kills_the_query() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("echo $$ > pid; head -c 8388609 /dev/zero; exec sleep 30");
command.current_dir(dir.path());
assert!(run_query(command, &CancellationToken::new(), Duration::from_secs(5)).await.is_none());
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap().trim().parse().unwrap();
assert!(!ide_core::process::process_alive(pid));
}
#[cfg(unix)]
#[tokio::test]
async fn preserves_output_from_a_nonzero_exit() {
assert_eq!(
run_query(shell("printf partial; exit 1"), &CancellationToken::new(), Duration::from_secs(5))
.await
.unwrap(),
b"partial"
);
}
#[cfg(unix)]
#[tokio::test]
async fn failed_spawn_does_not_poison_a_following_query() {
assert!(
run_query(Command::new("/no/such/go-query"), &CancellationToken::new(), Duration::from_secs(5))
.await
.is_none()
);
assert_eq!(
run_query(shell("printf ok"), &CancellationToken::new(), Duration::from_secs(5)).await.unwrap(),
b"ok"
);
}
fn at(line: u32, from: u32, to: u32) -> Range {
Range { start: Pos { line, col: from }, end: Pos { line, col: to } }
}
+2
Переглянути файл
@@ -22,7 +22,9 @@ pub(crate) mod configuration;
mod formatter;
mod hierarchy;
pub(crate) mod jvm_inspect;
mod move_refactoring;
pub(crate) mod reserved_names;
mod signature;
pub use formatter::configure_formatter;
/// First start imports the Maven / Gradle model, which can take minutes.
const READY_TIMEOUT: Duration = Duration::from_secs(240);
+8 -1
Переглянути файл
@@ -1,5 +1,6 @@
//! Pull Members Up / Push Members Down through the app-owned JDT extension
//! (`java/java-usages`). The server checks the move and computes the edit; the UI
//! (`java/java-usages`), or through Phoxite's own requests when the document's
//! server advertises them (`crate::phoxite`). The server checks the move and computes the edit; the UI
//! shows its problems and applies the edit itself.
use super::COMMAND_TIMEOUT;
use crate::types::{HierarchyChoice, HierarchyMembers, HierarchyRefactored, HierarchyRefactoring, RefactoringProblem};
@@ -75,6 +76,9 @@ impl LspManager {
kind: HierarchyRefactoring,
cancel: CancellationToken,
) -> IdeResult<HierarchyMembers> {
if let Some(phoxite) = self.phoxite_refactor_target(doc).await {
return self.phoxite_hierarchy_members(&phoxite, pos, kind, &cancel).await;
}
let (members, _, _) = self.hierarchy_command(doc, pos, kind, MEMBERS, &[], &cancel).await?;
Ok(members)
}
@@ -89,6 +93,9 @@ impl LspManager {
choices: Vec<HierarchyChoice>,
cancel: CancellationToken,
) -> IdeResult<HierarchyRefactored> {
if let Some(phoxite) = self.phoxite_refactor_target(doc).await {
return self.phoxite_hierarchy_refactor(&phoxite, pos, kind, target, &choices, &cancel).await;
}
let choices: Vec<Value> = choices.iter().map(|c| json!({ "id": c.id, "abstract": c.make_abstract })).collect();
let (refactored, _, t): (Refactored, _, _) =
self.hierarchy_command(doc, pos, kind, REFACTOR, &[json!(target), json!(choices)], &cancel).await?;
+116
Переглянути файл
@@ -0,0 +1,116 @@
//! Move (F6) through jdtls' own requests. jdtls offers Move as code actions whose command the
//! client runs (`java.action.applyRefactoringCommand` with `moveFile`, `moveType`,
//! `moveStaticMember` or `moveInstanceMethod`); the UI picks the destination from
//! `java/getMoveDestinations` or `java/searchSymbols` and `java/move` checks the move and
//! computes the edit, which the UI applies itself. Requests carry the code action's own
//! arguments back unchanged.
use super::COMMAND_TIMEOUT;
use super::signature::{RefactorEdit, changed};
use crate::types::ServerRefactored;
use crate::{LspManager, convert};
use ide_core::{CancellationToken, DocId, IdeError, IdeResult};
use serde_json::{Value, json};
const FEATURE: &str = "Move";
/// What `java/getMoveDestinations` and `java/move` accept as `moveKind`.
const KINDS: [&str; 6] =
["moveResource", "moveInstanceMethod", "moveStaticMember", "moveTypeToNewFile", "moveTypeToClass", "moveType"];
fn move_params(kind: &str, request: &Value) -> IdeResult<Value> {
if !KINDS.contains(&kind) {
return Err(IdeError::invalid(format!("unknown move kind `{kind}`")));
}
let mut params = json!({
"moveKind": kind,
"sourceUris": request.get("sourceUris").cloned().unwrap_or(json!([])),
"params": request.get("params").cloned().unwrap_or(Value::Null),
});
if let Some(destination) = request.get("destination").filter(|d| !d.is_null()) {
params["destination"] = destination.clone();
}
Ok(params)
}
impl LspManager {
/// Where the move of `kind` can go (packages, or the fields and parameters an instance
/// method can move to); an invalid-input error carries jdtls' reason when there is none.
pub async fn java_move_destinations(
&self,
doc: DocId,
kind: String,
request: Value,
cancel: CancellationToken,
) -> IdeResult<Vec<Value>> {
let (_, t) = self.jdtls_target(doc, FEATURE).await?;
let params = move_params(&kind, &request)?;
let answer: Value = self.call(&t, "java/getMoveDestinations", params, Some(&cancel), COMMAND_TIMEOUT).await?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
if let Some(message) = answer.get("errorMessage").and_then(Value::as_str).filter(|m| !m.is_empty()) {
return Err(IdeError::invalid(message.to_owned()));
}
Ok(answer.get("destinations").and_then(Value::as_array).cloned().unwrap_or_default())
}
/// The project's source types (`java/searchSymbols`), for moving a member or type into a class.
pub async fn java_source_types(
&self,
doc: DocId,
project: Option<String>,
cancel: CancellationToken,
) -> IdeResult<Vec<Value>> {
let (_, t) = self.jdtls_target(doc, FEATURE).await?;
let params = json!({ "query": "*", "projectName": project, "sourceOnly": true });
let answer: Option<Vec<Value>> =
self.call(&t, "java/searchSymbols", params, Some(&cancel), COMMAND_TIMEOUT).await?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
Ok(answer.unwrap_or_default())
}
/// Checks the move and computes the edit without applying it; `confirmation` accepts the
/// warnings an earlier check returned with it.
pub async fn java_move(
&self,
doc: DocId,
kind: String,
request: Value,
confirmation: Option<String>,
cancel: CancellationToken,
) -> IdeResult<ServerRefactored> {
let (_, t) = self.jdtls_target(doc, FEATURE).await?;
let mut params = move_params(&kind, &request)?;
params["updateReferences"] = json!(true);
if let Some(token) = confirmation {
params["confirmationToken"] = json!(token);
}
let answer: Option<RefactorEdit> = self.call(&t, "java/move", params, Some(&cancel), COMMAND_TIMEOUT).await?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let conv = self.conv(t.enc());
Ok(changed(answer.unwrap_or_default(), |e| convert::workspace_edit(&conv, e)))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn passes_the_code_action_arguments_back_for_known_kinds_only() {
let request = json!({
"sourceUris": ["file:///p/A.java"],
"params": { "textDocument": { "uri": "file:///p/A.java" } },
"destination": { "displayName": "com.example" },
});
let params = move_params("moveResource", &request).unwrap();
assert_eq!(params["moveKind"], "moveResource");
assert_eq!(params["sourceUris"][0], "file:///p/A.java");
assert_eq!(params["destination"]["displayName"], "com.example");
assert!(move_params("moveResource", &json!({})).unwrap().get("destination").is_none());
assert!(move_params("deleteEverything", &request).is_err());
}
}
+181
Переглянути файл
@@ -0,0 +1,181 @@
//! Change Signature through jdtls' own requests: `java/getChangeSignatureInfo` reads the method at
//! a position, `java/getRefactorEdit` (`changeSignature`) checks the new signature and computes the
//! edit. The UI edits the signature and applies the edit itself.
use super::{COMMAND_TIMEOUT, SERVER};
use crate::types::{MethodSignature, ProblemSeverity, RefactoringProblem, ServerRefactored};
use crate::{DocSnap, LspManager, Target, convert};
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, Pos};
use serde::Deserialize;
use serde_json::{Value, json};
const FEATURE: &str = "Change Signature";
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Info {
#[serde(flatten)]
signature: Option<MethodSignature>,
error_message: Option<String>,
}
#[derive(Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(super) struct RefactorEdit {
edit: Option<lsp_types::WorkspaceEdit>,
error_message: Option<String>,
confirmation_token: Option<String>,
}
/// A `java/getRefactorEdit` or `java/move` answer as the result: an error message alone is fatal;
/// with a confirmation token it lists warnings to accept before the edit is computed.
pub(super) fn changed(
answer: RefactorEdit,
convert_edit: impl FnOnce(lsp_types::WorkspaceEdit) -> ide_core::WorkspaceEdit,
) -> ServerRefactored {
let problem = |severity| {
answer
.error_message
.as_deref()
.filter(|m| !m.trim().is_empty())
.map(|message| RefactoringProblem { severity, message: message.trim().to_owned() })
};
if let Some(token) = answer.confirmation_token {
return ServerRefactored {
problems: problem(ProblemSeverity::Warning).into_iter().collect(),
edit: None,
confirmation: Some(token),
};
}
match answer.edit {
Some(edit) if answer.error_message.is_none() => {
ServerRefactored { problems: Vec::new(), edit: Some(convert_edit(edit)), confirmation: None }
}
_ => ServerRefactored {
problems: problem(ProblemSeverity::Fatal).into_iter().collect(),
edit: None,
confirmation: None,
},
}
}
impl LspManager {
pub(super) async fn jdtls_target(&self, doc: DocId, feature: &str) -> IdeResult<(DocSnap, Target)> {
let (snap, targets) = self.doc_targets(doc, feature, |_| true).await?;
let t = targets
.into_iter()
.find(|t| t.server.name == SERVER)
.ok_or_else(|| IdeError::unavailable(format!("{feature} needs the Java language server (jdtls)")))?;
Ok((snap, t))
}
fn signature_context(snap: &DocSnap, t: &Target, pos: Pos) -> Value {
let at = snap.position(t, pos);
json!({
"textDocument": { "uri": snap.uri },
"range": { "start": at, "end": at },
"context": { "diagnostics": [] },
})
}
/// The signature of the method at `pos`; an invalid-input error says why it can't be changed.
pub async fn change_signature_info(
&self,
doc: DocId,
pos: Pos,
cancel: CancellationToken,
) -> IdeResult<MethodSignature> {
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
let params = Self::signature_context(&snap, &t, pos);
let info: Option<Info> =
self.call(&t, "java/getChangeSignatureInfo", params, Some(&cancel), COMMAND_TIMEOUT).await?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
match info {
Some(Info { error_message: Some(message), .. }) => Err(IdeError::invalid(message)),
Some(Info { signature: Some(signature), .. }) => Ok(signature),
_ => Err(IdeError::invalid("Caret should be on a method declaration")),
}
}
/// Checks changing the method at `pos` to `signature` and computes the edit without applying it.
/// `confirmation` accepts the warnings an earlier check returned with it.
pub async fn change_signature(
&self,
doc: DocId,
pos: Pos,
signature: MethodSignature,
delegate: bool,
confirmation: Option<String>,
cancel: CancellationToken,
) -> IdeResult<ServerRefactored> {
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
let MethodSignature { method_identifier, modifier, return_type, method_name, parameters, exceptions } =
signature;
let mut params = json!({
"command": "changeSignature",
"context": Self::signature_context(&snap, &t, pos),
"options": { "tabSize": 4, "insertSpaces": true },
"commandArguments": [
method_identifier, delegate, method_name, modifier, return_type, parameters, exceptions, false
],
});
if let Some(token) = confirmation {
params["confirmationToken"] = json!(token);
}
let answer: Option<RefactorEdit> =
self.call(&t, "java/getRefactorEdit", params, Some(&cancel), COMMAND_TIMEOUT).await?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let answer = answer.unwrap_or_default();
let conv = self.conv(t.enc());
Ok(changed(answer, |e| convert::workspace_edit(&conv, e)))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn answer(v: Value) -> RefactorEdit {
serde_json::from_value(v).unwrap()
}
fn no_edit(_: lsp_types::WorkspaceEdit) -> ide_core::WorkspaceEdit {
ide_core::WorkspaceEdit::default()
}
#[test]
fn reads_the_signature_or_why_there_is_none() {
let info: Info = serde_json::from_value(json!({
"methodIdentifier": "=p/src<p{A.java[A~m~I",
"modifier": "public",
"returnType": "void",
"methodName": "m",
"parameters": [{ "type": "int", "name": "a", "defaultValue": "null", "originalIndex": 0 }],
"exceptions": [{ "type": "java.io.IOException", "typeHandleIdentifier": "=x" }],
"errorMessage": null,
}))
.unwrap();
let s = info.signature.unwrap();
assert_eq!((s.method_name.as_str(), s.parameters[0].type_name.as_str()), ("m", "int"));
assert_eq!(s.exceptions[0].type_name, "java.io.IOException");
let refused: Info = serde_json::from_value(json!({ "errorMessage": "Cannot change signature." })).unwrap();
assert!(refused.signature.is_none());
assert_eq!(refused.error_message.as_deref(), Some("Cannot change signature."));
}
#[test]
fn errors_are_fatal_and_tokens_ask_for_confirmation() {
let fatal = changed(answer(json!({ "errorMessage": "Duplicate parameter name" })), no_edit);
assert_eq!(fatal.problems[0].severity, ProblemSeverity::Fatal);
assert!(fatal.edit.is_none() && fatal.confirmation.is_none());
let warn = changed(answer(json!({ "errorMessage": "Overrides a method", "confirmationToken": "t1" })), no_edit);
assert_eq!(warn.problems[0].severity, ProblemSeverity::Warning);
assert_eq!(warn.confirmation.as_deref(), Some("t1"));
let ok = changed(answer(json!({ "edit": { "changes": {} } })), no_edit);
assert!(ok.problems.is_empty() && ok.edit.is_some());
}
}
Loaded 100 of 815 files, more files were not shown because too many files have changed in this diff. Show more