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

..
Автор SHA1 Повідомлення Дата
l0ng-ai 566631b6b8 fix(debugger): debug Python with a Windows venv interpreter given by its path
A Python run configuration whose command is a Windows path
(C:\…\.venv\Scripts\python.exe) was not recognised as an interpreter:
the path was only split at '/', so debugpy got a bare `python` from PATH
and the whole path as the module to run. When PATH has no usable
python, the launcher debugpy asks the IDE to start never connects
("Timed out waiting for launcher to connect"). Command names now split
at both separators, and a venv tool given by a backslash path debugs
with the python.exe next to it.

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

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

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

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

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

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

Refs #3874

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

Refs #3874

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

Refs #3874

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

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

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

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

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

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

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

Closes #3932

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

Closes #2197

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

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

Fixes #3919

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

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

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

Part of #3344.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Refs #3863
2026-11-17 13:06:31 +08:00
l0ng-ai 7392bd2547 fix(java): remove jdtls workspaces unused for 30 days (#3899)
A jdtls workspace is keyed by the project folder and the settings that need a clean import, so each change of those and each moved or deleted project left 50-200 MB behind for good. jdtls now marks its workspace when it starts, and start-up moves workspaces untouched for 30 days aside and deletes them in the background.

Refs #3869
2026-11-17 13:04:08 +08:00
Daniil Poliakovтаdan548 b1f73e3920 fix(editor): bound rainbow bracket scanning on minified lines (#3884)
Rainbow bracket scanning rescanned a whole minified line after every keystroke (the viewport always holds all of it), so typing lagged in minified files. Lines of at least 10,000 UTF-16 units, the indent-guide threshold, are now skipped by both the parsed and lexical scanners and excluded from nesting, and checkpoints are invalidated from the changed line's start so colours come back when the line shrinks below the limit.

Closes #3883

Co-authored-by: dan548 <[email protected]>
2026-11-17 12:39:54 +08:00
LU XIANGRUIтаwildcatDownstairs e8b12dfb51 fix(color-scheme): show the red-green colours on the Color Scheme page (#3878)
With Adjust colors for red-green vision deficiency on, the editor used the bundled schemes' red-green variants (#3510) but Editor › Color Scheme still showed the plain colours, because schemeTokens() read tokens.css without its [data-red-green] rules. Built-in schemes now resolve with the red-green variant when the setting is on (preview, attribute values, an explicitly chosen bundled scheme), and the page says so with a link to Appearance. Custom schemes and exported .icls files are unchanged.

Closes #3851

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-17 12:39:50 +08:00
l0ng-ai fd828c0ade test(plugins): keep the editor panel's problem levels out of the text catalog (#3896)
The severity map's `hint: "weakWarning"` entry read as UI text to the
text-catalog check (`hint` is a text property), failing it on main since #3885.
A function maps the levels instead.
2026-11-17 12:33:53 +08:00
381 змінених файлів з 16374 додано та 13761 видалено

No files matched your search

+3
Переглянути файл
@@ -98,6 +98,9 @@ jobs:
# Test fixtures write LF files; keep Git from converting them on checkout.
- run: git config --global core.autocrlf false
- run: cargo nextest run --workspace --no-fail-fast
# nextest skips doctests; ide-command's are its compile-fail tests.
- if: runner.os == 'Linux'
run: cargo test --doc -p ide-command
# nextest ran export_bindings, which rewrites src/bindings.ts and the command snapshot.
- name: Bindings and command snapshot are up to date
if: runner.os == 'Linux'
-119
Переглянути файл
@@ -1,119 +0,0 @@
name: Nightly
# Twice a day, builds the newest main commit that passed CI as a prerelease tagged with its own
# version, so remote development finds the server of that version. The `nightly` release holds
# the manifest the nightly app updates from; its tag marks the commit last built, and a run with
# nothing newer stops there. Only the latest builds are kept.
on:
schedule:
- cron: "17 2,14 * * *"
workflow_dispatch:
inputs:
force:
description: "Build even if nothing is newer than the last nightly"
type: boolean
default: false
permissions:
contents: read
concurrency:
group: nightly
env:
GH_TOKEN: ${{ github.token }}
GH_REPO: ${{ github.repository }}
jobs:
prepare:
permissions:
actions: read
contents: write
if: github.repository == 'l0ng-ai/openidea'
runs-on: ubuntu-latest
outputs:
sha: ${{ steps.commit.outputs.sha }}
tag: ${{ steps.release.outputs.tag }}
release_id: ${{ steps.release.outputs.id }}
steps:
- id: commit
env:
FORCE: ${{ inputs.force }}
run: |
sha="$(gh run list --workflow ci.yml --branch main --event push --status success --limit 1 \
--json headSha --jq '.[0].headSha // ""')"
if [ -z "$sha" ]; then
echo "::notice::no main commit has passed CI"
exit 0
fi
# No `nightly` tag yet (the first run): compare fails and the build goes on.
status="$(gh api "repos/$GH_REPO/compare/nightly...$sha" --jq .status 2>/dev/null)" || status=ahead
if [ "$status" != ahead ] && [ "$FORCE" != true ]; then
echo "::notice::$sha is not newer than the last nightly"
exit 0
fi
echo "sha=$sha" >> "$GITHUB_OUTPUT"
- uses: actions/checkout@v5
if: steps.commit.outputs.sha != ''
with: { ref: "${{ steps.commit.outputs.sha }}" }
- uses: actions/setup-node@v5
if: steps.commit.outputs.sha != ''
with: { node-version: 22 }
- uses: dtolnay/rust-toolchain@stable
if: steps.commit.outputs.sha != ''
- id: release
if: steps.commit.outputs.sha != ''
env:
SHA: ${{ steps.commit.outputs.sha }}
run: |
version="$(node scripts/nightly-prepare.ts "$(date -u +%Y%m%d%H%M)")"
tag="v$version"
git config user.name "github-actions[bot]"
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
git commit -am "chore: $tag"
git tag "$tag"
git push origin "$tag"
id="$(gh api -X POST "repos/$GH_REPO/releases" -f tag_name="$tag" -f name="OpenIDEA Nightly $version" \
-F draft=true -F prerelease=true -f body="Built from $SHA." --jq .id)"
echo "tag=$tag" >> "$GITHUB_OUTPUT"
echo "id=$id" >> "$GITHUB_OUTPUT"
binaries:
permissions:
contents: write
needs: prepare
if: needs.prepare.outputs.tag != ''
uses: ./.github/workflows/release-build.yml
with:
tag: ${{ needs.prepare.outputs.tag }}
release_id: ${{ needs.prepare.outputs.release_id }}
secrets: inherit
publish:
permissions:
contents: write
needs: [prepare, binaries]
runs-on: ubuntu-latest
env:
TAG: ${{ needs.prepare.outputs.tag }}
SHA: ${{ needs.prepare.outputs.sha }}
KEEP: 14
steps:
- name: Publish the build
run: gh release edit "$TAG" --tag "$TAG" --draft=false
- name: Point the updater at it
run: |
gh release download "$TAG" -p latest.json -D "$RUNNER_TEMP"
gh release view nightly >/dev/null 2>&1 ||
gh release create nightly --prerelease --latest=false --target "$SHA" --title "OpenIDEA Nightly" \
--notes "The update manifest of the nightly builds, and the commit last built."
gh release upload nightly "$RUNNER_TEMP/latest.json" --clobber
gh api -X PATCH "repos/$GH_REPO/git/refs/tags/nightly" -f sha="$SHA" -F force=true --silent
# Failed builds' drafts go too, once they are this old.
- name: Delete old builds
run: |
gh release list --limit 200 --json tagName,createdAt --jq \
'[.[] | select(.tagName | contains("-nightly."))] | sort_by(.createdAt) | reverse | .[env.KEEP | tonumber:][].tagName' |
while read -r tag; do
gh release delete "$tag" --cleanup-tag --yes
done
+8 -9
Переглянути файл
@@ -1,7 +1,7 @@
name: Release build
# Builds a tag's desktop apps, remote servers and updater manifest into its draft release.
# Stable releases (release.yml) and nightly builds (nightly.yml) both run it.
# Builds a tag's desktop apps, remote servers and updater manifest into its draft release
# (run by release.yml).
on:
workflow_call:
inputs:
@@ -224,18 +224,17 @@ jobs:
return;
}
// Bundle suffix → updater platform keys, as tauri-action names them.
// Nightly versions don't fit MSI or RPM, so those builds offer NSIS on Windows.
const nightly = tag.includes("-nightly.");
const windows = (arch, msi, nsis) => nightly
? [[nsis, [`windows-${arch}`, `windows-${arch}-nsis`]]]
: [[msi, [`windows-${arch}`, `windows-${arch}-msi`]], [nsis, [`windows-${arch}-nsis`]]];
const windows = (arch, msi, nsis) => [
[msi, [`windows-${arch}`, `windows-${arch}-msi`]],
[nsis, [`windows-${arch}-nsis`]],
];
const kinds = [
[/_aarch64\.AppImage$/, ["linux-aarch64", "linux-aarch64-appimage"]],
[/_arm64\.deb$/, ["linux-aarch64-deb"]],
...(nightly ? [] : [[/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]]]),
[/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]],
[/_amd64\.AppImage$/, ["linux-x86_64", "linux-x86_64-appimage"]],
[/_amd64\.deb$/, ["linux-x86_64-deb"]],
...(nightly ? [] : [[/\.x86_64\.rpm$/, ["linux-x86_64-rpm"]]]),
[/\.x86_64\.rpm$/, ["linux-x86_64-rpm"]],
[/_aarch64\.app\.tar\.gz$/, ["darwin-aarch64", "darwin-aarch64-app"]],
[/_x64\.app\.tar\.gz$/, ["darwin-x86_64", "darwin-x86_64-app"]],
...windows("aarch64", /_arm64_en-US\.msi$/, /_arm64-setup\.exe$/),
+2 -3
Переглянути файл
@@ -1,7 +1,7 @@
name: Release
on:
push:
tags: ["v*", "!v*-nightly.*"]
tags: ["v*"]
workflow_dispatch:
inputs:
tag:
@@ -23,7 +23,6 @@ env:
jobs:
# Creates (or reuses) one draft release that every platform build uploads into.
create-release:
if: ${{ !contains(github.event.inputs.tag || github.ref_name, '-nightly.') }}
permissions:
contents: write
runs-on: ubuntu-latest
@@ -62,7 +61,7 @@ jobs:
core.setOutput("id", existing.id);
return;
}
// Nightly builds are prereleases: the notes span stable release to stable release.
// Prereleases are skipped: the notes span stable release to stable release.
const previous = releases.find((r) => !r.draft && !r.prerelease);
const { data: notes } = await github.rest.repos.generateReleaseNotes({
owner, repo, tag_name: tag, previous_tag_name: previous?.tag_name,
+5 -1
Переглянути файл
@@ -9,7 +9,8 @@ Visual style: dark, low-contrast greys, one cool accent
- `crates/ide-*` — backend crates; one domain each. Depend on `ide-core` for shared
types; never reach into another crate's internals.
- `src-tauri/` — glue only: `state.rs` (AppState / Project), `commands/<domain>.rs`
(thin typed IPC adapters), `events.rs`. No domain logic here.
(desktop-only commands; the adapters of `ide-host` commands are derived), `events.rs`.
No domain logic here.
- `src/bindings.ts` — generated by tauri-specta (`pnpm gen:bindings`). Never edit.
- `src/platform/` — ipc (`call`, `onIdeEvent`, `nextRequestId`), actions registry,
keymap + dispatcher, context keys / `when` clauses, project store.
@@ -33,6 +34,9 @@ Visual style: dark, low-contrast greys, one cool accent
- IPC coordinates: 0-based lines, **UTF-16** columns/offsets everywhere (`ide-core::text`).
- Every command returns `IdeResult<T>`; convert internal errors at the crate edge.
- Declare a command once, on its implementation: `#[command(trust = …)]` in `ide-host::ops`
plus its module's `domain!` list (Tauri adapter, server handler and bindings are derived);
desktop-only commands use `#[desktop_command(trust = …)]` and `desktop_domain!`.
- Streaming → `tauri::ipc::Channel<T>`; cancellable → UI-allocated `RequestId` +
`cancel_request`. Backend → UI notifications → `IdeEvent` via `EventSink`.
- Long work never blocks the UI thread or a Tauri command thread: use
Створено
+13
Переглянути файл
@@ -4235,6 +4235,17 @@ dependencies = [
"png 0.18.1",
]
[[package]]
name = "ide-command"
version = "0.1.47"
dependencies = [
"heck 0.5.0",
"proc-macro2",
"quote",
"serde",
"syn 2.0.119",
]
[[package]]
name = "ide-core"
version = "0.1.47"
@@ -4424,6 +4435,7 @@ dependencies = [
"ide-agent",
"ide-analysis",
"ide-build",
"ide-command",
"ide-core",
"ide-coverage",
"ide-dap",
@@ -6661,6 +6673,7 @@ dependencies = [
"ide-build",
"ide-cli",
"ide-clipboard",
"ide-command",
"ide-core",
"ide-coverage",
"ide-dap",
+7
Переглянути файл
@@ -42,6 +42,7 @@ ide-fonts = { path = "crates/ide-fonts" }
ide-ssh = { path = "crates/ide-ssh" }
ide-remote = { path = "crates/ide-remote" }
ide-host = { path = "crates/ide-host" }
ide-command = { path = "crates/ide-command" }
ide-mcp = { path = "crates/ide-mcp" }
ide-scaffold = { path = "crates/ide-scaffold" }
ide-notebook = { path = "crates/ide-notebook" }
@@ -124,6 +125,12 @@ uuid = { version = "1", features = ["v4"] }
keyring = "4.2"
keyring-core = "1"
# proc macros
heck = "0.5"
proc-macro2 = "1"
quote = "1"
syn = { version = "2", features = ["full"] }
# testing
insta = { version = "1", features = ["yaml"] }
proptest = "1"
+78 -17
Переглянути файл
@@ -222,13 +222,26 @@ impl Shared {
if builtin_off { 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, overrides));
let mut off = mcp::servers_off(&configured, overrides);
if builtin_off {
off.push(BUILTIN_SERVER.to_owned());
}
let off = Self::mcp_off(&configured, provider, overrides);
McpForSession { servers, off }
}
fn mcp_servers_off_for_session(&self, provider: &str, overrides: &BTreeMap<String, bool>) -> Vec<String> {
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
Self::mcp_off(&configured, provider, overrides)
}
fn mcp_off(configured: &[McpServer], provider: &str, overrides: &BTreeMap<String, bool>) -> Vec<String> {
let mut off = mcp::servers_off(configured, provider, overrides);
if overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false) {
off.push(BUILTIN_SERVER.to_owned());
off.push(mcp::BUILTIN_MCP_NAME.to_owned());
off.sort();
off.dedup();
}
off
}
fn known_config(&self, provider: &str) -> Vec<AgentConfigOption> {
let config = self.paths.catalogs.cached(self, provider).config;
self.config_for_new_task(config, provider)
@@ -922,29 +935,50 @@ impl AgentManager {
Ok(item)
}
/// Sends queued message `queued` next, cancelling the current turn if there is one.
pub fn send_queued_now(&self, id: &str, queued: &str) -> IdeResult<()> {
/// Sends queued message `queued` now: into the running turn when the agent takes
/// messages mid-turn, else next, cancelling the current turn if there is one.
pub async fn send_queued_now(&self, id: &str, queued: &str) -> IdeResult<()> {
let task = self.task(id)?;
let idle = {
let (item, busy) = {
let mut s = task.state.lock();
let i =
s.task.queue.iter().position(|q| q.id == queued).ok_or_else(|| IdeError::not_found("already sent"))?;
let item = s.task.queue.remove(i);
if s.busy {
s.task.queue.insert(0, item);
None
} else {
let busy = s.busy;
if !busy {
s.busy = true;
Some(item)
}
(item, busy)
};
task.persist();
task.emit_task();
match idle {
Some(item) => {
self.shared.runtime.spawn(async move { task.run(item.prompt).await });
if !busy {
self.shared.runtime.spawn(async move { task.run(item.prompt).await });
return Ok(());
}
// Out of the queue while it is steered, so the turn ending meanwhile doesn't send it twice.
let prompt = match task.steer(item.prompt).await {
Ok(()) => return Ok(()),
Err(prompt) => prompt,
};
let start = {
let mut s = task.state.lock();
if s.busy {
s.task.queue.insert(0, AgentQueued { id: item.id, prompt });
None
} else {
// The turn ended while steering was tried: nothing is left to interrupt.
s.busy = true;
Some(prompt)
}
};
match start {
Some(prompt) => {
self.shared.runtime.spawn(async move { task.run(prompt).await });
}
None => {
task.persist();
task.emit_task();
task.send_now.store(true, Ordering::Release);
task.cancel();
}
@@ -1618,6 +1652,26 @@ impl AgentManager {
Ok(out)
}
/// Recycles idle resumable live sessions (or schedules reload after the running turn) when
/// global, workspace, or built-in IDE MCP server settings change.
pub fn notify_mcp_servers_changed(&self) {
let tasks: Vec<Arc<Task>> = self.tasks.read().values().cloned().collect();
for task in tasks {
let (archived, busy, has_bg) = {
let s = task.state.lock();
(s.task.status == AgentStatus::Archived, s.busy, !s.background_tasks.is_empty())
};
if archived {
continue;
}
if busy || has_bg || !task.permissions.lock().is_empty() {
task.mcp_reload_pending.store(true, Ordering::Release);
} else {
task.recycle_resumable_session();
}
}
}
/// Stops every agent (project closed).
pub fn shutdown(&self) {
for task in self.tasks.read().values() {
@@ -2218,9 +2272,16 @@ impl Task {
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))
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
.await
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?;
if spec.driver == provider::Driver::Acp && provider::is_copilot_provider(provider_id) {
let mcp_overrides = self.state.lock().task.mcp_overrides.clone();
for name in self.shared.mcp_servers_off_for_session(provider_id, &mcp_overrides) {
spec.args.push("--disable-mcp-server".into());
spec.args.push(name);
}
}
self.stderr.lock().clear();
self.config_sent.lock().clear();
let weak = Arc::downgrade(self);
@@ -2981,7 +3042,7 @@ fn blocks(prompt: &AgentPrompt, contents: &[Option<String>]) -> Vec<Value> {
});
}
for i in &prompt.images {
out.push(json!({ "type": "image", "mimeType": i.mime_type, "data": i.data }));
out.push(json!({ "type": "image", "mimeType": i.media_type(), "data": i.data }));
}
out
}
+67 -20
Переглянути файл
@@ -10,7 +10,7 @@ use crate::{
};
use ide_core::IpcPath;
use serde_json::{Value, json};
use std::collections::{BTreeMap, HashSet};
use std::collections::{BTreeMap, BTreeSet, HashSet};
use std::path::{Path, PathBuf};
use std::time::{Duration, Instant};
@@ -89,24 +89,61 @@ fn matches_agent(agents: &[String], provider: &str) -> bool {
/// The configured servers off for this session: off by default and not switched on for it, or
/// switched off for it. Named so an agent that also loads its own configuration can keep a
/// same-named server of it off too. Workspace entries take precedence, as in [`acp_mcp_servers`].
pub(crate) fn servers_off(all: &[McpServer], overrides: &BTreeMap<String, bool>) -> Vec<String> {
let mut seen = HashSet::new();
let ordered =
all.iter().filter(|s| s.scope == McpScope::Workspace).chain(all.iter().filter(|s| s.scope == McpScope::User));
let configured: Vec<String> = ordered
.filter(|s| seen.insert(s.name.as_str()))
.filter(|s| !overrides.get(&s.name).copied().unwrap_or(s.enabled))
.map(|s| s.name.clone())
.collect();
// A server switched off that the IDE doesn't configure may still be the agent's own.
let switched = overrides
pub(crate) fn servers_off(all: &[McpServer], provider: &str, overrides: &BTreeMap<String, bool>) -> Vec<String> {
let mut seen_configured = HashSet::new();
let mut enabled_names = HashSet::new();
let mut off = BTreeSet::new();
let ordered = all
.iter()
.filter(|(name, on)| !**on && name.as_str() != BUILTIN_MCP_NAME && !seen.contains(name.as_str()))
.map(|(name, _)| name.clone());
let mut off: Vec<String> = configured.into_iter().chain(switched).collect();
off.sort();
off.dedup();
off
.filter(|s| s.scope == McpScope::Workspace && !s.unapproved)
.chain(all.iter().filter(|s| s.scope == McpScope::User));
for srv in ordered {
if !seen_configured.insert(srv.name.as_str()) {
continue;
}
let explicit = overrides.get(&srv.name).copied();
let matches = explicit == Some(true) || matches_agent(&srv.agents, provider);
let active = explicit.unwrap_or(srv.enabled) && matches;
if active {
enabled_names.insert(srv.name.as_str());
} else {
off.insert(srv.name.clone());
}
}
for srv in all.iter().filter(|s| s.scope == McpScope::Workspace && s.unapproved) {
if !enabled_names.contains(srv.name.as_str()) {
off.insert(srv.name.clone());
}
}
// A server switched off that the IDE doesn't configure may still be the agent's own.
for (name, &on) in overrides {
if !on && name.as_str() != BUILTIN_MCP_NAME && !enabled_names.contains(name.as_str()) {
off.insert(name.clone());
}
}
off.into_iter().collect()
}
/// Names of MCP servers present in Codex's own TOML configuration files (`~/.codex/config.toml`
/// and `<workspace_root>/.codex/config.toml`).
pub(crate) fn codex_external_server_names(home_dir: Option<&Path>, workspace_root: &Path) -> BTreeSet<String> {
let mut names = BTreeSet::new();
let mut paths = Vec::new();
if let Some(home) = home_dir {
paths.push(home.join(".codex").join("config.toml"));
}
paths.push(workspace_root.join(".codex").join("config.toml"));
for path in paths {
if let Ok(text) = std::fs::read_to_string(&path) {
names.extend(parse_codex_toml_servers(&text).into_keys());
}
}
names
}
/// Builds the ACP `mcpServers` array for `session/new`, `session/load`, and `session/fork`.
@@ -1058,6 +1095,11 @@ mod tests {
#[test]
fn servers_off_follow_the_effective_state() {
let mut claude_only = configured("claude-only", McpScope::User, true);
claude_only.agents = vec!["claude".into()];
let mut unapproved_ws = configured("unapproved-ws", McpScope::Workspace, false);
unapproved_ws.unapproved = true;
let all = [
configured("default-off", McpScope::User, false),
configured("switched-on", McpScope::User, false),
@@ -1066,6 +1108,8 @@ mod tests {
// The workspace entry decides for its name.
configured("both", McpScope::User, true),
configured("both", McpScope::Workspace, false),
claude_only,
unapproved_ws,
];
let overrides = BTreeMap::from([
("switched-on".to_owned(), true),
@@ -1073,8 +1117,11 @@ mod tests {
("agent-own".to_owned(), false),
(BUILTIN_MCP_NAME.to_owned(), false),
]);
assert_eq!(servers_off(&all, &overrides), ["agent-own", "both", "default-off", "switched-off"]);
assert_eq!(servers_off(&all[2..4], &BTreeMap::new()), Vec::<String>::new());
assert_eq!(
servers_off(&all, "copilot", &overrides),
["agent-own", "both", "claude-only", "default-off", "switched-off", "unapproved-ws"]
);
assert_eq!(servers_off(&all[2..4], "copilot", &BTreeMap::new()), Vec::<String>::new());
}
#[test]
+16
Переглянути файл
@@ -281,6 +281,22 @@ pub struct AgentImage {
pub name: Option<String>,
}
impl AgentImage {
/// The type the bytes are in. Agents reject an image whose declared type doesn't match its
/// bytes, and a pasted image's declared type can be wrong (a browser's JPEG or WebP copied as
/// `image/png`). Falls back to `mime_type` for formats not recognised here.
pub fn media_type(&self) -> &str {
let head = crate::acp::normalize_base64(&self.data[..self.data.len().min(16)]);
match head.as_slice() {
[0x89, b'P', b'N', b'G', ..] => "image/png",
[0xFF, 0xD8, 0xFF, ..] => "image/jpeg",
[b'G', b'I', b'F', b'8', ..] => "image/gif",
[b'R', b'I', b'F', b'F', _, _, _, _, b'W', b'E', b'B', b'P', ..] => "image/webp",
_ => &self.mime_type,
}
}
}
/// A message to the agent: text, plus files to look at and images.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
+11
Переглянути файл
@@ -1671,6 +1671,17 @@ fn session_mcp_servers_become_thread_configuration() {
json!({"mcp_servers":{"OpenIDEA":{"command":"/app/openidea","args":["--mcp-stdio","--project","/project"],"env":{"K":"V"}}}})
)
);
let external = std::collections::BTreeSet::from(["linear".to_owned()]);
assert_eq!(
super::translate::mcp_config_with_external(
&json!({
"mcpServers": [],
"_meta": { "openidea": { "mcpServersOff": ["linear", "not-in-codex"] } }
}),
&external,
),
Some(json!({ "mcp_servers": { "linear": { "enabled": false } } }))
);
}
#[tokio::test(flavor = "multi_thread")]
+22 -1
Переглянути файл
@@ -923,8 +923,18 @@ fn str_of(v: &Value, key: &str) -> Option<String> {
/// Session-scoped MCP configuration, carried in thread/start, resume and fork.
pub(super) fn mcp_config(params: &Value) -> Option<Value> {
let home = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(std::path::PathBuf::from);
let cwd = params.get("cwd").and_then(Value::as_str).map_or_else(|| std::path::Path::new("."), std::path::Path::new);
let external = crate::mcp::codex_external_server_names(home.as_deref(), cwd);
mcp_config_with_external(params, &external)
}
pub(super) fn mcp_config_with_external(
params: &Value,
external_names: &std::collections::BTreeSet<String>,
) -> Option<Value> {
let mut servers = serde_json::Map::new();
for server in params.get("mcpServers")?.as_array()? {
for server in params.get("mcpServers").and_then(Value::as_array).into_iter().flatten() {
if server.get("type").and_then(Value::as_str).is_some_and(|t| t != "stdio") {
continue;
}
@@ -946,5 +956,16 @@ pub(super) fn mcp_config(params: &Value) -> Option<Value> {
"args":server.get("args").cloned().unwrap_or_else(||json!([])),"env":env}),
);
}
for name in params
.pointer("/_meta/openidea/mcpServersOff")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(Value::as_str)
{
if !servers.contains_key(name) && external_names.contains(name) {
servers.insert(name.to_owned(), json!({ "enabled": false }));
}
}
(!servers.is_empty()).then(|| json!({"mcp_servers":servers}))
}
+107 -31
Переглянути файл
@@ -19,6 +19,7 @@ mod translate;
mod tests;
use super::Shim;
use crate::BACKGROUND_TASKS_UPDATE;
use crate::acp::AUTH_REQUIRED;
use crate::provider::ProviderSpec;
use ide_jsonrpc::{Framing, Handler, Peer, RpcError, codes};
@@ -296,6 +297,25 @@ struct SessionEntry {
prompt: Option<oneshot::Sender<TurnTerminal>>,
early_cancel: Option<Instant>,
temp_files: Vec<PathBuf>,
/// Copilot's main agent loop is processing. It goes idle (`assistant.idle`) before the
/// turn ends (`session.idle`) while background shells or agents it started still run.
main_busy: bool,
/// Counts `session.tasks.list` requests, so only the latest answer is reported.
tasks_seq: u64,
}
impl SessionEntry {
fn new(settings: Settings) -> Self {
Self {
settings,
translator: EventTranslator::default(),
prompt: None,
early_cancel: None,
temp_files: Vec::new(),
main_busy: false,
tasks_seq: 0,
}
}
}
struct CopilotEvents(Weak<CopilotShim>);
@@ -411,6 +431,7 @@ impl CopilotShim {
"session/set_config_option" => self.set_config(&params).await,
"session/prompt" => self.prompt(&params, false).await,
"_openidea/steer" => self.prompt(&params, true).await,
"_openidea/stop_task" => self.stop_task(&params).await,
"session/close" => self.close_session(&params).await,
_ => Err(error(codes::METHOD_NOT_FOUND, format!("unsupported method {method}"))),
}
@@ -425,7 +446,7 @@ impl CopilotShim {
"promptCapabilities": { "image": true, "audio": false, "embeddedContext": true },
"mcpCapabilities": { "http": true, "sse": true, "stdio": true },
"sessionCapabilities": { "close": {}, "list": {} },
"_meta": { "openidea": { "steer": true } },
"_meta": { "openidea": { "steer": true, "backgroundTasks": true } },
},
"agentInfo": {
"name": "copilot",
@@ -471,6 +492,9 @@ impl CopilotShim {
if let Some(mcp) = translate::wire_mcp_servers(params.get("mcpServers")) {
req["mcpServers"] = mcp;
}
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
req["disabledMcpServers"] = disabled;
}
let created = self.call("session.create", req).await?;
let session_id = created
@@ -489,16 +513,7 @@ impl CopilotShim {
}
let options = models::config_options(&catalog, &settings);
self.state.lock().sessions.insert(
session_id.clone(),
SessionEntry {
settings,
translator: EventTranslator::default(),
prompt: None,
early_cancel: None,
temp_files: Vec::new(),
},
);
self.state.lock().sessions.insert(session_id.clone(), SessionEntry::new(settings));
self.publish_commands(&session_id, cwd);
Ok(json!({
"sessionId": session_id,
@@ -527,6 +542,9 @@ impl CopilotShim {
if let Some(mcp) = translate::wire_mcp_servers(params.get("mcpServers")) {
req["mcpServers"] = mcp;
}
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
req["disabledMcpServers"] = disabled;
}
let resumed = self.call("session.resume", req).await?;
if let Ok(current) = self.call("session.model.getCurrent", json!({ "sessionId": session_id })).await {
@@ -542,16 +560,7 @@ impl CopilotShim {
}
let actual_id = resumed.get("sessionId").and_then(Value::as_str).unwrap_or(&session_id).to_owned();
let options = models::config_options(&catalog, &settings);
self.state.lock().sessions.insert(
actual_id.clone(),
SessionEntry {
settings,
translator: EventTranslator::default(),
prompt: None,
early_cancel: None,
temp_files: Vec::new(),
},
);
self.state.lock().sessions.insert(actual_id.clone(), SessionEntry::new(settings));
self.publish_commands(&actual_id, cwd);
Ok(json!({
"sessionId": actual_id,
@@ -653,7 +662,11 @@ impl CopilotShim {
let (text, attachments, temp_files) = build_prompt_payload(&session_id, blocks);
if steer {
let is_running = self.state.lock().sessions.get(&session_id).is_some_and(|e| e.prompt.is_some());
let (is_running, main_busy) = {
let st = self.state.lock();
let entry = st.sessions.get(&session_id);
(entry.is_some_and(|e| e.prompt.is_some()), entry.is_some_and(|e| e.main_busy))
};
if !is_running {
cleanup_files(&temp_files);
return Err(error(codes::INVALID_PARAMS, "no turn running to steer"));
@@ -661,14 +674,25 @@ impl CopilotShim {
let mut send_req = json!({
"sessionId": session_id,
"prompt": text,
"mode": "immediate",
});
// Joins the running loop; once it went idle (only background work is left), a plain
// send starts the loop again with this message.
if main_busy {
send_req["mode"] = json!("immediate");
}
if !attachments.is_empty() {
send_req["attachments"] = Value::Array(attachments);
}
if !main_busy && let Some(entry) = self.state.lock().sessions.get_mut(&session_id) {
// Stop must abort the run this send starts, even before `assistant.turn_start`.
entry.main_busy = true;
}
let res = self.call("session.send", send_req).await;
if let Some(entry) = self.state.lock().sessions.get_mut(&session_id) {
entry.temp_files.extend(temp_files);
if res.is_err() && !main_busy {
entry.main_busy = false;
}
}
res?;
return Ok(json!({}));
@@ -685,6 +709,7 @@ impl CopilotShim {
let mode = entry.settings.mode.wire();
if !early {
entry.prompt = Some(done_tx);
entry.main_busy = true;
}
(mode, early)
};
@@ -734,19 +759,24 @@ impl CopilotShim {
}
fn cancel(&self, session_id: &str) {
let has_turn = {
let (has_turn, ended) = {
let mut st = self.state.lock();
if let Some(entry) = st.sessions.get_mut(session_id) {
if entry.prompt.is_none() {
match st.sessions.get_mut(session_id) {
Some(entry) if entry.prompt.is_none() => {
entry.early_cancel = Some(Instant::now());
false
} else {
true
(false, None)
}
} else {
false
// The agent is done with the turn and only its background work runs, which
// `session.idle` waits for: the turn ends now and that work keeps running
// (it shows as background tasks, stoppable one by one).
Some(entry) if !entry.main_busy => (false, entry.prompt.take()),
Some(_) => (true, None),
None => (false, None),
}
};
if let Some(tx) = ended {
let _ = tx.send(TurnTerminal::Idle { aborted: true });
}
if has_turn {
let peer = self.copilot().clone();
let sid = session_id.to_owned();
@@ -790,10 +820,23 @@ impl CopilotShim {
return;
}
let main_agent = event.get("agentId").and_then(Value::as_str).is_none_or(str::is_empty);
let event_type = event.get("type").and_then(Value::as_str).unwrap_or_default();
if main_agent && event_type == "session.background_tasks_changed" {
self.refresh_background_tasks(session_id);
}
let catalog_snapshot = self.catalog.try_lock().ok().and_then(|g| g.clone());
let (updates, done) = {
let mut st = self.state.lock();
let Some(entry) = st.sessions.get_mut(session_id) else { return };
if main_agent {
match event_type {
"assistant.turn_start" => entry.main_busy = true,
"assistant.idle" | "session.idle" | "session.error" => entry.main_busy = false,
_ => {}
}
}
let fallback_limit =
catalog_snapshot.as_deref().and_then(|models| entry.settings.active_context_tokens(models));
let translated = entry.translator.translate(session_id, event, fallback_limit);
@@ -803,11 +846,44 @@ impl CopilotShim {
for (target_session, update) in updates {
self.send_update(&target_session, update);
}
if main_agent && event_type == "session.idle" {
// Nothing runs in the background any more.
self.send_update(session_id, json!({ "sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": [] }));
}
if let Some((tx, outcome)) = done {
let _ = tx.send(outcome);
}
}
/// Reports the session's running background shells and agents (`session.tasks.list`).
fn refresh_background_tasks(self: &Arc<Self>, session_id: &str) {
let seq = {
let mut st = self.state.lock();
let Some(entry) = st.sessions.get_mut(session_id) else { return };
entry.tasks_seq += 1;
entry.tasks_seq
};
let shim = self.clone();
let sid = session_id.to_owned();
self.runtime.spawn(async move {
let Ok(list) = shim.call("session.tasks.list", json!({ "sessionId": sid })).await else { return };
let latest = shim.state.lock().sessions.get(&sid).is_some_and(|e| e.tasks_seq == seq);
if latest {
let tasks = translate::background_tasks(&list);
shim.send_update(&sid, json!({ "sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": tasks }));
}
});
}
/// Stops one background shell or agent (`session.tasks.cancel`).
async fn stop_task(self: &Arc<Self>, params: &Value) -> Result<Value, ResponseError> {
let session_id = str_param(params, "sessionId")?;
let task_id = str_param(params, "taskId")?;
self.call("session.tasks.cancel", json!({ "sessionId": session_id, "id": task_id })).await?;
self.refresh_background_tasks(session_id);
Ok(json!({}))
}
fn handle_permission_event(self: &Arc<Self>, session_id: &str, event: &Value) {
let data = &event["data"];
if data.get("resolvedByHook").and_then(Value::as_bool) == Some(true) {
+148 -1
Переглянути файл
@@ -6,6 +6,7 @@ use ide_jsonrpc::{Framing, Handler, Peer, codes};
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::sync::{Arc, OnceLock};
use std::time::Duration;
fn sample_models_list() -> Value {
json!({
@@ -340,6 +341,12 @@ fn headless_and_acp_args_roundtrip_while_preserving_user_flags() {
struct FakeCopilotServer {
peer: OnceLock<Peer>,
calls: Mutex<Vec<(String, Value)>>,
/// `session.send` leaves a shell running: the main loop goes idle but the session doesn't.
background_shell: bool,
}
fn copilot_event(sid: &str, event: Value) -> Value {
json!({ "sessionId": sid, "event": event })
}
impl Handler for FakeCopilotServer {
@@ -355,12 +362,36 @@ impl Handler for FakeCopilotServer {
"commands.list" => Ok(json!({ "commands": [{ "name": "compact", "description": "Compact context" }] })),
"skills.discover" => Ok(json!({ "skills": [] })),
"session.create" => Ok(json!({ "sessionId": "cop-sess-1" })),
"session.resume" => Ok(json!({ "sessionId": params["sessionId"] })),
"session.model.getCurrent" => Ok(json!({ "modelId": "gemini-4-carbon" })),
"session.model.switchTo" => Ok(json!({ "modelId": params["modelId"] })),
"session.mode.set" => Ok(json!({})),
"session.permissions.setApproveAll" => {
assert!(params.get("enabled").and_then(Value::as_bool).is_some());
Ok(json!({ "success": true }))
}
"session.tasks.list" => Ok(json!({ "tasks": [
{ "id": "shell-1", "type": "shell", "status": "running", "description": "",
"command": "gh pr checks 3819 --watch", "attachmentMode": "attached" },
{ "id": "shell-0", "type": "shell", "status": "completed", "description": "ls", "command": "ls" },
] })),
"session.tasks.cancel" => Ok(json!({ "cancelled": true })),
"session.abort" => Ok(json!({})),
"session.send" if self.background_shell => {
if let Some(peer) = self.peer.get().cloned() {
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
std::thread::spawn(move || {
for event in [
json!({ "id": "b1", "type": "assistant.turn_start", "data": { "turnId": "t1" } }),
json!({ "id": "b2", "type": "assistant.idle", "data": {} }),
json!({ "id": "b3", "type": "session.background_tasks_changed", "data": {} }),
] {
let _ = peer.notify("session.event", copilot_event(&sid, event));
}
});
}
Ok(json!({ "messageId": "msg-1" }))
}
"session.send" => {
if let Some(peer) = self.peer.get().cloned() {
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
@@ -423,7 +454,8 @@ impl Handler for CollectUpdates {
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_turns() {
let server = Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()) });
let server =
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: false });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates.clone(), move |events| {
@@ -538,3 +570,118 @@ async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_t
.any(|u| u["sessionUpdate"] == "usage_update" && u["size"] == 200_000 && u["used"] == 42_000)
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn shim_forwards_disabled_mcp_servers_on_create_and_resume() {
let server =
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: false });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates, move |events| {
let (a, b) = tokio::io::duplex(1 << 16);
let (ar, aw) = tokio::io::split(a);
let (br, bw) = tokio::io::split(b);
let srv_peer = Peer::connect_framed(br, bw, server_clone.clone(), Framing::ContentLength);
let _ = server_clone.peer.set(srv_peer);
Ok(Peer::connect_framed(ar, aw, events, Framing::ContentLength))
})
.unwrap();
let _: Value = client.request("initialize", json!({}), None).await.unwrap();
let disabled = json!(["datadog", "github-mcp-server", "linear", "playwright", "slack-official"]);
let _: Value = client
.request(
"session/new",
json!({
"cwd": "/tmp",
"mcpServers": [],
"_meta": { "openidea": { "mcpServersOff": disabled } }
}),
None,
)
.await
.unwrap();
let _: Value = client
.request(
"session/load",
json!({
"sessionId": "cop-sess-1",
"cwd": "/tmp",
"mcpServers": [],
"_meta": { "openidea": { "mcpServersOff": disabled } }
}),
None,
)
.await
.unwrap();
let calls = server.calls.lock();
let (_, create_params) = calls.iter().find(|(m, _)| m == "session.create").unwrap();
assert_eq!(create_params["disabledMcpServers"], disabled);
let (_, resume_params) = calls.iter().find(|(m, _)| m == "session.resume").unwrap();
assert_eq!(resume_params["disabledMcpServers"], disabled);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn stop_ends_a_turn_left_running_only_by_background_shells() {
let server =
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: true });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates.clone(), move |events| {
let (a, b) = tokio::io::duplex(1 << 16);
let (ar, aw) = tokio::io::split(a);
let (br, bw) = tokio::io::split(b);
let srv_peer = Peer::connect_framed(br, bw, server_clone.clone(), Framing::ContentLength);
let _ = server_clone.peer.set(srv_peer);
Ok(Peer::connect_framed(ar, aw, events, Framing::ContentLength))
})
.unwrap();
let init: Value = client.request("initialize", json!({}), None).await.unwrap();
assert_eq!(init["agentCapabilities"]["_meta"]["openidea"]["backgroundTasks"], true);
let _: Value = client.request("session/new", json!({ "cwd": "/tmp", "mcpServers": [] }), None).await.unwrap();
let prompt_client = client.clone();
let turn = tokio::spawn(async move {
prompt_client
.request::<_, Value>(
"session/prompt",
json!({ "sessionId": "cop-sess-1", "prompt": [{ "type": "text", "text": "watch CI" }] }),
None,
)
.await
});
// The running shell shows as a background task.
let mut shown = None;
for _ in 0..500 {
shown = updates.0.lock().iter().find(|u| u["sessionUpdate"] == crate::BACKGROUND_TASKS_UPDATE).cloned();
if shown.is_some() {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
assert_eq!(
shown.unwrap()["tasks"],
json!([{ "task_id": "shell-1", "task_type": "local_bash", "description": "gh pr checks 3819 --watch" }])
);
let _: Value = client
.request("_openidea/stop_task", json!({ "sessionId": "cop-sess-1", "taskId": "shell-1" }), None)
.await
.unwrap();
assert!(
server
.calls
.lock()
.iter()
.any(|(m, p)| m == "session.tasks.cancel" && p["sessionId"] == "cop-sess-1" && p["id"] == "shell-1")
);
// The main loop is idle, so Stop ends the turn even though `session.idle` never comes.
assert!(!turn.is_finished());
client.notify("session/cancel", json!({ "sessionId": "cop-sess-1" })).unwrap();
let res = tokio::time::timeout(Duration::from_secs(5), turn).await.unwrap().unwrap().unwrap();
assert_eq!(res["stopReason"], "cancelled");
assert!(!server.calls.lock().iter().any(|(m, _)| m == "session.abort"));
}
+30
Переглянути файл
@@ -522,6 +522,14 @@ pub(super) fn wire_mcp_servers(acp_servers: Option<&Value>) -> Option<Value> {
(!out.is_empty()).then_some(Value::Object(out))
}
/// Extracts `_meta.openidea.mcpServersOff` into Copilot's `disabledMcpServers` string array.
pub(super) fn wire_disabled_mcp_servers(params: &Value) -> Option<Value> {
let list = params.pointer("/_meta/openidea/mcpServersOff")?.as_array()?;
let names: Vec<Value> =
list.iter().filter_map(|v| v.as_str().map(str::trim).filter(|s| !s.is_empty()).map(|s| json!(s))).collect();
(!names.is_empty()).then_some(Value::Array(names))
}
/// Converts `commands.list` + `skills.discover` results into ACP `availableCommands`.
pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Option<&Value>) -> Vec<Value> {
let mut seen = HashSet::new();
@@ -568,6 +576,28 @@ pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Optio
out
}
/// The running entries of a `session.tasks.list` result, in the background-task shape the
/// app shows (`task_id`, `task_type`, `description`).
pub(super) fn background_tasks(list: &Value) -> Vec<Value> {
let tasks = list.get("tasks").and_then(Value::as_array).map(Vec::as_slice).unwrap_or_default();
tasks
.iter()
.filter(|t| matches!(str_of(t, "status"), Some("running" | "idle")))
.filter_map(|t| {
let id = str_of(t, "id")?;
let kind = str_of(t, "type").unwrap_or_default();
let task_type = match kind {
"shell" => "local_bash",
"agent" => "local_agent",
other => other,
};
let description =
str_of(t, "description").filter(|d| !d.is_empty()).or_else(|| str_of(t, "command")).unwrap_or(kind);
Some(json!({ "task_id": id, "task_type": task_type, "description": description }))
})
.collect()
}
fn trim_tail(text: &mut String) {
if text.len() > MAX_OUTPUT {
let mut cut = text.len() - MAX_OUTPUT;
+61 -18
Переглянути файл
@@ -1214,25 +1214,15 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
assert_eq!(queue.iter().map(|q| q.prompt.text.as_str()).collect::<Vec<_>>(), ["again"]);
assert!(mgr.prompt(&task.id, text(" "), false).await.is_err());
mgr.send_queued_now(&task.id, &queue[0].id).unwrap();
for _ in 0..500 {
if mgr.entries(&task.id, None).unwrap().iter().any(|e| *e == AgentEntry::Agent { text: "second turn".into() }) {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let users: Vec<String> = mgr
.entries(&task.id, None)
.unwrap()
.into_iter()
.filter_map(|e| match e {
AgentEntry::User { text, .. } => Some(text),
_ => None,
})
.collect();
assert_eq!(users, ["wait", "again"]);
// Sending it now joins the running turn when the agent takes messages mid-turn.
mgr.send_queued_now(&task.id, &queue[0].id).await.unwrap();
assert!(agent.calls.lock().iter().any(|c| c == "_openidea/steer \"again\""));
assert!(!agent.calls.lock().iter().any(|c| c == "session/cancel"));
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
let entries = mgr.entries(&task.id, None).unwrap();
assert!(entries.iter().any(|e| matches!(e, AgentEntry::User { text, steered: true, .. } if text == "again")));
mgr.cancel(&task.id, None).unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
// Stopping a turn keeps the queue for later.
mgr.prompt(&task.id, text("wait"), false).await.unwrap();
@@ -1247,6 +1237,40 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
}
#[tokio::test(flavor = "multi_thread")]
async fn send_now_interrupts_the_turn_when_steering_is_refused() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent { session_steering: true, ..FakeAgent::default() });
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("wait"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Running).await;
mgr.prompt(&task.id, text("too late"), false).await.unwrap();
let queued = mgr.task(&task.id).unwrap().state.lock().task.queue[0].id.clone();
mgr.send_queued_now(&task.id, &queued).await.unwrap();
// The fake agent's next turn asks for permission.
wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
let calls = agent.calls.lock().clone();
assert!(calls.contains(&"_session/steering \"too late\"".to_owned()), "{calls:?}");
assert!(calls.contains(&"session/cancel".to_owned()), "{calls:?}");
let entries = mgr.entries(&task.id, None).unwrap();
assert!(entries.iter().any(|e| matches!(e, AgentEntry::User { text, steered: false, .. } if text == "too late")));
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
mgr.cancel(&task.id, None).unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
}
#[tokio::test(flavor = "multi_thread")]
async fn subagents_get_their_own_conversation() {
let tmp = tempfile::tempdir().unwrap();
@@ -1311,6 +1335,25 @@ async fn subagents_get_their_own_conversation() {
check(&manager(tmp.path(), Arc::new(FakeAgent::default())));
}
#[test]
fn image_blocks_declare_the_type_of_their_bytes() {
let image = |mime: &str, data: &str| AgentImage { mime_type: mime.into(), data: data.into(), name: None };
let cases = [
// A browser's JPEG pasted as PNG.
(image("image/png", "/9j/4AAQSkZJRgABAQ"), "image/jpeg"),
(image("image/jpeg", "iVBORw0KGgoAAAANSUhEUg"), "image/png"),
(image("image/png", "R0lGODlhAQABAIAAAP"), "image/gif"),
(image("image/png", "UklGRiQAAABXRUJQVlA4"), "image/webp"),
// Not recognised: as declared.
(image("image/bmp", "Qk02AAAAAAAAADYAAA"), "image/bmp"),
(image("image/png", "AAA"), "image/png"),
];
for (image, expected) in cases {
let p = AgentPrompt { text: String::new(), files: vec![], images: vec![image] };
assert_eq!(blocks(&p, &[])[0]["mimeType"], expected, "{:?}", p.images[0].data);
}
}
#[test]
fn prompts_become_acp_content_blocks() {
let p = AgentPrompt {
+81 -13
Переглянути файл
@@ -10,11 +10,14 @@ use std::process::Command as ProcCommand;
/// Output file of the `dependency:build-classpath` probe, relative to each module.
const CP_FILE: &str = "target/ide-compile-cp.txt";
// Older records include undeclared reactor test outputs even in runtime classpaths.
const CLASSPATH_CACHE_VERSION: u32 = 1;
/// The resolved dependency classpath for one module and scope, tied to the same
/// inputs as its launch build so POM, JDK, settings and profile changes invalidate it.
#[derive(Debug, Deserialize, Serialize)]
struct CachedClasspath {
version: u32,
fingerprint: LaunchFingerprint,
classpath: String,
}
@@ -132,6 +135,7 @@ pub fn module_classpath(
if let (Some(fingerprint), Some(path)) = (&fingerprint, &cache_path)
&& let Ok(bytes) = fs::read(path)
&& let Ok(cached) = serde_json::from_slice::<CachedClasspath>(&bytes)
&& cached.version == CLASSPATH_CACHE_VERSION
&& cached.fingerprint == *fingerprint
&& classpath_entries_exist(root, &cached.classpath)
{
@@ -142,7 +146,7 @@ pub fn module_classpath(
return Err(IdeError::cancelled());
}
if let (Some(fingerprint), Some(path)) = (fingerprint, cache_path) {
let cached = CachedClasspath { fingerprint, classpath: classpath.clone() };
let cached = CachedClasspath { version: CLASSPATH_CACHE_VERSION, fingerprint, classpath: classpath.clone() };
if let Err(error) = cache_classpath(&path, &cached) {
tracing::debug!(path = %path.display(), %error, "Cannot cache the Java launch classpath");
}
@@ -208,11 +212,11 @@ fn classpath(
if dir == target.module {
continue;
}
for classes in ["target/classes", "target/test-classes"] {
let path = dir.join(classes);
if path.is_dir() {
entries.push(path.to_string_lossy().into_owned());
}
// A dependency's tests are not exported with its main artifact. Any explicitly
// declared test artifact is supplied by Maven's resolved classpath below.
let path = dir.join("target/classes");
if path.is_dir() {
entries.push(path.to_string_lossy().into_owned());
}
}
}
@@ -337,13 +341,19 @@ mod tests {
root,
"pom.xml",
r#"<project><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version>
<packaging>pom</packaging><modules><module>lib</module><module>app</module></modules></project>"#,
<packaging>pom</packaging><modules><module>shared</module><module>lib</module><module>app</module></modules></project>"#,
);
write(
root,
"lib/pom.xml",
r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>
<artifactId>lib</artifactId></project>"#,
<artifactId>lib</artifactId><dependencies><dependency><groupId>demo</groupId><artifactId>shared</artifactId><version>1</version></dependency></dependencies></project>"#,
);
write(
root,
"shared/pom.xml",
r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>
<artifactId>shared</artifactId></project>"#,
);
write(
root,
@@ -354,6 +364,7 @@ mod tests {
write(root, "app/src/main/java/demo/Main.java", "class Main {}");
write(root, "app/src/test/java/demo/MainTest.java", "class MainTest {}");
write(root, "lib/target/classes/Lib.class", "built");
write(root, "shared/target/classes/Shared.class", "built");
crate::load(root, &root.join("cache"), None)
}
@@ -436,7 +447,9 @@ mod tests {
let target = single_file_target(root, &model, &file).unwrap();
assert!(target.top.command.ends_with("mvnw"));
assert_eq!(target.pl, "app");
fs::create_dir_all(root.join("lib/target/test-classes")).unwrap();
let cp = single_file_classpath(root, &model, &target).unwrap();
assert!(!std::env::split_paths(&cp).any(|p| p == root.join("lib/target/test-classes")), "{cp}");
let separator = ':';
// Reactor class directories first, so fresh outputs shadow installed snapshots.
let lib = root.join("lib/target/classes").to_string_lossy().into_owned();
@@ -451,9 +464,16 @@ mod tests {
assert!(cp.split(separator).count() >= 3, "{cp}");
let args = fs::read_to_string(root.join("args.txt")).unwrap();
assert!(!args.lines().any(|a| a == "compile" || a == "package"), "{args}");
fs::create_dir_all(root.join("app/target/test-classes")).unwrap();
let target = single_file_target(root, &model, &root.join("app/src/test/java/demo/MainTest.java")).unwrap();
let cp = single_file_classpath(root, &model, &target).unwrap();
let paths: Vec<_> = std::env::split_paths(&cp).collect();
assert_eq!(paths[0], root.join("app/target/test-classes"));
assert!(paths.contains(&root.join("app/target/classes")), "{cp}");
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{cp}");
}
/// A launch uses runtime dependencies, while tests additionally see test-scope ones.
/// Launches request Maven's matching scope without adding reactor test outputs.
#[cfg(unix)]
#[test]
fn launch_module_classpath_uses_the_matching_dependency_scope() {
@@ -465,15 +485,29 @@ mod tests {
let script = root.join("mvnw");
fs::write(
&script,
"#!/bin/sh\nprintf '%s\\n' \"$@\" > args.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/runtime.jar:/repo/test.jar' > \"$pl/target/ide-compile-cp.txt\"\n",
"#!/bin/sh\nprintf '%s\\n' \"$@\" > args.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/runtime.jar:/repo/fixture-tests.jar:/repo/fixture/target/test-classes' > \"$pl/target/ide-compile-cp.txt\"\n",
)
.unwrap();
fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
let model = crate::load(root, &root.join("cache"), None);
for dir in
["app/target/classes", "app/target/test-classes", "lib/target/test-classes", "shared/target/test-classes"]
{
fs::create_dir_all(root.join(dir)).unwrap();
}
let cache = root.join("cache");
let runtime =
module_classpath(root, &model, &root.join("app"), false, None, &cache, &CancellationToken::new()).unwrap();
let paths: Vec<_> = std::env::split_paths(&runtime).collect();
assert!(paths.contains(&root.join("app/target/classes")), "{runtime}");
assert!(paths.contains(&root.join("lib/target/classes")), "{runtime}");
assert!(!paths.contains(&root.join("app/target/test-classes")), "{runtime}");
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{runtime}");
assert!(paths.contains(&root.join("shared/target/classes")), "{runtime}");
assert!(!paths.contains(&root.join("shared/target/test-classes")), "{runtime}");
assert!(paths.contains(&PathBuf::from("/repo/fixture-tests.jar")), "{runtime}");
assert!(paths.contains(&PathBuf::from("/repo/fixture/target/test-classes")), "{runtime}");
assert!(runtime.contains("/repo/runtime.jar"), "{runtime}");
let args = fs::read_to_string(root.join("args.txt")).unwrap();
assert!(args.lines().any(|a| a == "compile"), "{args}");
@@ -482,7 +516,15 @@ mod tests {
let test =
module_classpath(root, &model, &root.join("app"), true, None, &cache, &CancellationToken::new()).unwrap();
assert!(test.contains("/repo/test.jar"), "{test}");
assert!(test.contains("/repo/fixture-tests.jar"), "{test}");
let paths: Vec<_> = std::env::split_paths(&test).collect();
assert!(paths.contains(&root.join("app/target/test-classes")), "{test}");
assert!(paths.contains(&root.join("app/target/classes")), "{test}");
assert!(paths.contains(&root.join("lib/target/classes")), "{test}");
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{test}");
assert!(paths.contains(&root.join("shared/target/classes")), "{test}");
assert!(!paths.contains(&root.join("shared/target/test-classes")), "{test}");
assert!(paths.contains(&PathBuf::from("/repo/fixture/target/test-classes")), "{test}");
let args = fs::read_to_string(root.join("args.txt")).unwrap();
assert!(args.lines().any(|a| a == "-Dmdep.includeScope=test"), "{args}");
}
@@ -491,7 +533,7 @@ mod tests {
/// build input changes; the probe does not run packaging plugins.
#[cfg(unix)]
#[test]
fn launch_classpath_cache_follows_the_runner_jdk() {
fn launch_classpath_cache_follows_the_runner_jdk_and_format() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().unwrap();
@@ -513,6 +555,7 @@ mod tests {
fs::write(home.join("release"), format!("JAVA_VERSION=\"{version}\"\n")).unwrap();
fs::write(home.join("bin/java"), "").unwrap();
}
fs::create_dir_all(root.join("app/target/classes")).unwrap();
let cache = root.join("classpath-cache");
let cancel = CancellationToken::new();
let jdk21 = root.join("jdk21");
@@ -526,6 +569,30 @@ mod tests {
assert_eq!(second, first);
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), "x");
let record = classpath_cache_path(root, &cache, &root.join("app"), false).unwrap();
let current: serde_json::Value = serde_json::from_slice(&fs::read(&record).unwrap()).unwrap();
let test_output = root.join("lib/target/test-classes");
fs::create_dir_all(&test_output).unwrap();
let polluted = std::env::join_paths(std::env::split_paths(&first).chain([test_output])).unwrap();
let mut calls = "x".to_owned();
for version in [None, Some(0), Some(u32::MAX)] {
let mut stale = current.clone();
stale["classpath"] = polluted.to_string_lossy().as_ref().into();
if let Some(version) = version {
stale["version"] = version.into();
} else {
stale.as_object_mut().unwrap().remove("version");
}
fs::write(&record, serde_json::to_vec(&stale).unwrap()).unwrap();
let rebuilt = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
assert_eq!(rebuilt, first, "incompatible cache format {version:?} must be rebuilt");
calls.push('x');
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
let reused = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
assert_eq!(reused, rebuilt);
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
}
let jdk8 = root.join("jdk8");
for project in &mut model.maven.as_mut().unwrap().projects {
project.env.insert("JAVA_HOME".into(), jdk8.to_string_lossy().into_owned());
@@ -533,6 +600,7 @@ mod tests {
let switched = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
assert!(switched.contains("jdk8/classpath/jdk.jar"), "{switched}");
assert!(!switched.contains("jdk21/classpath/jdk.jar"), "{switched}");
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), "xx");
calls.push('x');
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
}
}
+36
Переглянути файл
@@ -348,6 +348,35 @@ mod imp {
paths
}
/// `Preferred DropEffect`: a `DWORD` saying whether the files were copied or cut.
/// Explorer writes it with every file list, and paste targets that move files
/// between machines (Remote Desktop's clipboard redirection, #3863) read it.
fn drop_effect_format() -> u32 {
let name: Vec<u16> = "Preferred DropEffect\0".encode_utf16().collect();
unsafe { RegisterClipboardFormatW(name.as_ptr()) }
}
/// `DROPEFFECT_COPY`.
const DROPEFFECT_COPY: u32 = 1;
/// An `HGLOBAL` holding a copy of `bytes`. Null when the allocation failed.
fn global_bytes(bytes: &[u8]) -> Handle {
unsafe {
let memory = GlobalAlloc(GMEM_MOVEABLE, bytes.len());
if memory.is_null() {
return ptr::null_mut();
}
let data = GlobalLock(memory);
if data.is_null() {
GlobalFree(memory);
return ptr::null_mut();
}
ptr::copy_nonoverlapping(bytes.as_ptr(), data as *mut u8, bytes.len());
GlobalUnlock(memory);
memory
}
}
/// An `HGLOBAL` holding `text` as UTF-16 with a terminating NUL, and its
/// byte size. Null when the allocation failed.
fn global_text(text: &str) -> (Handle, usize) {
@@ -430,6 +459,13 @@ mod imp {
if !taken {
GlobalFree(memory);
}
let effect = drop_effect_format();
if effect != 0 {
let effect_memory = global_bytes(&DROPEFFECT_COPY.to_le_bytes());
if !effect_memory.is_null() && SetClipboardData(effect, effect_memory).is_null() {
GlobalFree(effect_memory);
}
}
let (text_memory, _) = global_text(&text);
if !text_memory.is_null() {
// The text alone still pastes somewhere useful.
+18
Переглянути файл
@@ -0,0 +1,18 @@
[package]
name = "ide-command"
description = "Declares OpenIDEA's backend commands once and derives their adapters, trust class and placement"
version.workspace = true
edition.workspace = true
license.workspace = true
[lib]
proc-macro = true
[dependencies]
heck.workspace = true
proc-macro2.workspace = true
quote.workspace = true
syn.workspace = true
[dev-dependencies]
serde.workspace = true
+92
Переглянути файл
@@ -0,0 +1,92 @@
// Stand-in for the parts of `ide-host` that the code generated by `#[command]`, `domain!` and
// `domains!` names; doctests `include!` it at their crate root.
pub type IdeResult<T> = Result<T, IdeError>;
#[derive(Debug)]
pub struct IdeError(pub String);
impl IdeError {
pub fn unavailable(m: impl Into<String>) -> Self {
Self(m.into())
}
}
pub struct Host;
impl Host {
pub fn plugin_host(&self) -> Option<std::sync::Arc<plugins::PluginHost>> {
None
}
}
pub mod plugins {
pub struct PluginHost;
}
pub mod catalogue {
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TrustClass {
Always,
OutsideRestricted,
Trusted,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Placement {
Desktop,
ProjectHost,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mode {
Sync,
Async,
Spawn,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Command {
pub name: &'static str,
pub trust: TrustClass,
pub placement: Placement,
pub bindings: bool,
pub mode: Mode,
}
}
pub mod ops {
pub struct Channel<T>(pub std::marker::PhantomData<T>);
pub type Emit<T> = std::sync::Arc<dyn Fn(T) + Send + Sync>;
}
pub mod rpc {
use crate::catalogue::TrustClass;
use crate::{IdeResult, ops::Channel};
pub struct Call {
pub host: std::sync::Arc<crate::Host>,
pub window: String,
}
impl Call {
pub fn arg<T: Default>(&self, _name: &str) -> IdeResult<T> {
Ok(T::default())
}
pub fn sender<T>(&self, _name: &str) -> IdeResult<Channel<T>> {
Ok(Channel(std::marker::PhantomData))
}
}
#[derive(Default)]
pub struct Dispatcher(pub Vec<(&'static str, TrustClass)>);
impl Dispatcher {
pub fn add<F, Fut, T>(&mut self, name: &'static str, trust: TrustClass, _f: F) -> &mut Self
where
F: Fn(Call) -> Fut + Send + Sync + 'static,
Fut: Future<Output = IdeResult<T>> + Send + 'static,
T: serde::Serialize,
{
self.0.push((name, trust));
self
}
}
}
+884
Переглянути файл
@@ -0,0 +1,884 @@
//! Declares OpenIDEA's backend commands once, on the fn that implements them.
//!
//! A command that runs on the project host is an `ide-host` fn with `#[command]`; its module
//! lists it in `domain!`, and `ide-host` lists its domains in `domains!`. From that `src-tauri`
//! derives the Tauri adapter and its bindings entry, and `ide-host` derives the JSON-RPC handler
//! `openidea-server` answers. A command only the desktop runs keeps its hand-written Tauri fn,
//! with `#[desktop_command]`, and its module lists it in `desktop_domain!`. Every command
//! declares its trust class, and each declaration yields a `COMMAND`
//! (`ide_host::catalogue::Command`): its name, trust class, placement, bindings entry and
//! execution mode.
//!
//! The examples below build against a stand-in for `ide-host` (`src/doctest_host.rs`). Every
//! `compile_fail` example differs from the example before it only by the mistake it names.
use heck::ToLowerCamelCase;
use proc_macro::TokenStream;
use proc_macro2::TokenStream as T2;
use quote::{ToTokens, format_ident, quote};
use syn::ext::IdentExt;
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::{FnArg, GenericArgument, Ident, ItemFn, Pat, PathArguments, ReturnType, Token, Type};
/// `#[command(trust = …)]` on a project-host command's implementation in `ide-host`.
///
/// The fn's name is the command's name and its `///` lines are the bindings' docs. Parameters
/// of type `&Host` or `&Arc<Host>`, `window: &str` and `plugins: &Arc<PluginHost>` are injected;
/// every other parameter is an argument, owned, whose key is its camelCase name, and
/// `Channel<T>` streams values back. `async fn` gives an async Tauri adapter, `fn` a sync one.
/// A result of type `IdeResult<T>` is returned as is; any other result is a success. A JSON-RPC
/// request that leaves out an argument marked `#[default]` gets the type's default, so servers
/// keep answering clients older than the argument.
///
/// Options:
/// - `trust = always | outside_restricted | trusted` (required): where the command may run;
/// `always` includes Restricted Mode, `outside_restricted` needs no project or a trusted
/// one, `trusted` needs a trusted project.
/// - `desktop_body = async | sync | spawn`: the Tauri adapter calls the hand-written fn of the
/// same name in `src-tauri` instead of this one, which stays the server's implementation.
/// `spawn` runs that sync body off the invoking thread.
///
/// ```
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// use crate::{Host, IdeResult, ops::Channel};
/// use ide_command::command;
///
/// /// Renames a branch.
/// #[command(trust = trusted)]
/// pub async fn vcs_rename_branch(
/// host: &Host,
/// window: &str,
/// from: String,
/// to: String,
/// unset_upstream: bool,
/// ) -> IdeResult<()> {
/// Ok(())
/// }
///
/// #[command(trust = always)]
/// pub fn vcs_watch(window: &str, #[default] depth: u32, on_event: Channel<u32>) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_rename_branch, vcs_watch);
/// }
///
/// ide_command::domains!(vcs: crate::vcs);
///
/// fn main() {
/// use catalogue::{Mode, Placement, TrustClass};
/// let mut d = rpc::Dispatcher::default();
/// register_domains(&mut d);
/// assert_eq!(d.0, [("vcs_rename_branch", TrustClass::Trusted), ("vcs_watch", TrustClass::Always)]);
/// let watch = vcs::__cmd_vcs_watch::COMMAND;
/// assert_eq!((watch.placement, watch.bindings, watch.mode), (Placement::ProjectHost, true, Mode::Sync));
/// }
/// ```
///
/// A command without a trust class:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A command its module doesn't list:
///
/// ```compile_fail,E0425
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// #[ide_command::command(trust = always)]
/// pub fn vcs_unwatch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// Two commands with one name, in different modules:
///
/// ```compile_fail,E0428
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
///
/// pub mod search {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(search: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A borrowed argument:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str, path: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A stream that isn't a `Channel<T>`:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// use crate::ops::Emit;
///
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str, on_event: Emit<u32>) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
#[proc_macro_attribute]
pub fn command(attr: TokenStream, item: TokenStream) -> TokenStream {
let opts = syn::parse_macro_input!(attr as Opts);
let f = syn::parse_macro_input!(item as ItemFn);
expand_command(opts, f).unwrap_or_else(|e| e.to_compile_error()).into()
}
fn expand_command(opts: Opts, mut f: ItemFn) -> syn::Result<T2> {
opts.only(&["trust", "desktop_body"])?;
let trust = opts.trust()?;
// `#[default]` is read here and not emitted.
let defaulted: Vec<bool> = f
.sig
.inputs
.iter_mut()
.map(|input| match input {
FnArg::Typed(pt) => {
let before = pt.attrs.len();
pt.attrs.retain(|a| !a.path().is_ident("default"));
pt.attrs.len() != before
}
FnArg::Receiver(_) => false,
})
.collect();
let name = &f.sig.ident;
if !f.sig.generics.params.is_empty() {
return Err(syn::Error::new_spanned(&f.sig.generics, "a command is not generic"));
}
let is_async = f.sig.asyncness.is_some();
let (run, body) = match opts.value("desktop_body") {
None if is_async => (format_ident!("async"), quote!(derived)),
None => (format_ident!("sync"), quote!(derived)),
Some(Some(m)) if ["async", "sync", "spawn"].contains(&m.to_string().as_str()) => (m, quote!(desktop)),
Some(v) => return Err(error(v.as_ref().unwrap_or(name), "`desktop_body = async | sync | spawn`")),
};
let mode = match run.to_string().as_str() {
"async" => quote!(Async),
"spawn" => quote!(Spawn),
_ => quote!(Sync),
};
let mut aliases = Vec::new(); // one type alias per argument, resolved in the fn's own scope
let mut args = Vec::new(); // the arguments, for the Tauri adapter's signature
let mut call = Vec::new(); // every parameter in declared order, for the Tauri adapter's call
let mut rpc_call = Vec::new(); // the same, for the JSON-RPC handler
let mut needs_plugins = false;
for (input, defaulted) in f.sig.inputs.iter().zip(defaulted) {
let FnArg::Typed(pt) = input else {
return Err(error(input, "a command is a free fn"));
};
let Pat::Ident(pi) = &*pt.pat else {
return Err(error(&pt.pat, "command parameters are plain identifiers"));
};
let ident = &pi.ident;
let plain_only = || error(ident, "`#[default]` marks a plain argument");
if defaulted && injected(ident, &pt.ty).is_some() {
return Err(plain_only());
}
match injected(ident, &pt.ty) {
Some(Injected::Host) => {
call.push(quote!((inj host)));
rpc_call.push(quote!(&c.host));
continue;
}
Some(Injected::Window) => {
call.push(quote!((inj window)));
rpc_call.push(quote!(&c.window));
continue;
}
Some(Injected::Plugins) => {
needs_plugins = true;
call.push(quote!((inj plugins)));
rpc_call.push(quote!(&plugins));
continue;
}
None => {}
}
if matches!(&*pt.ty, Type::Reference(_)) {
return Err(error(
&pt.ty,
"command arguments are owned; the injected references are `&Host`, `window: &str` and `plugins: &Arc<PluginHost>`",
));
}
let seg = last_segment(&pt.ty);
if seg.is_some_and(|s| s.ident == "Emit") {
return Err(error(&pt.ty, "a command streams through `Channel<T>`, not `Emit<T>`"));
}
let key = ident.unraw().to_string().to_lower_camel_case();
let alias = format_ident!("A{}", args.len());
if let Some(inner) = seg.filter(|s| s.ident == "Channel").and_then(type_argument) {
if defaulted {
return Err(plain_only());
}
aliases.push(quote!(pub type #alias = #inner;));
args.push(quote!((#ident channel #alias)));
call.push(quote!((arg channel #ident)));
rpc_call.push(quote!(c.sender(#key)?));
} else {
let ty = &pt.ty;
aliases.push(quote!(pub type #alias = #ty;));
args.push(quote!((#ident plain #alias)));
call.push(quote!((arg plain #ident)));
rpc_call.push(if defaulted {
quote!(c.arg::<::core::option::Option<#ty>>(#key)?.unwrap_or_default())
} else {
quote!(c.arg(#key)?)
});
}
}
let ret: Type = match &f.sig.output {
ReturnType::Default => syn::parse_quote!(()),
ReturnType::Type(_, t) => (**t).clone(),
};
let fallible = last_segment(&ret).is_some_and(|s| s.ident == "IdeResult");
// specta exports `fn f()` as `void` and `fn f() -> ()` as `null`: keep which one was written.
let ret_alias = match &f.sig.output {
ReturnType::Default => quote!(),
ReturnType::Type(..) => quote!(Ret),
};
let shape = if fallible { quote!(fallible [#ret_alias]) } else { quote!(infallible [#ret_alias]) };
let await_ = is_async.then(|| quote!(.await));
let invoke = quote!(super::#name(#(#rpc_call),*) #await_);
let invoke = if fallible { invoke } else { quote!(Ok(#invoke)) };
let plugins = needs_plugins.then(|| {
quote! {
let plugins = c.host.plugin_host()
.ok_or_else(|| crate::IdeError::unavailable("the plugin host has shut down"))?;
}
});
let docs: Vec<_> = f.attrs.iter().filter(|a| a.path().is_ident("doc")).collect();
let module = format_ident!("__cmd_{}", name);
let tokens = format_ident!("__catalogue_{}", name);
let name_str = name.unraw().to_string();
Ok(quote! {
#f
// Resolves only if this module's `domain!` lists the command.
const _: () = self::__listed::#name;
#[doc(hidden)]
#[allow(non_snake_case)]
pub mod #module {
#[allow(unused_imports)]
use super::*;
#(#aliases)*
pub type Ret = #ret;
pub const COMMAND: crate::catalogue::Command = crate::catalogue::Command {
name: #name_str,
trust: crate::catalogue::TrustClass::#trust,
placement: crate::catalogue::Placement::ProjectHost,
bindings: true,
mode: crate::catalogue::Mode::#mode,
};
/// The JSON-RPC handler.
pub async fn rpc(c: crate::rpc::Call) -> crate::IdeResult<impl ::serde::Serialize + use<>> {
#plugins
#invoke
}
}
/// The command's signature, handed to `$cb!` for `src-tauri` to derive its Tauri adapter.
#[doc(hidden)]
#[macro_export]
macro_rules! #tokens {
([$($cb:tt)*] { $($ctx:tt)* }) => {
$($cb)*! { { $($ctx)* } {
name: #name,
module: #module,
docs: [ #(#docs)* ],
run: #run,
result: #shape,
body: #body,
args: [ #(#args)* ],
call: [ #(#call)* ],
} }
};
}
})
}
/// `domain!(vcs: vcs_status, vcs_rename_branch, …)`: the commands one `ide-host` module
/// declares with `#[command]`, in any order. It goes once at the end of that module and gives it
/// the server's `register`; `domains!` names the domain.
///
/// ```
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A listed name that isn't a command:
///
/// ```compile_fail,E0433
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch, vcs_unwatch);
/// }
/// # fn main() {}
/// ```
#[proc_macro]
pub fn domain(input: TokenStream) -> TokenStream {
let Domain { name, commands } = syn::parse_macro_input!(input as Domain);
let modules: Vec<_> = commands.iter().map(|c| format_ident!("__cmd_{}", c)).collect();
let tokens: Vec<_> = commands.iter().map(|c| format_ident!("__catalogue_{}", c)).collect();
let list = format_ident!("__domain_{}", name);
let names = commands.iter();
let listed = commands.iter();
let d = quote!($);
quote! {
#[doc(hidden)]
#[allow(non_upper_case_globals)]
mod __listed {
#( pub(super) const #listed: () = (); )*
}
// Resolves only from the `domains!` entry that names this domain.
#[doc(hidden)]
#[allow(non_upper_case_globals)]
pub(crate) const #list: () = ();
/// Adds this module's commands to the server.
pub(crate) fn register(d: &mut crate::rpc::Dispatcher) {
#( d.add(#modules::COMMAND.name, #modules::COMMAND.trust, #modules::rpc); )*
}
/// `@each`: each command's signature, in list order. `@names`: the list.
#[doc(hidden)]
#[macro_export]
macro_rules! #list {
(@each [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#( #d crate::#tokens!{ [#d (#d cb)*] { #d (#d ctx)* } } )*
};
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#d (#d cb)*! { { #d (#d ctx)* } [ #(#names)* ] }
};
}
}
.into()
}
/// `domains!(vcs: crate::ops::vcs::commands, …)`, once in `ide-host`: every domain, by the name
/// its `domain!` gives it and the crate path of its module. It gives the server
/// `register_domains`, and hands `src-tauri` the list of domains through `__domains!`.
///
/// ```
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
///
/// ide_command::domains!(vcs: crate::vcs);
/// # fn main() {}
/// ```
///
/// A domain under another name than its `domain!` gives it:
///
/// ```compile_fail,E0425
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
///
/// ide_command::domains!(git: crate::vcs);
/// # fn main() {}
/// ```
#[proc_macro]
pub fn domains(input: TokenStream) -> TokenStream {
let entries = syn::parse_macro_input!(input with Punctuated::<DomainPath, Token![,]>::parse_terminated);
let mut names = Vec::new();
let mut paths = Vec::new();
let mut from_crate = Vec::new();
for DomainPath { name, path } in entries {
let mut segments = path.segments.iter();
if path.leading_colon.is_some() || segments.next().is_none_or(|s| s.ident != "crate") {
return error(&path, "a domain's path starts with `crate::`").to_compile_error().into();
}
let rest: Vec<_> = segments.map(|s| &s.ident).collect();
from_crate.push(quote!(#(#rest)::*));
names.push(name);
paths.push(path);
}
let lists: Vec<_> = names.iter().map(|n| format_ident!("__domain_{}", n)).collect();
let d = quote!($);
quote! {
#( const _: () = #paths::#lists; )*
/// Adds every domain's commands to the server.
pub(crate) fn register_domains(d: &mut crate::rpc::Dispatcher) {
#( #paths::register(d); )*
}
/// `@names`: each domain as `(name __domain_name { path })`.
#[doc(hidden)]
#[macro_export]
macro_rules! __domains {
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#d (#d cb)*! { { #d (#d ctx)* } [ #( (#names #lists { #d crate::#from_crate }) )* ] }
};
}
}
.into()
}
/// `#[desktop_command(trust = …)]` on a command only the desktop runs, above its
/// `#[tauri::command]` in `src-tauri`, whose `(async)` it reads. The fn is left as written.
///
/// Options: `trust` as for `#[command]` (required), and `bindings = none` for a command that is
/// registered outside tauri-specta; such a command isn't listed in `desktop_domain!`.
///
/// ```
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// ide_command::desktop_domain!(clipboard_text);
/// }
///
/// fn main() {
/// let text = clipboard::clipboard_text::COMMAND;
/// assert_eq!((text.name, text.placement), ("clipboard_text", catalogue::Placement::Desktop));
/// }
/// ```
///
/// A command without a trust class:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// pub mod clipboard {
/// #[ide_command::desktop_command]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// ide_command::desktop_domain!(clipboard_text);
/// }
/// # fn main() {}
/// ```
///
/// A command its module doesn't list:
///
/// ```compile_fail,E0425
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_html() -> Option<String> {
/// None
/// }
///
/// ide_command::desktop_domain!(clipboard_text);
/// }
/// # fn main() {}
/// ```
#[proc_macro_attribute]
pub fn desktop_command(attr: TokenStream, item: TokenStream) -> TokenStream {
let opts = syn::parse_macro_input!(attr as Opts);
let f = syn::parse_macro_input!(item as ItemFn);
expand_desktop_command(opts, f).unwrap_or_else(|e| e.to_compile_error()).into()
}
fn expand_desktop_command(opts: Opts, f: ItemFn) -> syn::Result<T2> {
opts.only(&["trust", "bindings"])?;
let trust = opts.trust()?;
let bindings = match opts.value("bindings") {
None => true,
Some(Some(v)) if v == "none" => false,
Some(v) => return Err(error(v.as_ref().unwrap_or(&f.sig.ident), "`bindings = none`")),
};
// `#[tauri::command(async)]` runs a sync fn off the invoking thread.
let spawned = f.attrs.iter().any(|a| {
let path = a.path();
path.segments.len() == 2
&& path.segments[0].ident == "tauri"
&& path.segments[1].ident == "command"
&& a.parse_args::<Ident>().is_ok_and(|i| i == "async")
});
let mode = if f.sig.asyncness.is_some() {
quote!(Async)
} else if spawned {
quote!(Spawn)
} else {
quote!(Sync)
};
let name = &f.sig.ident;
let name_str = name.unraw().to_string();
let listed = bindings.then(|| quote!(const _: () = self::__listed::#name;));
Ok(quote! {
#f
#listed
#[doc(hidden)]
pub mod #name {
pub const COMMAND: ::ide_host::catalogue::Command = ::ide_host::catalogue::Command {
name: #name_str,
trust: ::ide_host::catalogue::TrustClass::#trust,
placement: ::ide_host::catalogue::Placement::Desktop,
bindings: #bindings,
mode: ::ide_host::catalogue::Mode::#mode,
};
}
})
}
/// `desktop_domain!(clipboard_text, clipboard_write_text, …)`: the `#[desktop_command]`s of one
/// `src-tauri` module that are in the bindings, in any order. It goes once at the end of that
/// module and gives it `__desktop_domain!(@names …)`.
#[proc_macro]
pub fn desktop_domain(input: TokenStream) -> TokenStream {
let commands = syn::parse_macro_input!(input with Punctuated::<Ident, Token![,]>::parse_terminated);
let names = commands.iter();
let listed = commands.iter();
let d = quote!($);
quote! {
#[doc(hidden)]
#[allow(non_upper_case_globals)]
mod __listed {
#( pub(super) const #listed: () = (); )*
}
#[doc(hidden)]
macro_rules! __desktop_domain {
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#d (#d cb)*! { { #d (#d ctx)* } [ #(#names)* ] }
};
}
#[allow(unused_imports)]
pub(crate) use __desktop_domain;
}
.into()
}
/// `sorted_catalogue!(bindings: a::x, b::y, …; raw: c::z, …)`, in `src-tauri`: every command,
/// sorted by name, as `(collect_commands![…bindings…], [COMMAND, …every command…])`. Each path
/// names a command fn and the module of the same name that holds its `COMMAND`.
///
/// ```
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// # extern crate self as tauri_specta;
/// # #[macro_export]
/// # macro_rules! collect_commands { ($($p:path),*) => { [$(stringify!($p)),*] } }
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// #[ide_command::desktop_command(trust = always)]
/// pub fn clipboard_clear() {}
///
/// ide_command::desktop_domain!(clipboard_text, clipboard_clear);
/// }
///
/// fn main() {
/// let (commands, rows) = ide_command::sorted_catalogue!(
/// bindings: clipboard::clipboard_text, clipboard::clipboard_clear;
/// raw:
/// );
/// assert_eq!(commands, ["clipboard :: clipboard_clear", "clipboard :: clipboard_text"]);
/// assert_eq!(rows.map(|c| c.name), ["clipboard_clear", "clipboard_text"]);
/// }
/// ```
///
/// Two commands with one name:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// # extern crate self as tauri_specta;
/// # #[macro_export]
/// # macro_rules! collect_commands { ($($p:path),*) => { [$(stringify!($p)),*] } }
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// #[ide_command::desktop_command(trust = always)]
/// pub fn clipboard_clear() {}
///
/// ide_command::desktop_domain!(clipboard_text, clipboard_clear);
/// }
///
/// pub mod editor {
/// #[ide_command::desktop_command(trust = always)]
/// pub fn clipboard_clear() {}
///
/// ide_command::desktop_domain!(clipboard_clear);
/// }
///
/// fn main() {
/// let (commands, rows) = ide_command::sorted_catalogue!(
/// bindings: clipboard::clipboard_text, clipboard::clipboard_clear, editor::clipboard_clear;
/// raw:
/// );
/// }
/// ```
#[proc_macro]
pub fn sorted_catalogue(input: TokenStream) -> TokenStream {
let Catalogue { bindings, raw } = syn::parse_macro_input!(input as Catalogue);
let key = |p: &syn::Path| p.segments.last().map(|s| s.ident.unraw().to_string()).unwrap_or_default();
let mut bindings: Vec<_> = bindings.into_iter().collect();
bindings.sort_by_cached_key(key);
let mut all: Vec<_> = bindings.iter().chain(&raw).collect();
all.sort_by_cached_key(|p| key(p));
for pair in all.windows(2) {
if key(pair[0]) == key(pair[1]) {
let (a, b) = (pair[0], pair[1]);
let message = format!(
"command `{}` is declared twice: `{}` and `{}`",
key(b),
a.to_token_stream(),
b.to_token_stream()
);
return syn::Error::new_spanned(b, message).to_compile_error().into();
}
}
quote! {
(
::tauri_specta::collect_commands![ #(#bindings),* ],
[ #( #all::COMMAND ),* ],
)
}
.into()
}
struct Catalogue {
bindings: Punctuated<syn::Path, Token![,]>,
raw: Punctuated<syn::Path, Token![,]>,
}
impl Parse for Catalogue {
fn parse(input: ParseStream) -> syn::Result<Self> {
let paths = |input: ParseStream, label: &str| -> syn::Result<Punctuated<syn::Path, Token![,]>> {
let ident: Ident = input.parse()?;
if ident != label {
return Err(error(&ident, &format!("expected `{label}:`")));
}
input.parse::<Token![:]>()?;
let mut out = Punctuated::new();
while !input.is_empty() && !input.peek(Token![;]) {
out.push_value(input.parse()?);
if !input.peek(Token![,]) {
break;
}
out.push_punct(input.parse()?);
}
Ok(out)
};
let bindings = paths(input, "bindings")?;
input.parse::<Token![;]>()?;
let raw = paths(input, "raw")?;
let _ = input.parse::<Option<Token![;]>>()?;
Ok(Self { bindings, raw })
}
}
enum Injected {
Host,
Window,
Plugins,
}
/// `&Host` or `&Arc<Host>` under any name, `window: &str`, `plugins: &Arc<PluginHost>`.
fn injected(ident: &Ident, ty: &Type) -> Option<Injected> {
let Type::Reference(r) = ty else { return None };
if r.mutability.is_some() {
return None;
}
let seg = last_segment(&r.elem)?;
let arc_of =
|name: &str| seg.ident == "Arc" && type_argument(seg).and_then(last_segment).is_some_and(|s| s.ident == name);
if seg.ident == "Host" || arc_of("Host") {
Some(Injected::Host)
} else if ident == "window" && seg.ident == "str" {
Some(Injected::Window)
} else if ident == "plugins" && arc_of("PluginHost") {
Some(Injected::Plugins)
} else {
None
}
}
fn last_segment(ty: &Type) -> Option<&syn::PathSegment> {
match ty {
Type::Path(p) if p.qself.is_none() => p.path.segments.last(),
_ => None,
}
}
fn type_argument(seg: &syn::PathSegment) -> Option<&Type> {
match &seg.arguments {
PathArguments::AngleBracketed(a) => a.args.iter().find_map(|g| match g {
GenericArgument::Type(t) => Some(t),
_ => None,
}),
_ => None,
}
}
fn error(span: impl ToTokens, message: &str) -> syn::Error {
syn::Error::new_spanned(span, message)
}
/// `name: a, b, …`
struct Domain {
name: Ident,
commands: Punctuated<Ident, Token![,]>,
}
impl Parse for Domain {
fn parse(input: ParseStream) -> syn::Result<Self> {
let name = input.parse()?;
input.parse::<Token![:]>()?;
Ok(Self { name, commands: Punctuated::parse_terminated(input)? })
}
}
/// `name: crate::path`
struct DomainPath {
name: Ident,
path: syn::Path,
}
impl Parse for DomainPath {
fn parse(input: ParseStream) -> syn::Result<Self> {
let name = input.parse()?;
input.parse::<Token![:]>()?;
Ok(Self { name, path: input.parse()? })
}
}
/// An attribute's options: `key = value` and bare `key`.
struct Opts(Vec<(Ident, Option<Ident>)>);
impl Parse for Opts {
fn parse(input: ParseStream) -> syn::Result<Self> {
let mut out = Vec::new();
while !input.is_empty() {
let key: Ident = input.parse()?;
let value = if input.peek(Token![=]) {
input.parse::<Token![=]>()?;
// `async` is a keyword.
Some(Ident::parse_any(input)?)
} else {
None
};
out.push((key, value));
if !input.is_empty() {
input.parse::<Token![,]>()?;
}
}
Ok(Self(out))
}
}
impl Opts {
fn value(&self, key: &str) -> Option<Option<Ident>> {
self.0.iter().find(|(k, _)| k == key).map(|(_, v)| v.clone())
}
fn only(&self, known: &[&str]) -> syn::Result<()> {
match self.0.iter().map(|(k, _)| k).find(|k| !known.iter().any(|n| *k == n)) {
Some(k) => Err(error(k, &format!("unknown option; the options are {}", known.join(", ")))),
None => Ok(()),
}
}
fn trust(&self) -> syn::Result<T2> {
match self.value("trust").flatten().map(|t| t.to_string()).as_deref() {
Some("always") => Ok(quote!(Always)),
Some("outside_restricted") => Ok(quote!(OutsideRestricted)),
Some("trusted") => Ok(quote!(Trusted)),
_ => Err(syn::Error::new(
proc_macro2::Span::call_site(),
"every command declares its trust class: `trust = always | outside_restricted | trusted`",
)),
}
}
}
+13
Переглянути файл
@@ -147,6 +147,19 @@ pub enum IdeEvent {
server: ServerId,
kind: LspRefreshKind,
},
/// A language server asked the user to choose an action, e.g. Dart's
/// "Renamed field will be invisible in …" warning during a rename. Answered
/// with `lsp_message_request_answer`; the server cancels if we reply null.
LspMessageRequest {
id: u32,
server: String,
message: String,
actions: Vec<String>,
},
/// The request was answered or timed out; every window drops its dialog.
LspMessageRequestDone {
id: u32,
},
TerminalExited {
terminal: TerminalId,
code: Option<i32>,
+33 -1
Переглянути файл
@@ -24,6 +24,16 @@ pub enum DockerEndpoint {
Tcp { host: String, tls_cert_dir: Option<String> },
/// A named `docker context`.
Context { name: String },
/// A daemon on the host of an SSH configuration (Settings › Tools › SSH Configurations),
/// reached with the IDE's own SSH client and its saved credentials. The host resolves it to
/// a local [`DockerEndpoint::Tcp`] tunnel before running docker; unresolved, the CLI is
/// pointed at an address it rejects rather than at another daemon.
Ssh { config: String },
}
/// What an unresolved [`DockerEndpoint::Ssh`] gives the CLI: an error, never a fallback daemon.
fn unresolved_ssh(config: &str) -> String {
format!("ssh-configuration://{}", config.trim())
}
impl DockerEndpoint {
@@ -55,6 +65,7 @@ impl DockerEndpoint {
args
}
Self::Context { name } => vec!["--context".into(), name.trim().to_owned()],
Self::Ssh { config } => vec!["--host".into(), unresolved_ssh(config)],
}
}
@@ -101,6 +112,11 @@ impl DockerEndpoint {
set("DOCKER_HOST", String::new());
set("DOCKER_TLS_VERIFY", String::new());
}
Self::Ssh { config } => {
set("DOCKER_HOST", unresolved_ssh(config));
set("DOCKER_CONTEXT", String::new());
set("DOCKER_TLS_VERIFY", String::new());
}
}
env
}
@@ -111,8 +127,13 @@ impl DockerEndpoint {
Self::Socket { path } => path.trim().is_empty(),
Self::Tcp { host, .. } => host.trim().is_empty(),
Self::Context { name } => name.trim().is_empty() || name.trim().starts_with('-'),
Self::Ssh { config } => config.trim().is_empty(),
};
if empty { Err(IdeError::invalid("the Docker connection needs a socket, host or context")) } else { Ok(()) }
if empty {
Err(IdeError::invalid("the Docker connection needs a socket, host, context or SSH configuration"))
} else {
Ok(())
}
}
}
@@ -325,6 +346,17 @@ fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
mod tests {
use super::*;
#[test]
fn an_unresolved_ssh_endpoint_never_falls_back_to_another_daemon() {
let ssh = DockerEndpoint::Ssh { config: "box".into() };
assert_eq!(ssh.global_args(), ["--host", "ssh-configuration://box"]);
let env = ssh.env_vars();
assert_eq!((env["DOCKER_HOST"].as_str(), env["DOCKER_CONTEXT"].as_str()), ("ssh-configuration://box", ""));
assert!(ssh.validate().is_ok());
assert!(DockerEndpoint::Ssh { config: " ".into() }.validate().is_err());
assert!(!crate::endpoint_is_local(&ssh).unwrap());
}
#[test]
fn endpoint_args() {
assert!(DockerEndpoint::Default.global_args().is_empty());
+1
Переглянути файл
@@ -483,6 +483,7 @@ pub fn endpoint_is_local(ep: &DockerEndpoint) -> IdeResult<bool> {
|name| context_host(&DockerEndpoint::Default, name),
)?,
DockerEndpoint::Context { name } => context_host(&DockerEndpoint::Default, Some(name.trim()))?,
DockerEndpoint::Ssh { .. } => return Ok(false),
};
Ok(daemon_url_is_local(&url))
}
+1
Переглянути файл
@@ -11,6 +11,7 @@ path = "src/bin/server.rs"
[dependencies]
encoding_rs.workspace = true
ide-command.workspace = true
ide-core.workspace = true
ide-mcp.workspace = true
futures.workspace = true
+2 -1
Переглянути файл
@@ -1,6 +1,7 @@
//! `openidea-server --stdio`: the IDE backend for remote development, serving
//! one desktop client over stdin / stdout (started by the client over SSH).
use ide_host::catalogue::TrustClass;
use ide_host::plugins::remote::{RemotePluginLanguages, SYNC_COMMAND};
use ide_host::plugins::remote_host::RemotePlugins;
use ide_host::rpc::{self, Dispatcher};
@@ -102,7 +103,7 @@ async fn run(base: PathBuf) -> i32 {
if let Some(plugins) = &plugins {
plugins.register(&mut dispatcher);
}
dispatcher.add(SYNC_COMMAND, move |c| {
dispatcher.add(SYNC_COMMAND, TrustClass::Trusted, move |c| {
let remote = plugin_languages.clone();
async move {
let report = remote.sync(c.arg("languages")?);
+40
Переглянути файл
@@ -0,0 +1,40 @@
//! What every command declares: its trust class, where it runs, and how Tauri runs it.
//! `#[ide_command::command]` and `#[ide_command::desktop_command]` give each command a
//! [`Command`].
/// Where a command may run, from the trust decision of the window's project.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TrustClass {
/// Everywhere, including Restricted Mode.
Always,
/// With no project open, or in a trusted project.
OutsideRestricted,
/// Only in a trusted project.
Trusted,
}
/// Which backend runs a command for a remote window.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Placement {
Desktop,
ProjectHost,
}
/// How Tauri runs the command: on the invoking thread, as a future, or on its thread pool.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Mode {
Sync,
Async,
Spawn,
}
/// One command's declaration.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Command {
pub name: &'static str,
pub trust: TrustClass,
pub placement: Placement,
/// In `bindings.ts`; a command registered outside tauri-specta isn't.
pub bindings: bool,
pub mode: Mode,
}
+11 -1
Переглянути файл
@@ -4,6 +4,7 @@
//! runs one on a remote machine and serves it over JSON-RPC ([`rpc`]).
pub mod agent_secrets;
pub mod catalogue;
pub mod data_dirs;
pub mod diagnostics_store;
pub mod environment;
@@ -23,7 +24,7 @@ pub mod rpc;
pub mod shell_env;
pub mod trust;
pub use project::{Project, apply_git_executable, apply_workspace_edit, history_retention};
pub use project::{Project, apply_git_executable, history_retention};
use ide_core::{CancellationToken, IdeError, IdeResult, RequestId, SharedSink};
use ide_language::{LanguageRegistry, Syntax};
@@ -91,6 +92,8 @@ pub struct Host {
pub ssh: Arc<ide_ssh::SshManager>,
/// SFTP deployment, remote file editing and runs on run targets.
pub remote: Arc<ide_remote::RemoteService>,
/// Tunnels of Docker connections made through an SSH configuration.
pub docker_tunnels: ops::docker::DockerTunnels,
/// What child processes get beyond this process's environment (Reload Environment, `remoteEnv`).
pub environment: environment::Environment,
/// The built-in web server (Open In › Browser, the editor's browser bar). On a remote host the
@@ -161,6 +164,7 @@ impl Host {
agent_secrets: Arc::new(agent_secrets::AgentSecrets::new(&data_dir)),
remote: Arc::new(ide_remote::RemoteService::new(ssh.clone(), data_dir.join("remote"))),
ssh,
docker_tunnels: Default::default(),
environment: environment::Environment::new(project_environment, local_data_dir.clone()),
web: ide_web::WebServer::new(),
global_settings,
@@ -191,6 +195,12 @@ impl Host {
};
host.apply_proxy();
host.apply_added_jdks();
// Before any project starts jdtls; the deleting itself can take a while.
let unused =
ide_sdk::jdtls_workspaces::take_unused(&host.local_data_dir, ide_sdk::jdtls_workspaces::UNUSED_FOR);
if !unused.is_empty() {
std::thread::spawn(move || ide_sdk::jdtls_workspaces::remove(unused));
}
ops::agent::move_user_mcp_values(&host);
host
}
+3 -3
Переглянути файл
@@ -873,15 +873,15 @@ async fn occurrences(
let host = call.host();
let request = crate::mcp::tool::request_id();
let files = Arc::new(Mutex::new(Vec::new()));
let emit: crate::ops::Emit<SearchEvent> = {
let emit = {
let files = files.clone();
Arc::new(move |event| {
crate::ops::Channel::new(move |event: SearchEvent| {
if let SearchEvent::File { file } = event {
files.lock().push(file);
}
})
};
let search = crate::ops::search::start(&host, call.window(), request, query, emit);
let search = crate::ops::search::search_start(&host, call.window(), request, query, emit);
tokio::pin!(search);
tokio::select! {
r = &mut search => r?,
+1 -1
Переглянути файл
@@ -57,7 +57,7 @@ The maximum accepted limit is 5000 lines.",
probe.size
)));
}
let text = crate::ops::fs::read_text(&call.host(), call.window(), path).await?;
let text = crate::ops::fs::fs_read_text(&call.host(), call.window(), path).await?;
Ok(Output::text(render_slice(&text, offset as usize, limit as usize, window)?))
},
)
+2 -2
Переглянути файл
@@ -37,7 +37,7 @@ Returns each request's 0-based `index`, optional `name`, `method`, URL as writte
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 text = crate::ops::fs::fs_read_text(&call.host(), call.window(), path).await?;
let requests: Vec<_> = ide_http::parse::requests(&text)
.into_iter()
.map(|b| {
@@ -139,7 +139,7 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
}
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 text = crate::ops::fs::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)))?;
+4 -2
Переглянути файл
@@ -9,7 +9,7 @@ pub use requests::Requests;
mod files;
mod http;
mod page;
mod reports;
pub mod reports;
mod scope;
mod search;
mod symbols;
@@ -19,7 +19,9 @@ mod util;
use crate::Host;
use ide_core::{CancellationToken, IdeError};
use ide_mcp::{ToolCallError, ToolRegistry};
pub use reports::{FileProblems, FocusedEditor, Reports};
pub use reports::{
FileProblems, FocusedEditor, Reports, mcp_report_problems, mcp_set_focused_editor, mcp_set_open_editors,
};
pub use run::agent::{AGENT_PARAM, AgentRun, AgentRuns, NAME_PREFIX, SHELL_PARAM};
use std::path::{Path, PathBuf};
use std::sync::Arc;
+39
Переглянути файл
@@ -1,4 +1,5 @@
//! Window-owned snapshots. A project close drops every report from that window.
use ide_command::command;
use ide_core::{Diagnostic, IpcPath, Range};
use parking_lot::RwLock;
use serde::{Deserialize, Serialize};
@@ -134,6 +135,37 @@ impl Reports {
}
}
#[command(trust = trusted)]
pub fn mcp_set_open_editors(host: &crate::Host, window: &str, paths: Vec<IpcPath>) -> ide_core::IdeResult<()> {
host.project(window)?;
host.mcp_reports.set_open_editors(window, paths.into_iter().map(PathBuf::from).collect());
Ok(())
}
#[command(trust = trusted)]
pub fn mcp_set_focused_editor(
host: &crate::Host,
window: &str,
editor: Option<FocusedEditor>,
focused: bool,
) -> ide_core::IdeResult<()> {
host.project(window)?;
host.mcp_reports.set_focused_editor(window, editor, focused);
Ok(())
}
#[command(trust = trusted)]
pub fn mcp_report_problems(
host: &crate::Host,
window: &str,
reset: bool,
files: Vec<FileProblems>,
) -> ide_core::IdeResult<()> {
host.project(window)?;
host.mcp_reports.report_problems(window, reset, files);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
@@ -154,3 +186,10 @@ mod tests {
assert_eq!(windows, ["a", "b", "never", "c"]);
}
}
ide_command::domain!(
mcp_reports:
mcp_report_problems,
mcp_set_focused_editor,
mcp_set_open_editors,
);
+4 -4
Переглянути файл
@@ -418,10 +418,10 @@ input). Terminal keys (arrows, Escape, Backspace, Ctrl+Z…) are refused. To ans
host.processes.write_stdin(id, &std::mem::take(&mut data))?;
}
if key == Key::EndOfInput {
crate::ops::run::close_stdin(&host, id)?;
crate::ops::run::run_close_stdin(&host, id)?;
} else {
run.agent_stopping();
crate::ops::run::stop(&host, &run.window(), id)?;
crate::ops::run::run_stop(&host, &run.window(), id)?;
break;
}
}
@@ -455,10 +455,10 @@ keeps `stopping`: call again with `force`. The tab stays open with its output."
let deadline = deadline(&call, STOP_TIMEOUT_MS)?;
let host = call.host();
run.agent_stopping();
crate::ops::run::stop(&host, &run.window(), id)?;
crate::ops::run::run_stop(&host, &run.window(), id)?;
if force {
// A second Stop kills the tree.
crate::ops::run::stop(&host, &run.window(), id)?;
crate::ops::run::run_stop(&host, &run.window(), id)?;
}
let end = run.wait(deadline, None, run.log_len(), &call.cancel).await?;
let mut extra = Map::new();
+6 -6
Переглянути файл
@@ -283,7 +283,7 @@ fn run_exit(host: &crate::Host, id: RunId) -> Option<Option<i32>> {
match host.processes.exit_code(id) {
Ok(exit) => exit,
// Remote (SSH) runs, or a finished run already forgotten: the run list knows whether it runs.
Err(_) => match crate::ops::run::list(host).into_iter().find(|r| r.id == id) {
Err(_) => match crate::ops::run::run_list(host).into_iter().find(|r| r.id == id) {
Some(r) if r.running => None,
_ => Some(None),
},
@@ -304,7 +304,7 @@ async fn wait_exit(call: &Call, id: RunId, deadline: Option<Instant>) -> IdeResu
tokio::select! {
_ = tokio::time::sleep(Duration::from_millis(50)) => {}
_ = call.cancel.cancelled() => {
let _ = crate::ops::run::stop(&host, call.window(), id);
let _ = crate::ops::run::run_stop(&host, call.window(), id);
return Err(IdeError::cancelled());
}
}
@@ -313,9 +313,9 @@ async fn wait_exit(call: &Call, id: RunId, deadline: Option<Instant>) -> IdeResu
/// An output callback that skips the IDE's own lines (`Process finished…`), as JetBrains
/// skips `ProcessOutputType.SYSTEM`.
fn process_output(mut f: impl FnMut(&str) + Send + 'static) -> crate::ops::Emit<OutputChunk> {
fn process_output(mut f: impl FnMut(&str) + Send + 'static) -> crate::ops::Channel<OutputChunk> {
let f = Mutex::new(move |t: &str| f(t));
Arc::new(move |chunk: OutputChunk| match &chunk {
crate::ops::Channel::new(move |chunk: OutputChunk| match &chunk {
OutputChunk::Stdout { text } | OutputChunk::Stderr { text } => (f.lock())(text),
OutputChunk::System { .. } => {}
})
@@ -356,7 +356,7 @@ async fn run_to_end(call: &Call, config: RunConfig, errors: &mut BuildErrors) ->
t.drain(..cut);
}
});
let info = crate::ops::run::start(&call.host(), call.window(), config, emit).await?;
let info = crate::ops::run::run_start(&call.host(), call.window(), config, emit, None).await?;
let exit = wait_exit(call, info.id, None).await?.flatten();
if exit == Some(0) {
return Ok(true);
@@ -612,7 +612,7 @@ one by one",
let output_path = collector.lock().path.clone();
let sink = collector.clone();
let emit = process_output(move |text| sink.lock().append(text));
let info = match crate::ops::run::start(&call.host(), call.window(), config, emit).await {
let info = match crate::ops::run::run_start(&call.host(), call.window(), config, emit, None).await {
Ok(info) => info,
Err(e) => {
let _ = std::fs::remove_file(&output_path);
+7 -7
Переглянути файл
@@ -317,7 +317,7 @@ async fn fill_lines(
for item in items {
let (Some(path), Some(line)) = (absolute(item), item.start_line) else { continue };
if current.as_ref().is_none_or(|(p, _)| p != &path) {
let text = crate::ops::fs::read_text(&host, call.window(), path.clone()).await.ok();
let text = crate::ops::fs::fs_read_text(&host, call.window(), path.clone()).await.ok();
let lines = text.map(|t| t.split('\n').map(|l| l.strip_suffix('\r').unwrap_or(l).to_owned()).collect());
current = Some((path, lines));
}
@@ -595,7 +595,7 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
// such lines are matched again in the file's whole text.
let long = |m: &ide_search::LineMatch| m.text_offset > 0 || m.text.encode_utf16().count() + 1 >= LINE_WINDOW;
let whole = if file.matches.iter().any(long) {
crate::ops::fs::read_text(&host, call.window(), file.path.0.clone())
crate::ops::fs::fs_read_text(&host, call.window(), file.path.0.clone())
.await
.ok()
.and_then(|text| Some((ide_search::match_ranges(&text, &query).ok()?, text)))
@@ -678,7 +678,7 @@ async fn extend_spanning(call: &Call, query: &SearchQuery, hits: &mut [TextHit],
let mut current: Option<FileText> = None;
for (i, path) in spanning {
if current.as_ref().is_none_or(|(p, ..)| p != &path) {
let Ok(text) = crate::ops::fs::read_text(&host, call.window(), path.clone()).await else { continue };
let Ok(text) = crate::ops::fs::fs_read_text(&host, call.window(), path.clone()).await else { continue };
let Ok(ranges) = ide_search::match_ranges(&text, query) else { continue };
let starts = std::iter::once(0).chain(text.match_indices('\n').map(|(i, _)| i + 1)).collect();
current = Some((path, text, starts, ranges));
@@ -714,14 +714,14 @@ async fn run_search(call: &Call, query: SearchQuery) -> IdeResult<(Vec<FileMatch
let request = crate::mcp::tool::request_id();
let files = Arc::new(Mutex::new(Vec::new()));
let done = Arc::new(Mutex::new(None));
let emit: crate::ops::Emit<SearchEvent> = {
let emit = {
let (files, done) = (files.clone(), done.clone());
Arc::new(move |event| match event {
crate::ops::Channel::new(move |event: SearchEvent| match event {
SearchEvent::File { file } => files.lock().push(file),
SearchEvent::Done { summary } => *done.lock() = Some(summary),
})
};
let search = crate::ops::search::start(&host, call.window(), request, query, emit);
let search = crate::ops::search::search_start(&host, call.window(), request, query, emit);
tokio::pin!(search);
let mut timed_out = false;
tokio::select! {
@@ -822,7 +822,7 @@ impl Walk {
/// Collects matching files under `dir` (inside the walked root `base`) depth first in
/// name order; true when it stopped early: more than `limit` match or the time ran out.
fn dir(&self, dir: &Path, base: &Path, found: &mut Vec<String>) -> bool {
let Ok(mut entries) = tokio::runtime::Handle::current().block_on(crate::ops::fs::read_dir(
let Ok(mut entries) = tokio::runtime::Handle::current().block_on(crate::ops::fs::fs_read_dir(
&self.host,
&self.window,
dir.to_path_buf(),
+182 -145
Переглянути файл
@@ -1,9 +1,8 @@
//! Agents tool window: coding agent tasks of the project (over ACP). In a remote
//! window they run on the host, next to the project they work on.
use super::{Channel, Emit};
use super::Channel;
use crate::Host;
use crate::agent_secrets::{AgentSecrets, Kept};
use crate::rpc::Dispatcher;
use ide_agent::registry::{AgentRegistry, RegistryPaths};
use ide_agent::{
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentEntry,
@@ -11,6 +10,7 @@ use ide_agent::{
ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput,
McpTransport, NewAgentTask,
};
use ide_command::command;
use ide_core::error::ErrorKind;
use ide_core::{IdeError, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
use ide_tools::InstallEvent;
@@ -18,38 +18,47 @@ use std::collections::HashSet;
use std::sync::{LazyLock, Mutex};
/// Streams the project's agent events to this window; returns every task.
pub fn subscribe(host: &Host, window: &str, on_event: Emit<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
Ok(host.project(window)?.agents.subscribe(on_event))
#[command(trust = always)]
pub fn agent_subscribe(host: &Host, window: &str, on_event: Channel<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
Ok(host.project(window)?.agents.subscribe(std::sync::Arc::new(move |e| {
let _ = on_event.send(e);
})))
}
pub fn providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
#[command(trust = trusted)]
pub fn agent_providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
host.require_trust(window)?;
let mut providers = host.project(window)?.agents.providers();
ide_agent::registry::mark_updates(&registry_paths(host), &mut providers);
Ok(providers)
}
/// Refreshes the selected agent's model catalog without sending a prompt.
pub fn refresh_models(
/// Refreshes the model catalog; force bypasses freshness, not the cooldown.
#[command(trust = trusted)]
pub fn agent_refresh_models(
host: &Host,
window: &str,
provider: String,
force: bool,
model: Option<String>,
) -> IdeResult<AgentModelCatalog> {
// Refreshes the selected agent's model catalog without sending a prompt.
host.require_trust(window)?;
host.project(window)?.agents.refresh_models(&provider, force, model.as_deref())
}
/// Overrides built-in agent `id`'s command with `command` (its agent file keeps the
/// built-in's driver and arguments), or returns it to auto-detection with `None`.
pub fn set_command(host: &Host, window: &str, id: String, command: Option<String>) -> IdeResult<()> {
#[command(trust = trusted)]
pub fn agent_set_command(host: &Host, window: &str, id: String, command: Option<String>) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.set_builtin_command(&id, command)
}
/// Environment variables built-in agent `id` starts with; empty clears them.
pub fn set_env(
/// Environment variables built-in agent `id` starts with (saved in its agent file);
/// an empty map clears them.
#[command(trust = trusted)]
pub fn agent_set_env(
host: &Host,
window: &str,
id: String,
@@ -88,7 +97,8 @@ fn join_err(e: impl std::fmt::Display) -> IdeError {
/// Agents of the ACP Registry this machine can run, with what is installed; the list
/// saved earlier when the registry is unreachable. Cancel with `cancel_request(request)`.
pub async fn registry_list(host: &Host, _window: &str, request: RequestId) -> IdeResult<AgentRegistry> {
#[command(trust = always)]
pub async fn agent_registry_list(host: &Host, request: RequestId) -> IdeResult<AgentRegistry> {
let paths = registry_paths(host);
let cancel = host.begin_request(request);
let result =
@@ -130,15 +140,15 @@ impl Drop for Installing {
}
/// Installs the registry's current version of agent `id` (also to update it), streaming
/// progress through `on_event`; the agent then shows in `agent_providers`. Cancel with
/// `cancel_request(request)`.
pub async fn registry_install(
/// progress through `on_event`. Cancel with `cancel_request(request)`.
#[command(trust = always)]
pub async fn agent_registry_install(
host: &Host,
_window: &str,
id: String,
request: RequestId,
on_event: Channel<InstallEvent>,
) -> IdeResult<()> {
// The agent then shows in `agent_providers`.
let paths = registry_paths(host);
let installing = Installing::begin(&id)?;
let cancel = host.begin_request(request);
@@ -189,7 +199,8 @@ pub async fn registry_install(
}
/// Removes a registry agent: its agent file and installed files.
pub async fn registry_remove(host: &Host, _window: &str, id: String) -> IdeResult<()> {
#[command(trust = always)]
pub async fn agent_registry_remove(host: &Host, id: String) -> IdeResult<()> {
let paths = registry_paths(host);
tokio::task::spawn_blocking(move || ide_agent::registry::remove(&paths, &id)).await.map_err(join_err)??;
for project in host.projects() {
@@ -200,7 +211,8 @@ pub async fn registry_remove(host: &Host, _window: &str, id: String) -> IdeResul
/// Slash commands to complete for `provider` in `task`'s directory, or in the project
/// before a task exists (skills and custom commands on disk included).
pub async fn commands(
#[command(trust = always)]
pub async fn agent_commands(
host: &Host,
window: &str,
provider: String,
@@ -210,26 +222,36 @@ pub async fn commands(
}
/// Entries of `task`'s conversation, or of its subagent `subagent`'s.
pub fn entries(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<Vec<AgentEntry>> {
#[command(trust = always)]
pub fn agent_entries(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<Vec<AgentEntry>> {
host.project(window)?.agents.entries(&task, subagent)
}
/// Sessions of the project on this machine that no task holds yet, newest first. Reads
/// transcripts from disk on the blocking pool.
pub async fn external_sessions(host: &Host, window: &str) -> IdeResult<Vec<ExternalSession>> {
/// Sessions of the project on this machine that no task holds yet, newest first.
#[command(trust = trusted)]
pub async fn agent_external_sessions(host: &Host, window: &str) -> IdeResult<Vec<ExternalSession>> {
// Reads transcripts from disk on the blocking pool.
let agents = host.project(window)?.agents.clone();
tokio::task::spawn_blocking(move || agents.external_sessions()).await.map_err(join_err)
}
/// Imports an external session as a task: its first turn loads and replays it.
pub async fn import_session(host: &Host, window: &str, provider: String, session_id: String) -> IdeResult<AgentTask> {
#[command(trust = trusted)]
pub async fn agent_import_session(
host: &Host,
window: &str,
provider: String,
session_id: String,
) -> IdeResult<AgentTask> {
host.require_trust(window)?;
let agents = host.project(window)?.agents.clone();
tokio::task::spawn_blocking(move || agents.import_session(&provider, &session_id)).await.map_err(join_err)?
}
pub async fn create(host: &Host, window: &str, mut request: NewAgentTask) -> IdeResult<AgentTask> {
#[command(trust = trusted)]
pub async fn agent_create(host: &Host, window: &str, request: NewAgentTask) -> IdeResult<AgentTask> {
host.require_trust(window)?;
let mut request = request;
let project = host.project(window)?;
let root = project.root.clone();
let requested = request.project_root.take();
@@ -240,98 +262,123 @@ pub async fn create(host: &Host, window: &str, mut request: NewAgentTask) -> Ide
}
/// Sends a message; while the agent works it is queued, or with `now` it interrupts the turn.
pub async fn prompt(host: &Host, window: &str, task: String, prompt: AgentPrompt, now: bool) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn agent_prompt(host: &Host, window: &str, task: String, prompt: AgentPrompt, now: bool) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.prompt(&task, prompt, now).await
}
/// Drops a queued message and returns it (to edit it).
pub fn unqueue(host: &Host, window: &str, task: String, queued: String) -> IdeResult<AgentQueued> {
#[command(trust = always)]
pub fn agent_unqueue(host: &Host, window: &str, task: String, queued: String) -> IdeResult<AgentQueued> {
host.project(window)?.agents.unqueue(&task, &queued)
}
/// Sends a queued message now, interrupting the current turn.
pub fn send_queued_now(host: &Host, window: &str, task: String, queued: String) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn agent_send_queued_now(host: &Host, window: &str, task: String, queued: String) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.send_queued_now(&task, &queued)
host.project(window)?.agents.send_queued_now(&task, &queued).await
}
/// Changes a session setting (model, mode, thinking effort…).
pub async fn set_config(host: &Host, window: &str, task: String, option: String, value: String) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn agent_set_config(host: &Host, window: &str, task: String, option: String, value: String) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.set_config(&task, &option, value).await
}
/// Copies the task's conversation into a new task, up to its first `turns` turns (all when `None`).
pub async fn fork(host: &Host, window: &str, task: String, turns: Option<u32>) -> IdeResult<AgentTask> {
#[command(trust = trusted)]
pub async fn agent_fork(host: &Host, window: &str, task: String, turns: Option<u32>) -> IdeResult<AgentTask> {
host.require_trust(window)?;
host.project(window)?.agents.fork(&task, turns).await
}
/// Drops the task's turns after its first `turns`; returns the message of the first dropped one.
pub async fn rollback(host: &Host, window: &str, task: String, turns: u32) -> IdeResult<Option<AgentPrompt>> {
#[command(trust = trusted)]
pub async fn agent_rollback(host: &Host, window: &str, task: String, turns: u32) -> IdeResult<Option<AgentPrompt>> {
host.require_trust(window)?;
host.project(window)?.agents.rollback(&task, turns).await
}
/// What the agent reports about itself when it starts, without opening a session.
pub async fn probe(host: &Host, window: &str, provider: String, refresh: bool) -> IdeResult<AgentProbe> {
/// What the agent reports about itself when it starts (no session: no MCP servers, hooks
/// or sign-in run). Remembered until `refresh`.
#[command(trust = trusted)]
pub async fn agent_probe(host: &Host, window: &str, provider: String, refresh: bool) -> IdeResult<AgentProbe> {
host.require_trust(window)?;
host.project(window)?.agents.probe(&provider, refresh).await
}
/// Stops the task's current turn, or with `subagent` only that subagent's work.
pub fn cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
#[command(trust = always)]
pub fn agent_cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
host.project(window)?.agents.cancel(&task, subagent)
}
/// Stops one of the task's background tasks.
pub async fn stop_background(host: &Host, window: &str, task: String, background: String) -> IdeResult<()> {
#[command(trust = always)]
pub async fn agent_stop_background(host: &Host, window: &str, task: String, background: String) -> IdeResult<()> {
host.project(window)?.agents.stop_background(&task, &background).await
}
/// Answers a permission request; `option: None` cancels it.
pub fn respond(host: &Host, window: &str, task: String, permission: u32, option: Option<String>) -> IdeResult<()> {
/// Answers a permission request; `option: null` cancels it.
#[command(trust = trusted)]
pub fn agent_respond(
host: &Host,
window: &str,
task: String,
permission: u32,
option: Option<String>,
) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.respond(&task, permission, option)
}
pub fn archive(host: &Host, window: &str, task: String) -> IdeResult<()> {
#[command(trust = always)]
pub fn agent_archive(host: &Host, window: &str, task: String) -> IdeResult<()> {
host.project(window)?.agents.archive(&task)
}
pub fn unarchive(host: &Host, window: &str, task: String) -> IdeResult<()> {
#[command(trust = always)]
pub fn agent_unarchive(host: &Host, window: &str, task: String) -> IdeResult<()> {
host.project(window)?.agents.unarchive(&task)
}
pub fn rename(host: &Host, window: &str, task: String, title: String) -> IdeResult<()> {
#[command(trust = trusted)]
pub fn agent_rename(host: &Host, window: &str, task: String, title: String) -> IdeResult<()> {
host.project(window)?.agents.rename(&task, &title)
}
pub async fn delete(host: &Host, window: &str, task: String, remove_worktree: bool) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn agent_delete(host: &Host, window: &str, task: String, remove_worktree: bool) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.delete(&task, remove_worktree).await
}
pub async fn changes(host: &Host, window: &str, task: String) -> IdeResult<Vec<AgentChange>> {
#[command(trust = trusted)]
pub async fn agent_changes(host: &Host, window: &str, task: String) -> IdeResult<Vec<AgentChange>> {
host.require_trust(window)?;
host.project(window)?.agents.changes(&task).await
}
/// The task's uncommitted changes and the commits made since it started.
pub async fn grouped_changes(host: &Host, window: &str, task: String) -> IdeResult<AgentChanges> {
#[command(trust = trusted)]
pub async fn agent_grouped_changes(host: &Host, window: &str, task: String) -> IdeResult<AgentChanges> {
host.require_trust(window)?;
host.project(window)?.agents.grouped_changes(&task).await
}
/// Content of `path` when the task started (left side of its diff).
pub async fn base_text(host: &Host, window: &str, task: String, path: IpcPath) -> IdeResult<Option<String>> {
#[command(trust = trusted)]
pub async fn agent_base_text(host: &Host, window: &str, task: String, path: IpcPath) -> IdeResult<Option<String>> {
host.require_trust(window)?;
host.project(window)?.agents.base_text(&task, path.into_path_buf()).await
}
/// Rollback: the task's changed files among `paths` (all without) back as `view` compares them.
pub async fn rollback_changes(
#[command(trust = trusted)]
pub async fn agent_rollback_changes(
host: &Host,
window: &str,
task: String,
@@ -344,7 +391,8 @@ pub async fn rollback_changes(
/// Accept: copies a worktree task's changed files among `paths` (all without) into the
/// local checkout, uncommitted; files the checkout changed itself are left alone and reported.
pub async fn accept_changes(
#[command(trust = trusted)]
pub async fn agent_accept_changes(
host: &Host,
window: &str,
task: String,
@@ -457,6 +505,7 @@ fn persist_mcp_map(
host.global_settings.set(ide_workspace::settings::SettingsScope::Global, "agents.mcpServers", value)?;
for p in host.projects() {
p.settings.reload();
p.agents.notify_mcp_servers_changed();
p.sink.emit(event.clone());
if kept == Kept::LocalFile {
host.agent_secrets.notify_kept_locally(&p.sink);
@@ -466,6 +515,7 @@ fn persist_mcp_map(
McpScope::Workspace => {
let p = project.ok_or_else(|| IdeError::invalid("Open a project to configure workspace MCP servers"))?;
p.settings.set(ide_workspace::settings::SettingsScope::Project, "agents.mcpServers", value)?;
p.agents.notify_mcp_servers_changed();
p.sink.emit(event);
}
}
@@ -533,20 +583,31 @@ 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 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)
let raw_workspace = settings.layer(SettingsScope::Project).agents.mcp_servers;
let workspace = approvals.apply(root, raw_workspace.clone());
let mut out = ide_agent::mcp::servers_from_settings(&user, &workspace);
for srv in &mut out {
if srv.scope == McpScope::Workspace
&& let Some(raw) = raw_workspace.get(&srv.name)
{
srv.unapproved = !approvals.approved(root, &srv.name, raw);
}
}
out
}
/// Lists configured MCP servers across User (`settings.toml`) and Workspace (`.openidea/settings.toml`) scopes.
pub fn mcp_list(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
/// Lists configured and discovered MCP servers across User, Workspace, Plugin, and Built-In scopes.
#[command(trust = always)]
pub fn agent_mcp_list(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
// Configured servers of the User (`settings.toml`) and Workspace (`.openidea/settings.toml`) scopes.
let (user, workspace, project) = mcp_maps(host, window);
Ok(listed(host, project.as_ref(), &user, workspace))
}
/// 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>> {
/// Creates or updates a User or Workspace MCP server and returns the updated list.
#[command(trust = always)]
pub fn agent_mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<Vec<McpServer>> {
// A Workspace server saved here is one the user turned on.
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| {
@@ -555,8 +616,9 @@ pub fn mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<V
}
/// 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(
/// single server object).
#[command(trust = always)]
pub fn agent_mcp_save_json(
host: &Host,
window: &str,
scope: McpScope,
@@ -564,6 +626,7 @@ pub fn mcp_save_json(
fallback_name: Option<String>,
agents: Vec<String>,
) -> IdeResult<Vec<McpServer>> {
// Workspace servers explicitly saved here by the user are approved.
update_mcp_maps(host, window, &[], |user, workspace, project_root| {
let saved = ide_agent::mcp::apply_save_json(
user,
@@ -579,7 +642,8 @@ pub fn mcp_save_json(
}
/// 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>> {
#[command(trust = always)]
pub fn agent_mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) -> IdeResult<Vec<McpServer>> {
let approve: Vec<String> = ide_agent::mcp::parse_server_id(&id)
.filter(|(scope, _)| enabled && *scope == McpScope::Workspace)
.map(|(_, name)| name.to_owned())
@@ -591,15 +655,17 @@ pub fn mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) ->
}
/// 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>> {
#[command(trust = always)]
pub fn agent_mcp_remove(host: &Host, window: &str, id: String) -> IdeResult<Vec<McpServer>> {
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>> {
/// Copies MCP servers from `.mcp.json` and `.vscode/mcp.json` into the workspace settings once.
#[command(trust = always)]
pub fn agent_mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
// They stay off until the user turns them on.
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);
@@ -608,7 +674,8 @@ pub fn mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
}
/// 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>> {
#[command(trust = always)]
pub async fn agent_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 || {
@@ -619,14 +686,15 @@ pub async fn mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<Mc
}
/// 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(
#[command(trust = always)]
pub async fn agent_mcp_import_selected(
host: &Host,
window: &str,
scope: McpScope,
selections: Vec<McpImportSelection>,
overwrite: bool,
) -> IdeResult<Vec<McpServer>> {
// Imported Workspace entries remain unapproved (disabled) until the user explicitly enables them.
let home = dirs::home_dir();
update_mcp_maps(host, window, &[], move |user, workspace, project_root| {
ide_agent::mcp::apply_import_selected(
@@ -643,7 +711,8 @@ pub async fn mcp_import_selected(
}
/// 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> {
#[command(trust = trusted)]
pub async fn agent_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)
@@ -823,8 +892,9 @@ fn parse_mcp_http_response(body: &str) -> Result<serde_json::Value, String> {
Err("Unexpected non-JSON MCP response".into())
}
/// Updates per-session MCP server enable/disable overrides on task `task`.
pub fn set_mcp_overrides(
/// Updates per-session MCP server enable/disable overrides on `task`.
#[command(trust = always)]
pub fn agent_set_mcp_overrides(
host: &Host,
window: &str,
task: String,
@@ -833,85 +903,6 @@ pub fn set_mcp_overrides(
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")?) });
d.add("agent_providers", |c| async move { providers(&c.host, &c.window) });
d.add("agent_refresh_models", |c| async move {
refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?, c.arg("model")?)
});
d.add("agent_set_command", |c| async move { set_command(&c.host, &c.window, c.arg("id")?, c.arg("command")?) });
d.add("agent_set_env", |c| async move { set_env(&c.host, &c.window, c.arg("id")?, c.arg("env")?) });
d.add("agent_registry_list", |c| async move { registry_list(&c.host, &c.window, c.arg("request")?).await });
d.add("agent_registry_install", |c| async move {
registry_install(&c.host, &c.window, c.arg("id")?, c.arg("request")?, c.sender("onEvent")?).await
});
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 });
d.add("agent_external_sessions", |c| async move { external_sessions(&c.host, &c.window).await });
d.add("agent_import_session", |c| async move {
import_session(&c.host, &c.window, c.arg("provider")?, c.arg("sessionId")?).await
});
d.add("agent_prompt", |c| async move {
prompt(&c.host, &c.window, c.arg("task")?, c.arg("prompt")?, c.arg("now")?).await
});
d.add("agent_unqueue", |c| async move { unqueue(&c.host, &c.window, c.arg("task")?, c.arg("queued")?) });
d.add(
"agent_send_queued_now",
|c| async move { send_queued_now(&c.host, &c.window, c.arg("task")?, c.arg("queued")?) },
);
d.add("agent_set_config", |c| async move {
set_config(&c.host, &c.window, c.arg("task")?, c.arg("option")?, c.arg("value")?).await
});
d.add("agent_fork", |c| async move { fork(&c.host, &c.window, c.arg("task")?, c.arg("turns")?).await });
d.add("agent_rollback", |c| async move { rollback(&c.host, &c.window, c.arg("task")?, c.arg("turns")?).await });
d.add("agent_probe", |c| async move { probe(&c.host, &c.window, c.arg("provider")?, c.arg("refresh")?).await });
d.add("agent_cancel", |c| async move { cancel(&c.host, &c.window, c.arg("task")?, c.arg("subagent")?) });
d.add("agent_stop_background", |call| async move {
stop_background(&call.host, &call.window, call.arg("task")?, call.arg("background")?).await
});
d.add("agent_respond", |c| async move {
respond(&c.host, &c.window, c.arg("task")?, c.arg("permission")?, c.arg("option")?)
});
d.add("agent_unarchive", |c| async move { unarchive(&c.host, &c.window, c.arg("task")?) });
d.add("agent_rename", |c| async move { rename(&c.host, &c.window, c.arg("task")?, c.arg("title")?) });
d.add("agent_archive", |c| async move { archive(&c.host, &c.window, c.arg("task")?) });
d.add(
"agent_delete",
|c| async move { delete(&c.host, &c.window, c.arg("task")?, c.arg("removeWorktree")?).await },
);
d.add("agent_changes", |c| async move { changes(&c.host, &c.window, c.arg("task")?).await });
d.add("agent_grouped_changes", |c| async move { grouped_changes(&c.host, &c.window, c.arg("task")?).await });
d.add("agent_base_text", |c| async move { base_text(&c.host, &c.window, c.arg("task")?, c.arg("path")?).await });
d.add("agent_rollback_changes", |c| async move {
rollback_changes(&c.host, &c.window, c.arg("task")?, c.arg("paths")?, c.arg("view")?).await
});
d.add("agent_accept_changes", |c| async move {
accept_changes(&c.host, &c.window, c.arg("task")?, c.arg("paths")?).await
});
}
fn validate_project_root(root: &std::path::Path, requested: Option<&std::path::Path>) -> IdeResult<std::path::PathBuf> {
let Some(requested) = requested else {
return Ok(root.to_path_buf());
@@ -1020,3 +1011,49 @@ mod tests {
assert!(!reloaded.approved(&tmp.path().join("other"), "extra", &extra));
}
}
ide_command::domain!(
agent:
agent_accept_changes,
agent_archive,
agent_base_text,
agent_cancel,
agent_changes,
agent_commands,
agent_create,
agent_delete,
agent_entries,
agent_external_sessions,
agent_fork,
agent_grouped_changes,
agent_import_session,
agent_mcp_discover_sources,
agent_mcp_import,
agent_mcp_import_selected,
agent_mcp_list,
agent_mcp_remove,
agent_mcp_save,
agent_mcp_save_json,
agent_mcp_set_enabled,
agent_mcp_test,
agent_probe,
agent_prompt,
agent_providers,
agent_refresh_models,
agent_registry_install,
agent_registry_list,
agent_registry_remove,
agent_rename,
agent_respond,
agent_rollback,
agent_rollback_changes,
agent_send_queued_now,
agent_set_command,
agent_set_config,
agent_set_env,
agent_set_mcp_overrides,
agent_stop_background,
agent_subscribe,
agent_unarchive,
agent_unqueue,
);
+16 -18
Переглянути файл
@@ -6,7 +6,7 @@
use crate::Host;
use crate::Project;
use crate::ops::Channel;
use crate::rpc::Dispatcher;
use ide_command::command;
use super::doc::blocking;
use ide_analysis::{
@@ -122,6 +122,7 @@ pub struct StructuralLanguage {
/// Inspect Code: diagnostics of every file in `scope` that a language server
/// serves. Files stream through `on_event` as they finish; ends with `Done`.
#[command(trust = trusted)]
pub async fn inspect_code(
host: &Host,
window: &str,
@@ -195,6 +196,7 @@ pub async fn inspect_code(
}
/// Locate Duplicates over the files of `scope`.
#[command(trust = always)]
pub async fn analysis_locate_duplicates(
host: &Host,
window: &str,
@@ -217,7 +219,8 @@ pub async fn analysis_locate_duplicates(
}
/// Languages Search Structurally supports (those with a bundled grammar).
pub async fn structural_languages(host: &Host, _window: &str) -> IdeResult<Vec<StructuralLanguage>> {
#[command(trust = always)]
pub async fn structural_languages(host: &Host) -> IdeResult<Vec<StructuralLanguage>> {
let syntax = host.syntax();
let mut out: Vec<StructuralLanguage> = host
.languages
@@ -231,7 +234,8 @@ pub async fn structural_languages(host: &Host, _window: &str) -> IdeResult<Vec<S
}
/// Checks a structural search template (and language) while the user types.
pub async fn structural_validate(host: &Host, _window: &str, query: StructuralQuery) -> IdeResult<()> {
#[command(trust = always)]
pub async fn structural_validate(host: &Host, query: StructuralQuery) -> IdeResult<()> {
let syntax = host.syntax();
blocking(move || ide_analysis::validate_structural(&syntax, &query)).await
}
@@ -239,6 +243,7 @@ pub async fn structural_validate(host: &Host, _window: &str, query: StructuralQu
/// Search Structurally over `scope`; files with matches stream through
/// `on_event`, ending with `Done`. With a replacement, matches carry their
/// replacement text (applied by the UI as a workspace edit).
#[command(trust = always)]
pub async fn structural_search(
host: &Host,
window: &str,
@@ -265,18 +270,11 @@ pub async fn structural_search(
Ok(())
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("inspect_code", |c| async move {
inspect_code(&c.host, &c.window, c.arg("request")?, c.arg("scope")?, c.sender("onEvent")?).await
});
d.add("analysis_locate_duplicates", |c| async move {
analysis_locate_duplicates(&c.host, &c.window, c.arg("request")?, c.arg("scope")?, c.arg("options")?).await
});
d.add("structural_languages", |c| async move { structural_languages(&c.host, &c.window).await });
d.add("structural_validate", |c| async move { structural_validate(&c.host, &c.window, c.arg("query")?).await });
d.add("structural_search", |c| async move {
structural_search(&c.host, &c.window, c.arg("request")?, c.arg("scope")?, c.arg("query")?, c.sender("onEvent")?)
.await
});
}
ide_command::domain!(
analysis:
analysis_locate_duplicates,
inspect_code,
structural_languages,
structural_search,
structural_validate,
);
+62 -91
Переглянути файл
@@ -4,8 +4,8 @@ mod workspace;
use super::dependencies::{MavenCentralArtifacts, MavenCentralGroups, MavenCentralVersions};
use crate::ops::Channel;
use crate::rpc::Dispatcher;
use crate::{Host, Project, apply_workspace_edit};
use crate::{Host, Project};
use ide_command::command;
use ide_build::compile::{self, BuildEvent, BuildKind, BuildResult};
use ide_build::maven::PomGoto;
@@ -126,6 +126,7 @@ fn with_profiles(mut model: BuildModel, cache: &Path) -> BuildModel {
}
/// Maven and Gradle projects of the window's project, from the build files plus the last sync.
#[command(trust = trusted)]
pub async fn build_model(host: &Host, window: &str) -> IdeResult<BuildModel> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -202,13 +203,15 @@ async fn set_gradle_projects(host: &Host, window: &str, paths: Vec<String>, link
.map_err(join_err)?
}
/// Links independent builds without changing their Gradle scripts.
#[command(trust = trusted)]
pub async fn gradle_link_projects(host: &Host, window: &str, paths: Vec<String>) -> IdeResult<BuildModel> {
// Links independent builds without changing their Gradle scripts.
set_gradle_projects(host, window, paths, true).await
}
/// Stops importing the selected independent builds; files and saved run configurations stay intact.
#[command(trust = trusted)]
pub async fn gradle_unlink_projects(host: &Host, window: &str, paths: Vec<String>) -> IdeResult<BuildModel> {
// Stops importing the selected independent builds; files and saved run configurations stay intact.
set_gradle_projects(host, window, paths, false).await
}
@@ -216,6 +219,7 @@ pub async fn gradle_unlink_projects(host: &Host, window: &str, paths: Vec<String
/// background, reporting progress on `on_progress`; cancellable with `cancel_request(request)`.
/// Returns the refreshed model; a failed build is reported in its `syncError`.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn build_sync(
host: &Host,
window: &str,
@@ -419,7 +423,8 @@ fn declaring_pom(
}
/// The `.toml` of a version catalog the build imports as `group:artifact:version`, once a
/// build has downloaded it (`ide_sdk::libraries::published_version_catalog`).
/// build has downloaded it.
#[command(trust = trusted)]
pub async fn gradle_published_catalog(
host: &Host,
window: &str,
@@ -434,8 +439,8 @@ pub async fn gradle_published_catalog(
.map_err(join_err)
}
/// The resolved dependency tree of the Gradle project `gradle_path` (`:`, `:app`) for
/// `configuration`, from Gradle's `dependencies` report; cancellable with `cancel_request(request)`.
/// The resolved dependency tree of a Gradle project for one configuration (Dependency Analyzer).
#[command(trust = trusted)]
pub async fn gradle_dependencies(
host: &Host,
window: &str,
@@ -445,6 +450,7 @@ pub async fn gradle_dependencies(
request: RequestId,
build_dir: Option<String>,
) -> IdeResult<Vec<ide_build::GradleDependency>> {
// `gradle_path` is `:`, `:app`…; the tree comes from Gradle's `dependencies` report.
host.require_trust(window)?;
let project = host.project(window)?;
let config = host.config_dir.clone();
@@ -518,6 +524,7 @@ pub(crate) fn analyzed_dependencies(
}
/// Where the direct dependency `dependency` of the Maven module `pom` is declared.
#[command(trust = trusted)]
pub async fn maven_dependency_declaration(
host: &Host,
window: &str,
@@ -534,14 +541,15 @@ pub async fn maven_dependency_declaration(
.map_err(join_err)?
}
/// The go-to-declaration target at `pos` of the Maven POM `pom` (project-relative, or
/// absolute for a parent POM opened from the local repository): the definition of the
/// The go-to-declaration target at `pos` of a Maven POM: the definition of the
/// `${property}` at the caret, or the `<dependencyManagement>` / `<pluginManagement>`
/// entry providing the dependency's / plugin's version, along the parent chain (into
/// the local repository when a parent is not in the project), else the artifact's own
/// POM (a project module's, or the local repository's). `None` when nothing
/// resolvable is under the caret.
/// entry providing the dependency's / plugin's version, along the parent chain.
#[command(trust = trusted)]
pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos: Pos) -> IdeResult<Option<PomGoto>> {
// `pom` is project-relative, or absolute for a parent POM opened from the local repository.
// The parent chain reaches into the local repository when a parent is not in the project;
// without a managed version the target is the artifact's own POM (a project module's, or the
// local repository's). `None` when nothing resolvable is under the caret.
let project = host.project(window)?;
tokio::task::spawn_blocking(move || {
let given = Path::new(&pom);
@@ -572,12 +580,8 @@ pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos:
const CENTRAL_WAIT: std::time::Duration = std::time::Duration::from_secs(1);
/// Completion of the `<dependency>` coordinate the caret (`offset`, UTF-16) sits
/// in the value of in the POM `doc`: the coordinates installed in the local
/// repository (Settings › Maven's, else `~/.m2/repository`) — group ids,
/// the chosen group's artifacts, the chosen artifact's versions — topped up
/// with Maven Central's (the search endpoint's popular coordinates, the
/// published version metadata), which the shared version cache keeps for the
/// session. `None` when the caret is not in a `<dependency>` coordinate element.
/// in the value of in the POM `doc`, from the local repository and Maven Central.
#[command(trust = trusted)]
pub async fn maven_dependency_completion(
host: &Host,
window: &str,
@@ -585,6 +589,10 @@ pub async fn maven_dependency_completion(
offset: u32,
request: RequestId,
) -> IdeResult<Option<PomCompletion>> {
// The local repository is Settings › Maven's, else `~/.m2/repository` (group ids, the chosen
// group's artifacts, the chosen artifact's versions), topped up with Maven Central's (the search
// endpoint's popular coordinates, the published version metadata), which the shared version
// cache keeps for the session. `None` when the caret is not in a `<dependency>` coordinate element.
use ide_build::maven::completion::{PomCompletionKind, local_options};
let project = host.project(window)?;
let cache = host.dependency_versions.clone();
@@ -654,6 +662,7 @@ pub async fn maven_dependency_completion(
/// Adds an `<exclusion>` of `exclusion` to the declaration of the direct dependency
/// `dependency` of the Maven module `pom`, through the open document when there is one
/// (saved). Returns the declaration; nothing changes when it already excludes it.
#[command(trust = trusted)]
pub async fn maven_exclude_dependency(
host: &Host,
window: &str,
@@ -671,7 +680,7 @@ pub async fn maven_exclude_dependency(
files: vec![FileEdit::Edit { path: path.clone().into(), edits: vec![edit], version: None }],
..Default::default()
};
apply_workspace_edit(&project.documents, &edit)?;
project.documents.apply_workspace_edit(&edit)?;
}
Some(Exclusion::Present) => {}
None => return Err(IdeError::not_found(format!("{dependency} is not declared in {}", path.display()))),
@@ -778,6 +787,7 @@ fn cmake_plan(root: &Path, kind: BuildKind, configs: &[ide_run::RunConfig], id:
/// with `cancel_request(request)`. Diagnostics of `clear` (the files of the previous build)
/// are cleared first; the new messages are published as `build` diagnostics.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn build_run(
host: &Host,
window: &str,
@@ -876,12 +886,19 @@ pub async fn build_run(
for (path, items) in compile::diagnostics(&result.messages) {
sink.emit(IdeEvent::Diagnostics { path: path.into(), source: compile::DIAGNOSTICS_SOURCE.into(), items });
}
Ok(result)
Ok::<_, IdeError>(result)
})
.await
.map_err(join_err);
host.end_request(request);
result?
let outcome = result??;
// Maven generated sources (protobuf, gRPC) stay invisible to jdtls until the
// folders the build wrote are attached. An up-to-date build skips Maven and
// still needs this: the classes can already be on disk.
if outcome.system == ide_build::compile::BuildSystem::Maven {
project.lsp.sync_maven_generated_sources(&project.root).await;
}
Ok(outcome)
}
/// Build › Compile File: compiles one Java source of a linked Maven module with
@@ -889,6 +906,7 @@ pub async fn build_run(
/// `cancel_request(request)`. Diagnostics of `clear` (the files of the previous
/// build) are cleared first; the new messages are published as `build`
/// diagnostics.
#[command(trust = trusted)]
pub async fn build_compile_file(
host: &Host,
window: &str,
@@ -917,79 +935,16 @@ pub async fn build_compile_file(
for (path, items) in compile::diagnostics(&result.messages) {
sink.emit(IdeEvent::Diagnostics { path: path.into(), source: compile::DIAGNOSTICS_SOURCE.into(), items });
}
Ok(result)
Ok::<_, IdeError>(result)
})
.await
.map_err(join_err);
host.end_request(request);
result?
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("build_model", |c| async move { build_model(&c.host, &c.window).await });
d.add("gradle_link_projects", |c| async move { gradle_link_projects(&c.host, &c.window, c.arg("paths")?).await });
d.add(
"gradle_unlink_projects",
|c| async move { gradle_unlink_projects(&c.host, &c.window, c.arg("paths")?).await },
);
d.add("build_sync", |c| async move {
build_sync(
&c.host,
&c.window,
c.arg("tool")?,
c.arg("request")?,
c.arg("offline")?,
c.arg("profiles")?,
c.arg("buildDir")?,
c.sender("onProgress")?,
)
.await
});
d.add("gradle_published_catalog", |c| async move {
gradle_published_catalog(&c.host, &c.window, c.arg("coordinates")?).await
});
d.add("gradle_dependencies", |c| async move {
gradle_dependencies(
&c.host,
&c.window,
c.arg("gradlePath")?,
c.arg("configuration")?,
c.arg("offline")?,
c.arg("request")?,
c.arg("buildDir")?,
)
.await
});
d.add("maven_dependency_declaration", |c| async move {
maven_dependency_declaration(&c.host, &c.window, c.arg("pom")?, c.arg("dependency")?).await
});
d.add("maven_goto_declaration", |c| async move {
maven_goto_declaration(&c.host, &c.window, c.arg("pom")?, c.arg("pos")?).await
});
d.add("maven_dependency_completion", |c| async move {
maven_dependency_completion(&c.host, &c.window, c.arg("doc")?, c.arg("offset")?, c.arg("request")?).await
});
d.add("maven_exclude_dependency", |c| async move {
maven_exclude_dependency(&c.host, &c.window, c.arg("pom")?, c.arg("dependency")?, c.arg("exclusion")?).await
});
d.add("build_run", |c| async move {
build_run(
&c.host,
&c.window,
c.arg("kind")?,
c.arg("file")?,
c.arg("cmake")?,
c.arg("request")?,
c.arg("clear")?,
c.sender("onEvent")?,
)
.await
});
d.add("build_compile_file", |c| async move {
build_compile_file(&c.host, &c.window, c.arg("file")?, c.arg("request")?, c.arg("clear")?, c.sender("onEvent")?)
.await
});
let outcome = result??;
if outcome.system == ide_build::compile::BuildSystem::Maven {
project.lsp.sync_maven_generated_sources(&project.root).await;
}
Ok(outcome)
}
#[cfg(test)]
@@ -1316,3 +1271,19 @@ mod maven_completion_tests {
host.close_project("main");
}
}
ide_command::domain!(
build:
build_compile_file,
build_model,
build_run,
build_sync,
gradle_dependencies,
gradle_link_projects,
gradle_published_catalog,
gradle_unlink_projects,
maven_dependency_completion,
maven_dependency_declaration,
maven_exclude_dependency,
maven_goto_declaration,
);
+11 -14
Переглянути файл
@@ -1,6 +1,6 @@
//! Raw file bytes for the image viewer and hex view (see `ide_vfs::bytes`).
use crate::Host;
use crate::rpc::Dispatcher;
use ide_command::command;
use crate::ops::doc::blocking;
use ide_core::IdeResult;
@@ -8,27 +8,24 @@ use ide_vfs::{ByteRange, FileProbe};
use std::path::PathBuf;
/// Size and text/binary classification, from the file's head only.
pub async fn fs_probe(_host: &Host, _window: &str, path: PathBuf) -> IdeResult<FileProbe> {
#[command(trust = always)]
pub async fn fs_probe(path: PathBuf) -> IdeResult<FileProbe> {
blocking(move || ide_vfs::probe(&path)).await
}
/// Up to `len` bytes from `offset` (capped per call), base64-encoded.
pub async fn fs_read_range(_host: &Host, _window: &str, path: PathBuf, offset: u64, len: u32) -> IdeResult<ByteRange> {
#[command(trust = always)]
pub async fn fs_read_range(path: PathBuf, offset: u64, len: u32) -> IdeResult<ByteRange> {
blocking(move || ide_vfs::read_range(&path, offset, len)).await
}
/// An image file as a `data:` URL. A network path is read only from a share an open project is
/// on: the path may come from Markdown, and opening a share signs in to its server.
pub async fn fs_read_image(host: &Host, _window: &str, path: PathBuf) -> IdeResult<String> {
/// An image file as a `data:` URL.
#[command(trust = always)]
pub async fn fs_read_image(host: &Host, path: PathBuf) -> IdeResult<String> {
// A network path is read only from a share an open project is on: the path may come from
// Markdown, and opening a share signs in to its server.
let opened: Vec<PathBuf> = host.projects().iter().map(|project| project.root.clone()).collect();
blocking(move || ide_vfs::read_data_url(&path, &opened)).await
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("fs_probe", |c| async move { fs_probe(&c.host, &c.window, c.arg("path")?).await });
d.add("fs_read_range", |c| async move {
fs_read_range(&c.host, &c.window, c.arg("path")?, c.arg("offset")?, c.arg("len")?).await
});
d.add("fs_read_image", |c| async move { fs_read_image(&c.host, &c.window, c.arg("path")?).await });
}
ide_command::domain!(bytes: fs_probe, fs_read_image, fs_read_range);
+7 -8
Переглянути файл
@@ -1,6 +1,6 @@
//! Run with Coverage: launch plans and coverage reports.
use crate::Host;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{IdeError, IdeResult, IpcPath};
use ide_coverage::{CoveragePrepared, CoverageReportSpec, CoverageSuite};
@@ -15,6 +15,7 @@ pub async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send
/// How to run `config` with coverage: the command to launch and where its report will be,
/// or which tool is missing.
#[command(trust = trusted)]
pub async fn coverage_prepare(host: &Host, window: &str, config: RunConfig) -> IdeResult<CoveragePrepared> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -27,21 +28,19 @@ pub async fn coverage_prepare(host: &Host, window: &str, config: RunConfig) -> I
}
/// Reads the report a coverage run left behind.
#[command(trust = trusted)]
pub async fn coverage_collect(host: &Host, window: &str, report: CoverageReportSpec) -> IdeResult<CoverageSuite> {
host.require_trust(window)?;
blocking(move || ide_coverage::collect(&report)).await
}
/// Reads a report collected elsewhere (CI): lcov, a Go cover profile, JaCoCo XML or a SimpleCov resultset,
/// Reads a report collected elsewhere (CI): lcov, a Go cover profile or JaCoCo XML,
/// with paths mapped into this project.
#[command(trust = always)]
pub async fn coverage_import(host: &Host, window: &str, path: IpcPath) -> IdeResult<CoverageSuite> {
// Also reads a SimpleCov resultset.
let root = host.project(window)?.root.clone();
blocking(move || ide_coverage::import(&path, &root)).await
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("coverage_prepare", |c| async move { coverage_prepare(&c.host, &c.window, c.arg("config")?).await });
d.add("coverage_collect", |c| async move { coverage_collect(&c.host, &c.window, c.arg("report")?).await });
d.add("coverage_import", |c| async move { coverage_import(&c.host, &c.window, c.arg("path")?).await });
}
ide_command::domain!(coverage: coverage_collect, coverage_import, coverage_prepare);
+237 -295
Переглянути файл
@@ -3,7 +3,7 @@
//! shell: its path comes from a local save dialog, so the export must land
//! on the user's machine, not the side the project runs on.
use crate::Host;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
use ide_db::split::SqlStatement;
use ide_db::{
@@ -24,172 +24,15 @@ pub struct StatementOutcome {
pub error: Option<String>,
}
pub(crate) fn register(d: &mut Dispatcher) {
d.add("db_sources", |c| async move { sources(&c.host, &c.window) });
d.add("db_save_sources", |c| async move {
let sources = c.arg("sources")?;
save_sources(&c.host, &c.window, sources).await
});
d.add("db_set_password", |c| async move {
let (id, password, save) =
(c.arg::<String>("id")?, c.arg::<Option<String>>("password")?, c.arg::<bool>("save")?);
set_password(&c.host, &c.window, &id, password, save).await
});
d.add("db_test", |c| async move {
let (source, password, ssh_secret) = (
c.arg::<DataSource>("source")?,
c.arg::<Option<String>>("password")?,
c.arg::<Option<String>>("sshSecret")?,
);
test(&c.host, &c.window, source, password, ssh_secret).await
});
d.add("db_test_tunnel", |c| async move {
let (source, ssh_secret) = (c.arg::<DataSource>("source")?, c.arg::<Option<String>>("sshSecret")?);
test_tunnel(&c.host, &c.window, source, ssh_secret).await
});
d.add("db_set_ssh_secret", |c| async move {
let (id, secret, save) = (c.arg::<String>("id")?, c.arg::<Option<String>>("secret")?, c.arg::<bool>("save")?);
set_ssh_secret(&c.host, &c.window, &id, secret, save).await
});
d.add("db_trust_ssh_host", |c| async move {
let id = c.arg::<String>("id")?;
trust_ssh_host(&c.host, &c.window, &id).await
});
d.add("db_connected", |c| async move { connected(&c.host, &c.window) });
d.add("db_connect", |c| async move {
let id = c.arg::<String>("id")?;
connect(&c.host, &c.window, &id).await
});
d.add("db_set_manual_commit", |c| async move {
let (id, manual) = (c.arg::<String>("id")?, c.arg::<bool>("manual")?);
set_manual_commit(&c.host, &c.window, &id, manual).await
});
d.add("db_finish_transaction", |c| async move {
let (id, commit) = (c.arg::<String>("id")?, c.arg::<bool>("commit")?);
finish_transaction(&c.host, &c.window, &id, commit).await
});
d.add("db_disconnect", |c| async move {
let id = c.arg::<String>("id")?;
disconnect(&c.host, &c.window, &id).await
});
d.add("db_databases", |c| async move {
let id = c.arg::<String>("id")?;
databases(&c.host, &c.window, &id).await
});
d.add("db_database_catalog", |c| async move {
let (id, database) = (c.arg::<String>("id")?, c.arg::<String>("database")?);
database_catalog(&c.host, &c.window, &id, &database).await
});
d.add("db_saved_catalog", |c| async move {
let id = c.arg::<String>("id")?;
saved_catalog(&c.host, &c.window, &id).await
});
d.add("db_retain_catalog", |c| async move {
let (id, databases) = (c.arg::<String>("id")?, c.arg::<Vec<String>>("databases")?);
retain_catalog(&c.host, &c.window, &id, databases).await
});
d.add("db_session_context", |c| async move {
let id = c.arg::<String>("id")?;
session_context(&c.host, &c.window, &id).await
});
d.add("db_schemas", |c| async move {
let id = c.arg::<String>("id")?;
schemas(&c.host, &c.window, &id).await
});
d.add("db_tables", |c| async move {
let (id, schema) = (c.arg::<String>("id")?, c.arg::<String>("schema")?);
tables(&c.host, &c.window, &id, &schema).await
});
d.add("db_table_details", |c| async move {
let (id, schema, table) = (c.arg::<String>("id")?, c.arg::<String>("schema")?, c.arg::<String>("table")?);
table_details(&c.host, &c.window, &id, &schema, &table).await
});
d.add("db_ddl", |c| async move {
let (id, schema, table) = (c.arg::<String>("id")?, c.arg::<String>("schema")?, c.arg::<String>("table")?);
ddl(&c.host, &c.window, &id, &schema, &table).await
});
d.add("db_schema_objects", |c| async move {
let (id, schema) = (c.arg::<String>("id")?, c.arg::<String>("schema")?);
schema_objects(&c.host, &c.window, &id, &schema).await
});
d.add("db_object_ddl", |c| async move {
let (id, schema, kind, name) = (
c.arg::<String>("id")?,
c.arg::<String>("schema")?,
c.arg::<DbObjectKind>("kind")?,
c.arg::<String>("name")?,
);
object_ddl(&c.host, &c.window, &id, &schema, kind, &name).await
});
d.add("db_explain", |c| async move {
let (request, id, statement) =
(c.arg::<RequestId>("request")?, c.arg::<String>("id")?, c.arg::<String>("statement")?);
let schema = c.arg::<Option<String>>("schema")?;
explain(&c.host, &c.window, request, &id, &statement, schema.as_deref()).await
});
d.add("db_history", |c| async move {
let id = c.arg::<String>("id")?;
history(&c.host, &c.window, &id).await
});
d.add("db_remove_history", |c| async move {
let (id, texts) = (c.arg::<String>("id")?, c.arg::<Option<Vec<String>>>("texts")?);
remove_history(&c.host, &c.window, &id, texts).await
});
d.add("db_completion", |c| async move {
let id = c.arg::<String>("id")?;
completion(&c.host, &c.window, &id).await
});
d.add("db_statements", |c| async move {
let (id, text, from, to) =
(c.arg::<String>("id")?, c.arg::<String>("text")?, c.arg::<u32>("from")?, c.arg::<u32>("to")?);
statements(&c.host, &c.window, &id, &text, from, to)
});
d.add("db_execute", |c| async move {
let (request, id, statements, skip, max_rows) = (
c.arg::<RequestId>("request")?,
c.arg::<String>("id")?,
c.arg::<Vec<SqlStatement>>("statements")?,
c.arg::<Option<u32>>("skip")?.unwrap_or(0),
c.arg::<u32>("maxRows")?,
);
let schema = c.arg::<Option<String>>("schema")?;
execute(&c.host, &c.window, request, &id, statements, skip, max_rows, schema.as_deref()).await
});
d.add("db_table_page", |c| async move {
let (request, id, schema, table) = (
c.arg::<RequestId>("request")?,
c.arg::<String>("id")?,
c.arg::<String>("schema")?,
c.arg::<String>("table")?,
);
let (filter, sort, offset, limit) = (
c.arg::<Option<String>>("filter")?,
c.arg::<Vec<SortKey>>("sort")?,
c.arg::<u32>("offset")?,
c.arg::<u32>("limit")?,
);
table_page(&c.host, &c.window, request, &id, &schema, &table, filter, sort, offset, limit).await
});
d.add("db_apply_edits", |c| async move {
let (id, schema, table, edits) = (
c.arg::<String>("id")?,
c.arg::<String>("schema")?,
c.arg::<String>("table")?,
c.arg::<Vec<DbRowEdit>>("edits")?,
);
apply_edits(&c.host, &c.window, &id, &schema, &table, edits).await
});
d.add("db_console_path", |c| async move { console_path(&c.host, &c.arg::<String>("id")?) });
d.add("db_consoles", |c| async move { consoles(&c.host, &c.arg::<String>("id")?, c.arg("create")?) });
}
/// The data sources configured for the project (the tree's roots).
pub fn sources(host: &Host, window: &str) -> IdeResult<Vec<DataSource>> {
#[command(trust = trusted)]
pub fn db_sources(host: &Host, window: &str) -> IdeResult<Vec<DataSource>> {
// The data sources configured for the project (the tree's roots).
host.project(window)?.db.sources()
}
/// Replaces the project's data sources with `sources`.
pub async fn save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn db_save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -> IdeResult<()> {
// Replaces the project's data sources with `sources`.
let db = host.project(window)?.db.clone();
db.save_sources(sources).await?;
let root = host.project(window)?.root.clone();
@@ -199,222 +42,279 @@ pub async fn save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -
Ok(())
}
/// Remembers the password of data source `id` for the session, and in the OS
/// saved passwords when `save` (`None` forgets it).
pub async fn set_password(host: &Host, window: &str, id: &str, password: Option<String>, save: bool) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn db_set_password(
host: &Host,
window: &str,
id: String,
password: Option<String>,
save: bool,
) -> IdeResult<()> {
// Remembers the password of data source `id` for the session, and in the OS
// saved passwords when `save` (`None` forgets it).
let db = host.project(window)?.db.clone();
db.set_password(id, password, save).await
db.set_password(&id, password, save).await
}
/// Test Connection: connects with unsaved settings and returns the server version.
pub async fn test(
#[command(trust = trusted)]
pub async fn db_test(
host: &Host,
window: &str,
source: DataSource,
password: Option<String>,
ssh_secret: Option<String>,
) -> IdeResult<String> {
// Test Connection: connects with unsaved settings and returns the server version.
let db = host.project(window)?.db.clone();
db.test(&source, password, ssh_secret).await
}
/// Checks the SSH tunnel of `source` alone: SSH login and the SSH host reaching the database.
pub async fn test_tunnel(
/// Data Source › SSH/SSL › Test SSH Tunnel.
#[command(trust = trusted)]
pub async fn db_test_tunnel(
host: &Host,
window: &str,
source: DataSource,
ssh_secret: Option<String>,
) -> IdeResult<String> {
// Checks the SSH tunnel of `source` alone: SSH login and the SSH host reaching the database.
let db = host.project(window)?.db.clone();
db.test_tunnel(&source, ssh_secret).await
}
/// Remembers the SSH password / key passphrase of a data source (see `set_password`).
pub async fn set_ssh_secret(host: &Host, window: &str, id: &str, secret: Option<String>, save: bool) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn db_set_ssh_secret(
host: &Host,
window: &str,
id: String,
secret: Option<String>,
save: bool,
) -> IdeResult<()> {
// Remembers the SSH password / key passphrase of a data source (see `db_set_password`).
let db = host.project(window)?.db.clone();
db.set_ssh_secret(id, secret, save).await
db.set_ssh_secret(&id, secret, save).await
}
/// Trusts the SSH host key that made the last connection of `id` fail with
/// "Unknown SSH host key" (records it in `~/.ssh/known_hosts`).
pub async fn trust_ssh_host(host: &Host, window: &str, id: &str) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn db_trust_ssh_host(host: &Host, window: &str, id: String) -> IdeResult<()> {
// Trusts the SSH host key that made the last connection of `id` fail with
// "Unknown SSH host key" (records it in `~/.ssh/known_hosts`).
let db = host.project(window)?.db.clone();
db.trust_ssh_host(id).await
db.trust_ssh_host(&id).await
}
/// The data sources with an open connection.
pub fn connected(host: &Host, window: &str) -> IdeResult<Vec<String>> {
#[command(trust = trusted)]
pub fn db_connected(host: &Host, window: &str) -> IdeResult<Vec<String>> {
// The data sources with an open connection.
Ok(host.project(window)?.db.connected())
}
/// Connects (fails with `permissionDenied` when the password is missing or wrong).
pub async fn connect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn db_connect(host: &Host, window: &str, id: String) -> IdeResult<()> {
// Connects (fails with `permissionDenied` when the password is missing or wrong).
let db = host.project(window)?.db.clone();
db.pool(id).await.map(|_| ())
db.pool(&id).await.map(|_| ())
}
/// Switches a data source between auto-commit and manual commit (leaving
/// manual mode rolls back what was not committed).
pub async fn set_manual_commit(host: &Host, window: &str, id: &str, manual: bool) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn db_set_manual_commit(host: &Host, window: &str, id: String, manual: bool) -> IdeResult<()> {
// Switches a data source between auto-commit and manual commit (leaving
// manual mode rolls back what was not committed).
let db = host.project(window)?.db.clone();
db.set_manual_commit(id, manual).await
db.set_manual_commit(&id, manual).await
}
/// Commits or rolls back the open transaction of a manual-commit data source.
pub async fn finish_transaction(host: &Host, window: &str, id: &str, commit: bool) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn db_finish_transaction(host: &Host, window: &str, id: String, commit: bool) -> IdeResult<()> {
// Commits or rolls back the open transaction of a manual-commit data source.
let db = host.project(window)?.db.clone();
db.finish_transaction(id, commit).await
db.finish_transaction(&id, commit).await
}
/// Closes the connection of data source `id`.
pub async fn disconnect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn db_disconnect(host: &Host, window: &str, id: String) -> IdeResult<()> {
// Closes the connection of data source `id`.
let db = host.project(window)?.db.clone();
db.disconnect(id).await;
db.disconnect(&id).await;
Ok(())
}
/// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
pub async fn databases(host: &Host, window: &str, id: &str) -> IdeResult<Databases> {
#[command(trust = trusted)]
pub async fn db_databases(host: &Host, window: &str, id: String) -> IdeResult<Databases> {
// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
let db = host.project(window)?.db.clone();
db.databases(id).await
db.databases(&id).await
}
/// The schemas of `database` of Snowflake data source `id` with their tables and views.
pub async fn database_catalog(
#[command(trust = trusted)]
pub async fn db_database_catalog(
host: &Host,
window: &str,
id: &str,
database: &str,
id: String,
database: String,
) -> IdeResult<Vec<ide_db::CatalogSchema>> {
// The schemas of `database` of Snowflake data source `id` with their tables and views.
let db = host.project(window)?.db.clone();
db.database_catalog(id, database).await
db.database_catalog(&id, &database).await
}
/// What earlier introspection of data source `id` saved; the data source is not connected to.
pub async fn saved_catalog(host: &Host, window: &str, id: &str) -> IdeResult<Option<ide_db::SourceCatalog>> {
#[command(trust = trusted)]
pub async fn db_saved_catalog(host: &Host, window: &str, id: String) -> IdeResult<Option<ide_db::SourceCatalog>> {
// What earlier introspection of data source `id` saved; the data source is not connected to.
let db = host.project(window)?.db.clone();
db.saved_catalog(id).await
db.saved_catalog(&id).await
}
/// Drops the saved databases of data source `id` that are not in `databases` any more.
pub async fn retain_catalog(host: &Host, window: &str, id: &str, databases: Vec<String>) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn db_retain_catalog(host: &Host, window: &str, id: String, databases: Vec<String>) -> IdeResult<()> {
// Drops the saved databases of data source `id` that are not in `databases` any more.
let db = host.project(window)?.db.clone();
db.retain_catalog(id, databases).await
db.retain_catalog(&id, databases).await
}
/// The warehouse and role of the Snowflake session of data source `id`, and what it may switch to.
pub async fn session_context(host: &Host, window: &str, id: &str) -> IdeResult<ide_db::SessionContext> {
#[command(trust = trusted)]
pub async fn db_session_context(host: &Host, window: &str, id: String) -> IdeResult<ide_db::SessionContext> {
// The warehouse and role of the Snowflake session of data source `id`, and what it may switch to.
let db = host.project(window)?.db.clone();
db.session_context(id).await
db.session_context(&id).await
}
/// The schemas of data source `id`.
pub async fn schemas(host: &Host, window: &str, id: &str) -> IdeResult<Vec<String>> {
#[command(trust = trusted)]
pub async fn db_schemas(host: &Host, window: &str, id: String) -> IdeResult<Vec<String>> {
// The schemas of data source `id`.
let db = host.project(window)?.db.clone();
db.schemas(id).await
db.schemas(&id).await
}
/// The tables and views of `schema`.
pub async fn tables(host: &Host, window: &str, id: &str, schema: &str) -> IdeResult<Vec<TableInfo>> {
#[command(trust = trusted)]
pub async fn db_tables(host: &Host, window: &str, id: String, schema: String) -> IdeResult<Vec<TableInfo>> {
// The tables and views of `schema`.
let db = host.project(window)?.db.clone();
db.tables(id, schema).await
db.tables(&id, &schema).await
}
/// Columns, keys and indexes of `table`.
pub async fn table_details(host: &Host, window: &str, id: &str, schema: &str, table: &str) -> IdeResult<TableDetails> {
let db = host.project(window)?.db.clone();
db.table_details(id, schema, table).await
}
/// The DDL of table or view `table` (Go to DDL, Generate DDL).
pub async fn ddl(host: &Host, window: &str, id: &str, schema: &str, table: &str) -> IdeResult<String> {
let db = host.project(window)?.db.clone();
db.ddl(id, schema, table).await
}
/// The routines and sequences of `schema` (the tree's `routines` / `sequences`).
pub async fn schema_objects(host: &Host, window: &str, id: &str, schema: &str) -> IdeResult<SchemaObjects> {
let db = host.project(window)?.db.clone();
db.schema_objects(id, schema).await
}
/// The definition of a routine, trigger or sequence (Go to DDL, Quick Documentation).
pub async fn object_ddl(
#[command(trust = trusted)]
pub async fn db_table_details(
host: &Host,
window: &str,
id: &str,
schema: &str,
kind: DbObjectKind,
name: &str,
) -> IdeResult<String> {
id: String,
schema: String,
table: String,
) -> IdeResult<TableDetails> {
// Columns, keys and indexes of `table`.
let db = host.project(window)?.db.clone();
db.object_ddl(id, schema, kind, name).await
db.table_details(&id, &schema, &table).await
}
/// Explain Plan: the execution plan of `statement` on `id`, without running it.
pub async fn explain(
#[command(trust = trusted)]
pub async fn db_ddl(host: &Host, window: &str, id: String, schema: String, table: String) -> IdeResult<String> {
// The DDL of table or view `table` (Go to DDL, Generate DDL).
let db = host.project(window)?.db.clone();
db.ddl(&id, &schema, &table).await
}
#[command(trust = trusted)]
pub async fn db_schema_objects(host: &Host, window: &str, id: String, schema: String) -> IdeResult<SchemaObjects> {
// The routines and sequences of `schema` (the tree's `routines` / `sequences`).
let db = host.project(window)?.db.clone();
db.schema_objects(&id, &schema).await
}
#[command(trust = trusted)]
pub async fn db_object_ddl(
host: &Host,
window: &str,
id: String,
schema: String,
kind: DbObjectKind,
name: String,
) -> IdeResult<String> {
// The definition of a routine, trigger or sequence (Go to DDL, Quick Documentation).
let db = host.project(window)?.db.clone();
db.object_ddl(&id, &schema, kind, &name).await
}
#[command(trust = trusted)]
pub async fn db_explain(
host: &Host,
window: &str,
request: RequestId,
id: &str,
statement: &str,
schema: Option<&str>,
id: String,
statement: String,
schema: Option<String>,
) -> IdeResult<Vec<PlanNode>> {
// Explain Plan: the execution plan of `statement` on `id`, without running it.
let db = host.project(window)?.db.clone();
let cancel = host.begin_request(request);
let result = db.explain(id, statement, &cancel, schema).await;
let result = db.explain(&id, &statement, &cancel, schema.as_deref()).await;
host.end_request(request);
result
}
/// The statements data source `id` ran, newest first (Browse Query History).
pub async fn history(host: &Host, window: &str, id: &str) -> IdeResult<Vec<HistoryEntry>> {
#[command(trust = trusted)]
pub async fn db_history(host: &Host, window: &str, id: String) -> IdeResult<Vec<HistoryEntry>> {
// The statements data source `id` ran, newest first (Browse Query History).
let db = host.project(window)?.db.clone();
db.history(id).await
db.history(&id).await
}
/// Removes statements from the query history of `id` (`None`: all of them).
pub async fn remove_history(host: &Host, window: &str, id: &str, texts: Option<Vec<String>>) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn db_remove_history(host: &Host, window: &str, id: String, texts: Option<Vec<String>>) -> IdeResult<()> {
// Removes statements from the query history of `id` (`None`: all of them).
let db = host.project(window)?.db.clone();
db.remove_history(id, texts).await
db.remove_history(&id, texts).await
}
/// Tables, columns and foreign keys for SQL completion.
pub async fn completion(host: &Host, window: &str, id: &str) -> IdeResult<CompletionModel> {
#[command(trust = trusted)]
pub async fn db_completion(host: &Host, window: &str, id: String) -> IdeResult<CompletionModel> {
// Tables, columns and foreign keys for SQL completion.
let db = host.project(window)?.db.clone();
db.completion(id).await
db.completion(&id).await
}
/// Statements a console runs: the selection's (`from < to`) or the one at the caret (`from`).
pub fn statements(host: &Host, window: &str, id: &str, text: &str, from: u32, to: u32) -> IdeResult<Vec<SqlStatement>> {
let driver = host.project(window)?.db.source(id)?.driver;
#[command(trust = trusted)]
pub fn db_statements(
host: &Host,
window: &str,
id: String,
text: String,
from: u32,
to: u32,
) -> IdeResult<Vec<SqlStatement>> {
// Statements a console runs: the selection's (`from < to`) or the one at the caret (`from`).
let driver = host.project(window)?.db.source(&id)?.driver;
Ok(if from < to {
ide_db::split::statements_in(text, from, to, driver)
ide_db::split::statements_in(&text, from, to, driver)
} else {
ide_db::split::statement_at(text, from, driver).into_iter().collect()
ide_db::split::statement_at(&text, from, driver).into_iter().collect()
})
}
/// Runs `statements` in order on data source `id`, stopping at the first
/// error. Each result reads past its first `skip` rows (a later page) and keeps
/// `max_rows`. `schema` is the console's active context: the connection running
/// each statement is put in it first. Cancel with `cancel_request(request)`.
#[allow(clippy::too_many_arguments)]
pub async fn execute(
#[command(trust = trusted)]
pub async fn db_execute(
host: &Host,
window: &str,
request: RequestId,
id: &str,
id: String,
statements: Vec<SqlStatement>,
skip: u32,
// Clients before pagination send no `skip`.
#[default] skip: u32,
max_rows: u32,
schema: Option<&str>,
schema: Option<String>,
) -> IdeResult<Vec<StatementOutcome>> {
// Runs `statements` in order on data source `id`, stopping at the first
// error. Each result reads past its first `skip` rows (a later page) and keeps
// `max_rows`. `schema` is the console's active context: the connection running
// each statement is put in it first. Cancel with `cancel_request(request)`.
let db = host.project(window)?.db.clone();
let cancel = host.begin_request(request);
let mut out = Vec::new();
for statement in statements {
match db.execute_from(id, &statement.text, skip as usize, max_rows.max(1) as usize, &cancel, schema).await {
match db
.execute_from(&id, &statement.text, skip as usize, max_rows.max(1) as usize, &cancel, schema.as_deref())
.await
{
Ok(result) => out.push(StatementOutcome { statement, result: Some(result), error: None }),
Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => {
host.end_request(request);
@@ -435,57 +335,62 @@ pub async fn execute(
Ok(out)
}
/// One page of the rows of `table` (the table editor).
#[allow(clippy::too_many_arguments)]
pub async fn table_page(
#[command(trust = trusted)]
pub async fn db_table_page(
host: &Host,
window: &str,
request: RequestId,
id: &str,
schema: &str,
table: &str,
id: String,
schema: String,
table: String,
filter: Option<String>,
sort: Vec<SortKey>,
offset: u32,
limit: u32,
) -> IdeResult<TablePage> {
// One page of the rows of `table` (the table editor).
let db = host.project(window)?.db.clone();
let cancel = host.begin_request(request);
let result =
db.table_page(id, schema, table, filter.as_deref(), &sort, offset.into(), limit.max(1).into(), &cancel).await;
let result = db
.table_page(&id, &schema, &table, filter.as_deref(), &sort, offset.into(), limit.max(1).into(), &cancel)
.await;
host.end_request(request);
result
}
/// Submits the table editor's changes in one transaction; returns the rows changed.
pub async fn apply_edits(
#[command(trust = trusted)]
pub async fn db_apply_edits(
host: &Host,
window: &str,
id: &str,
schema: &str,
table: &str,
id: String,
schema: String,
table: String,
edits: Vec<DbRowEdit>,
) -> IdeResult<f64> {
// Submits the table editor's changes in one transaction; returns the rows changed.
let db = host.project(window)?.db.clone();
Ok(db.apply_edits(id, schema, table, &edits).await? as f64)
Ok(db.apply_edits(&id, &schema, &table, &edits).await? as f64)
}
/// The query console file of data source `id` (`<dataDir>/consoles/db/<id>/console.sql`),
/// created on first use. Consoles are files of the project, so a remote
/// window resolves it on the host the project runs on.
pub fn console_path(host: &Host, id: &str) -> IdeResult<IpcPath> {
let file = console_dir(host, id)?.join("console.sql");
#[command(trust = always)]
pub fn db_console_path(host: &Host, id: String) -> IdeResult<IpcPath> {
// The query console file of data source `id` (`<dataDir>/consoles/db/<id>/console.sql`),
// created on first use. Consoles are files of the project, so a remote
// window resolves it on the host the project runs on.
let file = console_dir(host, &id)?.join("console.sql");
if !file.exists() {
std::fs::write(&file, "")?;
}
Ok(file.into())
}
/// The query consoles of data source `id`: the default `console.sql`, then
/// `console_1.sql`, `console_2.sql`… in order. `create` adds the next one first
/// (DataGrip's New › Query Console).
pub fn consoles(host: &Host, id: &str, create: bool) -> IdeResult<Vec<IpcPath>> {
let dir = console_dir(host, id)?;
/// The query consoles of data source `id`; `create` adds the next one first.
#[command(trust = always)]
pub fn db_consoles(host: &Host, id: String, create: bool) -> IdeResult<Vec<IpcPath>> {
// The default `console.sql`, then `console_1.sql`, `console_2.sql`… in order
// (`create`: DataGrip's New › Query Console).
let dir = console_dir(host, &id)?;
let default = dir.join("console.sql");
let mut numbered: Vec<(u32, PathBuf)> = std::fs::read_dir(&dir)?
.filter_map(|e| {
@@ -564,3 +469,40 @@ pub fn tool_preview(
pub async fn server_version(host: &Host, window: &str, id: &str) -> IdeResult<u32> {
host.project(window)?.db.server_version(id).await
}
ide_command::domain!(
db:
db_apply_edits,
db_completion,
db_connect,
db_connected,
db_console_path,
db_consoles,
db_database_catalog,
db_databases,
db_ddl,
db_disconnect,
db_execute,
db_explain,
db_finish_transaction,
db_history,
db_object_ddl,
db_remove_history,
db_retain_catalog,
db_save_sources,
db_saved_catalog,
db_schema_objects,
db_schemas,
db_session_context,
db_set_manual_commit,
db_set_password,
db_set_ssh_secret,
db_sources,
db_statements,
db_table_details,
db_table_page,
db_tables,
db_test,
db_test_tunnel,
db_trust_ssh_host,
);
+126 -232
Переглянути файл
@@ -4,12 +4,13 @@ mod kotlin_tests;
mod output;
use crate::Host;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{DebugSessionId, IdeResult};
use ide_dap::*;
use std::path::PathBuf;
/// Starts a session owned by this window: its events (and those of child sessions) go here only.
#[command(trust = trusted)]
pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> IdeResult<DebugSessionId> {
host.require_trust(window)?;
let unity_pid = if config.adapter == "unity" {
@@ -272,44 +273,38 @@ fn match_java_debug_encoding(mut config: LaunchConfig, windows: bool) -> LaunchC
config
}
#[command(trust = trusted)]
pub async fn debug_set_breakpoints(
host: &Host,
_window: &str,
path: PathBuf,
breakpoints: Vec<Breakpoint>,
) -> IdeResult<Vec<BreakpointState>> {
host.debugger.set_breakpoints(path, breakpoints).await
}
pub async fn debug_threads(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<Vec<ThreadInfo>> {
#[command(trust = trusted)]
pub async fn debug_threads(host: &Host, session: DebugSessionId) -> IdeResult<Vec<ThreadInfo>> {
host.debugger.threads(session).await
}
pub async fn debug_stack_trace(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
) -> IdeResult<Vec<StackFrame>> {
#[command(trust = trusted)]
pub async fn debug_stack_trace(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<Vec<StackFrame>> {
host.debugger.stack_trace(session, thread_id).await
}
pub async fn debug_scopes(host: &Host, _window: &str, session: DebugSessionId, frame_id: i64) -> IdeResult<Vec<Scope>> {
#[command(trust = trusted)]
pub async fn debug_scopes(host: &Host, session: DebugSessionId, frame_id: i64) -> IdeResult<Vec<Scope>> {
host.debugger.scopes(session, frame_id).await
}
pub async fn debug_variables(
host: &Host,
_window: &str,
session: DebugSessionId,
reference: i64,
) -> IdeResult<Vec<Variable>> {
#[command(trust = trusted)]
pub async fn debug_variables(host: &Host, session: DebugSessionId, reference: i64) -> IdeResult<Vec<Variable>> {
host.debugger.variables(session, reference).await
}
#[command(trust = trusted)]
pub async fn debug_evaluate(
host: &Host,
_window: &str,
session: DebugSessionId,
frame_id: Option<i64>,
expression: String,
@@ -317,40 +312,38 @@ pub async fn debug_evaluate(
host.debugger.evaluate(session, frame_id, expression).await
}
pub async fn debug_resume(host: &Host, _window: &str, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn debug_resume(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
host.debugger.resume(session, thread_id).await
}
pub async fn debug_pause(host: &Host, _window: &str, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn debug_pause(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
host.debugger.pause(session, thread_id).await
}
/// Types `text` into the session's program (a `runInTerminal` program).
pub async fn debug_send_input(host: &Host, _window: &str, session: DebugSessionId, text: String) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn debug_send_input(host: &Host, session: DebugSessionId, text: String) -> IdeResult<()> {
host.debugger.send_input(session, &text)
}
pub async fn debug_hot_reload(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
pub async fn debug_hot_reload(host: &Host, session: DebugSessionId) -> IdeResult<()> {
host.debugger.hot_reload(session).await
}
pub async fn debug_hot_restart(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
pub async fn debug_hot_restart(host: &Host, session: DebugSessionId) -> IdeResult<()> {
host.debugger.hot_restart(session).await
}
pub async fn debug_step(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
kind: StepKind,
) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn debug_step(host: &Host, session: DebugSessionId, thread_id: i64, kind: StepKind) -> IdeResult<()> {
host.debugger.step(session, thread_id, kind).await
}
#[command(trust = trusted)]
pub async fn debug_run_to(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
path: PathBuf,
@@ -360,14 +353,15 @@ pub async fn debug_run_to(
host.debugger.run_to(session, thread_id, path, line, force).await
}
pub async fn debug_stop(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
#[command(trust = always)]
pub async fn debug_stop(host: &Host, session: DebugSessionId) -> IdeResult<()> {
host.debugger.stop(session).await
}
/// The adapter's completions for an expression being typed in the frame `frame_id`.
/// Completions for an expression typed in Evaluate (`line` / `column` 0-based, UTF-16).
#[command(trust = trusted)]
pub async fn debug_completions(
host: &Host,
_window: &str,
session: DebugSessionId,
frame_id: Option<i64>,
text: String,
@@ -378,9 +372,9 @@ pub async fn debug_completions(
}
/// Evaluate with an explicit DAP context: `repl`, `watch`, `hover` or `clipboard`.
#[command(trust = trusted)]
pub async fn debug_evaluate_in(
host: &Host,
_window: &str,
session: DebugSessionId,
frame_id: Option<i64>,
expression: String,
@@ -390,31 +384,34 @@ pub async fn debug_evaluate_in(
}
/// Last known verification states of a file's breakpoints (refetch on `breakpointsChanged`).
pub fn debug_breakpoint_states(host: &Host, _window: &str, path: PathBuf) -> IdeResult<Vec<BreakpointState>> {
#[command(trust = trusted)]
pub fn debug_breakpoint_states(host: &Host, path: PathBuf) -> IdeResult<Vec<BreakpointState>> {
Ok(host.debugger.breakpoint_states(&path))
}
/// This window's live sessions, including adapter-started child sessions.
#[command(trust = always)]
pub fn debug_sessions(host: &Host, window: &str) -> IdeResult<Vec<SessionInfo>> {
Ok(host.debugger.sessions(Some(host.owner_window(window))))
}
#[command(trust = trusted)]
pub fn debug_exception_filters(host: &Host, window: &str) -> IdeResult<Vec<SessionExceptionFilters>> {
Ok(host.debugger.exception_filters(Some(host.owner_window(window))))
}
#[command(trust = trusted)]
pub async fn debug_set_exception_breakpoints(
host: &Host,
_window: &str,
choices: std::collections::BTreeMap<String, bool>,
) -> IdeResult<()> {
host.debugger.set_exception_breakpoints(choices).await
}
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn debug_set_variable(
host: &Host,
_window: &str,
session: DebugSessionId,
container: i64,
name: String,
@@ -426,28 +423,24 @@ pub async fn debug_set_variable(
}
/// Force Step Over: step over with every breakpoint suspended until the step ends.
pub async fn debug_force_step_over(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn debug_force_step_over(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
host.debugger.force_step_over(session, thread_id).await
}
/// Smart Step Into: the calls on the current line of `frame_id`.
#[command(trust = trusted)]
pub async fn debug_step_in_targets(
host: &Host,
_window: &str,
session: DebugSessionId,
frame_id: i64,
) -> IdeResult<Vec<StepInTarget>> {
host.debugger.step_in_targets(session, frame_id).await
}
#[command(trust = trusted)]
pub async fn debug_step_in_target(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
target_id: i64,
@@ -456,13 +449,15 @@ pub async fn debug_step_in_target(
}
/// Reset Frame (Drop Frame).
pub async fn debug_restart_frame(host: &Host, _window: &str, session: DebugSessionId, frame_id: i64) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn debug_restart_frame(host: &Host, session: DebugSessionId, frame_id: i64) -> IdeResult<()> {
host.debugger.restart_frame(session, frame_id).await
}
/// Breakpoints of a debugged page on DOM events and on requests (js-debug).
#[command(trust = trusted)]
pub async fn debug_js_custom_breakpoints(
host: &Host,
_window: &str,
session: DebugSessionId,
ids: Vec<String>,
xhr: Vec<String>,
@@ -470,61 +465,65 @@ pub async fn debug_js_custom_breakpoints(
host.debugger.js_set_custom_breakpoints(session, ids, xhr).await
}
/// The responses a debugged page gets in place of the server's, by a part of the URL; none
/// switches the replacing off.
#[command(trust = trusted)]
pub async fn debug_js_response_overrides(
host: &Host,
_window: &str,
session: DebugSessionId,
rules: Vec<ide_dap::JsResponseRule>,
) -> IdeResult<()> {
host.debugger.js_set_response_overrides(session, rules).await
}
/// The body of a response a debugged page received.
#[command(trust = trusted)]
pub async fn debug_js_response_body(
host: &Host,
_window: &str,
session: DebugSessionId,
request_id: String,
) -> IdeResult<ide_dap::JsResponseBody> {
host.debugger.js_response_body(session, request_id).await
}
pub async fn debug_js_start_profile(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
/// Starts recording a debugged page's CPU profile.
#[command(trust = trusted)]
pub async fn debug_js_start_profile(host: &Host, session: DebugSessionId) -> IdeResult<()> {
host.debugger.js_start_profile(session).await
}
pub async fn debug_js_stop_profile(
host: &Host,
_window: &str,
session: DebugSessionId,
) -> IdeResult<ide_core::IpcPath> {
/// Ends the recording: a directory holding the profile as `page.cpuprofile`.
#[command(trust = trusted)]
pub async fn debug_js_stop_profile(host: &Host, session: DebugSessionId) -> IdeResult<ide_core::IpcPath> {
host.debugger.js_stop_profile(session).await.map(Into::into)
}
pub fn debug_capabilities(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<DebugCapabilities> {
#[command(trust = trusted)]
pub fn debug_capabilities(host: &Host, session: DebugSessionId) -> IdeResult<DebugCapabilities> {
host.debugger.capabilities(session)
}
/// Method breakpoints (all files); states aligned with `breakpoints`.
#[command(trust = trusted)]
pub async fn debug_set_function_breakpoints(
host: &Host,
_window: &str,
breakpoints: Vec<FunctionBreakpoint>,
) -> IdeResult<Vec<BreakpointState>> {
host.debugger.set_function_breakpoints(breakpoints).await
}
/// Field watchpoints; states aligned with `breakpoints`.
#[command(trust = trusted)]
pub async fn debug_set_data_breakpoints(
host: &Host,
_window: &str,
breakpoints: Vec<DataBreakpoint>,
) -> IdeResult<Vec<BreakpointState>> {
host.debugger.set_data_breakpoints(breakpoints).await
}
#[command(trust = trusted)]
pub async fn debug_data_breakpoint_info(
host: &Host,
_window: &str,
session: DebugSessionId,
container: i64,
name: String,
@@ -534,20 +533,23 @@ pub async fn debug_data_breakpoint_info(
}
/// Attach to Process: the user's processes a debugger can attach to.
pub async fn debug_attachable_processes(_host: &Host, _window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
#[command(trust = always)]
pub async fn debug_attachable_processes() -> IdeResult<Vec<attach::AttachableProcess>> {
tokio::task::spawn_blocking(attach::attachable_processes)
.await
.map_err(|e| ide_core::IdeError::internal(format!("listing processes failed: {e}")))?
}
/// A loopback port that is free right now, for a debug agent the launch line starts
/// (`address=127.0.0.1:<port>`) — used when its "Listening for transport" line never reaches
/// the console (a Surefire fork holds it until the tests run, which `suspend=y` prevents).
/// A loopback port that is free right now, for a debug agent the launch line starts.
#[command(trust = trusted)]
pub async fn debug_free_port(host: &Host, window: &str) -> IdeResult<u16> {
// `address=127.0.0.1:<port>` — used when its "Listening for transport" line never reaches
// the console (a Surefire fork holds it until the tests run, which `suspend=y` prevents).
host.require_trust(window)?;
ide_dap::adapter::free_port().map_err(ide_core::IdeError::from)
}
#[command(trust = trusted)]
pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -561,26 +563,29 @@ pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<a
/// 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.
#[command(trust = trusted)]
pub async fn debug_listen_for_jvm(
host: &Host,
ide: &Host,
window: &str,
request: ide_core::RequestId,
jvm_host: String,
host: String,
port: u16,
) -> IdeResult<u16> {
host.require_trust(window)?;
let token = host.begin_request(request);
let result = jdwp::listen_for_jvm(&jvm_host, port, token).await;
host.end_request(request);
ide.require_trust(window)?;
let token = ide.begin_request(request);
let result = jdwp::listen_for_jvm(&host, port, token).await;
ide.end_request(request);
result
}
/// HotSwap (Reload Changed Classes) in a java-debug session.
pub async fn debug_redefine_classes(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<HotSwapResult> {
#[command(trust = trusted)]
pub async fn debug_redefine_classes(host: &Host, session: DebugSessionId) -> IdeResult<HotSwapResult> {
host.debugger.redefine_classes(session).await
}
/// The debuggee JVM's loaded classes, or why they cannot be read.
/// The debuggee JVM's loaded classes (instances and shallow bytes), or why they cannot be read.
#[command(trust = trusted)]
pub async fn debug_jvm_memory_classes(
host: &Host,
window: &str,
@@ -591,6 +596,7 @@ pub async fn debug_jvm_memory_classes(
}
/// Up to `limit` live instances of the class in the stopped JVM.
#[command(trust = trusted)]
pub async fn debug_jvm_memory_instances(
host: &Host,
window: &str,
@@ -602,7 +608,8 @@ pub async fn debug_jvm_memory_instances(
host.debugger.jvm_memory_instances(session, class_name, limit).await
}
/// The fields (or array elements) of an instance listed by [`debug_jvm_memory_instances`].
/// The fields (or array elements) of an instance in the stopped JVM.
#[command(trust = trusted)]
pub async fn debug_jvm_memory_fields(
host: &Host,
window: &str,
@@ -614,6 +621,7 @@ pub async fn debug_jvm_memory_fields(
}
/// The objects that hold a reference to `object`; `limit` 0 selects the default.
#[command(trust = trusted)]
pub async fn debug_jvm_memory_referrers(
host: &Host,
window: &str,
@@ -625,166 +633,6 @@ pub async fn debug_jvm_memory_referrers(
host.debugger.jvm_memory_referrers(session, object, limit).await
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("debug_start", |c| async move { debug_start(&c.host, &c.window, c.arg("config")?).await });
d.add("debug_set_breakpoints", |c| async move {
debug_set_breakpoints(&c.host, &c.window, c.arg("path")?, c.arg("breakpoints")?).await
});
d.add("debug_threads", |c| async move { debug_threads(&c.host, &c.window, c.arg("session")?).await });
d.add("debug_stack_trace", |c| async move {
debug_stack_trace(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await
});
d.add(
"debug_scopes",
|c| async move { debug_scopes(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?).await },
);
d.add("debug_variables", |c| async move {
debug_variables(&c.host, &c.window, c.arg("session")?, c.arg("reference")?).await
});
d.add("debug_evaluate", |c| async move {
debug_evaluate(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?, c.arg("expression")?).await
});
d.add(
"debug_resume",
|c| async move { debug_resume(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await },
);
d.add(
"debug_pause",
|c| async move { debug_pause(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await },
);
d.add("debug_send_input", |c| async move {
debug_send_input(&c.host, &c.window, c.arg("session")?, c.arg("text")?).await
});
d.add("debug_step", |c| async move {
debug_step(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?, c.arg("kind")?).await
});
d.add("debug_run_to", |c| async move {
debug_run_to(
&c.host,
&c.window,
c.arg("session")?,
c.arg("threadId")?,
c.arg("path")?,
c.arg("line")?,
c.arg("force")?,
)
.await
});
d.add("debug_stop", |c| async move { debug_stop(&c.host, &c.window, c.arg("session")?).await });
d.add("debug_completions", |c| async move {
debug_completions(
&c.host,
&c.window,
c.arg("session")?,
c.arg("frameId")?,
c.arg("text")?,
c.arg("line")?,
c.arg("column")?,
)
.await
});
d.add("debug_evaluate_in", |c| async move {
debug_evaluate_in(
&c.host,
&c.window,
c.arg("session")?,
c.arg("frameId")?,
c.arg("expression")?,
c.arg("context")?,
)
.await
});
d.add("debug_breakpoint_states", |c| async move { debug_breakpoint_states(&c.host, &c.window, c.arg("path")?) });
d.add("debug_sessions", |c| async move { debug_sessions(&c.host, &c.window) });
d.add("debug_exception_filters", |c| async move { debug_exception_filters(&c.host, &c.window) });
d.add("debug_set_exception_breakpoints", |c| async move {
debug_set_exception_breakpoints(&c.host, &c.window, c.arg("choices")?).await
});
d.add("debug_set_variable", |c| async move {
debug_set_variable(
&c.host,
&c.window,
c.arg("session")?,
c.arg("container")?,
c.arg("name")?,
c.arg("evaluateName")?,
c.arg("frameId")?,
c.arg("value")?,
)
.await
});
d.add("debug_force_step_over", |c| async move {
debug_force_step_over(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await
});
d.add("debug_step_in_targets", |c| async move {
debug_step_in_targets(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?).await
});
d.add("debug_step_in_target", |c| async move {
debug_step_in_target(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?, c.arg("targetId")?).await
});
d.add("debug_restart_frame", |c| async move {
debug_restart_frame(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?).await
});
d.add("debug_capabilities", |c| async move { debug_capabilities(&c.host, &c.window, c.arg("session")?) });
d.add("debug_js_response_overrides", |c| async move {
debug_js_response_overrides(&c.host, &c.window, c.arg("session")?, c.arg("rules")?).await
});
d.add("debug_js_response_body", |c| async move {
debug_js_response_body(&c.host, &c.window, c.arg("session")?, c.arg("requestId")?).await
});
d.add("debug_js_custom_breakpoints", |c| async move {
debug_js_custom_breakpoints(&c.host, &c.window, c.arg("session")?, c.arg("ids")?, c.arg("xhr")?).await
});
d.add(
"debug_js_start_profile",
|c| async move { debug_js_start_profile(&c.host, &c.window, c.arg("session")?).await },
);
d.add(
"debug_js_stop_profile",
|c| async move { debug_js_stop_profile(&c.host, &c.window, c.arg("session")?).await },
);
d.add("debug_set_function_breakpoints", |c| async move {
debug_set_function_breakpoints(&c.host, &c.window, c.arg("breakpoints")?).await
});
d.add("debug_set_data_breakpoints", |c| async move {
debug_set_data_breakpoints(&c.host, &c.window, c.arg("breakpoints")?).await
});
d.add("debug_data_breakpoint_info", |c| async move {
debug_data_breakpoint_info(
&c.host,
&c.window,
c.arg("session")?,
c.arg("container")?,
c.arg("name")?,
c.arg("frameId")?,
)
.await
});
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
});
d.add(
"debug_redefine_classes",
|c| async move { debug_redefine_classes(&c.host, &c.window, c.arg("session")?).await },
);
d.add("debug_jvm_memory_classes", |c| async move {
debug_jvm_memory_classes(&c.host, &c.window, c.arg("session")?).await
});
d.add("debug_jvm_memory_instances", |c| async move {
debug_jvm_memory_instances(&c.host, &c.window, c.arg("session")?, c.arg("className")?, c.arg("limit")?).await
});
d.add("debug_jvm_memory_fields", |c| async move {
debug_jvm_memory_fields(&c.host, &c.window, c.arg("session")?, c.arg("object")?).await
});
d.add("debug_jvm_memory_referrers", |c| async move {
debug_jvm_memory_referrers(&c.host, &c.window, c.arg("session")?, c.arg("object")?, c.arg("limit")?).await
});
}
#[cfg(test)]
mod tests {
use super::*;
@@ -918,3 +766,49 @@ mod tests {
}
}
}
ide_command::domain!(
debug:
debug_attachable_processes,
debug_breakpoint_states,
debug_capabilities,
debug_completions,
debug_data_breakpoint_info,
debug_evaluate,
debug_evaluate_in,
debug_exception_filters,
debug_force_step_over,
debug_free_port,
debug_js_custom_breakpoints,
debug_js_response_body,
debug_js_response_overrides,
debug_js_start_profile,
debug_js_stop_profile,
debug_jvm_memory_classes,
debug_jvm_memory_fields,
debug_jvm_memory_instances,
debug_jvm_memory_referrers,
debug_listen_for_jvm,
debug_pause,
debug_redefine_classes,
debug_restart_frame,
debug_resume,
debug_run_to,
debug_scopes,
debug_send_input,
debug_sessions,
debug_set_breakpoints,
debug_set_data_breakpoints,
debug_set_exception_breakpoints,
debug_set_function_breakpoints,
debug_set_variable,
debug_stack_trace,
debug_start,
debug_step,
debug_step_in_target,
debug_step_in_targets,
debug_stop,
debug_threads,
debug_unity_processes,
debug_variables,
);
+6 -8
Переглянути файл
@@ -1,5 +1,6 @@
//! Repository version lookups for manifest inspections and completion.
use crate::{Host, rpc::Dispatcher};
use crate::Host;
use ide_command::command;
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, RequestId};
use ide_workspace::dependencies::{DependencyVersionSource, DependencyVersions, cargo, go, maven, npm};
use std::collections::BTreeMap;
@@ -193,7 +194,7 @@ fn go_source(project: &crate::Project, config_dir: &Path, path: &Path) -> IdeRes
Ok(GoModules { root, env })
}
/// `offset` limits a completion request to its version string; inspections omit it.
#[command(trust = trusted)]
pub async fn dependency_versions(
host: &Host,
window: &str,
@@ -201,6 +202,7 @@ pub async fn dependency_versions(
offset: Option<u32>,
request: RequestId,
) -> IdeResult<Vec<DependencyVersions>> {
// `offset` limits a completion request to its version string; inspections omit it.
let project = host.project(window)?;
let cache = host.dependency_versions.clone();
let config_dir = host.config_dir.clone();
@@ -249,12 +251,6 @@ pub async fn dependency_versions(
result
}
pub(crate) fn register(d: &mut Dispatcher) {
d.add("dependency_versions", |c| async move {
dependency_versions(&c.host, &c.window, c.arg("doc")?, c.arg("offset")?, c.arg("request")?).await
});
}
#[cfg(test)]
mod tests {
use super::*;
@@ -361,3 +357,5 @@ mod tests {
host.close_project("main");
}
}
ide_command::domain!(dependencies: dependency_versions);
+101 -108
Переглянути файл
@@ -1,4 +1,5 @@
use crate::Host;
use ide_command::command;
use ide_core::{CancellationToken, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
use ide_remote::{DeployedPath, DeploymentCoverage, DeploymentRoot, SyncEntry, SyncStep, TransferReport};
use ide_ssh::{FsConnection, RemoteEntry};
@@ -31,212 +32,204 @@ fn local(paths: Vec<IpcPath>) -> Vec<PathBuf> {
paths.into_iter().map(|p| p.to_path_buf()).collect()
}
/// Eligible paths per server, without contacting any deployment host.
pub async fn deploy_coverage(window: &str, state: &Host, paths: Vec<IpcPath>) -> IdeResult<Vec<DeploymentCoverage>> {
let project = state.project(window)?;
#[command(trust = always)]
pub async fn deploy_coverage(window: &str, host: &Host, paths: Vec<IpcPath>) -> IdeResult<Vec<DeploymentCoverage>> {
// Eligible paths per server, without contacting any deployment host.
let project = host.project(window)?;
Ok(ide_remote::coverage(&project.settings.effective(), &project.root, &local(paths)))
}
/// Tools › Deployment › Upload to…: files and folders to `server` (default server when `None`).
#[command(trust = trusted)]
pub async fn deploy_upload(
window: &str,
state: &Host,
host: &Host,
paths: Vec<IpcPath>,
server: Option<String>,
request: RequestId,
) -> IdeResult<TransferReport> {
let project = state.project(window)?;
let token = state.begin_request(request);
// Tools › Deployment › Upload to…: files and folders to `server` (default server when `None`).
let project = host.project(window)?;
let token = host.begin_request(request);
let (mut report, done) = progress(project.sink.clone(), "Uploading", token.clone());
let r = state
let r = host
.remote
.upload(&project.settings.effective(), &project.root, server.as_deref(), &local(paths), token, &mut report)
.await;
done();
state.end_request(request);
host.end_request(request);
r
}
/// Download from…: the remote counterparts of files and folders.
#[command(trust = trusted)]
pub async fn deploy_download(
window: &str,
state: &Host,
host: &Host,
paths: Vec<IpcPath>,
server: Option<String>,
request: RequestId,
) -> IdeResult<TransferReport> {
let project = state.project(window)?;
let token = state.begin_request(request);
// Download from…: the remote counterparts of files and folders.
let project = host.project(window)?;
let token = host.begin_request(request);
let (mut report, done) = progress(project.sink.clone(), "Downloading", token.clone());
let r = state
let r = host
.remote
.download(&project.settings.effective(), &project.root, server.as_deref(), &local(paths), token, &mut report)
.await;
done();
state.end_request(request);
host.end_request(request);
r
}
/// Deletes the remote counterparts of files and folders.
#[command(trust = trusted)]
pub async fn deploy_delete_remote(
window: &str,
state: &Host,
host: &Host,
paths: Vec<IpcPath>,
server: Option<String>,
) -> IdeResult<TransferReport> {
let project = state.project(window)?;
state.remote.delete_remote(&project.settings.effective(), &project.root, server.as_deref(), &local(paths)).await
// Deletes the remote counterparts of files and folders.
let project = host.project(window)?;
host.remote.delete_remote(&project.settings.effective(), &project.root, server.as_deref(), &local(paths)).await
}
/// Sync with Deployed: local and remote files under `path`, side by side.
#[command(trust = trusted)]
pub async fn deploy_compare(
window: &str,
state: &Host,
host: &Host,
path: IpcPath,
server: Option<String>,
request: RequestId,
) -> IdeResult<Vec<SyncEntry>> {
let project = state.project(window)?;
let token = state.begin_request(request);
let r = state.remote.compare(&project.settings.effective(), &project.root, server.as_deref(), &path, token).await;
state.end_request(request);
// Sync with Deployed: local and remote files under `path`, side by side.
let project = host.project(window)?;
let token = host.begin_request(request);
let r = host.remote.compare(&project.settings.effective(), &project.root, server.as_deref(), &path, token).await;
host.end_request(request);
r
}
/// Applies the Sync with Deployed choices.
#[command(trust = trusted)]
pub async fn deploy_sync(
window: &str,
state: &Host,
host: &Host,
steps: Vec<SyncStep>,
server: Option<String>,
request: RequestId,
) -> IdeResult<TransferReport> {
let project = state.project(window)?;
let token = state.begin_request(request);
// Applies the Sync with Deployed choices.
let project = host.project(window)?;
let token = host.begin_request(request);
let (mut report, done) = progress(project.sink.clone(), "Synchronizing", token.clone());
let r = state
let r = host
.remote
.sync(&project.settings.effective(), &project.root, server.as_deref(), &steps, token, &mut report)
.await;
done();
state.end_request(request);
host.end_request(request);
r
}
/// Where `path` is deployed (remote path, web URL); `None` when not mapped.
#[command(trust = trusted)]
pub async fn deploy_info(
window: &str,
state: &Host,
host: &Host,
path: IpcPath,
server: Option<String>,
) -> IdeResult<Option<DeployedPath>> {
let project = state.project(window)?;
state.remote.deployed(&project.settings.effective(), &project.root, server.as_deref(), &path).await
// Where `path` is deployed (remote path, web URL); `None` when not mapped.
let project = host.project(window)?;
host.remote.deployed(&project.settings.effective(), &project.root, server.as_deref(), &path).await
}
/// Remote Host tool window: the resolved server root and project mappings.
pub async fn deploy_server_root(window: &str, state: &Host, server: String) -> IdeResult<DeploymentRoot> {
let project = state.project(window).ok();
let settings =
project.as_ref().map(|p| p.settings.effective()).unwrap_or_else(|| state.global_settings.effective());
state.remote.server_info(&settings, project.as_ref().map(|p| p.root.as_path()), &server).await
#[command(trust = trusted)]
pub async fn deploy_server_root(window: &str, host: &Host, server: String) -> IdeResult<DeploymentRoot> {
// Remote Host tool window: the resolved server root and project mappings.
let project = host.project(window).ok();
let settings = project.as_ref().map(|p| p.settings.effective()).unwrap_or_else(|| host.global_settings.effective());
host.remote.server_info(&settings, project.as_ref().map(|p| p.root.as_path()), &server).await
}
/// Entries of a folder on the selected filesystem (`~`: its home directory).
pub async fn remote_list(state: &Host, connection: FsConnection, path: String) -> IdeResult<Vec<RemoteEntry>> {
state.remote.list(&connection, &path).await
#[command(trust = always)]
pub async fn remote_list(host: &Host, connection: FsConnection, path: String) -> IdeResult<Vec<RemoteEntry>> {
// Entries of a folder on the selected filesystem (`~`: its home directory).
host.remote.list(&connection, &path).await
}
/// Opens a remote file for editing: a local copy, uploaded back on save.
pub async fn remote_open(state: &Host, connection: FsConnection, path: String) -> IdeResult<IpcPath> {
Ok(state.remote.open_remote(&connection, &path).await?.into())
#[command(trust = always)]
pub async fn remote_open(host: &Host, connection: FsConnection, path: String) -> IdeResult<IpcPath> {
// Opens a remote file for editing: a local copy, uploaded back on save.
Ok(host.remote.open_remote(&connection, &path).await?.into())
}
/// The filesystem connection and path a cached editing copy stands for.
pub fn remote_of(state: &Host, path: IpcPath) -> Option<(FsConnection, String)> {
state.remote.remote_of(&path)
#[command(trust = always)]
pub fn remote_of(host: &Host, path: IpcPath) -> Option<(FsConnection, String)> {
// The filesystem connection and path a cached editing copy stands for.
host.remote.remote_of(&path)
}
pub async fn remote_delete(state: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
state.remote.remote_delete(&connection, &path).await
#[command(trust = trusted)]
pub async fn remote_delete(host: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
host.remote.remote_delete(&connection, &path).await
}
pub async fn remote_mkdir(state: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
state.remote.remote_mkdir(&connection, &path).await
#[command(trust = trusted)]
pub async fn remote_mkdir(host: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
host.remote.remote_mkdir(&connection, &path).await
}
pub async fn remote_rename(state: &Host, connection: FsConnection, from: String, to: String) -> IdeResult<()> {
state.remote.remote_rename(&connection, &from, &to).await
#[command(trust = trusted)]
pub async fn remote_rename(host: &Host, connection: FsConnection, from: String, to: String) -> IdeResult<()> {
host.remote.remote_rename(&connection, &from, &to).await
}
/// Remote Host › Download to…: remote files and folders into a local folder, each under its
/// own name.
#[command(trust = trusted)]
pub async fn remote_download_into(
window: &str,
state: &Host,
host: &Host,
connection: FsConnection,
paths: Vec<String>,
target: IpcPath,
request: RequestId,
) -> IdeResult<TransferReport> {
let project = state.project(window)?;
let token = state.begin_request(request);
// Remote Host › Download to…: remote files and folders into a local folder, each under its
// own name.
let project = host.project(window)?;
let token = host.begin_request(request);
let (mut report, done) = progress(project.sink.clone(), "Downloading", token.clone());
let r = state.remote.download_into(&connection, &paths, &target, &token, &mut report).await;
let r = host.remote.download_into(&connection, &paths, &target, &token, &mut report).await;
done();
state.end_request(request);
host.end_request(request);
r
}
/// `password`: an FTP password typed in the settings but not applied yet.
#[command(trust = always)]
pub async fn deploy_test_connection(
state: &Host,
host: &Host,
connection: FsConnection,
path: String,
password: Option<String>,
) -> IdeResult<()> {
state.remote.test_connection_with(&connection, &path, password).await
// `password`: an FTP password typed in the settings but not applied yet.
host.remote.test_connection_with(&connection, &path, password).await
}
pub(crate) fn register(d: &mut crate::rpc::Dispatcher) {
d.add("deploy_coverage", |c| async move { deploy_coverage(&c.window, &c.host, c.arg("paths")?).await });
d.add("deploy_upload", |c| async move {
deploy_upload(&c.window, &c.host, c.arg("paths")?, c.arg("server")?, c.arg("request")?).await
});
d.add("deploy_download", |c| async move {
deploy_download(&c.window, &c.host, c.arg("paths")?, c.arg("server")?, c.arg("request")?).await
});
d.add("deploy_delete_remote", |c| async move {
deploy_delete_remote(&c.window, &c.host, c.arg("paths")?, c.arg("server")?).await
});
d.add("deploy_compare", |c| async move {
deploy_compare(&c.window, &c.host, c.arg("path")?, c.arg("server")?, c.arg("request")?).await
});
d.add("deploy_sync", |c| async move {
deploy_sync(&c.window, &c.host, c.arg("steps")?, c.arg("server")?, c.arg("request")?).await
});
d.add("deploy_info", |c| async move { deploy_info(&c.window, &c.host, c.arg("path")?, c.arg("server")?).await });
d.add("deploy_server_root", |c| async move { deploy_server_root(&c.window, &c.host, c.arg("server")?).await });
d.add("remote_list", |c| async move { remote_list(&c.host, c.arg("connection")?, c.arg("path")?).await });
d.add("remote_open", |c| async move { remote_open(&c.host, c.arg("connection")?, c.arg("path")?).await });
d.add("remote_of", |c| async move { Ok(remote_of(&c.host, c.arg("path")?)) });
d.add("remote_delete", |c| async move { remote_delete(&c.host, c.arg("connection")?, c.arg("path")?).await });
d.add("remote_mkdir", |c| async move { remote_mkdir(&c.host, c.arg("connection")?, c.arg("path")?).await });
d.add("remote_download_into", |c| async move {
remote_download_into(
&c.window,
&c.host,
c.arg("connection")?,
c.arg("paths")?,
c.arg("target")?,
c.arg("request")?,
)
.await
});
d.add("remote_rename", |c| async move {
remote_rename(&c.host, c.arg("connection")?, c.arg("from")?, c.arg("to")?).await
});
d.add("deploy_test_connection", |c| async move {
deploy_test_connection(&c.host, c.arg("connection")?, c.arg("path")?, c.arg("password")?).await
});
}
ide_command::domain!(
deploy:
deploy_compare,
deploy_coverage,
deploy_delete_remote,
deploy_download,
deploy_info,
deploy_server_root,
deploy_sync,
deploy_test_connection,
deploy_upload,
remote_delete,
remote_download_into,
remote_list,
remote_mkdir,
remote_of,
remote_open,
remote_rename,
);
+51 -19
Переглянути файл
@@ -1,9 +1,13 @@
use crate::Host;
use ide_command::command;
use ide_core::{ChangeSet, DocId, IdeResult};
use ide_workspace::DocumentInfo;
use std::path::PathBuf;
pub async fn open(host: &Host, window: &str, path: PathBuf) -> IdeResult<DocumentInfo> {
/// Opens a document. Async: reading and decoding a large file must not block
/// the main thread (synchronous commands run on it).
#[command(trust = always)]
pub async fn doc_open(host: &Host, window: &str, path: PathBuf) -> IdeResult<DocumentInfo> {
let project = host.project(window)?;
host.blocking(move || {
let info = project.documents.open(&path)?;
@@ -16,22 +20,30 @@ pub async fn open(host: &Host, window: &str, path: PathBuf) -> IdeResult<Documen
.await
}
pub fn close(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
host.project(window)?.documents.close(doc);
Ok(())
#[command(trust = always)]
pub async fn doc_close(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
let project = host.project(window)?;
blocking(move || {
project.documents.close(doc);
Ok(())
})
.await
}
/// Opens an editable untitled buffer (a new-file tab); it reaches the disk
/// through [`save_as`], which turns it into a regular file document. `name`
/// re-references an already minted buffer instead of creating one.
pub async fn open_untitled(host: &Host, window: &str, name: Option<String>) -> IdeResult<DocumentInfo> {
/// through `doc_save_as`, which turns it into a regular file document.
#[command(trust = always)]
pub async fn doc_open_untitled(host: &Host, window: &str, name: Option<String>) -> IdeResult<DocumentInfo> {
// `name` re-references an already minted buffer instead of creating one.
let project = host.project(window)?;
host.blocking(move || project.documents.open_untitled(name.as_deref())).await
}
/// Save As for an untitled buffer ([`Documents::save_as`]); LightEdit windows
/// start watching the saved file's folder.
pub async fn save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -> IdeResult<DocumentInfo> {
/// Save As for an untitled buffer: writes it to `path` and re-keys the buffer
/// (undo history and version are kept; the language is re-detected).
#[command(trust = always)]
pub async fn doc_save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -> IdeResult<DocumentInfo> {
// LightEdit windows start watching the saved file's folder.
let project = host.project(window)?;
host.blocking(move || {
let info = project.documents.save_as(doc, &path)?;
@@ -43,25 +55,31 @@ pub async fn save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -> Id
.await
}
/// Applies a CodeMirror change set; returns the new version (`outOfSync` when `base_version` is stale).
pub fn edit(host: &Host, window: &str, doc: DocId, base_version: u32, changes: ChangeSet) -> IdeResult<u32> {
host.project(window)?.documents.edit(doc, base_version, changes)
/// Applies a CodeMirror change set; returns the new version. Rejects with
/// `outOfSync` when `base_version` is stale; the UI then calls `doc_snapshot`.
#[command(trust = always, desktop_body = async)]
pub async fn doc_edit(host: &Host, window: &str, doc: DocId, base_version: u32, changes: ChangeSet) -> IdeResult<u32> {
let project = host.project(window)?;
blocking(move || project.documents.edit(doc, base_version, changes)).await
}
pub async fn save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
#[command(trust = always)]
pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
let project = host.project(window)?;
host.blocking(move || project.documents.save(doc)).await?;
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
}
pub async fn save_all(host: &Host, window: &str) -> IdeResult<()> {
#[command(trust = always)]
pub async fn doc_save_all(host: &Host, window: &str) -> IdeResult<()> {
let project = host.project(window)?;
host.blocking(move || project.documents.save_all()).await?;
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
}
/// Recovers external changes missed by the project's file watchers.
pub async fn sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
#[command(trust = always)]
pub async fn doc_sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
// Recovers external changes missed by the project's file watchers.
let project = host.project(window)?;
host.blocking(move || {
if project.settings.effective().files.sync_on_focus {
@@ -72,13 +90,27 @@ pub async fn sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
.await
}
pub async fn snapshot(host: &Host, window: &str, doc: DocId) -> IdeResult<DocumentInfo> {
#[command(trust = always)]
pub async fn doc_snapshot(host: &Host, window: &str, doc: DocId) -> IdeResult<DocumentInfo> {
let project = host.project(window)?;
host.blocking(move || project.documents.snapshot(doc)).await
}
mod commands;
pub mod commands;
pub use commands::*;
#[cfg(test)]
mod tests;
ide_command::domain!(
doc:
doc_close,
doc_edit,
doc_open,
doc_open_untitled,
doc_save,
doc_save_all,
doc_save_as,
doc_snapshot,
doc_sync_from_disk,
);
+42 -38
Переглянути файл
@@ -1,7 +1,5 @@
#[allow(unused_imports)]
use super::*;
use crate::Host;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{DocId, IdeError, IdeResult, OutlineItem, Range};
use ide_language::{FoldRange, SyntaxHighlights};
use ide_text::LineEnding;
@@ -16,6 +14,7 @@ pub async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send
/// Opens a read-only virtual document (see `lsp_virtual_document`) as an
/// editor buffer, so syntax features and language-server requests work in it.
#[command(trust = always)]
pub async fn doc_open_virtual(host: &Host, window: &str, uri: String) -> IdeResult<DocumentInfo> {
let project = host.project(window)?;
let vd = crate::ops::lsp::lsp_virtual_document(host, window, uri).await?;
@@ -35,6 +34,7 @@ pub async fn doc_open_virtual(host: &Host, window: &str, uri: String) -> IdeResu
/// The language and CodeMirror mode `path` is shown with in an editor, without opening
/// it: previews of closed files and diffs. `first_line` is the shown text's (a revision's)
/// for hashbang detection; without it the file's on disk counts.
#[command(trust = always)]
pub async fn doc_language(
host: &Host,
window: &str,
@@ -46,8 +46,7 @@ pub async fn doc_language(
}
/// "Reload with Encoding" (`reload`) or "Convert to Encoding"; returns the new encoding and BOM state.
/// Virtual documents re-read their origin (archive, language server, Git blob)
/// instead of a disk file; converting them would write to it, so it stays refused.
#[command(trust = always)]
pub async fn doc_set_encoding(
host: &Host,
window: &str,
@@ -55,6 +54,8 @@ pub async fn doc_set_encoding(
encoding: String,
reload: bool,
) -> IdeResult<DocumentEncoding> {
// Virtual documents re-read their origin (archive, language server, Git blob)
// instead of a disk file; converting them would write to it, so it stays refused.
let project = host.project(window)?;
if reload
&& !project.documents.is_untitled(doc)?
@@ -70,20 +71,24 @@ pub async fn doc_set_encoding(
host.blocking(move || project.documents.set_encoding(doc, &encoding, reload)).await
}
/// Adds or removes the BOM on a UTF-8 document; the change is written on save.
#[command(trust = always)]
pub async fn doc_set_bom(host: &Host, window: &str, doc: DocId, has_bom: bool) -> IdeResult<DocumentEncoding> {
// Adds or removes the BOM on a UTF-8 document; the change is written on save.
let project = host.project(window)?;
host.blocking(move || project.documents.set_bom(doc, has_bom)).await
}
pub fn doc_set_line_ending(host: &Host, window: &str, doc: DocId, line_ending: LineEnding) -> IdeResult<()> {
host.project(window)?.documents.set_line_ending(doc, line_ending)
#[command(trust = always)]
pub async fn doc_set_line_ending(host: &Host, window: &str, doc: DocId, line_ending: LineEnding) -> IdeResult<()> {
let project = host.project(window)?;
blocking(move || project.documents.set_line_ending(doc, line_ending)).await
}
/// Structure view: LSP document symbols when available (with tree-sitter
/// visibility), tree-sitter otherwise.
/// Tree-sitter answers come from the per-document tree cache (incremental
/// re-parse); large documents get no syntax structure.
#[command(trust = always)]
pub async fn doc_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<OutlineItem>> {
let project = host.project(window)?;
let lsp = project.lsp.document_symbols(doc).await.ok().flatten();
@@ -122,6 +127,7 @@ pub async fn doc_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec
.await
}
#[command(trust = always)]
pub async fn doc_folding(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<FoldRange>> {
let project = host.project(window)?;
blocking(move || {
@@ -156,6 +162,7 @@ pub async fn doc_folding(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec
/// Tree-sitter highlighting for languages the UI has no CodeMirror mode for;
/// empty when the grammar has no highlights query or the document is large.
#[command(trust = always)]
pub async fn doc_highlights(host: &Host, window: &str, doc: DocId) -> IdeResult<SyntaxHighlights> {
let project = host.project(window)?;
blocking(move || {
@@ -168,9 +175,10 @@ pub async fn doc_highlights(host: &Host, window: &str, doc: DocId) -> IdeResult<
.await
}
/// Python class facts the inheritance inspections read: base names as written, a method's
/// parameters, decorator semantics and its body shape. Tree-sitter answers; no LSP.
/// Python class facts for the inheritance inspections: tree-sitter, no language server.
#[command(trust = always)]
pub async fn doc_python_facts(host: &Host, window: &str, doc: DocId) -> IdeResult<ide_language::PythonFacts> {
// Base names as written, a method's parameters, decorator semantics and its body shape.
let project = host.project(window)?;
let syntax = host.syntax();
let snap = project.documents.text_snapshot(doc)?;
@@ -179,6 +187,7 @@ pub async fn doc_python_facts(host: &Host, window: &str, doc: DocId) -> IdeResul
/// Extend Selection (⌥↑): syntax ranges around `offset`, innermost first.
/// Large documents fall back to word / line / document ranges.
#[command(trust = always)]
pub async fn doc_selection_ranges(host: &Host, window: &str, doc: DocId, offset: u32) -> IdeResult<Vec<Range>> {
let project = host.project(window)?;
blocking(move || {
@@ -204,35 +213,30 @@ pub async fn doc_selection_ranges(host: &Host, window: &str, doc: DocId, offset:
.await
}
pub fn history_list(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec<HistoryEntry>> {
host.project(window)?.history.list(&path)
#[command(trust = always)]
pub async fn history_list(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec<HistoryEntry>> {
let project = host.project(window)?;
blocking(move || project.history.list(&path)).await
}
pub fn history_content(host: &Host, window: &str, id: String) -> IdeResult<String> {
host.project(window)?.history.content(&id)
#[command(trust = always)]
pub async fn history_content(host: &Host, window: &str, id: String) -> IdeResult<String> {
let project = host.project(window)?;
blocking(move || project.history.content(&id)).await
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("doc_open_virtual", |c| async move { doc_open_virtual(&c.host, &c.window, c.arg("uri")?).await });
d.add(
"doc_language",
|c| async move { doc_language(&c.host, &c.window, c.arg("path")?, c.arg("firstLine")?).await },
);
d.add("doc_set_encoding", |c| async move {
doc_set_encoding(&c.host, &c.window, c.arg("doc")?, c.arg("encoding")?, c.arg("reload")?).await
});
d.add("doc_set_bom", |c| async move { doc_set_bom(&c.host, &c.window, c.arg("doc")?, c.arg("hasBom")?).await });
d.add("doc_set_line_ending", |c| async move {
blocking(move || doc_set_line_ending(&c.host, &c.window, c.arg("doc")?, c.arg("lineEnding")?)).await
});
d.add("doc_outline", |c| async move { doc_outline(&c.host, &c.window, c.arg("doc")?).await });
d.add("doc_folding", |c| async move { doc_folding(&c.host, &c.window, c.arg("doc")?).await });
d.add("doc_highlights", |c| async move { doc_highlights(&c.host, &c.window, c.arg("doc")?).await });
d.add("doc_python_facts", |c| async move { doc_python_facts(&c.host, &c.window, c.arg("doc")?).await });
d.add("doc_selection_ranges", |c| async move {
doc_selection_ranges(&c.host, &c.window, c.arg("doc")?, c.arg("offset")?).await
});
d.add("history_list", |c| async move { history_list(&c.host, &c.window, c.arg("path")?) });
d.add("history_content", |c| async move { history_content(&c.host, &c.window, c.arg("id")?) });
}
ide_command::domain!(
doc_commands:
doc_folding,
doc_highlights,
doc_language,
doc_open_virtual,
doc_outline,
doc_python_facts,
doc_selection_ranges,
doc_set_bom,
doc_set_encoding,
doc_set_line_ending,
history_content,
history_list,
);
+5 -4
Переглянути файл
@@ -46,11 +46,11 @@ impl Fixture {
}
async fn open(&self, path: &Path) -> DocumentInfo {
open(&self.host, "main", path.to_path_buf()).await.unwrap()
doc_open(&self.host, "main", path.to_path_buf()).await.unwrap()
}
async fn sync(&self) {
sync_from_disk(&self.host, "main").await.unwrap();
doc_sync_from_disk(&self.host, "main").await.unwrap();
}
fn document_events(&self) -> Vec<IdeEvent> {
@@ -95,13 +95,14 @@ async fn unchanged_document_has_no_patch_or_event() {
async fn dirty_document_keeps_edits_and_warns_once() {
let f = Fixture::new();
let original = f.open(&f.path).await;
edit(
doc_edit(
&f.host,
"main",
original.id,
original.version,
ChangeSet { changes: vec![TextChange { from: 0, to: 0, insert: "local ".into() }] },
)
.await
.unwrap();
f.events.lock().clear();
std::fs::write(&f.path, "external replacement\n").unwrap();
@@ -196,7 +197,7 @@ async fn synchronization_only_changes_the_calling_windows_documents() {
let other_root = f.outside.parent().unwrap().join("other-project");
std::fs::create_dir(&other_root).unwrap();
let other = f.host.open_project("other", &other_root).unwrap();
let other_doc = open(&f.host, "other", f.outside.clone()).await.unwrap();
let other_doc = doc_open(&f.host, "other", f.outside.clone()).await.unwrap();
std::fs::write(&f.outside, "external change in shared file\n").unwrap();
f.sync().await;
assert_eq!(f.project.documents.snapshot(original.id).unwrap().text, "external change in shared file\n");
+49 -10
Переглянути файл
@@ -1,17 +1,56 @@
//! Docker run configurations: the environment their `docker` command line runs with.
//! Docker run configurations: the environment their `docker` command line runs with; and Docker
//! connections through an SSH configuration, tunnelled with the IDE's own SSH client.
use crate::Host;
use crate::rpc::Dispatcher;
use ide_core::IdeResult;
use ide_command::command;
use ide_core::{IdeError, IdeResult};
use ide_docker::DockerEndpoint;
use std::collections::BTreeMap;
use ide_ssh::Tunnel;
use std::collections::{BTreeMap, HashMap};
use std::sync::Arc;
/// The endpoint's variables plus a `PATH` that finds this host's `docker`. A remote project
/// gets them from the server, since its run configurations start on the remote host.
pub async fn run_env(host: &Host, endpoint: DockerEndpoint) -> IdeResult<BTreeMap<String, String>> {
/// What each tunnelled connection runs on the SSH host, as the Docker CLI's `ssh://` does.
const DIAL: &str = "docker system dial-stdio";
/// Open tunnels of [`DockerEndpoint::Ssh`] connections, by SSH configuration id.
#[derive(Default)]
pub struct DockerTunnels(tokio::sync::Mutex<HashMap<String, Arc<Tunnel>>>);
/// `endpoint` as docker can use it: an SSH configuration becomes the local end of a tunnel to its
/// host's daemon (opened on first use, reopened when the SSH connection dropped).
pub async fn resolve(host: &Host, endpoint: DockerEndpoint) -> IdeResult<DockerEndpoint> {
let DockerEndpoint::Ssh { config } = endpoint else { return Ok(endpoint) };
let id = config.trim().to_owned();
let mut tunnels = host.docker_tunnels.0.lock().await;
let tunnel = match tunnels.get(&id).filter(|t| !t.is_closed()) {
Some(t) => t.clone(),
None => {
let session = host.ssh.session(&id).await?;
// Fail with the reason here: a missing docker only shows as a dropped connection later.
let probe = session.exec("docker version --format {{.Client.Version}}", None).await?;
if !probe.success() {
let why = String::from_utf8_lossy(&probe.stderr).trim().to_owned();
return Err(IdeError::unavailable(format!(
"docker could not be run on {} over SSH{}",
session.label(),
if why.is_empty() { String::new() } else { format!(": {why}") }
)));
}
let t = Arc::new(Tunnel::command(session, DIAL).await?);
tunnels.insert(id, t.clone());
t
}
};
Ok(DockerEndpoint::Tcp { host: format!("tcp://127.0.0.1:{}", tunnel.port()), tls_cert_dir: None })
}
/// Environment for a Docker run configuration's command line: selects `endpoint`'s
/// daemon and puts the docker executable on `PATH`.
#[command(trust = always)]
pub async fn docker_run_env(host: &Host, endpoint: DockerEndpoint) -> IdeResult<BTreeMap<String, String>> {
// A remote project gets them from the server, since its run configurations start on the remote host.
endpoint.validate()?;
let endpoint = resolve(host, endpoint).await?;
host.blocking(move || Ok(ide_docker::run_env(&endpoint))).await
}
pub(crate) fn register(d: &mut Dispatcher) {
d.add("docker_run_env", |c| async move { run_env(&c.host, c.arg("endpoint")?).await });
}
ide_command::domain!(docker: docker_run_env);
+8 -7
Переглянути файл
@@ -2,19 +2,20 @@
//! (and, on the remote server, the project's `remoteEnv`) without a restart.
use crate::Host;
use crate::environment::EnvReloaded;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::IdeResult;
use std::sync::Arc;
/// Re-reads the login shell (and the window's project `remoteEnv` where it applies);
/// running terminals and processes keep their environment.
pub async fn reload(host: &Arc<Host>, window: &str) -> IdeResult<EnvReloaded> {
/// Reload Environment: new child processes get the login shell's current environment
/// (and the project's `remoteEnv` on a remote host); running ones keep theirs.
#[command(trust = always)]
pub async fn env_reload(host: &Arc<Host>, window: &str) -> IdeResult<EnvReloaded> {
// Re-reads the login shell (and the window's project `remoteEnv` where it applies);
// running terminals and processes keep their environment.
let root = host.project(window).ok().filter(|p| !p.light && p.is_trusted()).map(|p| p.root.clone());
let sink = host.window_sink(window);
let h = host.clone();
host.blocking(move || h.environment.reload(root.as_deref(), &sink)).await
}
pub(crate) fn register(d: &mut Dispatcher) {
d.add("env_reload", |c| async move { reload(&c.host, &c.window).await });
}
ide_command::domain!(env: env_reload);
+49 -14
Переглянути файл
@@ -1,10 +1,12 @@
use super::Channel;
use crate::Host;
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId};
use ide_vfs::FileEntry;
use std::path::{Path, PathBuf};
pub async fn entry_kind(host: &Host, path: PathBuf) -> IdeResult<ide_vfs::EntryKind> {
#[command(trust = always)]
pub async fn fs_entry_kind(host: &Host, path: PathBuf) -> IdeResult<ide_vfs::EntryKind> {
host.blocking(move || {
let meta = std::fs::metadata(path)?;
Ok(if meta.is_dir() { ide_vfs::EntryKind::Dir } else { ide_vfs::EntryKind::File })
@@ -12,7 +14,8 @@ pub async fn entry_kind(host: &Host, path: PathBuf) -> IdeResult<ide_vfs::EntryK
.await
}
pub async fn compare_directories(
#[command(trust = always)]
pub async fn fs_compare_directories(
host: &Host,
window: &str,
left: PathBuf,
@@ -38,7 +41,8 @@ pub async fn compare_directories(
result
}
pub async fn copy_merge(
#[command(trust = always)]
pub async fn fs_copy_merge(
host: &Host,
window: &str,
source_root: PathBuf,
@@ -73,8 +77,9 @@ pub async fn copy_merge(
/// Files of a deleted folder snapshotted in Local History.
const DELETE_SNAPSHOT_LIMIT: usize = 2000;
/// Runs on the blocking pool: on a network share (`\\wsl.localhost`) every stat is slow.
pub async fn read_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec<FileEntry>> {
#[command(trust = always)]
pub async fn fs_read_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec<FileEntry>> {
// Runs on the blocking pool: on a network share (`\\wsl.localhost`) every stat is slow.
let project = host.project(window);
host.blocking(move || {
let excludes = project
@@ -99,7 +104,8 @@ pub async fn read_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<Vec
/// Creates an empty file; inside a project, honours the EditorConfig
/// `charset` (writes the BOM for `utf-8-bom` / UTF-16).
pub fn create_file(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
#[command(trust = always)]
pub fn fs_create_file(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
match host.project(window) {
Ok(p) => {
let defaults = p.documents.file_defaults();
@@ -124,7 +130,8 @@ pub fn create_file(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
}
}
pub async fn create_file_bytes(host: &Host, window: &str, path: PathBuf, data: Vec<u8>) -> IdeResult<()> {
#[command(trust = always)]
pub async fn fs_create_file_bytes(host: &Host, window: &str, path: PathBuf, data: Vec<u8>) -> IdeResult<()> {
let project = host.project(window).ok();
host.blocking(move || {
ide_vfs::create_file_bytes(&path, &data)?;
@@ -138,17 +145,25 @@ pub async fn create_file_bytes(host: &Host, window: &str, path: PathBuf, data: V
.await
}
#[command(trust = always)]
pub fn fs_create_dir(path: PathBuf) -> IdeResult<()> {
ide_vfs::create_dir(&path)
}
/// Toggle Read-only Attribute: sets the writable bit (and the open document's
/// state). Returns whether the file is read-only now.
pub fn set_writable(host: &Host, window: &str, path: PathBuf, writable: bool) -> IdeResult<bool> {
#[command(trust = always)]
pub fn fs_set_writable(host: &Host, window: &str, path: PathBuf, writable: bool) -> IdeResult<bool> {
match host.project(window) {
Ok(p) => p.documents.set_writable(&path, writable),
Err(_) => ide_vfs::set_writable(&path, writable).map(|()| !writable),
}
}
/// Moves to the trash; Local History keeps the contents so deleted files can be restored.
pub async fn delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
/// Moving to the trash can take a while (large trees): kept off the main thread.
#[command(trust = always)]
pub async fn fs_delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
// Local History keeps the contents so deleted files can be restored.
let project = host.project(window).ok();
let history = project.as_ref().map(|p| p.history.clone());
host.blocking(move || {
@@ -168,7 +183,8 @@ pub async fn delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
.await
}
pub async fn copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
#[command(trust = always)]
pub async fn fs_copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
let project = host.project(window).ok();
host.blocking(move || {
ide_workspace::file_ops::copy(&from, &to)?;
@@ -183,7 +199,8 @@ pub async fn copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeR
.await
}
pub async fn rename(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
#[command(trust = always)]
pub async fn fs_rename(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
let project = host.project(window).ok();
host.blocking(move || {
ide_workspace::file_ops::rename(&from, &to)?;
@@ -199,8 +216,10 @@ pub async fn rename(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> Id
.await
}
/// Reads a text file without opening it as a document; prefers the unsaved buffer.
pub async fn read_text(host: &Host, window: &str, path: PathBuf) -> IdeResult<String> {
/// Reads a text file without opening it as a document (previews, quick
/// definition). Prefers the unsaved buffer when the file is open.
#[command(trust = always)]
pub async fn fs_read_text(host: &Host, window: &str, path: PathBuf) -> IdeResult<String> {
let project = host.project(window).ok();
host.blocking(move || match project {
Some(p) => p.text_of(&path),
@@ -251,3 +270,19 @@ mod tests {
assert!(!inside_any_root(Path::new("/work/spec.pdf"), &[]));
}
}
ide_command::domain!(
fs:
fs_compare_directories,
fs_copy,
fs_copy_merge,
fs_create_dir,
fs_create_file,
fs_create_file_bytes,
fs_delete,
fs_entry_kind,
fs_read_dir,
fs_read_text,
fs_rename,
fs_set_writable,
);
+31 -45
Переглянути файл
@@ -4,7 +4,7 @@
use crate::Host;
use crate::ops::Channel;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{CancellationToken, DebugSessionId, IdeError, IdeResult, IpcPath, RequestId};
use ide_dap::{JvmHeapOutcome, JvmHeapUnavailable};
use ide_heap::{AnalyzeOptions, HeapError, HeapOrigin, OpenSnapshot};
@@ -55,8 +55,8 @@ pub enum HeapOpenResult {
Cancelled,
}
/// Dumps the session's JVM into a new snapshot directory and analyzes the dump there; cancel with
/// `request`. Anything but `Ready` leaves no directory behind.
/// Dumps the session's JVM and analyzes the dump; cancel with `request`.
#[command(trust = trusted)]
pub async fn debug_heap_capture(
host: &Host,
window: &str,
@@ -64,6 +64,7 @@ pub async fn debug_heap_capture(
request: RequestId,
on_progress: Channel<HeapProgress>,
) -> IdeResult<HeapCaptureResult> {
// Dumps into a new snapshot directory; anything but `Ready` leaves no directory behind.
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
let running = Running::begin(host, request, &cancel);
@@ -119,8 +120,8 @@ async fn capture(
})
}
/// Analyzes the `.hprof` at `path` into a new snapshot directory; the file itself is never
/// changed or deleted. Cancel with `request`.
/// Analyzes an `.hprof` file; cancel with `request`.
#[command(trust = trusted)]
pub async fn debug_heap_open(
host: &Host,
window: &str,
@@ -128,6 +129,7 @@ pub async fn debug_heap_open(
request: RequestId,
on_progress: Channel<HeapProgress>,
) -> IdeResult<HeapOpenResult> {
// Analyzes into a new snapshot directory; the file itself is never changed or deleted.
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
let running = Running::begin(host, request, &cancel);
@@ -297,14 +299,14 @@ fn reporter<'a>(
}
}
/// The class table of a snapshot.
#[command(trust = trusted)]
pub async fn debug_heap_classes(host: &Host, window: &str, snapshot: HeapSnapshotId) -> IdeResult<Vec<HeapClassRow>> {
let snapshot = open_snapshot(host, window, snapshot)?;
host.blocking(move || Ok(snapshot.index().class_rows())).await
}
/// A page of the dominator tree; see [`ide_heap::HeapIndex::dominated`] for what `parent` and
/// `class_index` select.
/// A page of the dominator tree: under `parent`, of type `classIndex`, or both.
#[command(trust = trusted)]
pub async fn debug_heap_dominators(
host: &Host,
window: &str,
@@ -314,11 +316,13 @@ pub async fn debug_heap_dominators(
offset: u32,
limit: u32,
) -> IdeResult<HeapObjectPage> {
// See `ide_heap::HeapIndex::dominated` for what `parent` and `class_index` select.
let snapshot = open_snapshot(host, window, snapshot)?;
host.blocking(move || Ok(snapshot.index().dominated(parent, class_index, offset, limit))).await
}
/// The shortest path from `object` to a GC root; `None` when it is unreachable.
/// The shortest path from `object` to a GC root; `null` when it is unreachable.
#[command(trust = trusted)]
pub async fn debug_heap_path(
host: &Host,
window: &str,
@@ -329,27 +333,30 @@ pub async fn debug_heap_path(
host.blocking(move || Ok(snapshot.index().path_to_root(object))).await
}
/// Class-by-class differences from `base` to `current`.
#[command(trust = trusted)]
pub async fn debug_heap_compare(
host: &Host,
window: &str,
base: HeapSnapshotId,
current: HeapSnapshotId,
) -> IdeResult<Vec<HeapClassDiff>> {
// Class-by-class differences from `base` to `current`.
let base = open_snapshot(host, window, base)?;
let current = open_snapshot(host, window, current)?;
host.blocking(move || Ok(ide_heap::compare(base.index(), current.index()))).await
}
/// Copies the snapshot's dump to `path`, replacing a file there (the UI has asked).
/// Copies the snapshot's dump to `path`, replacing a file there.
#[command(trust = trusted)]
pub async fn debug_heap_save(host: &Host, window: &str, snapshot: HeapSnapshotId, path: IpcPath) -> IdeResult<()> {
let snapshot = open_snapshot(host, window, snapshot)?;
let target = path.into_path_buf();
host.blocking(move || copy_replacing(&snapshot.dump, &target)).await
}
/// Forgets the snapshot and deletes its directory once no query is using it.
#[command(trust = trusted)]
pub async fn debug_heap_close(host: &Host, window: &str, snapshot: HeapSnapshotId) -> IdeResult<()> {
// Forgets the snapshot and deletes its directory once no query is using it.
open_snapshot(host, window, snapshot)?;
close(host, snapshot).await
}
@@ -483,38 +490,17 @@ fn now_ms() -> u64 {
.map_or(0, |d| u64::try_from(d.as_millis()).unwrap_or(u64::MAX))
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("debug_heap_capture", |c| async move {
debug_heap_capture(&c.host, &c.window, c.arg("session")?, c.arg("request")?, c.sender("onProgress")?).await
});
d.add("debug_heap_open", |c| async move {
debug_heap_open(&c.host, &c.window, c.arg("path")?, c.arg("request")?, c.sender("onProgress")?).await
});
d.add("debug_heap_classes", |c| async move { debug_heap_classes(&c.host, &c.window, c.arg("snapshot")?).await });
d.add("debug_heap_dominators", |c| async move {
debug_heap_dominators(
&c.host,
&c.window,
c.arg("snapshot")?,
c.arg("parent")?,
c.arg("classIndex")?,
c.arg("offset")?,
c.arg("limit")?,
)
.await
});
d.add("debug_heap_path", |c| async move {
debug_heap_path(&c.host, &c.window, c.arg("snapshot")?, c.arg("object")?).await
});
d.add("debug_heap_compare", |c| async move {
debug_heap_compare(&c.host, &c.window, c.arg("base")?, c.arg("current")?).await
});
d.add("debug_heap_save", |c| async move {
debug_heap_save(&c.host, &c.window, c.arg("snapshot")?, c.arg("path")?).await
});
d.add("debug_heap_close", |c| async move { debug_heap_close(&c.host, &c.window, c.arg("snapshot")?).await });
}
#[cfg(test)]
mod tests;
ide_command::domain!(
heap:
debug_heap_capture,
debug_heap_classes,
debug_heap_close,
debug_heap_compare,
debug_heap_dominators,
debug_heap_open,
debug_heap_path,
debug_heap_save,
);
+5 -10
Переглянути файл
@@ -1,6 +1,6 @@
//! Local History beyond single files: folders, labels, restoring deleted files.
use crate::Host;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::IdeResult;
use ide_workspace::DirectoryHistory;
@@ -9,12 +9,14 @@ use std::path::PathBuf;
use super::doc::blocking;
/// Show History on a folder: snapshots of the files under it (deleted ones included) and labels.
#[command(trust = always)]
pub async fn history_list_dir(host: &Host, window: &str, path: PathBuf) -> IdeResult<DirectoryHistory> {
let project = host.project(window)?;
blocking(move || project.history.list_dir(&path)).await
}
/// Local History › Put Label…: a named point in the history of every file.
#[command(trust = always)]
pub fn history_put_label(host: &Host, window: &str, label: String) -> IdeResult<()> {
let project = host.project(window)?;
project.history.put_label(&project.root, &label)
@@ -22,6 +24,7 @@ pub fn history_put_label(host: &Host, window: &str, label: String) -> IdeResult<
/// Revert to a snapshot: writes its content to `path` (re-creating a deleted
/// file and its folders); an open editor updates in place.
#[command(trust = always)]
pub async fn history_restore(host: &Host, window: &str, path: PathBuf, id: String) -> IdeResult<()> {
let project = host.project(window)?;
blocking(move || {
@@ -44,12 +47,4 @@ pub async fn history_restore(host: &Host, window: &str, path: PathBuf, id: Strin
.await
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("history_list_dir", |c| async move { history_list_dir(&c.host, &c.window, c.arg("path")?).await });
d.add("history_put_label", |c| async move { history_put_label(&c.host, &c.window, c.arg("label")?) });
d.add(
"history_restore",
|c| async move { history_restore(&c.host, &c.window, c.arg("path")?, c.arg("id")?).await },
);
}
ide_command::domain!(history: history_list_dir, history_put_label, history_restore);
+9 -15
Переглянути файл
@@ -2,7 +2,7 @@
pub(crate) mod cache;
use crate::Host;
use crate::rpc::Dispatcher;
use ide_command::command;
use super::build::load;
use ide_build::compile;
@@ -13,10 +13,10 @@ use ide_run::BuildPolicy;
use std::path::PathBuf;
/// Cancellable with `cancel_request(request)`.
/// Builds the workspace (when `build`), then resolves the runtime (or test)
/// Builds according to `policy`, then resolves the runtime (or test)
/// classpath and the JDK of the module at `module` (absolute, or relative to the project root).
/// A module with Kotlin / Groovy / Scala sources is built by its build system, whose class directories come first.
/// Resources a Gradle build filters or renames are processed by Gradle, replacing the language server's plain copies.
#[command(trust = trusted)]
pub async fn java_resolve_launch(
host: &Host,
window: &str,
@@ -25,6 +25,8 @@ pub async fn java_resolve_launch(
policy: BuildPolicy,
request: RequestId,
) -> IdeResult<JavaLaunchInfo> {
// Resources a Gradle build filters or renames are processed by Gradle, replacing the language
// server's plain copies.
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
let result = resolve_launch(host, window, module, test, policy, &cancel).await;
@@ -373,6 +375,7 @@ fn use_snapshot_on(
}
/// Port of java-debug's DAP server inside the jdtls serving `module` (started on demand).
#[command(trust = trusted)]
pub async fn java_debug_server(host: &Host, window: &str, module: PathBuf) -> IdeResult<u16> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -381,6 +384,7 @@ pub async fn java_debug_server(host: &Host, window: &str, module: PathBuf) -> Id
}
/// Incremental build of the jdtls workspace serving `module` (e.g. before HotSwap).
#[command(trust = trusted)]
pub async fn java_build_workspace(
host: &Host,
window: &str,
@@ -399,18 +403,6 @@ pub async fn java_build_workspace(
result
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("java_resolve_launch", |c| async move {
java_resolve_launch(&c.host, &c.window, c.arg("module")?, c.arg("test")?, c.arg("policy")?, c.arg("request")?)
.await
});
d.add("java_debug_server", |c| async move { java_debug_server(&c.host, &c.window, c.arg("module")?).await });
d.add("java_build_workspace", |c| async move {
java_build_workspace(&c.host, &c.window, c.arg("module")?, c.arg("request")?).await
});
}
/// An annotation processor's error for writing a file this build already wrote (JDT's
/// `IdeFilerImpl`: "Source file already created", javac's Filer: "Attempt to recreate a file").
fn processor_recreated_a_file(message: &str) -> bool {
@@ -678,3 +670,5 @@ mod tests {
}
}
}
ide_command::domain!(java: java_build_workspace, java_debug_server, java_resolve_launch);
+4
Переглянути файл
@@ -1,5 +1,6 @@
//! Bounded, read-only JVM presentation for visible files, also served remotely.
use crate::Host;
use ide_command::command;
use ide_core::{CancellationToken, IdeError, IdeResult, LanguageId};
use ide_syntax::{JvmPresentation, Snapshot, StructureService, jvm_type_header};
use serde::{Deserialize, Serialize};
@@ -59,6 +60,7 @@ fn read_presentation(
Ok(presentation)
}
#[command(trust = always)]
pub async fn jvm_file_presentations(
host: &Host,
window: &str,
@@ -132,3 +134,5 @@ mod tests {
assert_eq!(presentation.kind, Some(ide_syntax::JvmTypeKind::Class));
}
}
ide_command::domain!(jvm_icons: jvm_file_presentations);
+152 -257
Переглянути файл
@@ -1,8 +1,7 @@
use super::doc::blocking;
use crate::Host;
use crate::apply_workspace_edit as apply_edit;
use crate::plugins::{ProviderKind, editor_providers_for as editor_providers};
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::error::ErrorKind;
use ide_core::{DocId, IdeError, IdeResult, Location, Pos, Range, RequestId, ServerId, TextEdit, WorkspaceEdit};
use ide_lsp::types::*;
@@ -60,6 +59,7 @@ async fn prepare_actions(
.await
}
#[command(trust = trusted)]
pub async fn lsp_completion(
host: &Host,
window: &str,
@@ -224,6 +224,7 @@ fn plugin_completion(item: ide_plugin::CompletionItem) -> CompletionItem {
}
/// Inline (ghost text) suggestions at `pos`; `automatic` when triggered by typing.
#[command(trust = trusted)]
pub async fn lsp_inline_completion(
host: &Host,
window: &str,
@@ -256,6 +257,7 @@ pub async fn lsp_inline_completion(
}
}
#[command(trust = trusted)]
pub async fn lsp_resolve_completion(
host: &Host,
window: &str,
@@ -265,6 +267,7 @@ pub async fn lsp_resolve_completion(
host.project(window)?.lsp.resolve_completion(doc, item).await
}
#[command(trust = trusted)]
pub async fn lsp_hover(
host: &Host,
window: &str,
@@ -294,6 +297,7 @@ pub async fn lsp_hover(
Ok(crate::plugins::merge_hover(server, hovers))
}
#[command(trust = trusted)]
pub async fn lsp_signature_help(host: &Host, window: &str, doc: DocId, pos: Pos) -> IdeResult<Option<SignatureHelp>> {
let target = position_document(host, window, doc, pos).await?;
let server = host.project(window)?.lsp.signature_help(target, pos).await;
@@ -313,6 +317,7 @@ pub async fn lsp_signature_help(host: &Host, window: &str, doc: DocId, pos: Pos)
}
}
#[command(trust = trusted)]
pub async fn lsp_goto(host: &Host, window: &str, doc: DocId, pos: Pos, kind: GotoKind) -> IdeResult<Vec<Location>> {
let target = position_document(host, window, doc, pos).await?;
// ⌘B on a declaration shows its usages, also when a plugin's index links the name elsewhere
@@ -459,7 +464,8 @@ fn without_generated_helpers(locations: Vec<Location>) -> Vec<Location> {
locations.into_iter().filter(|l| !generated(l)).collect()
}
/// Gutter markers from plugins (`line-markers` providers) for `doc`.
/// Gutter markers of plugin `line-markers` providers for an open document.
#[command(trust = trusted)]
pub async fn plugin_line_markers(
host: &Host,
window: &str,
@@ -484,6 +490,7 @@ pub async fn plugin_line_markers(
/// Implementations of the symbols at `positions`, one list per position (the
/// editor's "is implemented / overridden" gutter markers). Cancel with
/// `cancel_request(request)`.
#[command(trust = trusted)]
pub async fn lsp_implementations(
host: &Host,
window: &str,
@@ -553,6 +560,7 @@ pub async fn lsp_implementations(
/// Refines the implementations `targets` of the method at `pos` to their declarations (Java
/// dependencies' class files point at the start of the class). Cancel with
/// `cancel_request(request)`.
#[command(trust = trusted)]
pub async fn lsp_implementation_locations(
host: &Host,
window: &str,
@@ -568,9 +576,10 @@ pub async fn lsp_implementation_locations(
result
}
/// Go to Implementation of the symbol at `pos`. Implementations found before a slower
/// search for the rest (Java: the project's, before the dependencies') arrive on
/// `on_partial`; the result has them all. Cancel with `cancel_request(request)`.
/// Go to Implementation of the symbol at `pos`. Implementations found before a
/// slower search for the rest arrive on `on_partial`; the result has them all.
/// Cancel with `cancel_request(request)`.
#[command(trust = trusted)]
pub async fn lsp_goto_implementation(
host: &Host,
window: &str,
@@ -579,6 +588,7 @@ pub async fn lsp_goto_implementation(
pos: Pos,
on_partial: super::Channel<Vec<Location>>,
) -> IdeResult<Vec<Location>> {
// Java: the project's implementations arrive before the dependencies'.
let lsp = host.project(window)?.lsp.clone();
let (target, cancel) = begin_position_request(host, window, request, doc, pos).await?;
let result = lsp
@@ -596,6 +606,7 @@ pub async fn lsp_goto_implementation(
/// Contents of a read-only language-server document, including JDT library
/// classes and disk class files. Cached per project.
#[command(trust = trusted)]
pub async fn lsp_virtual_document(host: &Host, window: &str, uri: String) -> IdeResult<VirtualDocument> {
if uri.starts_with("git-revision:") {
return crate::ops::vcs::revision_virtual_document(host, window, &uri, None).await;
@@ -603,8 +614,9 @@ pub async fn lsp_virtual_document(host: &Host, window: &str, uri: String) -> Ide
host.project(window)?.lsp.virtual_document(&uri).await
}
/// Whether this class belongs to the project's Maven local repository.
#[command(trust = trusted)]
pub async fn lsp_can_download_sources(host: &Host, window: &str, uri: String) -> IdeResult<bool> {
// Whether this class belongs to the project's Maven local repository.
let project = host.project(window)?;
if !project.is_trusted() {
return Ok(false);
@@ -620,7 +632,7 @@ pub async fn lsp_can_download_sources(host: &Host, window: &str, uri: String) ->
.await
}
/// Download with the project's Maven configuration, or attach an archive selected by the user.
#[command(trust = trusted)]
pub async fn lsp_library_sources(
host: &Host,
window: &str,
@@ -629,6 +641,7 @@ pub async fn lsp_library_sources(
pos: Pos,
sources: Option<std::path::PathBuf>,
) -> IdeResult<Option<Location>> {
// Download with the project's Maven configuration, or attach an archive selected by the user.
host.require_trust(window)?;
let project = host.project(window)?;
let cancel = host.begin_project_request(window, request);
@@ -679,19 +692,21 @@ pub async fn lsp_library_sources(
result
}
/// Opens compiled classes through JDT, with project source taking priority on disk.
#[command(trust = trusted)]
pub async fn lsp_resolve_class_file(host: &Host, window: &str, path: std::path::PathBuf) -> IdeResult<String> {
// Opens compiled classes through JDT, with project source taking priority on disk.
let archive = ide_vfs::split_archive_path(&path);
host.project(window)?.lsp.java_class_file(&path, archive).await
}
/// References of the symbol at `pos`. `project_wide` also searches project files
/// outside the language server's analysis scope; bulk scans over many symbols
/// leave it off. Java: without `libraries`, the dependencies and the JDK are not
/// searched; with it and `project_wide`, those found in the sources arrive on `on_partial` before
/// leave it off. Java, `project_wide`: without `libraries`, the dependencies and the JDK
/// are not searched; with it, those found in the sources arrive on `on_partial` before
/// the slower search for the rest, and the result has them all. Cancel with
/// `cancel_request(request)`.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn lsp_references(
host: &Host,
window: &str,
@@ -703,6 +718,7 @@ pub async fn lsp_references(
libraries: bool,
on_partial: super::Channel<References>,
) -> IdeResult<References> {
// Java: without `libraries`, the dependencies and the JDK are not searched.
let project = host.project(window)?;
let lsp = project.lsp.clone();
let (target, cancel) = begin_position_request(host, window, request, doc, pos).await?;
@@ -842,6 +858,7 @@ fn merge_indexed_references(mut server: References, symbol: &crate::plugins::nav
server
}
#[command(trust = trusted)]
pub async fn lsp_document_highlights(host: &Host, window: &str, doc: DocId, pos: Pos) -> IdeResult<Vec<Highlight>> {
let target = position_document(host, window, doc, pos).await?;
let server = host.project(window)?.lsp.document_highlights(target, pos).await;
@@ -852,6 +869,7 @@ pub async fn lsp_document_highlights(host: &Host, window: &str, doc: DocId, pos:
Ok(merge_language_highlights(provider_server(server)?, items))
}
#[command(trust = trusted)]
pub async fn lsp_workspace_symbols(
host: &Host,
window: &str,
@@ -865,6 +883,7 @@ pub async fn lsp_workspace_symbols(
result
}
#[command(trust = trusted)]
pub async fn lsp_code_actions(
host: &Host,
window: &str,
@@ -1018,6 +1037,7 @@ async fn resolve_action(host: &Host, window: &str, doc: DocId, action: CodeActio
}
/// Cancellable code actions with the kinds the servers advertise (Refactor This, refactoring availability).
#[command(trust = trusted)]
pub async fn lsp_code_action_query(
host: &Host,
window: &str,
@@ -1038,7 +1058,8 @@ pub async fn lsp_code_action_query(
Ok(result)
}
/// Resolves a code action's edit without applying it.
/// Resolves a code action's edit without applying it (intention preview).
#[command(trust = trusted)]
pub async fn lsp_resolve_code_action(
host: &Host,
window: &str,
@@ -1056,6 +1077,7 @@ pub async fn lsp_resolve_code_action(
}
/// Resolves (if needed), applies the edit, then runs the command of a code action.
#[command(trust = trusted)]
pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action: CodeAction) -> IdeResult<()> {
let project = host.project(window)?;
let action = if action.edit.is_none() && action.command.is_none() {
@@ -1072,7 +1094,7 @@ pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action
if let Some(edit) = &action.edit {
let documents = project.documents.clone();
let edit = edit.clone();
blocking(move || apply_edit(&documents, &edit)).await?;
blocking(move || documents.apply_workspace_edit(&edit)).await?;
}
open_plugin_action_target(&action, window);
if let Some(command) = &action.command
@@ -1122,6 +1144,7 @@ async fn is_client_follow_up(
!provided
}
#[command(trust = trusted)]
pub async fn lsp_prepare_rename(host: &Host, window: &str, doc: DocId, pos: Pos) -> IdeResult<Option<Range>> {
if let Some(symbol) = indexed_symbol(host, window, doc, pos).await? {
let project = host.project(window)?;
@@ -1140,8 +1163,8 @@ pub async fn lsp_prepare_rename(host: &Host, window: &str, doc: DocId, pos: Pos)
host.project(window)?.lsp.prepare_rename(doc, pos).await
}
/// Computes the rename edit without applying it, so the UI can preview conflicts.
/// The class at `pos` and the members a class-hierarchy refactoring can move.
/// The class at `pos` and the members Pull Members Up / Push Members Down can move.
#[command(trust = trusted)]
pub async fn lsp_hierarchy_members(
host: &Host,
window: &str,
@@ -1157,8 +1180,9 @@ pub async fn lsp_hierarchy_members(
result
}
/// Checks a class-hierarchy refactoring and computes its edit without applying it.
/// Checks Pull Members Up / Push Members Down and computes the edit without applying it.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn lsp_hierarchy_refactor(
host: &Host,
window: &str,
@@ -1191,7 +1215,7 @@ pub async fn lsp_hierarchy_refactor(
.await
}
/// The signature of the method at `pos`, for Change Signature.
#[command(trust = trusted)]
pub async fn lsp_signature_info(
host: &Host,
window: &str,
@@ -1199,6 +1223,7 @@ pub async fn lsp_signature_info(
doc: DocId,
pos: Pos,
) -> IdeResult<MethodSignature> {
// The signature of the method at `pos`, for Change Signature.
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.change_signature_info(doc, pos, cancel).await;
@@ -1206,8 +1231,8 @@ pub async fn lsp_signature_info(
result
}
/// Checks changing the method at `pos` to `signature` and computes the edit without applying it.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn lsp_change_signature(
host: &Host,
window: &str,
@@ -1218,6 +1243,7 @@ pub async fn lsp_change_signature(
delegate: bool,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
// Checks changing the method at `pos` to `signature` and computes the edit without applying it.
let project = host.project(window)?;
let documents = project.documents.clone();
let version = blocking(move || documents.version(doc)).await?;
@@ -1248,8 +1274,7 @@ 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.
#[command(trust = trusted)]
pub async fn lsp_java_move_destinations(
host: &Host,
window: &str,
@@ -1258,6 +1283,8 @@ pub async fn lsp_java_move_destinations(
kind: String,
args: String,
) -> IdeResult<Vec<String>> {
// 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.
let args = json_argument(&args)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
@@ -1266,7 +1293,7 @@ pub async fn lsp_java_move_destinations(
result.map(json_strings)
}
/// The project's Java source types, for moving a member or type into a class.
#[command(trust = trusted)]
pub async fn lsp_java_source_types(
host: &Host,
window: &str,
@@ -1274,6 +1301,7 @@ pub async fn lsp_java_source_types(
doc: DocId,
project_name: Option<String>,
) -> IdeResult<Vec<String>> {
// The project's Java source types, for moving a member or type into a class.
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.java_source_types(doc, project_name, cancel).await;
@@ -1281,8 +1309,8 @@ pub async fn lsp_java_source_types(
result.map(json_strings)
}
/// Checks a Java move and computes its edit without applying it.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn lsp_java_move(
host: &Host,
window: &str,
@@ -1292,6 +1320,7 @@ pub async fn lsp_java_move(
args: String,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
// Checks a Java move and computes its edit without applying it.
let args = json_argument(&args)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
@@ -1307,7 +1336,7 @@ pub async fn lsp_java_move(
.await
}
/// The Java class to extract an interface from: its members and the packages for the interface.
#[command(trust = trusted)]
pub async fn lsp_extract_interface_info(
host: &Host,
window: &str,
@@ -1315,6 +1344,7 @@ pub async fn lsp_extract_interface_info(
doc: DocId,
pos: Pos,
) -> IdeResult<ExtractInterfaceInfo> {
// The Java class to extract an interface from: its members and the packages for the interface.
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.extract_interface_info(doc, pos, cancel).await;
@@ -1322,9 +1352,8 @@ pub async fn lsp_extract_interface_info(
result
}
/// Checks extracting a Java interface and computes its edit without applying it; `destination`
/// is one of the info's packages.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn lsp_extract_interface(
host: &Host,
window: &str,
@@ -1336,6 +1365,8 @@ pub async fn lsp_extract_interface(
destination: String,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
// Checks extracting a Java interface and computes its edit without applying it; `destination`
// is one of the info's packages.
let destination = json_argument(&destination)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
@@ -1351,6 +1382,8 @@ pub async fn lsp_extract_interface(
.await
}
/// Computes the rename edit without applying it, so the UI can preview conflicts.
#[command(trust = trusted)]
pub async fn lsp_rename(
host: &Host,
window: &str,
@@ -1533,6 +1566,7 @@ fn merge_indexed_rename(
renamed.edit.deduplicate();
}
#[command(trust = trusted)]
pub async fn lsp_format(
host: &Host,
window: &str,
@@ -1543,6 +1577,7 @@ pub async fn lsp_format(
crate::formatter::format(host, window, doc, range, options).await
}
#[command(trust = trusted)]
pub async fn lsp_inlay_hints(host: &Host, window: &str, doc: DocId, range: Range) -> IdeResult<Vec<InlayHint>> {
let lsp = host.project(window)?.lsp.clone();
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::InlayHints) else {
@@ -1562,6 +1597,7 @@ pub async fn lsp_inlay_hints(host: &Host, window: &str, doc: DocId, range: Range
Ok(crate::plugins::merge_inlay_hints(server, hints, range))
}
#[command(trust = trusted)]
pub async fn lsp_semantic_tokens(host: &Host, window: &str, doc: DocId) -> IdeResult<Option<SemanticTokens>> {
let lsp = host.project(window)?.lsp.clone();
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::SemanticTokens) else {
@@ -1581,6 +1617,7 @@ pub async fn lsp_semantic_tokens(host: &Host, window: &str, doc: DocId) -> IdeRe
Ok(Some(crate::plugins::merge_semantic_tokens(server, tokens)))
}
#[command(trust = trusted)]
pub async fn lsp_code_lens(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<CodeLens>> {
let server = host.project(window)?.lsp.code_lens(doc).await;
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::CodeLenses) else {
@@ -1600,6 +1637,7 @@ pub async fn lsp_code_lens(host: &Host, window: &str, doc: DocId) -> IdeResult<V
}
/// Links in a document (`href`s, Markdown links, `#include`s…) from its language servers.
#[command(trust = trusted)]
pub async fn lsp_document_links(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<DocumentLink>> {
let server = host.project(window)?.lsp.document_links(doc).await;
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::DocumentLinks) else {
@@ -1630,6 +1668,7 @@ pub async fn lsp_document_links(host: &Host, window: &str, doc: DocId) -> IdeRes
Ok(out)
}
#[command(trust = trusted)]
pub async fn lsp_call_hierarchy(
host: &Host,
window: &str,
@@ -1645,6 +1684,7 @@ pub async fn lsp_call_hierarchy(
result
}
#[command(trust = trusted)]
pub async fn lsp_type_hierarchy(
host: &Host,
window: &str,
@@ -1655,6 +1695,7 @@ pub async fn lsp_type_hierarchy(
host.project(window)?.lsp.type_hierarchy(doc, pos, direction).await
}
#[command(trust = trusted)]
pub async fn lsp_prepare_type_hierarchy(
host: &Host,
window: &str,
@@ -1664,15 +1705,27 @@ pub async fn lsp_prepare_type_hierarchy(
host.project(window)?.lsp.prepare_type_hierarchy(doc, pos).await
}
#[command(trust = always)]
pub fn lsp_servers(host: &Host, window: &str) -> IdeResult<Vec<ServerInfo>> {
Ok(host.project(window)?.lsp.servers())
}
/// Answers a server's `window/showMessageRequest` question (`null`: dismissed). It runs where the
/// language server runs: the question waits in that process, a remote project's server included.
#[command(trust = trusted)]
pub fn lsp_message_request_answer(id: u32, choice: Option<String>) -> IdeResult<()> {
ide_lsp::answer_message_request(id, choice);
Ok(())
}
/// Re-emits the language servers' current diagnostics (the UI loaded after they arrived).
#[command(trust = always)]
pub fn lsp_resend_diagnostics(host: &Host, window: &str) -> IdeResult<()> {
host.project(window)?.lsp.resend_diagnostics();
Ok(())
}
#[command(trust = trusted)]
pub async fn lsp_restart(host: &Host, window: &str, server: ServerId) -> IdeResult<()> {
let project = host.project(window)?;
let java = project.lsp.servers().iter().any(|s| s.id == server && s.name == "jdtls");
@@ -1706,11 +1759,12 @@ pub async fn lsp_restart_named(host: &Host, name: &str) -> IdeResult<()> {
}
/// Applies a (previewed) workspace edit, e.g. after rename confirmation.
#[command(trust = always)]
pub async fn apply_workspace_edit(host: &Host, window: &str, edit: WorkspaceEdit) -> IdeResult<()> {
let project = host.project(window)?;
blocking(move || {
record_before_multi_file_edit(&project, &edit);
apply_edit(&project.documents, &edit)
project.documents.apply_workspace_edit(&edit)
})
.await
}
@@ -1741,6 +1795,7 @@ fn record_before_multi_file_edit(project: &crate::Project, edit: &WorkspaceEdit)
}
}
#[command(trust = always)]
pub async fn prepare_workspace_edit(host: &Host, window: &str, mut edit: WorkspaceEdit) -> IdeResult<WorkspaceEdit> {
let project = host.project(window)?;
blocking(move || {
@@ -1750,11 +1805,13 @@ pub async fn prepare_workspace_edit(host: &Host, window: &str, mut edit: Workspa
.await
}
#[command(trust = always)]
pub async fn undo_workspace_edit(host: &Host, window: &str, id: u32) -> IdeResult<()> {
let project = host.project(window)?;
blocking(move || project.documents.undo_workspace_edit(id)).await
}
#[command(trust = always)]
pub async fn redo_workspace_edit(host: &Host, window: &str, id: u32) -> IdeResult<()> {
let project = host.project(window)?;
blocking(move || project.documents.redo_workspace_edit(id)).await
@@ -1762,6 +1819,7 @@ pub async fn redo_workspace_edit(host: &Host, window: &str, id: u32) -> IdeResul
/// Runs a server command (`workspace/executeCommand`), e.g. a completion item's
/// follow-up command. Edits the server requests arrive via `workspace/applyEdit`.
#[command(trust = trusted)]
pub async fn lsp_execute_command(host: &Host, window: &str, doc: DocId, command: Command) -> IdeResult<()> {
if let Some(rest) = command.command.strip_prefix("openidea.plugin-language:") {
let (plugin, command_id) =
@@ -1832,7 +1890,7 @@ async fn run_plugin_server_command(
Some(blocking(move || plugins.run_language_command(&plugin, &run, Some(&arguments), invocation)).await)
}
/// Resolves an interactive command without applying edits or executing it.
#[command(trust = trusted)]
pub async fn lsp_resolve_command(
host: &Host,
window: &str,
@@ -1842,6 +1900,7 @@ pub async fn lsp_resolve_command(
command: Command,
answers: Vec<FormAnswer>,
) -> IdeResult<Option<CommandForm>> {
// Resolves an interactive command without applying edits or executing it.
let lsp = host.project(window)?.lsp.clone();
let cancel = host.begin_request(request);
let result = lsp.resolve_command(doc, server, command, answers, cancel).await;
@@ -1849,7 +1908,7 @@ pub async fn lsp_resolve_command(
result
}
/// Applies an explicitly invoked action after the interactive answers have been validated.
#[command(trust = trusted)]
pub async fn lsp_execute_code_action(
host: &Host,
window: &str,
@@ -1858,6 +1917,7 @@ pub async fn lsp_execute_code_action(
action: CodeAction,
answers: Vec<FormAnswer>,
) -> IdeResult<Vec<ide_core::IpcPath>> {
// Applies an explicitly invoked action after the interactive answers have been validated.
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = async {
@@ -1869,7 +1929,7 @@ pub async fn lsp_execute_code_action(
let open = plugin_action_open(&action).map(|(_, path)| path);
if let Some(edit) = action.edit {
let documents = project.documents.clone();
tokio::task::spawn_blocking(move || apply_edit(&documents, &edit))
tokio::task::spawn_blocking(move || documents.apply_workspace_edit(&edit))
.await
.map_err(|e| ide_core::IdeError::internal(e.to_string()))??;
}
@@ -1905,6 +1965,7 @@ pub struct PluginLanguageVisuals {
pub colors: Vec<(String, ide_plugin::language_features::ColorInfo)>,
pub gutter_actions: Vec<(String, ide_plugin::language_features::GutterAction)>,
}
#[command(trust = trusted)]
pub async fn plugin_language_visuals(host: &Host, window: &str, doc: DocId) -> IdeResult<PluginLanguageVisuals> {
let project = host.project(window)?;
let snap = project.documents.snapshot(doc)?;
@@ -1941,6 +2002,7 @@ pub async fn plugin_language_visuals(host: &Host, window: &str, doc: DocId) -> I
})
.await
}
#[command(trust = trusted)]
pub async fn plugin_color_presentations(
host: &Host,
window: &str,
@@ -1965,234 +2027,9 @@ pub async fn plugin_color_presentations(
})
.await
}
pub fn plugin_formatters() -> Vec<crate::plugins::language_features::FormatterChoice> {
crate::plugins::editor_plugin_host().map(|p| p.formatter_choices()).unwrap_or_default()
}
pub(crate) fn register(d: &mut Dispatcher) {
d.add(
"plugin_language_visuals",
|c| async move { plugin_language_visuals(&c.host, &c.window, c.arg("doc")?).await },
);
d.add("plugin_color_presentations", |c| async move {
plugin_color_presentations(&c.host, &c.window, c.arg("doc")?, c.arg("plugin")?, c.arg("color")?).await
});
d.add("plugin_formatters", |_c| async move { Ok(plugin_formatters()) });
d.add("lsp_completion", |c| async move {
lsp_completion(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, c.arg("trigger")?).await
});
d.add("lsp_inline_completion", |c| async move {
lsp_inline_completion(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, c.arg("automatic")?)
.await
});
d.add("lsp_resolve_completion", |c| async move {
lsp_resolve_completion(&c.host, &c.window, c.arg("doc")?, c.arg("item")?).await
});
d.add("lsp_hover", |c| async move {
lsp_hover(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_signature_help", |c| async move {
lsp_signature_help(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?).await
});
d.add(
"lsp_goto",
|c| async move { lsp_goto(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?, c.arg("kind")?).await },
);
d.add("lsp_implementations", |c| async move {
lsp_implementations(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("positions")?).await
});
d.add("lsp_goto_implementation", |c| async move {
let on_partial = c.sender("onPartial")?;
lsp_goto_implementation(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, on_partial).await
});
d.add("lsp_implementation_locations", |c| async move {
lsp_implementation_locations(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("targets")?,
)
.await
});
d.add(
"lsp_resolve_class_file",
|c| async move { lsp_resolve_class_file(&c.host, &c.window, c.arg("path")?).await },
);
d.add("lsp_virtual_document", |c| async move { lsp_virtual_document(&c.host, &c.window, c.arg("uri")?).await });
d.add(
"lsp_can_download_sources",
|c| async move { lsp_can_download_sources(&c.host, &c.window, c.arg("uri")?).await },
);
d.add("lsp_library_sources", |c| async move {
lsp_library_sources(&c.host, &c.window, c.arg("request")?, c.arg("uri")?, c.arg("pos")?, c.arg("sources")?)
.await
});
d.add("lsp_references", |c| async move {
let on_partial = c.sender("onPartial")?;
lsp_references(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("includeDeclaration")?,
c.arg("projectWide")?,
c.arg("libraries")?,
on_partial,
)
.await
});
d.add("lsp_document_highlights", |c| async move {
lsp_document_highlights(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_workspace_symbols", |c| async move {
lsp_workspace_symbols(&c.host, &c.window, c.arg("request")?, c.arg("query")?).await
});
d.add("lsp_code_actions", |c| async move {
lsp_code_actions(&c.host, &c.window, c.arg("doc")?, c.arg("range")?, c.arg("only")?).await
});
d.add("lsp_code_action_query", |c| async move {
lsp_code_action_query(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("range")?, c.arg("only")?)
.await
});
d.add("lsp_resolve_code_action", |c| async move {
lsp_resolve_code_action(&c.host, &c.window, c.arg("doc")?, c.arg("action")?).await
});
d.add("lsp_apply_code_action", |c| async move {
lsp_apply_code_action(&c.host, &c.window, c.arg("doc")?, c.arg("action")?).await
});
d.add("lsp_prepare_rename", |c| async move {
lsp_prepare_rename(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_rename", |c| async move {
lsp_rename(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, c.arg("newName")?).await
});
d.add("lsp_hierarchy_members", |c| async move {
lsp_hierarchy_members(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, c.arg("kind")?).await
});
d.add("lsp_hierarchy_refactor", |c| async move {
lsp_hierarchy_refactor(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("kind")?,
c.arg("target")?,
c.arg("choices")?,
)
.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_extract_interface_info", |c| async move {
lsp_extract_interface_info(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_extract_interface", |c| async move {
lsp_extract_interface(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("members")?,
c.arg("name")?,
c.arg("destination")?,
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
});
d.add(
"lsp_inlay_hints",
|c| async move { lsp_inlay_hints(&c.host, &c.window, c.arg("doc")?, c.arg("range")?).await },
);
d.add("lsp_semantic_tokens", |c| async move { lsp_semantic_tokens(&c.host, &c.window, c.arg("doc")?).await });
d.add("lsp_code_lens", |c| async move { lsp_code_lens(&c.host, &c.window, c.arg("doc")?).await });
d.add("lsp_document_links", |c| async move { lsp_document_links(&c.host, &c.window, c.arg("doc")?).await });
d.add("lsp_call_hierarchy", |c| async move {
lsp_call_hierarchy(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, c.arg("direction")?)
.await
});
d.add("lsp_type_hierarchy", |c| async move {
lsp_type_hierarchy(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?, c.arg("direction")?).await
});
d.add("lsp_prepare_type_hierarchy", |c| async move {
lsp_prepare_type_hierarchy(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_servers", |c| async move { lsp_servers(&c.host, &c.window) });
d.add("lsp_resend_diagnostics", |c| async move { lsp_resend_diagnostics(&c.host, &c.window) });
d.add("lsp_restart", |c| async move { lsp_restart(&c.host, &c.window, c.arg("server")?).await });
d.add("apply_workspace_edit", |c| async move { apply_workspace_edit(&c.host, &c.window, c.arg("edit")?).await });
d.add("lsp_resolve_command", |c| async move {
lsp_resolve_command(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("server")?,
c.arg("command")?,
c.arg("answers")?,
)
.await
});
d.add("lsp_execute_code_action", |c| async move {
lsp_execute_code_action(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("action")?,
c.arg("answers")?,
)
.await
});
d.add(
"prepare_workspace_edit",
|c| async move { prepare_workspace_edit(&c.host, &c.window, c.arg("edit")?).await },
);
d.add("redo_workspace_edit", |c| async move { redo_workspace_edit(&c.host, &c.window, c.arg("id")?).await });
d.add("undo_workspace_edit", |c| async move { undo_workspace_edit(&c.host, &c.window, c.arg("id")?).await });
d.add("lsp_execute_command", |c| async move {
lsp_execute_command(&c.host, &c.window, c.arg("doc")?, c.arg("command")?).await
});
#[command(trust = trusted)]
pub fn plugin_formatters() -> IdeResult<Vec<crate::plugins::language_features::FormatterChoice>> {
Ok(crate::plugins::editor_plugin_host().map(|p| p.formatter_choices()).unwrap_or_default())
}
#[cfg(test)]
@@ -2915,3 +2752,61 @@ mod tests {
assert_eq!(plugin_completion_kind("nonsense"), None);
}
}
ide_command::domain!(
lsp:
apply_workspace_edit,
lsp_apply_code_action,
lsp_call_hierarchy,
lsp_can_download_sources,
lsp_change_signature,
lsp_code_action_query,
lsp_code_actions,
lsp_code_lens,
lsp_completion,
lsp_document_highlights,
lsp_document_links,
lsp_execute_code_action,
lsp_execute_command,
lsp_extract_interface,
lsp_extract_interface_info,
lsp_format,
lsp_goto,
lsp_goto_implementation,
lsp_hierarchy_members,
lsp_hierarchy_refactor,
lsp_hover,
lsp_implementation_locations,
lsp_implementations,
lsp_inlay_hints,
lsp_inline_completion,
lsp_java_move,
lsp_java_move_destinations,
lsp_java_source_types,
lsp_library_sources,
lsp_message_request_answer,
lsp_prepare_rename,
lsp_prepare_type_hierarchy,
lsp_references,
lsp_rename,
lsp_resend_diagnostics,
lsp_resolve_class_file,
lsp_resolve_code_action,
lsp_resolve_command,
lsp_resolve_completion,
lsp_restart,
lsp_semantic_tokens,
lsp_servers,
lsp_signature_help,
lsp_signature_info,
lsp_type_hierarchy,
lsp_virtual_document,
lsp_workspace_symbols,
plugin_color_presentations,
plugin_formatters,
plugin_language_visuals,
plugin_line_markers,
prepare_workspace_edit,
redo_workspace_edit,
undo_workspace_edit,
);
+49 -33
Переглянути файл
@@ -32,7 +32,7 @@ pub mod scaffold;
pub mod sdk;
pub mod search;
pub mod spell;
mod ssh;
pub mod ssh;
pub mod stream_trace;
pub mod syntax;
pub mod term;
@@ -69,38 +69,54 @@ impl<T> Clone for Channel<T> {
}
}
/// Registers the commands of every module with the remote server.
pub fn register_all(d: &mut crate::rpc::Dispatcher) {
agent::register(d);
lsp::register(d);
notebook::register(d);
nav::register(d);
refactor::register(d);
analysis::register(d);
syntax::register(d);
spell::register(d);
dependencies::register(d);
history::register(d);
coverage::register(d);
build::register(d);
tools::register(d);
scaffold::register(d);
sdk::register(d);
java::register(d);
debug::register(d);
heap::register(d);
stream_trace::register(d);
bytes::register(d);
vcs::register(d);
doc::register(d);
search::register(d);
run::register(d);
env::register(d);
deploy::register(d);
docker::register(d);
db::register(d);
ssh::register(d);
}
// Every module that declares `#[command]`s, by domain name.
ide_command::domains!(
agent: crate::ops::agent,
analysis: crate::ops::analysis,
build: crate::ops::build,
bytes: crate::ops::bytes,
coverage: crate::ops::coverage,
db: crate::ops::db,
debug: crate::ops::debug,
dependencies: crate::ops::dependencies,
deploy: crate::ops::deploy,
doc: crate::ops::doc,
doc_commands: crate::ops::doc::commands,
docker: crate::ops::docker,
env: crate::ops::env,
fs: crate::ops::fs,
heap: crate::ops::heap,
history: crate::ops::history,
java: crate::ops::java,
jvm_icons: crate::ops::jvm_icons,
lsp: crate::ops::lsp,
mcp_reports: crate::mcp::reports,
nav: crate::ops::nav,
notebook: crate::ops::notebook,
plugins_commands: crate::plugins::commands,
plugins_commit: crate::plugins::commit,
plugins_index_ops: crate::plugins::index_ops,
plugins_run_targets: crate::plugins::run_targets,
plugins_views: crate::plugins::views,
project: crate::ops::project,
refactor: crate::ops::refactor,
run: crate::ops::run,
run_commands: crate::ops::run::commands,
scaffold: crate::ops::scaffold,
sdk: crate::ops::sdk,
sdk_container_python: crate::ops::sdk::container_python,
search: crate::ops::search,
search_commands: crate::ops::search::commands,
spell: crate::ops::spell,
ssh: crate::ops::ssh,
stream_trace: crate::ops::stream_trace,
syntax: crate::ops::syntax,
term: crate::ops::term,
tools: crate::ops::tools,
vcs: crate::ops::vcs,
vcs_commands: crate::ops::vcs::commands,
web: crate::ops::web,
);
impl Host {
/// Runs blocking work (disk I/O, parsing, large copies) on the blocking pool.
+58 -52
Переглянути файл
@@ -1,7 +1,7 @@
use super::doc::blocking;
use crate::Host;
use crate::Project;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{DocId, IdeResult, IpcPath, LanguageId, Location, Pos};
use ide_index::{ExtensionCount, FileMatch, IndexStatus, SymbolFilter, SymbolMatch};
use ide_language::{FileReference, WebReference};
@@ -45,30 +45,37 @@ fn reference_roots(project: &Project) -> (PathBuf, Vec<PathBuf>) {
(project.root.clone(), resources)
}
#[command(trust = always)]
pub fn index_status(host: &Host, window: &str) -> IdeResult<IndexStatus> {
Ok(host.project(window)?.index.status())
}
/// The project's file extensions, most common first.
#[command(trust = always)]
pub fn index_file_extensions(host: &Host, window: &str) -> IdeResult<Vec<ExtensionCount>> {
// Most common first.
Ok(host.project(window)?.index.file_extensions())
}
#[command(trust = always)]
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
}
#[command(trust = always)]
pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeResult<Vec<IpcPath>> {
let project = host.project(window)?;
blocking(move || Ok(project.index.files_named(&name).into_iter().map(Into::into).collect())).await
}
/// Folders holding indexed files, for `@` references.
#[command(trust = always)]
pub async fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
let project = host.project(window)?;
blocking(move || Ok(project.index.find_dirs(&query, limit as usize))).await
}
#[command(trust = always)]
pub async fn find_symbols(
host: &Host,
window: &str,
@@ -80,35 +87,40 @@ pub async fn find_symbols(
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.
/// Index symbols named exactly one of `names` inside `within` (an agent task's folder).
#[command(trust = always)]
pub async fn find_symbols_named(
host: &Host,
window: &str,
names: Vec<String>,
within: IpcPath,
) -> IdeResult<Vec<SymbolMatch>> {
// At most `SYMBOLS_PER_NAME` each: every name an agent reply shows, in one lookup.
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
}
#[command(trust = always)]
pub fn mark_recent(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
host.project(window)?.index.mark_recent(&path);
Ok(())
}
#[command(trust = always)]
pub fn remove_recent(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
host.project(window)?.index.remove_recent(&path);
Ok(())
}
/// Recently opened files, most recent first (⌘E).
#[command(trust = always)]
pub fn recent_files(host: &Host, window: &str) -> IdeResult<Vec<ide_core::IpcPath>> {
Ok(host.project(window)?.index.recent_files().into_iter().map(Into::into).collect())
}
/// The web reference at `pos` of `doc` and its targets; `None` when there is no reference.
#[command(trust = always)]
pub async fn web_goto(host: &Host, window: &str, doc: DocId, pos: Pos) -> IdeResult<Option<WebGoto>> {
let project = host.project(window)?;
let syntax = host.syntax();
@@ -145,12 +157,14 @@ pub async fn web_goto(host: &Host, window: &str, doc: DocId, pos: Pos) -> IdeRes
.await
}
/// The file a Python import path names: `a.b.c` is `a/b/c.py(i)` or `a/b/c/__init__.py(i)`
/// in the project or one of its content roots (an attached dependency project included);
/// `.x` names it relative to `from`'s directory. Neither the language server (it analyses a
/// single root) nor the definition index resolves a package segment, so ⌘B on the `a.b` of
/// `from a.b import x` needs this.
/// The file a Python import path (`a.b.c`, or `.x` relative to `from`) names; `None` when
/// no project or content root has it.
#[command(trust = always)]
pub async fn nav_resolve_module(host: &Host, window: &str, name: String, from: IpcPath) -> IdeResult<Option<IpcPath>> {
// `a.b.c` is `a/b/c.py(i)` or `a/b/c/__init__.py(i)` in the project or one of its content roots
// (an attached dependency project included). Neither the language server (it analyses a single
// root) nor the definition index resolves a package segment, so ⌘B on the `a.b` of
// `from a.b import x` needs this.
let project = host.project(window)?;
blocking(move || {
let dots = name.len() - name.trim_start_matches('.').len();
@@ -182,17 +196,19 @@ pub async fn nav_resolve_module(host: &Host, window: &str, name: String, from: I
.await
}
/// Index definitions named `name` in the other roots `from` may navigate into (its configured
/// dependencies and extra content roots — see `navigation_roots`): the cross-root answer when
/// the language server cannot resolve an import into an attached dependency project. `from`'s
/// own root is left out: the server sees it, so a name it could not resolve there is not
/// answered by every declaration that happens to share it (any `save` for `repo.save()`).
/// Index definitions named `name` within the roots `from` may navigate into (its own root
/// plus its configured dependencies).
#[command(trust = always)]
pub async fn nav_index_definitions(
host: &Host,
window: &str,
name: String,
from: IpcPath,
) -> IdeResult<Vec<SymbolMatch>> {
// The cross-root answer when the language server cannot resolve an import into an attached
// dependency project. `from`'s own root is left out: the server sees it, so a name it could
// not resolve there is not answered by every declaration that happens to share it (any `save`
// for `repo.save()`).
let project = host.project(window)?;
blocking(move || {
let roots = crate::project::navigation_roots(&project, &from);
@@ -207,11 +223,12 @@ pub async fn nav_index_definitions(
.await
}
/// Every Python class in the project (attached dependency roots included) and its base
/// names, answered from the project index: its symbols already carry the bases, and it
/// covers content roots, so this is the whole-project answer the UI uses for inheritance
/// gutter markers when no type-hierarchy provider exists. No file is parsed here.
/// Every Python class in the project (attached dependency roots included) and its base names,
/// for native inheritance gutter markers.
#[command(trust = always)]
pub async fn nav_inheritance(host: &Host, window: &str) -> IdeResult<Vec<ClassInheritance>> {
// The index covers content roots, so this is the whole-project answer when no type-hierarchy
// provider exists.
let project = host.project(window)?;
let syntax = host.syntax();
blocking(move || {
@@ -284,6 +301,7 @@ static CLASS_BASES: std::sync::LazyLock<parking_lot::Mutex<ClassBasesCache>> =
std::sync::LazyLock::new(Default::default);
/// The existing file or directory a path written in `from` names (`href`, `url()`, a string literal).
#[command(trust = always)]
pub async fn fs_resolve_reference(
host: &Host,
window: &str,
@@ -300,6 +318,7 @@ pub async fn fs_resolve_reference(
}
/// Files and folders that continue `prefix`, a path being typed in `from`.
#[command(trust = always)]
pub async fn path_completions(
host: &Host,
window: &str,
@@ -316,6 +335,7 @@ pub async fn path_completions(
}
/// Paths in an HTML document or stylesheet that name no existing file.
#[command(trust = always)]
pub async fn web_unresolved_references(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<FileReference>> {
let project = host.project(window)?;
let syntax = host.syntax();
@@ -338,37 +358,23 @@ pub async fn web_unresolved_references(host: &Host, window: &str, doc: DocId) ->
.await
}
/// Commands of this module the remote server answers.
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")?).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")?).await });
d.add("find_symbols", |c| async move {
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")?) });
d.add("recent_files", |c| async move { recent_files(&c.host, &c.window) });
d.add("web_goto", |c| async move { web_goto(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?).await });
d.add("nav_resolve_module", |c| async move {
nav_resolve_module(&c.host, &c.window, c.arg("name")?, c.arg("from")?).await
});
d.add("nav_index_definitions", |c| async move {
nav_index_definitions(&c.host, &c.window, c.arg("name")?, c.arg("from")?).await
});
d.add("nav_inheritance", |c| async move { nav_inheritance(&c.host, &c.window).await });
d.add("fs_resolve_reference", |c| async move {
fs_resolve_reference(&c.host, &c.window, c.arg("from")?, c.arg("value")?).await
});
d.add("path_completions", |c| async move {
path_completions(&c.host, &c.window, c.arg("from")?, c.arg("prefix")?).await
});
d.add("web_unresolved_references", |c| async move {
web_unresolved_references(&c.host, &c.window, c.arg("doc")?).await
});
}
ide_command::domain!(
nav:
find_dirs,
find_files,
find_files_named,
find_symbols,
find_symbols_named,
fs_resolve_reference,
index_file_extensions,
index_status,
mark_recent,
nav_index_definitions,
nav_inheritance,
nav_resolve_module,
path_completions,
recent_files,
remove_recent,
web_goto,
web_unresolved_references,
);
+41 -41
Переглянути файл
@@ -2,12 +2,13 @@
use crate::Host;
pub use crate::notebook::NotebookOutputEvent;
use crate::ops::Channel;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId};
use ide_notebook::{NotebookEdit, NotebookSnapshot};
use std::path::PathBuf;
pub async fn open(host: &Host, window: &str, path: String) -> IdeResult<NotebookSnapshot> {
#[command(trust = always)]
pub async fn notebook_open(host: &Host, window: &str, path: String) -> IdeResult<NotebookSnapshot> {
let project = host.project(window)?;
let path = PathBuf::from(path);
let path = if path.is_absolute() { path } else { project.root.join(path) };
@@ -15,18 +16,21 @@ pub async fn open(host: &Host, window: &str, path: String) -> IdeResult<Notebook
host.blocking(move || notebooks.open(&path)).await
}
pub fn get(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
#[command(trust = always)]
pub fn notebook_get(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
host.project(window)?.notebooks.get(&id)
}
/// The language-server documents of the notebook's code cells (empty when no server syncs notebooks).
pub fn cell_docs(host: &Host, window: &str, id: String) -> IdeResult<Vec<ide_lsp::NotebookCellDoc>> {
#[command(trust = trusted)]
pub fn notebook_cell_docs(host: &Host, window: &str, id: String) -> IdeResult<Vec<ide_lsp::NotebookCellDoc>> {
// The language-server documents of the notebook's code cells (empty when no server syncs notebooks).
let project = host.project(window)?;
let path = project.notebooks.path_of(&id)?;
Ok(project.lsp.notebook_cells(&path))
}
pub async fn edit(
#[command(trust = always)]
pub async fn notebook_edit(
host: &Host,
window: &str,
id: String,
@@ -37,22 +41,26 @@ pub async fn edit(
host.blocking(move || notebooks.edit(&id, version, edit)).await
}
pub async fn save(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
#[command(trust = always)]
pub async fn notebook_save(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
let notebooks = host.project(window)?.notebooks.clone();
host.blocking(move || notebooks.save(&id)).await
}
pub async fn undo(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
#[command(trust = always)]
pub async fn notebook_undo(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
let notebooks = host.project(window)?.notebooks.clone();
host.blocking(move || notebooks.undo(&id, false)).await
}
pub async fn redo(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
#[command(trust = always)]
pub async fn notebook_redo(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
let notebooks = host.project(window)?.notebooks.clone();
host.blocking(move || notebooks.undo(&id, true)).await
}
pub async fn reload(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
#[command(trust = always)]
pub async fn notebook_reload(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
let notebooks = host.project(window)?.notebooks.clone();
// An abandoned IPC future must not leave a lifecycle transition half applied.
tokio::spawn(async move { notebooks.reload(&id, false).await })
@@ -60,7 +68,8 @@ pub async fn reload(host: &Host, window: &str, id: String) -> IdeResult<Notebook
.map_err(|error| IdeError::internal(error.to_string()))?
}
pub async fn restart(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
#[command(trust = trusted)]
pub async fn notebook_restart(host: &Host, window: &str, id: String) -> IdeResult<NotebookSnapshot> {
host.require_trust(window)?;
let notebooks = host.project(window)?.notebooks.clone();
tokio::spawn(async move { notebooks.reload(&id, true).await })
@@ -68,14 +77,16 @@ pub async fn restart(host: &Host, window: &str, id: String) -> IdeResult<Noteboo
.map_err(|error| IdeError::internal(error.to_string()))?
}
pub async fn close(host: &Host, window: &str, id: String) -> IdeResult<()> {
#[command(trust = always)]
pub async fn notebook_close(host: &Host, window: &str, id: String) -> IdeResult<()> {
let notebooks = host.project(window)?.notebooks.clone();
tokio::spawn(async move { notebooks.close(&id).await })
.await
.map_err(|error| IdeError::internal(error.to_string()))?
}
pub async fn interrupt(host: &Host, window: &str, id: String) -> IdeResult<()> {
#[command(trust = always)]
pub async fn notebook_interrupt(host: &Host, window: &str, id: String) -> IdeResult<()> {
let notebooks = host.project(window)?.notebooks.clone();
tokio::spawn(async move { notebooks.interrupt(&id).await })
.await
@@ -83,7 +94,8 @@ pub async fn interrupt(host: &Host, window: &str, id: String) -> IdeResult<()> {
}
#[allow(clippy::too_many_arguments)]
pub async fn execute(
#[command(trust = trusted)]
pub async fn notebook_execute(
host: &Host,
window: &str,
id: String,
@@ -136,30 +148,18 @@ impl Drop for RequestGuard<'_> {
}
}
pub(crate) fn register(d: &mut Dispatcher) {
d.add("notebook_open", |c| async move { open(&c.host, &c.window, c.arg("path")?).await });
d.add("notebook_get", |c| async move { get(&c.host, &c.window, c.arg("id")?) });
d.add("notebook_cell_docs", |c| async move { cell_docs(&c.host, &c.window, c.arg("id")?) });
d.add("notebook_edit", |c| async move {
edit(&c.host, &c.window, c.arg("id")?, c.arg("version")?, c.arg("edit")?).await
});
d.add("notebook_save", |c| async move { save(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_reload", |c| async move { reload(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_undo", |c| async move { undo(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_redo", |c| async move { redo(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_close", |c| async move { close(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_interrupt", |c| async move { interrupt(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_restart", |c| async move { restart(&c.host, &c.window, c.arg("id")?).await });
d.add("notebook_execute", |c| async move {
execute(
&c.host,
&c.window,
c.arg("id")?,
c.arg("cells")?,
c.arg("python")?,
c.arg("request")?,
c.sender("onOutput")?,
)
.await
});
}
ide_command::domain!(
notebook:
notebook_cell_docs,
notebook_close,
notebook_edit,
notebook_execute,
notebook_get,
notebook_interrupt,
notebook_open,
notebook_redo,
notebook_reload,
notebook_restart,
notebook_save,
notebook_undo,
);
+103 -8
Переглянути файл
@@ -1,10 +1,11 @@
use crate::{Host, Project};
use ide_core::IdeResult;
use ide_command::command;
use ide_core::settings::Settings;
use ide_core::{IdeEvent, IdeResult, RequestId, TaskId};
use ide_workspace::settings::SettingsScope;
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
use std::path::{Path, PathBuf};
use std::sync::Arc;
#[derive(Serialize, Deserialize, Type)]
@@ -53,20 +54,36 @@ pub async fn open(host: &Arc<Host>, window: &str, path: &Path) -> IdeResult<Arc<
host.blocking(move || h.open_project(&window, &path)).await
}
pub fn current(host: &Host, window: &str) -> Option<ProjectInfo> {
#[command(trust = always, desktop_body = async)]
pub async fn open_project(host: &Arc<Host>, window: &str, path: PathBuf) -> IdeResult<ProjectInfo> {
let project = open(host, window, &path).await?;
Ok(info(&project))
}
/// The project open in this window (a settings window: its parent's), if any.
#[command(trust = always, desktop_body = sync)]
pub fn project_current(host: &Host, window: &str) -> Option<ProjectInfo> {
host.project(window).ok().filter(|p| !p.light).map(|p| info(&p))
}
#[command(trust = always, desktop_body = spawn)]
pub fn close_project(host: &Host, window: &str) {
host.close_project(window);
}
/// Effective settings for the window's project, or global settings without one.
pub fn settings(host: &Host, window: &str) -> Settings {
#[command(trust = always, desktop_body = sync)]
pub fn settings_get(host: &Host, window: &str) -> Settings {
host.with_proxy_password(match host.project(window) {
Ok(p) => p.settings.effective(),
Err(_) => host.global_settings.effective(),
})
}
/// 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.
/// The removed built-in theme id a settings file of this window still names, if any:
/// `settings_get` reports the built-in that stands in for it, so the notice about
/// a theme that moved to a plugin can address the installs it concerns.
#[command(trust = always, desktop_body = sync)]
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()),
@@ -74,10 +91,66 @@ pub fn settings_removed_theme(host: &Host, window: &str) -> Option<String> {
}
}
pub fn roots(host: &Host, window: &str) -> IdeResult<ide_workspace::ProjectRoots> {
/// `value` is JSON text, e.g. `14` or `"dark"`. Every window (for a project
/// value: that project's windows) is told (`IdeEvent::SettingsChanged`) so it
/// re-reads its effective settings.
#[command(trust = always, desktop_body = sync)]
pub fn settings_set(
host: &Host,
window: &str,
scope: SettingsScope,
key: String,
value: String,
) -> IdeResult<Settings> {
let applied = set_settings(host, window, scope, &key, &value)?;
let sink = host.window_sink(window);
sink.emit(IdeEvent::SettingsChanged { key });
if let Some(root) = applied.roots_changed {
sink.emit(IdeEvent::ProjectRootsChanged { root });
}
Ok(applied.settings)
}
/// Effective source / test / resource / excluded roots of the window's project:
/// auto-detected from build files, overridden by Settings › Project Structure.
#[command(trust = always)]
pub fn project_roots(host: &Host, window: &str) -> IdeResult<ide_workspace::ProjectRoots> {
Ok(host.project(window)?.roots())
}
#[command(trust = always)]
pub fn cancel_request(host: &Host, id: RequestId) {
host.cancel_request(id);
}
/// Stops a background task the backend reported with `cancellable` set; false when it
/// has ended or can't be cancelled.
#[command(trust = always)]
pub fn cancel_task(id: TaskId) -> bool {
ide_core::task::cancel(id)
}
#[command(trust = always)]
pub fn project_trust_status(host: &Host, path: PathBuf) -> IdeResult<crate::trust::TrustStatus> {
host.trust.status(&path)
}
#[command(trust = always)]
pub fn project_trust_list(host: &Host) -> IdeResult<crate::trust::TrustDecisions> {
host.trust.decisions()
}
#[command(trust = always, desktop_body = async)]
pub async fn project_trust_set(host: &Host, path: PathBuf, trusted: bool, folder: bool) -> IdeResult<()> {
host.set_project_trust(&path, trusted, folder).await
}
#[command(trust = always, desktop_body = async)]
pub async fn project_trust_remove_location(host: &Host, path: PathBuf) -> IdeResult<()> {
host.trust.remove_location(&path)?;
host.refresh_project_trust().await
}
pub fn save_workspace(host: &Host, window: &str, name: &str, paths: Vec<std::path::PathBuf>) -> IdeResult<ProjectInfo> {
let project = host.project(window)?;
let previous = ide_workspace::workspace::Workspace::load(&project.root)?
@@ -175,7 +248,7 @@ pub fn set_settings(
let is_proxy = key == "proxy" || key.starts_with("proxy.");
let Some(mut value) = host.take_proxy_password(key, value)? else {
host.apply_proxy();
return Ok(SettingsApplied { settings: settings(host, window), project_scope, roots_changed: None });
return Ok(SettingsApplied { settings: settings_get(host, window), project_scope, roots_changed: None });
};
// One canonical spelling per linked POM, including a project outside the opened root.
if project_scope
@@ -238,6 +311,11 @@ pub fn set_settings(
if is_proxy {
host.apply_proxy();
}
if key == "agents" || key == "agents.mcpServers" || key.starts_with("agents.mcpServers.") {
for project in affected() {
project.agents.notify_mcp_servers_changed();
}
}
// A new interpreter / toolchain / server executable restarts the language servers it affects.
// So do inspections that are compiler options (`ide-sdk` `configure_java_compiler`).
let code_style = key == "editor"
@@ -285,3 +363,20 @@ pub fn set_settings(
let roots_changed = current.as_ref().filter(|_| roots_changed && project_scope).map(|p| p.root.clone().into());
Ok(SettingsApplied { settings: host.with_proxy_password(settings), project_scope, roots_changed })
}
ide_command::domain!(
project:
cancel_request,
cancel_task,
close_project,
open_project,
project_current,
project_roots,
project_trust_list,
project_trust_remove_location,
project_trust_set,
project_trust_status,
settings_get,
settings_removed_theme,
settings_set,
);
+14 -21
Переглянути файл
@@ -1,7 +1,7 @@
//! File move / rename refactoring: reference updates from the language
//! servers, the move itself (one undoable step) and its undo.
use crate::Host;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{IdeResult, RequestId, WorkspaceEdit};
use ide_lsp::types::FileRenameEdits;
@@ -15,6 +15,7 @@ fn pairs(moves: &[FileMove]) -> Vec<(PathBuf, PathBuf)> {
}
/// `workspace/willRenameFiles` on every interested server (before the move). Cancellable.
#[command(trust = always)]
pub async fn refactor_file_move_edits(
host: &Host,
window: &str,
@@ -35,6 +36,7 @@ pub async fn refactor_file_move_edits(
/// Applies `edit` (from [`refactor_file_move_edits`], possibly empty), moves the
/// files and notifies the servers. Returns the id for [`refactor_undo_file_move`].
#[command(trust = always)]
pub async fn refactor_move_files(
host: &Host,
window: &str,
@@ -55,6 +57,7 @@ pub async fn refactor_move_files(
}
/// Undoes a file move: moves back and reverts the reference updates.
#[command(trust = always)]
pub async fn refactor_undo_file_move(host: &Host, window: &str, id: u32) -> IdeResult<UndoOutcome> {
let project = host.project(window)?;
let p = project.clone();
@@ -64,12 +67,14 @@ pub async fn refactor_undo_file_move(host: &Host, window: &str, id: u32) -> IdeR
}
/// Whether the file move `id` can still be undone.
#[command(trust = always)]
pub fn refactor_can_undo_file_move(host: &Host, window: &str, id: u32) -> IdeResult<bool> {
Ok(host.project(window)?.moves.can_undo(id))
}
/// "Search in comments and strings": textual occurrences of the moved files'
/// names, qualified names and paths (before the move). Cancellable.
#[command(trust = always)]
pub async fn refactor_file_move_text_edits(
host: &Host,
window: &str,
@@ -98,23 +103,11 @@ pub async fn refactor_file_move_text_edits(
result
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("refactor_file_move_edits", |c| async move {
refactor_file_move_edits(&c.host, &c.window, c.arg("request")?, c.arg("moves")?).await
});
d.add("refactor_move_files", |c| async move {
refactor_move_files(&c.host, &c.window, c.arg("moves")?, c.arg("edit")?, c.arg("label")?).await
});
d.add(
"refactor_undo_file_move",
|c| async move { refactor_undo_file_move(&c.host, &c.window, c.arg("id")?).await },
);
d.add(
"refactor_can_undo_file_move",
|c| async move { refactor_can_undo_file_move(&c.host, &c.window, c.arg("id")?) },
);
d.add("refactor_file_move_text_edits", |c| async move {
refactor_file_move_text_edits(&c.host, &c.window, c.arg("request")?, c.arg("moves")?).await
});
}
ide_command::domain!(
refactor:
refactor_can_undo_file_move,
refactor_file_move_edits,
refactor_file_move_text_edits,
refactor_move_files,
refactor_undo_file_move,
);
+77 -20
Переглянути файл
@@ -1,11 +1,33 @@
use super::Emit;
use super::{Channel, Emit};
use crate::Host;
use ide_command::command;
use ide_core::remote_settings::RunTargetKind;
use ide_core::{IdeError, IdeResult, RunId};
use ide_run::{OutputChunk, RunConfig, RunInfo, StartOptions};
use std::path::Path;
use std::sync::Arc;
use std::time::Duration;
/// Detected configs followed by user-defined ones (user ids win on conflict).
#[command(trust = trusted)]
pub async fn run_configs(host: &Arc<Host>, window: &str) -> IdeResult<Vec<RunConfig>> {
// Detection reads build files (and Spring Boot sources): off the command thread.
let (host, window) = (host.clone(), window.to_owned());
super::doc::blocking(move || configs(&host, &window)).await
}
#[command(trust = trusted)]
pub async fn run_save_configs(
host: &Arc<Host>,
window: &str,
configs: Vec<RunConfig>,
removed_detected_ids: Option<Vec<String>>,
) -> IdeResult<()> {
let (host, window) = (host.clone(), window.to_owned());
let removed = removed_detected_ids.unwrap_or_default();
super::doc::blocking(move || save_configs(&host, &window, &configs, &removed)).await
}
/// Detected configs followed by user-defined ones (user ids win on conflict).
pub fn configs(host: &Host, window: &str) -> IdeResult<Vec<RunConfig>> {
host.require_trust(window)?;
@@ -183,9 +205,16 @@ fn settings_only(
})
}
/// Temporary configurations as they are kept between sessions: without what settings derived
/// (toolchain commands, Maven options, `JAVA_HOME`…), so they follow later settings changes.
pub fn without_derived(host: &Host, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
/// Temporary configurations as they are kept between sessions: without what settings derived.
#[command(trust = trusted)]
pub async fn run_without_derived(host: &Arc<Host>, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
let (host, window) = (host.clone(), window.to_owned());
super::doc::blocking(move || without_derived(&host, &window, configs)).await
}
/// Without what settings derived (toolchain commands, Maven options, `JAVA_HOME`…), so they
/// follow later settings changes.
fn without_derived(host: &Host, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
host.require_trust(window)?;
let project = host.project(window)?;
configs
@@ -200,8 +229,15 @@ pub fn without_derived(host: &Host, window: &str, configs: Vec<RunConfig>) -> Id
.collect()
}
/// Kept temporary configurations with today's settings applied, as [`configs`] lists the others.
pub fn apply_settings(host: &Host, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
/// Kept temporary configurations with the current settings applied.
#[command(trust = trusted)]
pub async fn run_apply_settings(host: &Arc<Host>, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
let (host, window) = (host.clone(), window.to_owned());
super::doc::blocking(move || apply_settings(&host, &window, configs)).await
}
/// Today's settings applied, as [`configs`] lists the others.
fn apply_settings(host: &Host, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
host.require_trust(window)?;
let project = host.project(window)?;
configs
@@ -221,17 +257,17 @@ pub fn apply_settings(host: &Host, window: &str, configs: Vec<RunConfig>) -> Ide
.collect()
}
pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emit<OutputChunk>) -> IdeResult<RunInfo> {
start_request(host, window, config, on_output, None).await
}
pub async fn start_request(
#[command(trust = trusted)]
pub async fn run_start(
host: &Host,
window: &str,
config: RunConfig,
on_output: Emit<OutputChunk>,
on_output: Channel<OutputChunk>,
request: Option<ide_core::RequestId>,
) -> IdeResult<RunInfo> {
let on_output: Emit<OutputChunk> = Arc::new(move |chunk| {
let _ = on_output.send(chunk);
});
let cancel = request.map(|id| host.begin_request(id)).unwrap_or_default();
let operation = config.extras.params.get("plugin.operation").cloned();
let mut config = config;
@@ -486,8 +522,9 @@ fn ruby_reporter_dir(host: &Host, config: &RunConfig) -> Option<std::path::PathB
}
}
/// Stops a run (interrupt, then kill after Settings › Run's termination timeout).
pub fn stop(host: &Host, window: &str, id: RunId) -> IdeResult<()> {
#[command(trust = always)]
pub fn run_stop(host: &Host, window: &str, id: RunId) -> IdeResult<()> {
// Interrupt, then kill after Settings › Run's termination timeout.
if let Some(plugins) = host.plugin_host() {
plugins.run_operation_stopped(id);
}
@@ -503,8 +540,10 @@ pub fn stop(host: &Host, window: &str, id: RunId) -> IdeResult<()> {
host.processes.stop_with_grace(id, grace)
}
/// Input the user typed into a run (the agent's goes to the process directly).
pub fn stdin(host: &Host, id: RunId, data: &str) -> IdeResult<()> {
#[command(trust = trusted)]
pub fn run_stdin(host: &Host, id: RunId, data: String) -> IdeResult<()> {
// Input the user typed into a run (the agent's goes to the process directly).
let data = data.as_str();
host.mcp_agent_runs.user_input(id, data);
if host.remote.runs.contains(id) {
return host.remote.runs.write_stdin(id, data);
@@ -512,27 +551,31 @@ pub fn stdin(host: &Host, id: RunId, data: &str) -> IdeResult<()> {
host.processes.write_stdin(id, data)
}
pub fn resize(host: &Host, id: RunId, cols: u16, rows: u16) -> IdeResult<()> {
/// Terminal size of a run started with "Emulate terminal in output console".
#[command(trust = trusted)]
pub fn run_resize(host: &Host, id: RunId, cols: u16, rows: u16) -> IdeResult<()> {
if host.remote.runs.contains(id) {
return host.remote.runs.resize(id, cols, rows);
}
host.processes.resize(id, cols, rows)
}
pub fn close_stdin(host: &Host, id: RunId) -> IdeResult<()> {
#[command(trust = trusted)]
pub fn run_close_stdin(host: &Host, id: RunId) -> IdeResult<()> {
if host.remote.runs.contains(id) {
return host.remote.runs.close_stdin(id);
}
host.processes.close_stdin(id)
}
pub fn list(host: &Host) -> Vec<RunInfo> {
#[command(trust = always)]
pub fn run_list(host: &Host) -> Vec<RunInfo> {
let mut runs = host.processes.list();
runs.extend(host.remote.runs.list());
runs
}
mod commands;
pub mod commands;
pub(crate) mod container;
pub use commands::*;
@@ -563,3 +606,17 @@ mod ownership_tests {
assert!(configs.is_empty(), "{configs:?}");
}
}
ide_command::domain!(
run:
run_apply_settings,
run_close_stdin,
run_configs,
run_list,
run_resize,
run_save_configs,
run_start,
run_stdin,
run_stop,
run_without_derived,
);
+68 -78
Переглянути файл
@@ -1,11 +1,10 @@
#[allow(unused_imports)]
use super::*;
use crate::Host;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{IdeError, IdeResult};
use ide_run::RunConfig;
use ide_run::import::{RunImport, RunImportSource};
#[command(trust = trusted)]
pub async fn run_dotnet_resolve(host: &Host, window: &str, config: RunConfig, debug: bool) -> IdeResult<RunConfig> {
host.require_trust(window)?;
if !matches!(config.kind.as_str(), "dotnet" | "dotnet-test")
@@ -30,6 +29,7 @@ fn application_cache(project: &crate::project::Project, id: &str) -> std::path::
project.cache_dir.join("application-update").join(format!("{:x}", hash.finish()))
}
#[command(trust = trusted)]
pub async fn run_application_build(
host: &Host,
window: &str,
@@ -74,6 +74,7 @@ pub async fn run_application_build(
.map_err(|e| IdeError::internal(e.to_string()))?
}
#[command(trust = trusted)]
pub async fn run_application_publish(
host: &Host,
window: &str,
@@ -96,54 +97,61 @@ pub async fn run_application_publish(
}
/// Configuration templates: per-type defaults applied to new configurations.
pub fn run_templates(host: &Host, window: &str) -> IdeResult<Vec<RunConfig>> {
#[command(trust = trusted)]
pub async fn run_templates(host: &Host, window: &str) -> IdeResult<Vec<RunConfig>> {
let root = host.project(window)?.root.clone();
ide_run::load_templates(&root)
crate::ops::doc::blocking(move || ide_run::load_templates(&root)).await
}
pub fn run_save_templates(host: &Host, window: &str, templates: Vec<RunConfig>) -> IdeResult<()> {
#[command(trust = trusted)]
pub async fn run_save_templates(host: &Host, window: &str, templates: Vec<RunConfig>) -> IdeResult<()> {
let root = host.project(window)?.root.clone();
ide_run::save_templates(&root, &templates)
crate::ops::doc::blocking(move || ide_run::save_templates(&root, &templates)).await
}
/// Project files run configurations can be imported from (`.vscode/launch.json`).
pub fn run_import_sources(host: &Host, window: &str) -> IdeResult<Vec<RunImportSource>> {
#[command(trust = trusted)]
pub async fn run_import_sources(host: &Host, window: &str) -> IdeResult<Vec<RunImportSource>> {
let root = host.project(window)?.root.clone();
Ok(ide_run::import::available(&root))
crate::ops::doc::blocking(move || Ok(ide_run::import::available(&root))).await
}
/// Configurations read from `source`, not saved; names already in `existing` (the
/// configurations being edited) are skipped.
pub fn run_import_configs(
/// Configurations read from `source`, not saved; names already in `existing` are skipped.
#[command(trust = trusted)]
pub async fn run_import_configs(
host: &Host,
window: &str,
source: RunImportSource,
existing: Vec<RunConfig>,
) -> IdeResult<RunImport> {
// `existing`: the configurations being edited.
host.require_trust(window)?;
let root = host.project(window)?.root.clone();
ide_run::import_configs(&root, source, &existing)
crate::ops::doc::blocking(move || ide_run::import_configs(&root, source, &existing)).await
}
/// The environment runs inherit when "Include system environment variables" is on.
pub fn run_system_env(_host: &Host, _window: &str) -> std::collections::BTreeMap<String, String> {
#[command(trust = always)]
pub fn run_system_env() -> std::collections::BTreeMap<String, String> {
ide_run::system_env()
}
/// Variables of the `.env` files a debug launch names, in order (later files win):
/// the same files a run loads, over the system environment debug adapters inherit.
pub fn run_env_files(
_host: &Host,
_window: &str,
files: Vec<std::path::PathBuf>,
) -> IdeResult<std::collections::BTreeMap<String, String>> {
ide_run::envfile::load(&files, &ide_run::system_env())
.map_err(|e| IdeError::not_found(format!("cannot read .env file: {e}")))
/// Variables of the `.env` files a debug launch names, for the debugger to start with.
#[command(trust = trusted)]
pub async fn run_env_files(files: Vec<std::path::PathBuf>) -> IdeResult<std::collections::BTreeMap<String, String>> {
// In order (later files win): the same files a run loads, over the system environment
// debug adapters inherit.
crate::ops::doc::blocking(move || {
ide_run::envfile::load(&files, &ide_run::system_env())
.map_err(|e| IdeError::not_found(format!("cannot read .env file: {e}")))
})
.await
}
/// Writes the Gradle init script that adds `jvm_args` to the JVMs the build forks
/// (`bootRun`, `run`, tests) and returns its path, for `--init-script`.
pub async fn run_gradle_jvm_args_script(_host: &Host, _window: &str, jvm_args: Vec<String>) -> IdeResult<String> {
/// Writes the Gradle init script adding `jvm_args` to the JVMs the build forks; returns its path.
#[command(trust = always)]
pub async fn run_gradle_jvm_args_script(jvm_args: Vec<String>) -> IdeResult<String> {
// The forked JVMs: `bootRun`, `run`, tests; the path is for `--init-script`.
tokio::task::spawn_blocking(move || {
ide_run::gradle_jvm::write_init_script(&ide_run::gradle_jvm::default_dir(), &jvm_args)
.map(|p| p.to_string_lossy().into_owned())
@@ -153,9 +161,10 @@ pub async fn run_gradle_jvm_args_script(_host: &Host, _window: &str, jvm_args: V
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// Writes one of the IDE's Gradle init scripts (`text`; the file is named `<name>-<hash>`) on
/// the machine that runs the build, for `--init-script`, and returns its path.
pub async fn run_gradle_init_script(_host: &Host, _window: &str, name: String, text: String) -> IdeResult<String> {
/// Writes one of the IDE's Gradle init scripts where the build runs; returns its path.
#[command(trust = trusted)]
pub async fn run_gradle_init_script(name: String, text: String) -> IdeResult<String> {
// `text`; the file is named `<name>-<hash>`, for `--init-script`.
if name.is_empty() || !name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-') {
return Err(IdeError::invalid(format!("invalid init script name {name:?}")));
}
@@ -170,6 +179,7 @@ pub async fn run_gradle_init_script(_host: &Host, _window: &str, name: String, t
/// Results from the JUnit XML reports (Surefire, Failsafe, Gradle) of the module at
/// `module` (relative to the project root) written since `since_ms` (Unix epoch, ms).
#[command(trust = trusted)]
pub async fn run_test_reports(
host: &Host,
window: &str,
@@ -184,6 +194,7 @@ pub async fn run_test_reports(
.map_err(|e| IdeError::internal(e.to_string()))
}
#[command(trust = trusted)]
pub async fn run_tomcat_home(host: &Host, window: &str, home: String) -> IdeResult<ide_run::tomcat::TomcatHome> {
host.require_trust(window)?;
let root = host.project(window)?.root.clone();
@@ -192,6 +203,7 @@ pub async fn run_tomcat_home(host: &Host, window: &str, home: String) -> IdeResu
.map_err(|e| IdeError::internal(e.to_string()))?
}
#[command(trust = trusted)]
pub async fn run_tomcat_installations(
host: &Host,
window: &str,
@@ -268,6 +280,7 @@ fn build_project_war(
Ok(())
}
#[command(trust = trusted)]
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)?;
@@ -287,6 +300,7 @@ pub async fn run_tomcat_artifacts(host: &Host, window: &str) -> IdeResult<Vec<id
.map_err(|e| IdeError::internal(e.to_string()))
}
#[command(trust = trusted)]
pub async fn run_tomcat_build(host: &Host, window: &str, config: RunConfig) -> IdeResult<Option<RunConfig>> {
host.require_trust(window)?;
if config.extras.params.get("deployment").is_some_and(|v| v != "artifact") {
@@ -355,6 +369,7 @@ pub async fn run_tomcat_build(host: &Host, window: &str, config: RunConfig) -> I
.map_err(|e| IdeError::internal(e.to_string()))?
}
#[command(trust = trusted)]
pub async fn run_tomcat_update(host: &Host, window: &str, config: RunConfig, mode: String) -> IdeResult<()> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -366,8 +381,7 @@ pub async fn run_tomcat_update(host: &Host, window: &str, config: RunConfig, mod
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// Updates a running Tomcat artifact deployment from the module's compiled output and web
/// resources (`ide_run::tomcat::sync_outputs`). `false`: rebuild the WAR instead.
#[command(trust = trusted)]
pub async fn run_tomcat_sync(
host: &Host,
window: &str,
@@ -376,6 +390,8 @@ pub async fn run_tomcat_sync(
class_paths: Vec<String>,
resources_only: bool,
) -> IdeResult<bool> {
// Updates a running Tomcat artifact deployment from the module's compiled output and web
// resources (`ide_run::tomcat::sync_outputs`). `false`: rebuild the WAR instead.
host.require_trust(window)?;
let project = host.project(window)?;
if !host.processes.list().iter().any(|r| r.running && r.config_id == config.id) {
@@ -395,50 +411,24 @@ pub async fn run_tomcat_sync(
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("run_dotnet_resolve", |c| async move {
run_dotnet_resolve(&c.host, &c.window, c.arg("config")?, c.arg("debug")?).await
});
d.add("run_application_build", |c| async move {
run_application_build(&c.host, &c.window, c.arg("config")?, c.arg("module")?).await
});
d.add("run_application_publish", |c| async move {
run_application_publish(&c.host, &c.window, c.arg("config")?, c.arg("classPaths")?, c.arg("mainClass")?).await
});
d.add("run_tomcat_home", |c| async move { run_tomcat_home(&c.host, &c.window, c.arg("home")?).await });
d.add("run_tomcat_installations", |c| async move { run_tomcat_installations(&c.host, &c.window).await });
d.add("run_tomcat_artifacts", |c| async move { run_tomcat_artifacts(&c.host, &c.window).await });
d.add("run_tomcat_build", |c| async move { run_tomcat_build(&c.host, &c.window, c.arg("config")?).await });
d.add("run_tomcat_sync", |c| async move {
run_tomcat_sync(
&c.host,
&c.window,
c.arg("config")?,
c.arg("module")?,
c.arg("classPaths")?,
c.arg("resourcesOnly")?,
)
.await
});
d.add("run_tomcat_update", |c| async move {
run_tomcat_update(&c.host, &c.window, c.arg("config")?, c.arg("mode")?).await
});
d.add("run_templates", |c| async move { run_templates(&c.host, &c.window) });
d.add("run_save_templates", |c| async move { run_save_templates(&c.host, &c.window, c.arg("templates")?) });
d.add("run_import_sources", |c| async move { run_import_sources(&c.host, &c.window) });
d.add("run_import_configs", |c| async move {
run_import_configs(&c.host, &c.window, c.arg("source")?, c.arg("existing")?)
});
d.add("run_system_env", |c| async move { Ok(run_system_env(&c.host, &c.window)) });
d.add("run_env_files", |c| async move { run_env_files(&c.host, &c.window, c.arg("files")?) });
d.add("run_gradle_jvm_args_script", |c| async move {
run_gradle_jvm_args_script(&c.host, &c.window, c.arg("jvmArgs")?).await
});
d.add("run_gradle_init_script", |c| async move {
run_gradle_init_script(&c.host, &c.window, c.arg("name")?, c.arg("text")?).await
});
d.add("run_test_reports", |c| async move {
run_test_reports(&c.host, &c.window, c.arg("module")?, c.arg("sinceMs")?).await
});
}
ide_command::domain!(
run_commands:
run_application_build,
run_application_publish,
run_dotnet_resolve,
run_env_files,
run_gradle_init_script,
run_gradle_jvm_args_script,
run_import_configs,
run_import_sources,
run_save_templates,
run_system_env,
run_templates,
run_test_reports,
run_tomcat_artifacts,
run_tomcat_build,
run_tomcat_home,
run_tomcat_installations,
run_tomcat_sync,
run_tomcat_update,
);
+21 -29
Переглянути файл
@@ -1,7 +1,8 @@
//! File › New Project (`ide-scaffold`).
//! File › New Project (`ide-scaffold`). Its commands run in Restricted Mode: New Project writes
//! only where the user chose and runs no code of an open project.
use crate::Host;
use crate::ops::Channel;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
use ide_scaffold::{CreateRequest, Field, GeneratorInfo, Requirement, ScaffoldEvent, Values};
@@ -11,20 +12,21 @@ fn join_err(e: impl std::fmt::Display) -> IdeError {
}
/// The project generators File › New Project offers, in list order.
pub fn scaffold_catalog(_host: &Host, _window: &str) -> Vec<GeneratorInfo> {
#[command(trust = always)]
pub fn scaffold_catalog() -> Vec<GeneratorInfo> {
ide_scaffold::catalog()
}
/// The fields a generator's project service adds for `values` (Spring Initializr's
/// Boot versions and dependencies…); empty for other generators. Cancellable with
/// The fields a generator's project service adds for `values`; cancellable with
/// `cancel_request(request)`.
#[command(trust = always)]
pub async fn scaffold_options(
host: &Host,
_window: &str,
generator: String,
values: Values,
request: RequestId,
) -> IdeResult<Vec<Field>> {
// Spring Initializr's Boot versions and dependencies…; empty for other generators.
let cancel = host.begin_request(request);
let result = tokio::task::spawn_blocking(move || ide_scaffold::options(&generator, &values, &cancel))
.await
@@ -34,25 +36,21 @@ pub async fn scaffold_options(
}
/// The programs a generator needs for `values`, and whether they are installed.
pub async fn scaffold_requirements(
_host: &Host,
_window: &str,
generator: String,
values: Values,
) -> IdeResult<Vec<Requirement>> {
#[command(trust = always)]
pub async fn scaffold_requirements(generator: String, values: Values) -> IdeResult<Vec<Requirement>> {
tokio::task::spawn_blocking(move || ide_scaffold::requirements(&generator, &values)).await.map_err(join_err)?
}
/// Creates a project, streaming its steps and tool output through `on_event`, and
/// returns its directory, trusted: the user just created it. Cancellable with
/// `cancel_request(request)`; a failed or cancelled run leaves no files behind.
/// Creates a project, streaming progress through `on_event`, and returns its directory,
/// trusted. Cancellable with `cancel_request(request)`; a failed or cancelled run leaves nothing.
#[command(trust = always)]
pub async fn scaffold_create(
host: &Host,
_window: &str,
req: CreateRequest,
request: RequestId,
on_event: Channel<ScaffoldEvent>,
) -> IdeResult<IpcPath> {
// Trusted because the user just created it; a failed or cancelled run leaves no files behind.
let cancel = host.begin_request(request);
let result = tokio::task::spawn_blocking(move || {
ide_scaffold::create(&req, &cancel, &|e| {
@@ -67,16 +65,10 @@ pub async fn scaffold_create(
Ok(dir.into())
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("scaffold_catalog", |c| async move { Ok(scaffold_catalog(&c.host, &c.window)) });
d.add("scaffold_options", |c| async move {
scaffold_options(&c.host, &c.window, c.arg("generator")?, c.arg("values")?, c.arg("request")?).await
});
d.add("scaffold_requirements", |c| async move {
scaffold_requirements(&c.host, &c.window, c.arg("generator")?, c.arg("values")?).await
});
d.add("scaffold_create", |c| async move {
scaffold_create(&c.host, &c.window, c.arg("req")?, c.arg("request")?, c.sender("onEvent")?).await
});
}
ide_command::domain!(
scaffold:
scaffold_catalog,
scaffold_create,
scaffold_options,
scaffold_requirements,
);
+41 -68
Переглянути файл
@@ -1,7 +1,7 @@
//! Interpreters / toolchains (`ide-sdk`): discovery, Python virtualenvs and packages.
use crate::Host;
use crate::ops::Channel;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId};
use ide_sdk::python::PythonPackage;
@@ -10,7 +10,7 @@ use std::path::PathBuf;
use std::sync::Mutex;
use std::sync::atomic::{AtomicUsize, Ordering};
pub(crate) mod container_python;
pub mod container_python;
pub use container_python::{ContainerPython, sdk_container_python, sdk_container_python_refresh};
fn join_err(e: impl std::fmt::Display) -> IdeError {
@@ -34,6 +34,7 @@ pub struct ProjectInterpreter {
}
/// Installed interpreters / toolchains of `kind`; project-local ones first.
#[command(trust = trusted)]
pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
host.require_trust(window)?;
let project = host.project(window).ok();
@@ -61,9 +62,10 @@ pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<V
.map_err(join_err)
}
/// The Python interpreters of the projects opened recently (newest first), each with the
/// project it belongs to. The open project is skipped: [`sdk_detect`] lists its own.
/// The Python interpreters of the recently opened projects, each with its project.
#[command(trust = trusted)]
pub async fn sdk_python_project_interpreters(host: &Host, window: &str) -> IdeResult<Vec<ProjectInterpreter>> {
// Newest first. The open project is skipped: `sdk_detect` lists its own.
host.require_trust(window)?;
let current = host.project(window).ok().map(|p| p.root.clone());
let config = host.config_dir.clone();
@@ -109,6 +111,7 @@ pub async fn sdk_python_project_interpreters(host: &Host, window: &str) -> IdeRe
}
/// An existing Python executable or virtualenv folder as an SDK; `None` if Python cannot run.
#[command(trust = trusted)]
pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) -> IdeResult<Option<Sdk>> {
host.require_trust(window)?;
let root = host.project(window).ok().map(|p| p.root.clone());
@@ -118,6 +121,7 @@ pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) ->
}
/// The interpreter the project uses: the configured one, else its virtualenv.
#[command(trust = trusted)]
pub fn sdk_python_effective(host: &Host, window: &str, near: Option<PathBuf>) -> IdeResult<Option<ide_core::IpcPath>> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -143,6 +147,7 @@ pub fn sdk_python_effective(host: &Host, window: &str, near: Option<PathBuf>) ->
}
/// The PHP interpreter chosen in Settings › Languages & Frameworks › PHP; `None`: the `php` on `PATH`.
#[command(trust = trusted)]
pub fn sdk_php_effective(host: &Host, window: &str) -> IdeResult<Option<ide_core::IpcPath>> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -152,6 +157,7 @@ pub fn sdk_php_effective(host: &Host, window: &str) -> IdeResult<Option<ide_core
/// The version of the PHP interpreter `php` and of the Xdebug it loads, run in `cwd` (default: the
/// project root).
#[command(trust = trusted)]
pub async fn sdk_php_xdebug(
host: &Host,
window: &str,
@@ -177,6 +183,8 @@ pub struct PhpLanguageLevels {
pub member: Option<ide_core::IpcPath>,
}
/// The PHP language level of the project `path` belongs to: the effective one and Auto's.
#[command(trust = trusted)]
pub async fn sdk_php_language_level(host: &Host, window: &str, path: PathBuf) -> IdeResult<PhpLanguageLevels> {
let project = host.project(window)?;
let (project_root, project_settings) = (project.root.clone(), project.settings.effective());
@@ -207,12 +215,14 @@ pub struct ComposerInstallState {
pub reason: ide_sdk::php::ComposerInstall,
}
/// `None` in an untrusted project too: `composer install` runs the project's scripts.
/// The Composer project `path` belongs to, when its dependencies need `composer install`.
#[command(trust = trusted)]
pub async fn sdk_php_composer_install(
host: &Host,
window: &str,
path: PathBuf,
) -> IdeResult<Option<ComposerInstallState>> {
// `None` in an untrusted project too: `composer install` runs the project's scripts.
let project = host.project(window)?;
if !project.is_trusted() {
return Ok(None);
@@ -228,6 +238,7 @@ pub async fn sdk_php_composer_install(
/// SDK / library source folders shown under "External Libraries" in the Project view,
/// with the Maven / Gradle dependency jars of the build model.
#[command(trust = trusted)]
pub async fn sdk_project_libraries(
host: &Host,
window: &str,
@@ -292,6 +303,7 @@ pub async fn sdk_project_libraries(
}
/// Looks up `names` (bare command names): `node_modules/.bin` above `near`, then the search path.
#[command(trust = trusted)]
pub async fn sdk_locate_tools(
host: &Host,
window: &str,
@@ -308,6 +320,7 @@ pub async fn sdk_locate_tools(
}
/// Creates a Python environment with `tool` (`venv` / `uv` / `poetry`); output streams through `on_output`.
#[command(trust = trusted)]
pub async fn sdk_python_create_venv(
host: &Host,
window: &str,
@@ -330,6 +343,7 @@ pub async fn sdk_python_create_venv(
result?
}
#[command(trust = trusted)]
pub async fn sdk_python_packages(
host: &Host,
window: &str,
@@ -346,6 +360,7 @@ pub async fn sdk_python_packages(
/// Installs (`uninstall = false`) or removes a package; output streams through `on_output`.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn sdk_python_pip(
host: &Host,
window: &str,
@@ -375,9 +390,10 @@ 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…).
/// The JDK whose home is `path`, as the SDK list shows it; `None` when it is no JDK home.
#[command(trust = trusted)]
pub async fn sdk_jdk_at(path: String) -> IdeResult<Option<Sdk>> {
// A macOS bundle too (Add JDK from Disk…).
tokio::task::spawn_blocking(move || {
ide_sdk::java::jdk_at(std::path::Path::new(&path)).map(|j| ide_sdk::jdk_sdk(&j))
})
@@ -385,67 +401,6 @@ pub async fn sdk_jdk_at(path: String) -> IdeResult<Option<Sdk>> {
.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 },
);
d.add(
"sdk_python_interpreter",
|c| async move { sdk_python_interpreter(&c.host, &c.window, c.arg("path")?).await },
);
d.add("sdk_python_effective", |c| async move { sdk_python_effective(&c.host, &c.window, c.arg("near")?) });
d.add("sdk_php_effective", |c| async move { sdk_php_effective(&c.host, &c.window) });
d.add("sdk_container_python", |c| async move { sdk_container_python(&c.host, &c.window) });
d.add("sdk_container_python_refresh", |c| async move { sdk_container_python_refresh(&c.host, &c.window).await });
d.add("sdk_php_xdebug", |c| async move { sdk_php_xdebug(&c.host, &c.window, c.arg("php")?, c.arg("cwd")?).await });
d.add(
"sdk_php_language_level",
|c| async move { sdk_php_language_level(&c.host, &c.window, c.arg("path")?).await },
);
d.add(
"sdk_php_composer_install",
|c| async move { sdk_php_composer_install(&c.host, &c.window, c.arg("path")?).await },
);
d.add("sdk_project_libraries", |c| async move {
sdk_project_libraries(&c.host, &c.window, c.arg("request")?, c.sender("onGroups")?).await
});
d.add("sdk_locate_tools", |c| async move {
sdk_locate_tools(&c.host, &c.window, c.arg("names")?, c.arg("near")?).await
});
d.add("sdk_python_create_venv", |c| async move {
sdk_python_create_venv(
&c.host,
&c.window,
c.arg("tool")?,
c.arg("base")?,
c.arg("location")?,
c.arg("request")?,
c.sender("onOutput")?,
)
.await
});
d.add("sdk_python_packages", |c| async move {
sdk_python_packages(&c.host, &c.window, c.arg("python")?, c.arg("request")?).await
});
d.add("sdk_python_pip", |c| async move {
sdk_python_pip(
&c.host,
&c.window,
c.arg("python")?,
c.arg("requirement")?,
c.arg("uninstall")?,
c.arg("upgrade")?,
c.arg("request")?,
c.sender("onOutput")?,
)
.await
});
}
#[cfg(all(test, unix))]
mod tests {
use super::*;
@@ -560,3 +515,21 @@ mod tests {
host.close_project("main");
}
}
ide_command::domain!(
sdk:
sdk_detect,
sdk_jdk_at,
sdk_locate_tools,
sdk_php_composer_install,
sdk_php_effective,
sdk_php_language_level,
sdk_php_xdebug,
sdk_project_libraries,
sdk_python_create_venv,
sdk_python_effective,
sdk_python_interpreter,
sdk_python_packages,
sdk_python_pip,
sdk_python_project_interpreters,
);
+8 -3
Переглянути файл
@@ -7,6 +7,7 @@
use crate::Host;
use crate::project::Project;
use ide_command::command;
use ide_core::event::NotifyLevel;
use ide_core::remote_settings::{RunTarget, RunTargetKind};
use ide_core::settings::Settings;
@@ -100,7 +101,8 @@ pub(crate) fn library_group(host: &Host, root: &Path, settings: &Settings) -> Op
snapshots::library_group(name, &dir, &snapshot)
}
/// The project interpreter when it is a run target's, with its snapshot.
/// The project interpreter when it is a Docker or Compose run target's, with its snapshot.
#[command(trust = trusted)]
pub fn sdk_container_python(host: &Host, window: &str) -> IdeResult<Option<ContainerPython>> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -129,9 +131,10 @@ fn describe(host: &Host, root: &Path, settings: &Settings) -> Option<ContainerPy
Some(out)
}
/// Takes a new snapshot of the project interpreter's container (also of an image that
/// has one already), then the language servers pick it up.
/// Copies the container's Python libraries again (after the image changed).
#[command(trust = trusted)]
pub async fn sdk_container_python_refresh(host: &Host, window: &str) -> IdeResult<Option<ContainerPython>> {
// A new snapshot even of an image that has one already; the language servers then pick it up.
host.require_trust(window)?;
let project = host.project(window)?;
update(Dirs::of(host), &project, true).await?;
@@ -296,3 +299,5 @@ fn unique() -> String {
let secs = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_or(0, |d| d.as_secs());
format!("{:x}-{}-{}", secs & 0xff_ffff, std::process::id(), COUNT.fetch_add(1, Ordering::Relaxed))
}
ide_command::domain!(sdk_container_python: sdk_container_python, sdk_container_python_refresh);
+12 -6
Переглянути файл
@@ -1,5 +1,6 @@
use super::Emit;
use super::Channel;
use crate::Host;
use ide_command::command;
use ide_core::{IdeResult, RequestId};
use ide_search::{FileMatches, ProjectFileSet, SearchQuery, SearchSummary};
use serde::{Deserialize, Serialize};
@@ -23,12 +24,13 @@ pub fn literal_range(l: ide_language::Literal) -> ide_search::LiteralRange {
/// Find in Files. Results stream through `on_event`; ends with `Done`.
/// Cancel with `cancel_request(request)`.
pub async fn start(
#[command(trust = always)]
pub async fn search_start(
host: &Host,
window: &str,
request: RequestId,
mut query: SearchQuery,
on_event: Emit<SearchEvent>,
on_event: Channel<SearchEvent>,
) -> IdeResult<()> {
let project = host.project(window)?;
// Excluded roots (Project Structure marks and detected `target`, `node_modules`, …) and
@@ -39,11 +41,13 @@ pub async fn start(
let syntax = host.syntax();
let summary = host
.blocking(move || {
search_project(&project, &syntax, &query, &cancel, &|file| events(SearchEvent::File { file }))
search_project(&project, &syntax, &query, &cancel, &|file| {
let _ = events.send(SearchEvent::File { file });
})
})
.await;
host.end_request(request);
on_event(SearchEvent::Done { summary: summary? });
let _ = on_event.send(SearchEvent::Done { summary: summary? });
Ok(())
}
@@ -173,5 +177,7 @@ mod tests {
}
}
mod commands;
pub mod commands;
pub use commands::*;
ide_command::domain!(search: search_start);
+6 -33
Переглянути файл
@@ -1,8 +1,6 @@
#[allow(unused_imports)]
use super::*;
use crate::Host;
use crate::ops::Channel;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{IdeResult, Pos, RequestId, TextEdit};
use ide_search::{ReplaceEvent, ReplaceHost, ReplacePreview, ReplaceTarget, SearchQuery};
use ide_workspace::Documents;
@@ -51,6 +49,7 @@ impl ReplaceHost for DocumentsHost<'_> {
/// editor buffers are replaced in place and left unsaved; files that were not
/// open are opened transiently, saved and closed.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn replace_in_files(
host: &Host,
window: &str,
@@ -79,6 +78,7 @@ pub async fn replace_in_files(
}
/// Before / after text of `path` for Replace › Preview (unsaved buffer included).
#[command(trust = trusted)]
pub async fn replace_preview(
host: &Host,
window: &str,
@@ -98,36 +98,9 @@ pub async fn replace_preview(
}
/// Validates a query (e.g. regex syntax) while the user types.
pub fn search_validate(_host: &Host, _window: &str, query: SearchQuery) -> IdeResult<()> {
#[command(trust = always)]
pub fn search_validate(query: SearchQuery) -> IdeResult<()> {
ide_search::validate_query(&query)
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("replace_in_files", |c| async move {
replace_in_files(
&c.host,
&c.window,
c.arg("request")?,
c.arg("query")?,
c.arg("replacement")?,
c.arg("preserveCase")?,
c.arg("targets")?,
c.sender("onEvent")?,
)
.await
});
d.add("replace_preview", |c| async move {
replace_preview(
&c.host,
&c.window,
c.arg("query")?,
c.arg("replacement")?,
c.arg("preserveCase")?,
c.arg("path")?,
c.arg("only")?,
)
.await
});
d.add("search_validate", |c| async move { search_validate(&c.host, &c.window, c.arg("query")?) });
}
ide_command::domain!(search_commands: replace_in_files, replace_preview, search_validate);
+4 -8
Переглянути файл
@@ -1,7 +1,7 @@
//! Proofreading › Typo: spell checking of open documents.
use crate::Host;
use crate::Project;
use crate::rpc::Dispatcher;
use ide_command::command;
use super::doc::blocking;
use ide_core::settings::SpellingSettings;
@@ -36,6 +36,7 @@ fn speller(project: &Project) -> Speller {
/// Misspelt words in the comments, string literals and declared names of
/// `doc` that `scope` includes (all of its text for prose). Cancel with
/// `cancel_request(request)`.
#[command(trust = always)]
pub async fn spell_check(
host: &Host,
window: &str,
@@ -105,6 +106,7 @@ pub async fn spell_check(
}
/// Replacements for a misspelt `word`, best first (Typo › Change to…).
#[command(trust = always)]
pub async fn spell_suggest(host: &Host, window: &str, word: String) -> IdeResult<Vec<String>> {
let project = host.project(window).ok();
blocking(move || {
@@ -114,10 +116,4 @@ pub async fn spell_suggest(host: &Host, window: &str, word: String) -> IdeResult
.await
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("spell_check", |c| async move {
spell_check(&c.host, &c.window, c.arg("doc")?, c.arg("scope")?, c.arg("request")?).await
});
d.add("spell_suggest", |c| async move { spell_suggest(&c.host, &c.window, c.arg("word")?).await });
}
ide_command::domain!(spell: spell_check, spell_suggest);
+53 -22
Переглянути файл
@@ -2,28 +2,59 @@
//! server ([`crate::rpc`]). A remote window connects from the server (deployment, database
//! tunnels, run targets, SSH sessions), so the host keys it trusts and the passwords it is
//! given belong to the server's [`ide_ssh::SshManager`], not the desktop's.
use crate::rpc::Dispatcher;
use crate::Host;
use ide_command::command;
use ide_core::IdeResult;
use ide_core::remote_settings::SshConfiguration;
pub(crate) fn register(d: &mut Dispatcher) {
d.add("ssh_test", |c| async move {
let (config, secret) = (c.arg::<SshConfiguration>("config")?, c.arg::<Option<String>>("secret")?);
c.host.ssh.test(&config, secret).await
});
d.add("ssh_set_secret", |c| async move {
let (id, secret, save) = (c.arg::<String>("id")?, c.arg::<Option<String>>("secret")?, c.arg::<bool>("save")?);
c.host.ssh.set_secret(&id, secret, save);
Ok(())
});
d.add("ssh_password_saved", |c| async move { Ok(c.host.ssh.password_saved(&c.arg::<String>("key")?)) });
d.add("ssh_needs_secret", |c| async move {
let ssh = &c.host.ssh;
Ok(ssh.needs_secret(&ssh.config(&c.arg::<String>("id")?)?))
});
d.add("ssh_trust_host", |c| async move { c.host.ssh.trust_host(&c.arg::<String>("id")?).await });
d.add("ssh_connected", |c| async move { Ok(c.host.ssh.connected()) });
d.add("ssh_disconnect", |c| async move {
c.host.ssh.disconnect(&c.arg::<String>("id")?);
Ok(())
});
/// Test Connection: connects with `config` as edited (not necessarily saved).
#[command(trust = always)]
pub async fn ssh_test(host: &Host, config: SshConfiguration, secret: Option<String>) -> IdeResult<String> {
host.ssh.test(&config, secret).await
}
/// Remembers the password / passphrase of configuration `id` (`None` forgets it).
#[command(trust = always)]
pub fn ssh_set_secret(host: &Host, id: String, secret: Option<String>, save: bool) {
host.ssh.set_secret(&id, secret, save);
}
/// Whether a password is saved under `key` (an FTP deployment server's).
#[command(trust = always)]
pub fn ssh_password_saved(host: &Host, key: String) -> bool {
host.ssh.password_saved(&key)
}
/// Whether connecting with configuration `id` needs a password first.
#[command(trust = always)]
pub fn ssh_needs_secret(host: &Host, id: String) -> IdeResult<bool> {
Ok(host.ssh.needs_secret(&host.ssh.config(&id)?))
}
/// Trusts the host key that failed the last connection of configuration `id`.
#[command(trust = always)]
pub async fn ssh_trust_host(host: &Host, id: String) -> IdeResult<()> {
host.ssh.trust_host(&id).await
}
/// Ids of the configurations with an open connection.
#[command(trust = always)]
pub fn ssh_connected(host: &Host) -> Vec<String> {
host.ssh.connected()
}
#[command(trust = always)]
pub fn ssh_disconnect(host: &Host, id: String) {
host.ssh.disconnect(&id);
}
ide_command::domain!(
ssh:
ssh_connected,
ssh_disconnect,
ssh_needs_secret,
ssh_password_saved,
ssh_set_secret,
ssh_test,
ssh_trust_host,
);
+20 -33
Переглянути файл
@@ -3,7 +3,7 @@
use crate::Host;
use crate::ops::Channel;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{CancellationToken, DebugSessionId, IdeError, IdeResult, LanguageId, Range, RequestId};
use ide_dap::{StackFrame, TraceRun};
pub use ide_dap::{TracePhase, TraceProgress, TraceUnavailable};
@@ -102,8 +102,8 @@ pub enum TerminalView {
Threw { exception: JvmValue },
}
/// The stream chains around `frame`'s line, in source order, with why each cannot be traced.
/// `top`: `frame` is the thread's top frame, the only one a trace can run from.
/// The stream chains around `frame`'s line; `top`: it is the thread's top frame.
#[command(trust = trusted)]
pub async fn debug_stream_chains(
host: &Host,
window: &str,
@@ -111,17 +111,16 @@ pub async fn debug_stream_chains(
frame: StackFrame,
top: bool,
) -> IdeResult<Vec<StreamChainInfo>> {
// In source order, with why each cannot be traced; only the top frame can run a trace.
host.require_trust(window)?;
let backend = host.debugger.capabilities(session)?.stream_trace;
Ok(candidates(host, window, frame, top, backend).await?.into_iter().map(|c| c.info).collect())
}
/// Runs the program from `thread_id`, stopped in `frame`, through the chain `chain_index` of
/// [`debug_stream_chains`], recording each element, and leaves it stopped after the chain's
/// terminal operation. `range` is that chain's [`StreamChainInfo::range`]: an edit in between
/// can move another chain to the same index. Cancelling `request` stops recording while the
/// program runs on.
/// Traces chain `chain_index` of [`debug_stream_chains`], whose `range` the UI showed, while the
/// program runs it; cancelling `request` stops recording.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn debug_stream_trace(
host: &Host,
window: &str,
@@ -133,6 +132,9 @@ pub async fn debug_stream_trace(
range: Range,
on_progress: Channel<TraceProgress>,
) -> IdeResult<StreamTraceResult> {
// Runs the program from `thread_id`, stopped in `frame`, and leaves it stopped after the
// chain's terminal operation. `range` is that chain's [`StreamChainInfo::range`]: an edit in
// between can move another chain to the same index. The program runs on after a cancel.
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
let chain = ChainRef { frame, index: chain_index, range };
@@ -195,12 +197,14 @@ async fn trace(
})
}
/// Ends the running trace's terminal operation (Abort Operation); `None` when no trace runs.
/// Ends the running trace's terminal operation; `None` when no trace runs.
#[command(trust = trusted)]
pub async fn debug_stream_trace_abort(
host: &Host,
window: &str,
session: DebugSessionId,
) -> IdeResult<Option<AbortState>> {
// Backs the debugger's Abort Operation action.
host.require_trust(window)?;
host.debugger.stream_trace_abort(session).await
}
@@ -438,29 +442,12 @@ fn box_kind(type_name: &str) -> Option<BoxKind> {
})
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("debug_stream_chains", |c| async move {
debug_stream_chains(&c.host, &c.window, c.arg("session")?, c.arg("frame")?, c.arg("top")?).await
});
d.add("debug_stream_trace", |c| async move {
debug_stream_trace(
&c.host,
&c.window,
c.arg("session")?,
c.arg("request")?,
c.arg("threadId")?,
c.arg("frame")?,
c.arg("chainIndex")?,
c.arg("range")?,
c.sender("onProgress")?,
)
.await
});
d.add("debug_stream_trace_abort", |c| async move {
debug_stream_trace_abort(&c.host, &c.window, c.arg("session")?).await
});
}
#[cfg(test)]
mod tests;
ide_command::domain!(
stream_trace:
debug_stream_chains,
debug_stream_trace,
debug_stream_trace_abort,
);
+20 -27
Переглянути файл
@@ -8,7 +8,7 @@
//! `unavailable`.
use crate::Host;
use crate::Project;
use crate::rpc::Dispatcher;
use ide_command::command;
use super::doc::blocking;
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, LanguageId, Pos, Range, RequestId};
@@ -46,11 +46,13 @@ async fn on_doc<T: Send + 'static>(
/// What the structure service supports for a language (`tree`: every query,
/// `locals`: scope analysis).
#[command(trust = always)]
pub fn syntax_support(host: &Host, window: &str, language: LanguageId) -> IdeResult<StructureSupport> {
Ok(host.project(window)?.structure.support(&language))
}
/// The smallest named node covering `range`, with its ancestors (parent first).
#[command(trust = always)]
pub async fn syntax_node_at(
host: &Host,
window: &str,
@@ -63,6 +65,7 @@ pub async fn syntax_node_at(
/// The expression a selection denotes (exact or minimally enclosing), with its
/// statement, block and caret candidates.
#[command(trust = always)]
pub async fn syntax_expression_at(
host: &Host,
window: &str,
@@ -74,6 +77,7 @@ pub async fn syntax_expression_at(
}
/// `ERROR` / `MISSING` nodes (e.g. a missing `;`) in document order.
#[command(trust = always)]
pub async fn syntax_errors(
host: &Host,
window: &str,
@@ -85,6 +89,7 @@ pub async fn syntax_errors(
/// Scope analysis of the identifier at `pos`: its local definition and
/// references, or why it is not a local.
#[command(trust = always)]
pub async fn syntax_locals(
host: &Host,
window: &str,
@@ -96,6 +101,7 @@ pub async fn syntax_locals(
}
/// Identifier tokens spelled `name` in a document, excluding comments and strings.
#[command(trust = always)]
pub async fn syntax_identifiers(
host: &Host,
window: &str,
@@ -108,6 +114,7 @@ pub async fn syntax_identifiers(
/// [`syntax_identifiers`] over files (open buffers win over disk); files
/// without occurrences or without a grammar are left out. Cancellable.
#[command(trust = always)]
pub async fn syntax_identifiers_in_files(
host: &Host,
window: &str,
@@ -137,6 +144,7 @@ pub async fn syntax_identifiers_in_files(
/// Extend Selection chain plus statement / declaration ranges at `pos`
/// (Move Statement, Complete Statement for languages without a Lezer grammar).
#[command(trust = always)]
pub async fn syntax_structural_ranges(
host: &Host,
window: &str,
@@ -147,29 +155,14 @@ pub async fn syntax_structural_ranges(
on_doc(host, window, doc, request, move |s, snap, c| s.structural_ranges(snap, pos, c)).await
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("syntax_support", |c| async move { syntax_support(&c.host, &c.window, c.arg("language")?) });
d.add("syntax_node_at", |c| async move {
syntax_node_at(&c.host, &c.window, c.arg("doc")?, c.arg("range")?, c.arg("request")?).await
});
d.add("syntax_expression_at", |c| async move {
syntax_expression_at(&c.host, &c.window, c.arg("doc")?, c.arg("range")?, c.arg("request")?).await
});
d.add(
"syntax_errors",
|c| async move { syntax_errors(&c.host, &c.window, c.arg("doc")?, c.arg("request")?).await },
);
d.add("syntax_locals", |c| async move {
syntax_locals(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?, c.arg("request")?).await
});
d.add("syntax_identifiers", |c| async move {
syntax_identifiers(&c.host, &c.window, c.arg("doc")?, c.arg("name")?, c.arg("request")?).await
});
d.add("syntax_identifiers_in_files", |c| async move {
syntax_identifiers_in_files(&c.host, &c.window, c.arg("paths")?, c.arg("name")?, c.arg("request")?).await
});
d.add("syntax_structural_ranges", |c| async move {
syntax_structural_ranges(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?, c.arg("request")?).await
});
}
ide_command::domain!(
syntax:
syntax_errors,
syntax_expression_at,
syntax_identifiers,
syntax_identifiers_in_files,
syntax_locals,
syntax_node_at,
syntax_structural_ranges,
syntax_support,
);
+54 -12
Переглянути файл
@@ -1,5 +1,6 @@
use super::Emit;
use super::{Channel, Emit};
use crate::Host;
use ide_command::command;
use ide_core::{IdeResult, TerminalId};
use ide_terminal::{TerminalInfo, TerminalOptions};
@@ -7,7 +8,8 @@ mod images;
const MAX_IMAGE_BYTES: usize = 20 * 1024 * 1024;
pub async fn store_image(host: &Host, id: TerminalId, data: Vec<u8>, mime: String) -> IdeResult<String> {
#[command(trust = always)]
pub async fn term_store_image(host: &Host, id: TerminalId, data: Vec<u8>, mime: String) -> IdeResult<String> {
if data.len() > MAX_IMAGE_BYTES {
return Err(ide_core::IdeError::invalid("image is too large to paste (limit 20 MB)"));
}
@@ -18,11 +20,14 @@ pub async fn store_image(host: &Host, id: TerminalId, data: Vec<u8>, mime: Strin
host.blocking(move || images::store(&data_dir, &data, &mime)).await
}
pub fn spawn(
/// Async to stay off the main thread: forking the IDE (its whole address space)
/// to start the shell takes tens of milliseconds, a frozen UI if run there.
#[command(trust = always)]
pub async fn term_spawn(
host: &Host,
window: &str,
mut options: TerminalOptions,
on_output: Emit<String>,
on_output: Channel<String>,
) -> IdeResult<TerminalInfo> {
if !host.project(window).is_ok_and(|p| p.is_trusted()) {
// Project terminal settings can otherwise start a command as soon as a tab restores.
@@ -41,7 +46,14 @@ pub fn spawn(
.filter(|p| p.is_trusted())
.and_then(|p| ide_sdk::apply::terminal_activation(&p.root, &p.settings.effective(), &shell));
let key = host.owner_window(window).to_owned();
let info = host.terminals.spawn(options, key, host.window_sink(window), Box::new(move |chunk| on_output(chunk)))?;
let info = host.terminals.spawn(
options,
key,
host.window_sink(window),
Box::new(move |chunk| {
let _ = on_output.send(chunk);
}),
)?;
if let Some(line) = activation {
let _ = host.terminals.write(info.id, &format!(" {line}\r"));
}
@@ -133,22 +145,40 @@ impl ide_terminal::TerminalChannel for SshTerminal {
}
}
pub fn write(host: &Host, id: TerminalId, data: &str) -> IdeResult<()> {
host.terminals.write(id, data)
#[command(trust = always)]
pub fn term_write(host: &Host, id: TerminalId, data: String) -> IdeResult<()> {
host.terminals.write(id, &data)
}
pub fn resize(host: &Host, id: TerminalId, cols: u16, rows: u16) -> IdeResult<()> {
#[command(trust = always)]
pub fn term_resize(host: &Host, id: TerminalId, cols: u16, rows: u16) -> IdeResult<()> {
host.terminals.resize(id, cols, rows)
}
pub fn kill(host: &Host, id: TerminalId) -> IdeResult<()> {
#[command(trust = always)]
pub fn term_kill(host: &Host, id: TerminalId) -> IdeResult<()> {
host.terminals.kill(id)
}
pub fn is_busy(host: &Host, id: TerminalId) -> IdeResult<bool> {
/// Whether the session is running a command (closing its tab asks first). A
/// `tcgetpgrp` or one process snapshot: async only to stay off the main thread.
#[command(trust = always)]
pub async fn term_is_busy(host: &Host, id: TerminalId) -> IdeResult<bool> {
host.terminals.is_busy(id)
}
/// Shell used when Settings › Terminal › Shell path is empty.
#[command(trust = always)]
pub fn term_default_shell() -> String {
ide_terminal::default_shell_path()
}
/// Installed shells for the Terminal's "New Predefined Session" menu.
#[command(trust = always)]
pub fn term_available_shells() -> Vec<String> {
ide_terminal::available_shells()
}
#[cfg(test)]
mod tests {
use super::*;
@@ -171,11 +201,23 @@ mod tests {
project_environment: false,
});
let id = TerminalId::next();
let error = store_image(&host, id, vec![0; MAX_IMAGE_BYTES + 1], "image/png".into()).await.unwrap_err();
let error = term_store_image(&host, id, vec![0; MAX_IMAGE_BYTES + 1], "image/png".into()).await.unwrap_err();
assert_eq!(error.kind, ErrorKind::InvalidInput);
assert_eq!(error.message, "image is too large to paste (limit 20 MB)");
let error = store_image(&host, id, vec![0; MAX_IMAGE_BYTES], "image/png".into()).await.unwrap_err();
let error = term_store_image(&host, id, vec![0; MAX_IMAGE_BYTES], "image/png".into()).await.unwrap_err();
assert_eq!(error.message, "terminal session not found");
assert!(!host.data_dir.join("terminal-images").exists());
}
}
ide_command::domain!(
term:
term_available_shells,
term_default_shell,
term_is_busy,
term_kill,
term_resize,
term_spawn,
term_store_image,
term_write,
);
+26 -40
Переглянути файл
@@ -1,7 +1,7 @@
//! Language server / debug adapter installer and JDK downloads (`ide-tools`).
use crate::Host;
use crate::ops::Channel;
use crate::rpc::Dispatcher;
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId};
use ide_sdk::Sdk;
@@ -56,6 +56,7 @@ fn reconfigure_servers(host: &Host) {
}
/// Status of every known language server / debug adapter and the languages using it.
#[command(trust = trusted)]
pub async fn tools_list(host: &Host, window: &str) -> IdeResult<Vec<ToolInfo>> {
let tools = tools(host, window)?;
let langs = languages(host, window);
@@ -64,6 +65,7 @@ pub async fn tools_list(host: &Host, window: &str) -> IdeResult<Vec<ToolInfo>> {
/// Installs (or reinstalls) a tool into `<app-data>/tools`, streaming output through
/// `on_event`. Cancel with `cancel_request(request)`.
#[command(trust = trusted)]
pub async fn tools_install(
host: &Host,
window: &str,
@@ -91,6 +93,7 @@ pub async fn tools_install(
/// Newer versions of the tools the IDE installed (release downloads and npm packages).
/// Cancel with `cancel_request(request)`.
#[command(trust = trusted)]
pub async fn tools_updates(host: &Host, window: &str, request: RequestId) -> IdeResult<Vec<ToolUpdate>> {
let tools = tools(host, window)?;
let cancel = host.begin_request(request);
@@ -100,6 +103,7 @@ pub async fn tools_updates(host: &Host, window: &str, request: RequestId) -> Ide
}
/// Removes a tool the IDE installed.
#[command(trust = trusted)]
pub async fn tools_uninstall(host: &Host, window: &str, name: String) -> IdeResult<ToolInfo> {
let tools = tools(host, window)?;
let langs = languages(host, window);
@@ -109,17 +113,14 @@ pub async fn tools_uninstall(host: &Host, window: &str, name: String) -> IdeResu
}
/// JDK distributions Download JDK offers.
pub fn jdk_download_vendors(_host: &Host, _window: &str) -> Vec<JdkVendor> {
#[command(trust = always)]
pub fn jdk_download_vendors() -> Vec<JdkVendor> {
ide_tools::jdk::vendors()
}
/// Java versions `vendor` publishes; cancellable with `cancel_request(request)`.
pub async fn jdk_download_releases(
host: &Host,
_window: &str,
vendor: String,
request: RequestId,
) -> IdeResult<JdkReleases> {
#[command(trust = always)]
pub async fn jdk_download_releases(host: &Host, vendor: String, request: RequestId) -> IdeResult<JdkReleases> {
let tools = Tools::new(&host.local_data_dir);
let cancel = host.begin_request(request);
let result = tokio::task::spawn_blocking(move || tools.jdk_releases(&vendor, &cancel)).await.map_err(join_err);
@@ -128,7 +129,8 @@ pub async fn jdk_download_releases(
}
/// Where Download JDK puts JDKs unless told otherwise.
pub fn jdk_download_location(host: &Host, _window: &str) -> IdeResult<ide_core::IpcPath> {
#[command(trust = always)]
pub fn jdk_download_location(host: &Host) -> IdeResult<ide_core::IpcPath> {
Ok(ide_tools::jdk::jdks_dir(&host.local_data_dir).into())
}
@@ -136,10 +138,9 @@ pub fn jdk_download_location(host: &Host, _window: &str) -> IdeResult<ide_core::
/// [`jdk_download_location`]), streaming progress through `on_event`; cancellable
/// with `cancel_request(request)`. The JDK is then detected like an installed one,
/// and language servers waiting for a JDK (jdtls) start on it.
#[allow(clippy::too_many_arguments)]
#[command(trust = always)]
pub async fn jdk_download(
host: &Host,
_window: &str,
vendor: String,
version: u32,
location: Option<PathBuf>,
@@ -171,8 +172,8 @@ pub async fn jdk_download(
Ok(sdk)
}
/// The Java version the jdtls this window launches needs; `None` while it isn't
/// installed or doesn't tell.
/// The Java version the window's jdtls needs; `None` while it isn't installed or doesn't tell.
#[command(trust = always)]
pub async fn jdtls_required_java(host: &Host, window: &str) -> IdeResult<Option<u32>> {
let settings = match host.project(window) {
Ok(project) => project.settings.effective(),
@@ -188,30 +189,15 @@ pub async fn jdtls_required_java(host: &Host, window: &str) -> IdeResult<Option<
tokio::task::spawn_blocking(move || ide_sdk::java::jdtls_required_java(&cfg)).await.map_err(join_err)
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("tools_list", |c| async move { tools_list(&c.host, &c.window).await });
d.add("tools_install", |c| async move {
tools_install(&c.host, &c.window, c.arg("name")?, c.arg("request")?, c.sender("onEvent")?).await
});
d.add("tools_uninstall", |c| async move { tools_uninstall(&c.host, &c.window, c.arg("name")?).await });
d.add("tools_updates", |c| async move { tools_updates(&c.host, &c.window, c.arg("request")?).await });
d.add("jdk_download_vendors", |c| async move { Ok(jdk_download_vendors(&c.host, &c.window)) });
d.add("jdk_download_releases", |c| async move {
jdk_download_releases(&c.host, &c.window, c.arg("vendor")?, c.arg("request")?).await
});
d.add("jdk_download_location", |c| async move { jdk_download_location(&c.host, &c.window) });
d.add("jdtls_required_java", |c| async move { jdtls_required_java(&c.host, &c.window).await });
d.add("jdk_download", |c| async move {
jdk_download(
&c.host,
&c.window,
c.arg("vendor")?,
c.arg("version")?,
c.arg("location")?,
c.arg("request")?,
c.sender("onEvent")?,
)
.await
});
}
ide_command::domain!(
tools:
jdk_download,
jdk_download_location,
jdk_download_releases,
jdk_download_vendors,
jdtls_required_java,
tools_install,
tools_list,
tools_uninstall,
tools_updates,
);
+10 -5
Переглянути файл
@@ -1,9 +1,11 @@
use crate::{Host, apply_git_executable};
use ide_command::command;
use ide_core::IdeResult;
use ide_vcs::FileStatus;
/// Changes of every repository of the project.
pub async fn status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>> {
#[command(trust = always)]
pub async fn vcs_status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>> {
let project = host.project(window)?;
host.blocking(move || {
let settings = project.settings.effective();
@@ -22,9 +24,10 @@ pub async fn status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>> {
.await
}
/// Changes of `paths` only: the dirty-scope refresh after a watcher batch. `paths` that belong
/// to no repository are ignored, and an empty list is the full status.
pub async fn status_paths(host: &Host, window: &str, paths: Vec<std::path::PathBuf>) -> IdeResult<Vec<FileStatus>> {
/// Changes of `paths` only: the dirty-scope refresh after a watcher batch.
#[command(trust = always)]
pub async fn vcs_status_paths(host: &Host, window: &str, paths: Vec<std::path::PathBuf>) -> IdeResult<Vec<FileStatus>> {
// `paths` that belong to no repository are ignored, and an empty list is the full status.
let project = host.project(window)?;
host.blocking(move || {
let settings = project.settings.effective();
@@ -43,7 +46,7 @@ pub async fn status_paths(host: &Host, window: &str, paths: Vec<std::path::PathB
.await
}
mod commands;
pub mod commands;
pub use commands::*;
/// Refuses (with `refusal`) to remove or move the worktree that holds the open project.
@@ -84,3 +87,5 @@ fn check_worktree_away_from_project(
}
Ok(())
}
ide_command::domain!(vcs: vcs_status, vcs_status_paths);
File diff suppressed because it is too large. Load diff
+9 -4
Переглянути файл
@@ -1,9 +1,10 @@
//! The built-in web server's URLs.
use crate::Host;
use ide_command::command;
use ide_core::IdeResult;
use ide_core::IpcPath;
use ide_core::proxy_settings::{ProxyMode, ProxySettings};
use std::path::Path;
use std::time::Duration;
/// Whether `url` names this machine (`localhost` or a loopback address).
@@ -46,10 +47,12 @@ pub async fn serves_page(url: &str) -> bool {
response.status().is_success() && html
}
/// The URL serving `file`, under the window's project when it holds the file.
pub async fn url(host: &Host, window: &str, file: &Path) -> IdeResult<String> {
/// The built-in server's URL for `path` (started on first use).
#[command(trust = always)]
pub async fn web_url(host: &Host, window: &str, path: IpcPath) -> IdeResult<String> {
// Under the window's project when it holds the file.
let root = host.project(window).ok().map(|p| p.root.clone());
host.web.url_for(root.as_deref(), file).await
host.web.url_for(root.as_deref(), &path).await
}
#[cfg(test)]
@@ -105,3 +108,5 @@ mod tests {
assert!(!serves_page("not a url").await);
}
}
ide_command::domain!(web: web_url);
+284 -11
Переглянути файл
@@ -1,23 +1,48 @@
//! Plugin command requests shared by local IPC and remote RPC.
//! Plugin window commands shared by local IPC and remote RPC.
use super::PluginHost;
use ide_core::{IdeResult, RequestId};
use super::{
CommandAnswer, CommitAnswer, DecorationSet, EventKind, PluginContextKey, PluginEditor, PluginHost, PluginInfo,
PluginStatusItem, WorkbenchEvent,
};
use crate::Host;
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId};
use ide_plugin::Invocation;
use ide_workspace::settings::SettingsScope;
use std::collections::BTreeMap;
use std::path::PathBuf;
use std::sync::Arc;
pub async fn run_command(
host: &crate::Host,
plugins: Arc<PluginHost>,
async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send + 'static) -> IdeResult<T> {
tokio::task::spawn_blocking(f).await.map_err(|e| IdeError::internal(e.to_string()))?
}
/// Runs a plugin command in the context of this window's project and focused editor.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn plugin_run_command(
host: &Host,
plugins: &Arc<PluginHost>,
window: &str,
plugin_id: String,
command_id: String,
arg: Option<String>,
invocation: Invocation,
editor: Option<PluginEditor>,
paths: Option<Vec<PathBuf>>,
settings_scope: Option<SettingsScope>,
command_chain: Option<Vec<String>>,
request: Option<RequestId>,
) -> IdeResult<Option<String>> {
let cancel = request.map(|id| match invocation.client.as_deref() {
Some(window) => host.begin_project_read_request(window, id),
None => host.begin_request(id),
});
let plugins = plugins.clone();
let invocation = Invocation {
command_chain: command_chain.unwrap_or_default(),
client: Some(window.to_owned()),
workspace_root: host.project(window).ok().map(|p| p.root.clone()),
editor: editor.map(PluginEditor::context),
selected_paths: paths.unwrap_or_default(),
global_settings: matches!(settings_scope, Some(SettingsScope::Global)),
};
let cancel = request.map(|id| host.begin_project_read_request(window, id));
let result = host
.blocking(move || {
plugins.run_command_with_cancel(&plugin_id, &command_id, arg.as_deref(), invocation, cancel.as_ref())
@@ -28,3 +53,251 @@ pub async fn run_command(
}
result
}
/// The UI language (BCP 47) that plugin code reads with `ui.locale()`.
#[command(trust = always)]
pub async fn plugin_set_ui_locale(plugins: &Arc<PluginHost>, tag: String) -> IdeResult<()> {
plugins.set_ui_locale(&tag);
Ok(())
}
/// Workbench events from this window (only the kinds of `plugin_event_kinds`).
#[command(trust = trusted)]
pub fn plugin_post_events(
plugins: &Arc<PluginHost>,
window: &str,
events: Vec<WorkbenchEvent>,
editor: Option<PluginEditor>,
) {
plugins.post_window_events(window, events, editor);
}
/// Kinds of workbench events plugins want (re-fetch on `subscriptionsChanged`).
#[command(trust = trusted, desktop_body = async)]
pub async fn plugin_event_kinds(plugins: &Arc<PluginHost>) -> Vec<EventKind> {
plugins.event_kinds().into_iter().collect()
}
/// Every plugin status bar item (later changes arrive as `statusItemChanged`).
#[command(trust = trusted)]
pub fn plugin_status_items(plugins: &Arc<PluginHost>, window: &str) -> Vec<PluginStatusItem> {
plugins.status_snapshot(window)
}
/// Plugin context keys in effect for this window (later changes arrive as `contextChanged`).
#[command(trust = trusted)]
pub fn plugin_context_keys(plugins: &Arc<PluginHost>, window: &str) -> Vec<PluginContextKey> {
plugins.context_keys(Some(window))
}
/// Cancels a plugin task (`taskStarted` with `cancellable`).
#[command(trust = trusted)]
pub fn plugin_cancel_task(plugins: &Arc<PluginHost>, task_id: String) -> bool {
plugins.cancel_task(&task_id)
}
/// Reports the user's answer to a plugin's `promptRequested`: the chosen keys
/// (pick), `[text]` (input), anything (confirm: OK), or `None` when dismissed.
#[command(trust = trusted)]
pub fn plugin_answer_prompt(plugins: &Arc<PluginHost>, prompt_id: String, answer: Option<Vec<String>>) -> bool {
plugins.answer_prompt(&prompt_id, answer)
}
/// A window's answer to a plugin's `commitRequested`; false when the call no
/// longer waits.
#[command(trust = trusted)]
pub fn plugin_answer_commit(plugins: &Arc<PluginHost>, request_id: String, answer: CommitAnswer) -> bool {
plugins.answer_commit(&request_id, answer)
}
/// The UI reports the focused editor's file (`editor-focused` events).
#[command(trust = always)]
pub fn plugin_set_active_file(plugins: &Arc<PluginHost>, window: &str, path: Option<String>) {
plugins.set_active_file(window, path);
}
/// The invoking window's reply to a plugin command request.
#[command(trust = trusted)]
pub fn plugin_answer_command(
plugins: &Arc<PluginHost>,
window: &str,
request_id: String,
answer: CommandAnswer,
) -> IdeResult<bool> {
Ok(plugins.answer_command(window, &request_id, answer))
}
/// The project root a `scope` setting applies to (`None`: global).
fn scope_root(host: &Host, window: &str, scope: SettingsScope) -> IdeResult<Option<PathBuf>> {
Ok(match scope {
SettingsScope::Global => None,
SettingsScope::Project => Some(host.project(window)?.root.clone()),
})
}
/// Re-approves a plugin's executable, globally or for this window's project.
#[command(trust = outside_restricted)]
pub async fn plugin_choose_program(
host: &Host,
plugins: &Arc<PluginHost>,
window: &str,
plugin_id: String,
capability: String,
scope: SettingsScope,
path: Option<PathBuf>,
) -> IdeResult<PluginInfo> {
let plugins = plugins.clone();
let root = scope_root(host, window, scope)?;
blocking(move || plugins.choose_program(&plugin_id, &capability, root.as_deref(), path.as_deref())).await
}
/// The currently approved executable in the selected scope, after revalidating its pin.
#[command(trust = outside_restricted)]
pub async fn plugin_program(
host: &Host,
plugins: &Arc<PluginHost>,
window: &str,
plugin_id: String,
program: String,
scope: SettingsScope,
) -> IdeResult<ide_core::IpcPath> {
let plugins = plugins.clone();
let root = scope_root(host, window, scope)?;
blocking(move || plugins.program_for_project(&plugin_id, &program, root.as_deref()).map(Into::into)).await
}
/// Project-scoped decoration snapshots; the window filters to its current root.
#[command(trust = trusted)]
pub fn plugin_decoration_sets(plugins: &Arc<PluginHost>) -> BTreeMap<String, Vec<DecorationSet>> {
plugins.decoration_sets()
}
/// Reports exactly one completion from the operation's launching window.
#[command(trust = trusted)]
pub fn plugin_finish_operation(
plugins: &Arc<PluginHost>,
window: &str,
id: String,
status: Option<i32>,
stopped: bool,
) -> IdeResult<bool> {
Ok(plugins.finish_operation(window, &id, status, stopped))
}
/// Dispatches a wasm content editor action through the owning plugin's event handler.
#[command(trust = trusted)]
pub fn plugin_content_tab_action(
plugins: &Arc<PluginHost>,
window: &str,
plugin_id: String,
action: ide_plugin::ContentTabAction,
) -> IdeResult<()> {
plugins.content_tab_action(window, &plugin_id, action)
}
/// Selects test-tree paths in an owned plugin test configuration.
#[command(trust = trusted)]
pub async fn plugin_select_tests(
plugins: &Arc<PluginHost>,
window: &str,
config: String,
tests: Vec<Vec<String>>,
) -> IdeResult<Option<Vec<String>>> {
let (plugins, client) = (plugins.clone(), window.to_owned());
blocking(move || plugins.select_tests(&client, &config, tests)).await
}
/// Parses one batch of an owned test configuration's output.
#[command(trust = trusted)]
pub async fn plugin_parse_test_results(
plugins: &Arc<PluginHost>,
window: &str,
config: String,
chunk: String,
) -> IdeResult<Option<Vec<ide_plugin::PluginTestEvent>>> {
let (plugins, client) = (plugins.clone(), window.to_owned());
blocking(move || plugins.parse_test_results(&client, &config, chunk)).await
}
/// Starts only the pinned command recorded for this window's terminal operation.
#[command(trust = trusted)]
pub async fn plugin_terminal_session_spawn(
host: &Arc<Host>,
plugins: &Arc<PluginHost>,
window: &str,
operation: String,
cols: u16,
rows: u16,
on_output: crate::ops::Channel<String>,
) -> IdeResult<ide_terminal::TerminalInfo> {
let (plugins, host, window) = (plugins.clone(), host.clone(), window.to_owned());
blocking(move || {
plugins.spawn_terminal_session(
&host,
&window,
&operation,
cols,
rows,
Arc::new(move |chunk| {
let _ = on_output.send(chunk);
}),
)
})
.await
}
/// Marks a keyed tab closed before ending its process.
#[command(trust = trusted)]
pub fn plugin_terminal_session_close(plugins: &Arc<PluginHost>, window: &str, operation: String) -> IdeResult<()> {
plugins.close_terminal_session(window, &operation)
}
/// Revalidates a plugin run's executable before debugging, including reruns.
#[command(trust = trusted)]
pub async fn plugin_prepare_debug_run(
plugins: &Arc<PluginHost>,
window: &str,
config: ide_run::RunConfig,
) -> IdeResult<ide_run::RunConfig> {
let (plugins, client) = (plugins.clone(), window.to_owned());
blocking(move || plugins.prepare_debug_run(&client, config)).await
}
/// Waits for the process an `attach-child` plugin configuration's debugger attaches to.
#[command(trust = trusted)]
pub async fn plugin_debug_attach_target(
host: &Arc<Host>,
plugins: &Arc<PluginHost>,
window: &str,
config: String,
run: ide_core::RunId,
) -> IdeResult<ide_dap::attach::AttachableProcess> {
let (plugins, host, client) = (plugins.clone(), host.clone(), window.to_owned());
blocking(move || plugins.debug_attach_target(&host, &client, &config, run)).await
}
ide_command::domain!(
plugins_commands:
plugin_answer_command,
plugin_answer_commit,
plugin_answer_prompt,
plugin_cancel_task,
plugin_choose_program,
plugin_content_tab_action,
plugin_context_keys,
plugin_debug_attach_target,
plugin_decoration_sets,
plugin_event_kinds,
plugin_finish_operation,
plugin_parse_test_results,
plugin_post_events,
plugin_prepare_debug_run,
plugin_program,
plugin_run_command,
plugin_select_tests,
plugin_set_active_file,
plugin_set_ui_locale,
plugin_status_items,
plugin_terminal_session_close,
plugin_terminal_session_spawn,
);
+9 -4
Переглянути файл
@@ -3,20 +3,23 @@
//! local projects, `openidea-server` for remote ones.
use super::{CommitSelection, PluginCommitCheckRef, PluginCommitCheckResult, PluginHost};
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId};
use std::sync::Arc;
/// Runs the plugins' before-commit checks `checks` on what `selection` commits,
/// until request `request` is cancelled.
pub async fn commit_checks(
/// Runs plugins' before-commit checks on what `selection` commits, until
/// `request` is cancelled.
#[command(trust = trusted)]
pub async fn plugin_commit_checks(
host: &crate::Host,
plugins: Arc<PluginHost>,
plugins: &Arc<PluginHost>,
window: &str,
selection: CommitSelection,
checks: Vec<PluginCommitCheckRef>,
request: RequestId,
) -> IdeResult<Vec<PluginCommitCheckResult>> {
host.require_trust(window)?;
let plugins = plugins.clone();
let invocation = super::views::view_invocation(host, window, None, None)?;
let cancel = host.begin_project_read_request(window, request);
let result = tokio::task::spawn_blocking(move || plugins.commit_checks(invocation, selection, checks, &cancel))
@@ -26,3 +29,5 @@ pub async fn commit_checks(
host.end_request(request);
result
}
ide_command::domain!(plugins_commit: plugin_commit_checks);
+1 -1
Переглянути файл
@@ -638,7 +638,7 @@ impl PluginHost {
let contains = owned.extras.params.get(DEBUG_ATTACH_CONTAINS).cloned();
let deadline = Instant::now() + Duration::from_secs(60);
loop {
let info = crate::ops::run::list(host).into_iter().find(|r| r.id == run && r.config_id == owned.id);
let info = crate::ops::run::run_list(host).into_iter().find(|r| r.id == run && r.config_id == owned.id);
let Some(pid) = info.as_ref().filter(|r| r.running).and_then(|r| r.pid) else {
return Err(IdeError::not_found("the run ended before a process to debug started"));
};
+31 -9
Переглянути файл
@@ -1,4 +1,5 @@
use super::PluginHost;
use ide_command::command;
use ide_core::{IdeError, IdeResult};
use ide_plugin::Invocation;
use std::{path::PathBuf, sync::Arc};
@@ -9,13 +10,15 @@ pub struct NavigationFiles {
pub extensions: Vec<String>,
}
/// File discovery is separate from clicking: the UI schedules small background
/// batches after initial index completion and updates only changed files later.
#[command(trust = trusted)]
pub async fn plugin_navigation_files(
host: &crate::Host,
plugins: Arc<PluginHost>,
plugins: &Arc<PluginHost>,
window: &str,
) -> IdeResult<NavigationFiles> {
// File discovery is separate from clicking: the UI schedules small background
// batches after initial index completion and updates only changed files later.
let plugins = plugins.clone();
let project = host.project(window)?;
blocking(move || {
let extensions = plugins.navigation_extensions(&project.root);
@@ -40,9 +43,10 @@ pub async fn plugin_navigation_files(
.await
}
#[command(trust = trusted)]
pub fn plugin_navigation_invalidate(
host: &crate::Host,
plugins: Arc<PluginHost>,
plugins: &Arc<PluginHost>,
window: &str,
paths: Option<Vec<PathBuf>>,
) -> IdeResult<()> {
@@ -51,9 +55,10 @@ pub fn plugin_navigation_invalidate(
Ok(())
}
#[command(trust = trusted)]
pub async fn plugin_navigation_index(
host: &crate::Host,
plugins: Arc<PluginHost>,
plugins: &Arc<PluginHost>,
window: &str,
paths: Vec<PathBuf>,
request: ide_core::RequestId,
@@ -61,6 +66,7 @@ pub async fn plugin_navigation_index(
if paths.len() > 16 {
return Err(IdeError::invalid("navigation batches are limited to 16 files"));
}
let plugins = plugins.clone();
let project = host.project(window)?;
let cancel = host.begin_project_request(window, request);
let client = window.to_owned();
@@ -140,24 +146,28 @@ pub async fn plugin_navigation_index(
result
}
/// The HTTP routes `plugin_id` reports for this window's project.
#[command(trust = trusted)]
pub async fn plugin_endpoints(
host: &crate::Host,
plugins: Arc<PluginHost>,
plugins: &Arc<PluginHost>,
window: &str,
plugin_id: String,
) -> IdeResult<Vec<crate::plugins::endpoints::PluginEndpoint>> {
// The HTTP routes `plugin_id` reports for this window's project.
let plugins = plugins.clone();
let project = host.project(window)?;
blocking(move || Ok(plugins.endpoints(&plugin_id, &project.root)?.as_ref().clone())).await
}
#[command(trust = trusted)]
pub async fn plugin_navigation_goto(
host: &crate::Host,
plugins: Arc<PluginHost>,
plugins: &Arc<PluginHost>,
window: &str,
doc: ide_core::DocId,
pos: ide_core::Pos,
) -> IdeResult<Option<crate::plugins::navigation::NavigationResult>> {
let plugins = plugins.clone();
let project = host.project(window)?;
let client = window.to_owned();
blocking(move || {
@@ -169,15 +179,17 @@ pub async fn plugin_navigation_goto(
.await
}
#[command(trust = trusted)]
pub async fn plugin_navigation_markers(
host: &crate::Host,
plugins: Arc<PluginHost>,
plugins: &Arc<PluginHost>,
window: &str,
paths: Vec<PathBuf>,
) -> IdeResult<Vec<crate::plugins::navigation::FileMarkers>> {
if paths.len() > 64 {
return Err(IdeError::invalid("marker batches are limited to 64 files"));
}
let plugins = plugins.clone();
let project = host.project(window)?;
let client = window.to_owned();
blocking(move || {
@@ -191,3 +203,13 @@ pub async fn plugin_navigation_markers(
async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send + 'static) -> IdeResult<T> {
tokio::task::spawn_blocking(f).await.map_err(|e| IdeError::internal(e.to_string()))?
}
ide_command::domain!(
plugins_index_ops:
plugin_endpoints,
plugin_navigation_files,
plugin_navigation_goto,
plugin_navigation_index,
plugin_navigation_invalidate,
plugin_navigation_markers,
);
+8 -409
Переглянути файл
@@ -11,25 +11,21 @@
//! grants (a `process:` grant is pinned to the program on this machine's
//! `PATH`).
//!
//! The commands a window needs at run time (`plugin_run_command`,
//! `plugin_post_events`, `plugin_event_kinds`, `plugin_status_items`,
//! `plugin_context_keys`, `plugin_cancel_task`, `plugin_answer_prompt`, `plugin_set_active_file`,
//! `plugin_line_markers`, `plugin_set_ui_locale`, `plugin_view_render`, `plugin_view_event`,
//! `plugin_service_detail`, `plugin_service_log`, `plugin_answer_commit`, `plugin_commit_checks`)
//! carry the desktop commands' names and arguments, so a remote window's UI
//! routes them here unchanged. Plugin results come back as `plugin`
//! The commands a window needs at run time (`plugin_run_command`, `plugin_post_events`, …) are
//! `#[command]`s served by every project host, so a remote window's UI routes them here
//! unchanged. Plugin results come back as `plugin`
//! notifications ([`PluginEventMessage`]); secrets stay in the desktop's
//! keychain and are asked for with a `plugin_secret` request
//! ([`SecretRequest`]) when a request header needs one (rule 4).
use super::{Consent, HostWorkspace, PluginEditor, PluginEvent, PluginHost, PluginSource, SecretStore};
use super::{Consent, HostWorkspace, PluginEvent, PluginHost, PluginSource, SecretStore};
use crate::catalogue::TrustClass;
use crate::rpc::Dispatcher;
use base64::Engine as _;
use ide_core::{IdeError, IdeResult};
use ide_extension::{MANIFEST_FILE, ledger};
use ide_jsonrpc::Peer;
use ide_plugin::{Invocation, Limits};
use ide_workspace::settings::SettingsScope;
use ide_plugin::Limits;
use parking_lot::Mutex;
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, BTreeSet};
@@ -47,49 +43,6 @@ pub const SECRET_REQUEST: &str = "plugin_secret";
pub const SECRET_WRITE: &str = "plugin_secret_write";
/// OAuth listeners bound on the desktop, never the project server.
pub const AUTH_REQUEST: &str = "plugin_auth";
/// What [`RemotePlugins::register`] adds to a server's commands.
pub const COMMANDS: &[&str] = &[
SYNC_PACKAGES,
"plugin_run_command",
"plugin_set_ui_locale",
"plugin_select_tests",
"plugin_parse_test_results",
"plugin_terminal_session_close",
"plugin_terminal_session_spawn",
"plugin_prepare_debug_run",
"plugin_debug_attach_target",
"plugin_finish_operation",
"plugin_content_tab_action",
"plugin_post_events",
"plugin_event_kinds",
"plugin_status_items",
"plugin_context_keys",
"plugin_cancel_task",
"plugin_answer_prompt",
"plugin_choose_program",
"plugin_program",
"plugin_answer_command",
"plugin_answer_commit",
"plugin_commit_checks",
"mcp_set_open_editors",
"mcp_set_focused_editor",
"mcp_report_problems",
"plugin_decoration_sets",
"plugin_set_active_file",
"plugin_view_render",
"plugin_view_event",
"plugin_service_detail",
"plugin_service_log",
"plugin_navigation_files",
"plugin_navigation_invalidate",
"plugin_navigation_index",
"plugin_navigation_goto",
"plugin_navigation_markers",
"plugin_endpoints",
"plugin_run_targets",
"plugin_answer_run_target",
"plugin_line_markers",
];
#[derive(Clone, Serialize, Deserialize)]
pub struct SecretWrite {
@@ -482,10 +435,10 @@ impl RemotePlugins {
result
}
/// The run-time commands of remote windows plus [`SYNC_PACKAGES`].
/// [`SYNC_PACKAGES`]; the plugin commands of remote windows are `#[command]`s.
pub fn register(self: &Arc<Self>, d: &mut Dispatcher) {
let this = self.clone();
d.add(SYNC_PACKAGES, move |c| {
d.add(SYNC_PACKAGES, TrustClass::Trusted, move |c| {
let this = this.clone();
async move {
let packages: Vec<RemotePackage> = c.arg("packages")?;
@@ -493,363 +446,9 @@ impl RemotePlugins {
blocking(move || Ok(this.sync(packages, files.unwrap_or_default()))).await
}
});
let host = Arc::downgrade(&self.host);
let h = host.clone();
d.add("plugin_run_command", move |c| {
let h = h.clone();
async move {
let host = alive(&h)?;
let plugin_id: String = c.arg("pluginId")?;
let command_id: String = c.arg("commandId")?;
let arg: Option<String> = c.arg("arg")?;
let editor: Option<PluginEditor> = c.arg("editor")?;
let paths: Option<Vec<PathBuf>> = c.arg("paths")?;
let settings_scope: Option<SettingsScope> = c.arg("settingsScope")?;
let invocation = Invocation {
command_chain: c.arg::<Option<Vec<String>>>("commandChain")?.unwrap_or_default(),
client: Some(c.window.clone()),
workspace_root: c.host.project(&c.window).ok().map(|p| p.root.clone()),
editor: editor.map(PluginEditor::context),
selected_paths: paths.unwrap_or_default(),
global_settings: matches!(settings_scope, Some(SettingsScope::Global)),
};
super::commands::run_command(&c.host, host, plugin_id, command_id, arg, invocation, c.arg("request")?)
.await
}
});
let h = host.clone();
d.add("plugin_set_ui_locale", move |c| {
let h = h.clone();
async move {
alive(&h)?.set_ui_locale(&c.arg::<String>("tag")?);
Ok(())
}
});
let h = host.clone();
d.add("plugin_select_tests", move |c| {
let h = h.clone();
async move {
let host = alive(&h)?;
let config = c.arg::<String>("config")?;
let tests = c.arg("tests")?;
blocking(move || host.select_tests(&c.window, &config, tests)).await
}
});
let h = host.clone();
d.add("plugin_parse_test_results", move |c| {
let h = h.clone();
async move {
let host = alive(&h)?;
let config = c.arg::<String>("config")?;
let chunk = c.arg("chunk")?;
blocking(move || host.parse_test_results(&c.window, &config, chunk)).await
}
});
let h = host.clone();
d.add("plugin_terminal_session_close", move |c| {
let h = h.clone();
async move { alive(&h)?.close_terminal_session(&c.window, &c.arg::<String>("operation")?) }
});
let h = host.clone();
d.add("plugin_terminal_session_spawn", move |c| {
let h = h.clone();
async move {
let plugins = alive(&h)?;
let operation: String = c.arg("operation")?;
let cols = c.arg("cols")?;
let rows = c.arg("rows")?;
let output = c.channel("onOutput")?;
blocking(move || plugins.spawn_terminal_session(&c.host, &c.window, &operation, cols, rows, output))
.await
}
});
let h = host.clone();
d.add("plugin_prepare_debug_run", move |c| {
let h = h.clone();
async move {
let plugins = alive(&h)?;
let config = c.arg("config")?;
blocking(move || plugins.prepare_debug_run(&c.window, config)).await
}
});
let h = host.clone();
d.add("plugin_debug_attach_target", move |c| {
let h = h.clone();
async move {
let plugins = alive(&h)?;
let (config, run) = (c.arg::<String>("config")?, c.arg("run")?);
blocking(move || plugins.debug_attach_target(&c.host, &c.window, &config, run)).await
}
});
let h = host.clone();
d.add("plugin_finish_operation", move |c| {
let h = h.clone();
async move {
Ok(alive(&h)?.finish_operation(&c.window, &c.arg::<String>("id")?, c.arg("status")?, c.arg("stopped")?))
}
});
let h = host.clone();
d.add("plugin_content_tab_action", move |c| {
let h = h.clone();
async move { alive(&h)?.content_tab_action(&c.window, &c.arg::<String>("pluginId")?, c.arg("action")?) }
});
let h = host.clone();
d.add("plugin_post_events", move |c| {
let h = h.clone();
async move {
alive(&h)?.post_window_events(&c.window, c.arg("events")?, c.arg("editor")?);
Ok(())
}
});
let h = host.clone();
d.add("plugin_event_kinds", move |_| {
let h = h.clone();
async move { Ok(alive(&h)?.event_kinds().into_iter().collect::<Vec<_>>()) }
});
let h = host.clone();
d.add("plugin_status_items", move |c| {
let h = h.clone();
async move { Ok(alive(&h)?.status_snapshot(&c.window)) }
});
let h = host.clone();
d.add("plugin_context_keys", move |c| {
let h = h.clone();
async move { Ok(alive(&h)?.context_keys(Some(&c.window))) }
});
let h = host.clone();
d.add("plugin_cancel_task", move |c| {
let h = h.clone();
async move { Ok(alive(&h)?.cancel_task(&c.arg::<String>("taskId")?)) }
});
let h = host.clone();
d.add("plugin_answer_prompt", move |c| {
let h = h.clone();
async move { Ok(alive(&h)?.answer_prompt(&c.arg::<String>("promptId")?, c.arg("answer")?)) }
});
let h = host.clone();
d.add("plugin_choose_program", move |c| {
let h = h.clone();
async move {
let host = alive(&h)?;
let id: String = c.arg("pluginId")?;
let cap: String = c.arg("capability")?;
let scope: SettingsScope = c.arg("scope")?;
let path: Option<PathBuf> = c.arg("path")?;
let root = match scope {
SettingsScope::Global => None,
SettingsScope::Project => Some(c.host.project(&c.window)?.root.clone()),
};
blocking(move || host.choose_program(&id, &cap, root.as_deref(), path.as_deref())).await
}
});
let h = host.clone();
d.add("plugin_program", move |c| {
let h = h.clone();
async move {
let host = alive(&h)?;
let id: String = c.arg("pluginId")?;
let program: String = c.arg("program")?;
let scope: SettingsScope = c.arg("scope")?;
let root = match scope {
SettingsScope::Global => None,
SettingsScope::Project => Some(c.host.project(&c.window)?.root.clone()),
};
blocking(move || host.program_for_project(&id, &program, root.as_deref()).map(ide_core::IpcPath::from))
.await
}
});
let h = host.clone();
d.add("plugin_answer_command", move |c| {
let h = h.clone();
async move { Ok(alive(&h)?.answer_command(&c.window, &c.arg::<String>("requestId")?, c.arg("answer")?)) }
});
let h = host.clone();
d.add("plugin_answer_commit", move |c| {
let h = h.clone();
async move { Ok(alive(&h)?.answer_commit(&c.arg::<String>("requestId")?, c.arg("answer")?)) }
});
let h = host.clone();
d.add("plugin_commit_checks", move |c| {
let h = h.clone();
async move {
super::commit::commit_checks(
&c.host,
alive(&h)?,
&c.window,
c.arg("selection")?,
c.arg("checks")?,
c.arg("request")?,
)
.await
}
});
d.add("mcp_set_open_editors", |c| async move {
let paths: Vec<ide_core::IpcPath> = c.arg("paths")?;
c.host.project(&c.window)?;
c.host.mcp_reports.set_open_editors(&c.window, paths.into_iter().map(PathBuf::from).collect());
Ok(())
});
d.add("mcp_set_focused_editor", |c| async move {
c.host.project(&c.window)?;
c.host.mcp_reports.set_focused_editor(&c.window, c.arg("editor")?, c.arg("focused")?);
Ok(())
});
d.add("mcp_report_problems", |c| async move {
c.host.project(&c.window)?;
c.host.mcp_reports.report_problems(&c.window, c.arg("reset")?, c.arg("files")?);
Ok(())
});
let h = host.clone();
d.add("plugin_decoration_sets", move |_c| {
let h = h.clone();
async move { Ok(alive(&h)?.decoration_sets()) }
});
let h = host.clone();
d.add("plugin_set_active_file", move |c| {
let h = h.clone();
async move {
alive(&h)?.set_active_file(&c.window, c.arg("path")?);
Ok(())
}
});
let h = host.clone();
d.add("plugin_view_render", move |c| {
let h = h.clone();
async move {
let plugins = alive(&h)?;
super::views::render(
&c.host,
plugins,
&c.window,
c.arg("pluginId")?,
c.arg("view")?,
c.arg("viewport")?,
c.arg("doc")?,
c.arg("editor")?,
)
.await
}
});
let h = host.clone();
d.add("plugin_view_event", move |c| {
let h = h.clone();
async move {
let plugins = alive(&h)?;
super::views::event(
&c.host,
plugins,
&c.window,
c.arg("pluginId")?,
c.arg("view")?,
c.arg("event")?,
c.arg("doc")?,
c.arg("editor")?,
)
.await
}
});
let h = host.clone();
d.add("plugin_service_detail", move |c| {
let h = h.clone();
async move {
super::views::service_detail(
&c.host,
alive(&h)?,
&c.window,
c.arg("pluginId")?,
c.arg("view")?,
c.arg("key")?,
)
.await
}
});
let h = host.clone();
d.add("plugin_service_log", move |c| {
let h = h.clone();
async move {
super::views::service_log(
&c.host,
alive(&h)?,
&c.window,
c.arg("pluginId")?,
c.arg("view")?,
c.arg("key")?,
c.arg("tab")?,
c.arg("on")?,
c.arg("request")?,
c.sender("onLine")?,
)
.await
}
});
let h = host.clone();
d.add("plugin_navigation_files", move |c| {
let h = h.clone();
async move { super::index_ops::plugin_navigation_files(&c.host, alive(&h)?, &c.window).await }
});
let h = host.clone();
d.add("plugin_navigation_invalidate", move |c| { let h = h.clone(); async move {
super::index_ops::plugin_navigation_invalidate(&c.host, alive(&h)?, &c.window, c.arg("paths")?)
} });
let h = host.clone();
d.add("plugin_navigation_index", move |c| {
let h = h.clone();
async move {
super::index_ops::plugin_navigation_index(
&c.host,
alive(&h)?,
&c.window,
c.arg("paths")?,
c.arg("request")?,
)
.await
}
});
let h = host.clone();
d.add("plugin_navigation_goto", move |c| {
let h = h.clone();
async move {
super::index_ops::plugin_navigation_goto(&c.host, alive(&h)?, &c.window, c.arg("doc")?, c.arg("pos")?)
.await
}
});
let h = host.clone();
d.add("plugin_navigation_markers", move |c| {
let h = h.clone();
async move {
super::index_ops::plugin_navigation_markers(&c.host, alive(&h)?, &c.window, c.arg("paths")?).await
}
});
let h = host.clone();
d.add("plugin_endpoints", move |c| {
let h = h.clone();
async move { super::index_ops::plugin_endpoints(&c.host, alive(&h)?, &c.window, c.arg("pluginId")?).await }
});
let h = host.clone();
d.add("plugin_run_targets", move |c| {
let h = h.clone();
async move { super::run_targets::list(&c.host, alive(&h)?.as_ref(), &c.window) }
});
let h = host.clone();
d.add("plugin_answer_run_target", move |c| {
let h = h.clone();
async move {
let plugins = alive(&h)?;
let id: String = c.arg("id")?;
let use_target = c.arg("useTarget")?;
blocking(move || super::run_targets::answer(&c.host, &plugins, &c.window, &id, use_target)).await
}
});
d.add("plugin_line_markers", |c| async move {
crate::ops::lsp::plugin_line_markers(&c.host, &c.window, c.arg("doc")?).await
});
}
}
fn alive(host: &Weak<PluginHost>) -> IdeResult<Arc<PluginHost>> {
host.upgrade().ok_or_else(|| IdeError::unavailable("the plugin host has shut down"))
}
async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send + 'static) -> IdeResult<T> {
tokio::task::spawn_blocking(f).await.map_err(|e| IdeError::internal(e.to_string()))?
}
+26
Переглянути файл
@@ -1,9 +1,12 @@
//! Project-owned registrations, retained across idle instance reclamation.
use super::api::{PluginApi, Shared};
use super::{PluginEvent, PluginHost};
use crate::Host;
use ide_command::command;
use ide_core::{IdeError, IdeResult};
use ide_plugin::{HostError, PluginRunTarget};
use std::path::{Path, PathBuf};
use std::sync::Arc;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, specta::Type)]
#[serde(rename_all = "camelCase")]
@@ -151,6 +154,27 @@ impl PluginHost {
}
}
#[command(trust = trusted)]
pub async fn plugin_run_targets(
host: &Host,
plugins: &Arc<PluginHost>,
window: &str,
) -> IdeResult<Vec<RegisteredRunTarget>> {
list(host, plugins, window)
}
#[command(trust = trusted)]
pub async fn plugin_answer_run_target(
host: &Arc<Host>,
plugins: &Arc<PluginHost>,
window: &str,
id: String,
use_target: bool,
) -> IdeResult<ide_core::settings::Settings> {
let (shared, plugins, window) = (host.clone(), plugins.clone(), window.to_owned());
host.blocking(move || answer(&shared, &plugins, &window, &id, use_target)).await
}
pub fn list(host: &crate::Host, plugins: &PluginHost, window: &str) -> IdeResult<Vec<RegisteredRunTarget>> {
Ok(plugins.run_targets(&host.project(window)?.root))
}
@@ -194,3 +218,5 @@ pub fn answer(
plugins.shared.sink.emit(None, PluginEvent::RunTargetsChanged);
Ok(project.settings.effective())
}
ide_command::domain!(plugins_run_targets: plugin_answer_run_target, plugin_run_targets);
+34 -13
Переглянути файл
@@ -4,6 +4,7 @@
//! the desktop for local projects, `openidea-server` for remote ones.
use super::{PluginEditor, PluginHost, PluginOutputLine};
use ide_command::command;
use ide_core::{DocId, IdeError, IdeResult};
use ide_plugin::{EditorContext, Invocation, ServiceTab, View, ViewEvent, Viewport};
use std::sync::Arc;
@@ -38,10 +39,13 @@ async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send + '
tokio::task::spawn_blocking(f).await.map_err(|e| IdeError::internal(e.to_string()))?
}
/// Content of a plugin view (`doc`: the document of a custom editor; `editor`: for
/// a tool window, the window's active editor, as commands get it).
#[allow(clippy::too_many_arguments)]
pub async fn render(
#[command(trust = trusted)]
pub async fn plugin_view_render(
host: &crate::Host,
plugins: Arc<PluginHost>,
plugins: &Arc<PluginHost>,
window: &str,
plugin_id: String,
view: String,
@@ -49,14 +53,17 @@ pub async fn render(
doc: Option<DocId>,
editor: Option<PluginEditor>,
) -> IdeResult<View> {
let plugins = plugins.clone();
let invocation = view_invocation(host, window, doc, editor)?;
blocking(move || plugins.render_view(&plugin_id, &view, viewport, invocation)).await
}
/// A user action in a plugin view or custom editor (`doc`, `editor`: as for rendering).
#[allow(clippy::too_many_arguments)]
pub async fn event(
#[command(trust = trusted)]
pub async fn plugin_view_event(
host: &crate::Host,
plugins: Arc<PluginHost>,
plugins: &Arc<PluginHost>,
window: &str,
plugin_id: String,
view: String,
@@ -64,39 +71,45 @@ pub async fn event(
doc: Option<DocId>,
editor: Option<PluginEditor>,
) -> IdeResult<()> {
let plugins = plugins.clone();
let invocation = view_invocation(host, window, doc, editor)?;
blocking(move || plugins.view_event(&plugin_id, &view, event, invocation)).await
}
/// The Services pane of node `key` of a plugin's services view.
pub async fn service_detail(
/// The Services pane of node `key` of a plugin's `location = "services"` view.
#[command(trust = trusted)]
pub async fn plugin_service_detail(
host: &crate::Host,
plugins: Arc<PluginHost>,
plugins: &Arc<PluginHost>,
window: &str,
plugin_id: String,
view: String,
key: String,
) -> IdeResult<Vec<ServiceTab>> {
let plugins = plugins.clone();
let invocation = view_invocation(host, window, None, None)?;
blocking(move || plugins.service_detail(&plugin_id, &view, &key, invocation)).await
}
/// Runs the program of the log tab `tab` of node `key`'s pane in the window's
/// project root, streaming its lines until it exits or request `request` is
/// cancelled; returns its exit code.
/// Runs the program of the log tab `tab` of node `key`'s Services pane (with
/// the toggles in `on`), streaming its output until it exits or `request` is
/// cancelled; returns the exit code.
#[allow(clippy::too_many_arguments)]
pub async fn service_log(
#[command(trust = trusted)]
pub async fn plugin_service_log(
host: &crate::Host,
plugins: Arc<PluginHost>,
plugins: &Arc<PluginHost>,
window: &str,
request: ide_core::RequestId,
plugin_id: String,
view: String,
key: String,
tab: String,
on: Vec<String>,
request: ide_core::RequestId,
on_line: crate::ops::Channel<PluginOutputLine>,
) -> IdeResult<Option<i32>> {
// Runs in the window's project root.
let plugins = plugins.clone();
let invocation = view_invocation(host, window, None, None)?;
let cancel = host.begin_project_read_request(window, request);
let result = blocking(move || {
@@ -137,3 +150,11 @@ mod tests {
assert!(view_invocation(&host, "main", None, None).unwrap().editor.is_none());
}
}
ide_command::domain!(
plugins_views:
plugin_service_detail,
plugin_service_log,
plugin_view_event,
plugin_view_render,
);
+8 -11
Переглянути файл
@@ -286,6 +286,7 @@ impl Host {
lsp.set_prepare_hook(Box::new(move |cfg, _, cancel| {
let effective = settings.effective();
if cfg.name == "jdtls" {
ide_sdk::jdtls_workspaces::mark_used(cfg);
crate::java_runtime::prepare(
cfg,
&data_dir,
@@ -305,7 +306,7 @@ impl Host {
}
{
let documents = documents.clone();
lsp.set_apply_edit_hook(Box::new(move |edit| apply_workspace_edit(&documents, &edit).is_ok()));
lsp.set_apply_edit_hook(Box::new(move |edit| documents.apply_workspace_edit(&edit).is_ok()));
}
let syntax = Arc::new(SyntaxCache::new(self.syntax()));
documents.add_observer(Arc::new(SyntaxObserver(syntax.clone())));
@@ -1319,11 +1320,6 @@ impl Project {
}
}
/// Applies a multi-file edit through the document layer so open editors update live.
pub fn apply_workspace_edit(documents: &Documents, edit: &ide_core::WorkspaceEdit) -> IdeResult<()> {
documents.apply_workspace_edit(edit)
}
/// Files the watcher reports per batch that Local History snapshots.
const HISTORY_BATCH_LIMIT: usize = 500;
@@ -2148,11 +2144,12 @@ mod workspace_edit_tests {
version: None,
edits: vec![TextEdit { range: Range::new(Pos::new(0, 0), Pos::new(0, 3)), new_text: "sum_values".into() }],
};
apply_workspace_edit(
&documents,
&WorkspaceEdit { files: vec![changes(real.clone()), changes(alias)], ..Default::default() },
)
.unwrap();
documents
.apply_workspace_edit(&WorkspaceEdit {
files: vec![changes(real.clone()), changes(alias)],
..Default::default()
})
.unwrap();
assert_eq!(std::fs::read_to_string(real).unwrap(), "sum_values();\n");
assert_eq!(documents.snapshot(doc.id).unwrap().text, "sum_values();\n");
}
+24 -170
Переглянути файл
@@ -15,15 +15,15 @@
//! remote project (`plugins::remote_host`).
use crate::Host;
use crate::catalogue::TrustClass;
use crate::ops::{self, Emit};
use ide_core::{IdeError, IdeEvent, IdeResult, RequestId, TaskId};
use ide_core::{IdeError, IdeEvent, IdeResult};
use ide_jsonrpc::{Handler, Peer, codes};
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashMap;
use std::future::Future;
use std::path::PathBuf;
use std::pin::Pin;
use std::sync::{Arc, OnceLock};
@@ -104,30 +104,28 @@ impl Call {
type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
type HandlerFn = Arc<dyn Fn(Call) -> BoxFuture<IdeResult<Value>> + Send + Sync>;
/// Commands the server answers, by name.
/// Commands the server answers, by name, each with the trust class it declares.
#[derive(Default, Clone)]
pub struct Dispatcher {
handlers: HashMap<&'static str, HandlerFn>,
handlers: HashMap<&'static str, (TrustClass, HandlerFn)>,
}
impl Dispatcher {
pub fn add<F, Fut, T>(&mut self, name: &'static str, f: F) -> &mut Self
pub fn add<F, Fut, T>(&mut self, name: &'static str, trust: TrustClass, f: F) -> &mut Self
where
F: Fn(Call) -> Fut + Send + Sync + 'static,
Fut: Future<Output = IdeResult<T>> + Send + 'static,
T: Serialize,
{
let f = Arc::new(f);
self.handlers.insert(
name,
Arc::new(move |call| {
let fut = f(call);
Box::pin(async move {
let value = fut.await?;
serde_json::to_value(value).map_err(|e| IdeError::internal(e.to_string()))
})
}),
);
let handler: HandlerFn = Arc::new(move |call| {
let fut = f(call);
Box::pin(async move {
let value = fut.await?;
serde_json::to_value(value).map_err(|e| IdeError::internal(e.to_string()))
})
});
assert!(self.handlers.insert(name, (trust, handler)).is_none(), "command {name} is registered twice");
self
}
@@ -137,150 +135,15 @@ impl Dispatcher {
out
}
/// The commands of the core remote slice: project, files, documents, search,
/// terminals, runs and VCS status.
/// The trust class `name` was registered with.
pub fn trust(&self, name: &str) -> Option<TrustClass> {
self.handlers.get(name).map(|(trust, _)| *trust)
}
/// The commands every project host answers: those declared with `#[command]`.
pub fn standard() -> Self {
let mut d = Self::default();
d.add("project_trust_status", |c| async move { c.host.trust.status(&c.arg::<PathBuf>("path")?) })
.add("project_trust_list", |c| async move { c.host.trust.decisions() })
.add("project_trust_set", |c| async move {
c.host.set_project_trust(&c.arg::<PathBuf>("path")?, c.arg("trusted")?, c.arg("folder")?).await
})
.add("project_trust_remove_location", |c| async move {
c.host.trust.remove_location(&c.arg::<PathBuf>("path")?)?;
c.host.refresh_project_trust().await
});
d.add("open_project", |c| async move {
let path: PathBuf = c.arg("path")?;
let project = ops::project::open(&c.host, &c.window, &path).await?;
Ok(ops::project::info(&project))
})
.add("project_current", |c| async move { Ok(ops::project::current(&c.host, &c.window)) })
.add("close_project", |c| async move {
c.host.close_project(&c.window);
Ok(())
})
.add("jvm_file_presentations", |c| async move {
ops::jvm_icons::jvm_file_presentations(&c.host, &c.window, c.arg("paths")?).await
})
.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")?;
let applied = ops::project::set_settings(&c.host, &c.window, scope, &key, &c.arg::<String>("value")?)?;
let sink = c.host.window_sink(&c.window);
sink.emit(IdeEvent::SettingsChanged { key });
if let Some(root) = applied.roots_changed {
sink.emit(IdeEvent::ProjectRootsChanged { root });
}
Ok(applied.settings)
})
.add("cancel_request", |c| async move {
c.host.cancel_request(c.arg::<RequestId>("id")?);
Ok(())
})
.add("cancel_task", |c| async move { Ok(ide_core::task::cancel(c.arg::<TaskId>("id")?)) })
.add("fs_read_dir", |c| async move { ops::fs::read_dir(&c.host, &c.window, c.arg("path")?).await })
.add("fs_entry_kind", |c| async move { ops::fs::entry_kind(&c.host, c.arg("path")?).await })
.add("fs_create_file", |c| async move { ops::fs::create_file(&c.host, &c.window, c.arg("path")?) })
.add("fs_create_file_bytes", |c| async move {
ops::fs::create_file_bytes(&c.host, &c.window, c.arg("path")?, c.arg("data")?).await
})
.add("fs_create_dir", |c| async move { ide_vfs::create_dir(&c.arg::<PathBuf>("path")?) })
.add("fs_rename", |c| async move { ops::fs::rename(&c.host, &c.window, c.arg("from")?, c.arg("to")?).await })
.add("fs_set_writable", |c| async move {
ops::fs::set_writable(&c.host, &c.window, c.arg("path")?, c.arg("writable")?)
})
.add("fs_delete", |c| async move { ops::fs::delete(&c.host, &c.window, c.arg("path")?).await })
.add("fs_copy", |c| async move { ops::fs::copy(&c.host, &c.window, c.arg("from")?, c.arg("to")?).await })
.add("fs_copy_merge", |c| async move {
ops::fs::copy_merge(
&c.host,
&c.window,
c.arg("sourceRoot")?,
c.arg("destinationRoot")?,
c.arg("path")?,
c.arg("overwrite")?,
)
.await
})
.add("fs_compare_directories", |c| async move {
ops::fs::compare_directories(
&c.host,
&c.window,
c.arg("left")?,
c.arg("right")?,
c.arg("request")?,
c.sender("onProgress")?,
)
.await
})
.add("fs_read_text", |c| async move { ops::fs::read_text(&c.host, &c.window, c.arg("path")?).await })
.add("doc_open", |c| async move { ops::doc::open(&c.host, &c.window, c.arg("path")?).await })
.add("doc_open_untitled", |c| async move {
ops::doc::open_untitled(&c.host, &c.window, c.arg::<Option<String>>("name")?).await
})
.add(
"doc_save_as",
|c| async move { ops::doc::save_as(&c.host, &c.window, c.arg("doc")?, c.arg("path")?).await },
)
.add("doc_close", |c| async move {
ops::doc::blocking(move || ops::doc::close(&c.host, &c.window, c.arg("doc")?)).await
})
.add("doc_edit", |c| async move {
ops::doc::blocking(move || {
ops::doc::edit(&c.host, &c.window, c.arg("doc")?, c.arg("baseVersion")?, c.arg("changes")?)
})
.await
})
.add("doc_save", |c| async move { ops::doc::save(&c.host, &c.window, c.arg("doc")?).await })
.add("doc_save_all", |c| async move { ops::doc::save_all(&c.host, &c.window).await })
.add("doc_sync_from_disk", |c| async move { ops::doc::sync_from_disk(&c.host, &c.window).await })
.add("doc_snapshot", |c| async move { ops::doc::snapshot(&c.host, &c.window, c.arg("doc")?).await })
.add("search_start", |c| async move {
let on_event = c.channel("onEvent")?;
ops::search::start(&c.host, &c.window, c.arg("request")?, c.arg("query")?, on_event).await
})
.add("term_spawn", |c| async move {
let on_output = c.channel("onOutput")?;
ops::term::spawn(&c.host, &c.window, c.arg("options")?, on_output)
})
.add("term_store_image", |c| async move {
ops::term::store_image(&c.host, c.arg("id")?, c.arg("data")?, c.arg("mime")?).await
})
.add("term_write", |c| async move { ops::term::write(&c.host, c.arg("id")?, &c.arg::<String>("data")?) })
.add("term_resize", |c| async move { ops::term::resize(&c.host, c.arg("id")?, c.arg("cols")?, c.arg("rows")?) })
.add("term_kill", |c| async move { ops::term::kill(&c.host, c.arg("id")?) })
.add("term_is_busy", |c| async move { ops::term::is_busy(&c.host, c.arg("id")?) })
.add("term_default_shell", |_| async move { Ok(ide_terminal::default_shell_path()) })
.add("term_available_shells", |_| async move { Ok(ide_terminal::available_shells()) })
.add("run_configs", |c| async move { ops::doc::blocking(move || ops::run::configs(&c.host, &c.window)).await })
.add("run_save_configs", |c| async move {
ops::run::save_configs(
&c.host,
&c.window,
&c.arg::<Vec<ide_run::RunConfig>>("configs")?,
&c.arg::<Option<Vec<String>>>("removedDetectedIds")?.unwrap_or_default(),
)
})
.add("run_without_derived", |c| async move { ops::run::without_derived(&c.host, &c.window, c.arg("configs")?) })
.add("run_apply_settings", |c| async move { ops::run::apply_settings(&c.host, &c.window, c.arg("configs")?) })
.add("run_system_env", |_| async move { Ok(ide_run::system_env()) })
.add("run_start", |c| async move {
let on_output = c.channel("onOutput")?;
ops::run::start_request(&c.host, &c.window, c.arg("config")?, on_output, c.arg("request")?).await
})
.add("run_stop", |c| async move { ops::run::stop(&c.host, &c.window, c.arg("id")?) })
.add("web_url", |c| async move { ops::web::url(&c.host, &c.window, &c.arg::<PathBuf>("path")?).await })
.add("run_stdin", |c| async move { ops::run::stdin(&c.host, c.arg("id")?, &c.arg::<String>("data")?) })
.add("run_resize", |c| async move { ops::run::resize(&c.host, c.arg("id")?, c.arg("cols")?, c.arg("rows")?) })
.add("run_close_stdin", |c| async move { ops::run::close_stdin(&c.host, c.arg("id")?) })
.add("run_list", |c| async move { Ok(ops::run::list(&c.host)) })
.add("vcs_status", |c| async move { ops::vcs::status(&c.host, &c.window).await })
.add("vcs_status_paths", |c| async move { ops::vcs::status_paths(&c.host, &c.window, c.arg("paths")?).await });
ops::register_all(&mut d);
ops::register_domains(&mut d);
d
}
}
@@ -335,6 +198,8 @@ pub fn client_accepts(event: &IdeEvent) -> bool {
| IdeEvent::LanguageServerWarning { .. }
| IdeEvent::LanguageServerRemoved { .. }
| IdeEvent::LspRefresh { .. }
| IdeEvent::LspMessageRequest { .. }
| IdeEvent::LspMessageRequestDone { .. }
| IdeEvent::TerminalExited { .. }
| IdeEvent::RunExited { .. }
| IdeEvent::Debug { .. }
@@ -347,17 +212,6 @@ pub fn client_accepts(event: &IdeEvent) -> bool {
}
}
/// The commands a desktop routes to its server: what `openidea-server` of this build answers,
/// fixed here rather than taken from the server, so a server cannot move a command to this machine.
pub fn client_commands() -> Vec<&'static str> {
let mut out = Dispatcher::standard().commands();
out.extend(crate::plugins::remote_host::COMMANDS);
out.push(crate::plugins::remote::SYNC_COMMAND);
out.sort_unstable();
out.dedup();
out
}
struct PeerSink {
peer: Arc<OnceLock<Peer>>,
window: Option<String>,
@@ -398,10 +252,10 @@ impl Handler for ServerHandler {
"invoke" => {
let call: Invoke =
serde_json::from_value(params).map_err(|e| (codes::INVALID_PARAMS, e.to_string()))?;
let Some(handler) = self.dispatcher.handlers.get(call.cmd.as_str()).cloned() else {
let Some((trust, handler)) = self.dispatcher.handlers.get(call.cmd.as_str()).cloned() else {
return Err((codes::METHOD_NOT_FOUND, format!("command {} is not available remotely", call.cmd)));
};
self.host.authorize_command(&call.window, &call.cmd).map_err(error_reply)?;
self.host.authorize(&call.window, trust).map_err(error_reply)?;
let c = Call { host: self.host.clone(), window: call.window, args: call.args, peer: self.peer.clone() };
// Requests run on blocking-capable threads: wait for the command here.
self.host.runtime.block_on(handler(c)).map_err(error_reply)
+5 -367
Переглянути файл
@@ -1,4 +1,5 @@
//! User-owned project execution decisions. Project settings never grant trust.
use crate::catalogue::TrustClass;
use ide_core::{IdeError, IdeResult};
use parking_lot::Mutex;
use serde::{Deserialize, Serialize};
@@ -304,366 +305,15 @@ impl crate::Host {
}
}
/// Commands allowed in Restricted Mode, by exact name: those which only inspect/edit source or
/// operate user-owned application state. A new command is denied until deliberately listed here.
pub fn restricted_command_allowed(cmd: &str) -> bool {
matches!(
cmd,
"fs_compare_directories"
| "fs_copy"
| "fs_copy_merge"
| "fs_create_dir"
| "fs_create_file"
| "fs_create_file_bytes"
| "fs_delete"
| "fs_entry_kind"
| "fs_open_with_system"
// The user's own diff program (global settings) on the diff's two sides.
| "diff_external_tool"
| "fs_probe"
| "fs_read_dir"
| "fs_read_image"
| "fs_read_range"
| "fs_read_text"
| "fs_rename"
| "fs_resolve_reference"
| "fs_set_writable"
| "doc_close"
| "doc_edit"
| "doc_folding"
| "doc_highlights"
| "doc_language"
| "doc_open"
| "doc_open_untitled"
| "doc_open_virtual"
| "doc_outline"
| "doc_python_facts"
| "doc_save"
| "doc_save_as"
| "doc_save_all"
| "doc_selection_ranges"
| "doc_set_bom"
| "doc_set_encoding"
| "doc_set_line_ending"
| "doc_snapshot"
| "doc_sync_from_disk"
| "syntax_errors"
| "syntax_expression_at"
| "syntax_identifiers"
| "syntax_identifiers_in_files"
| "syntax_locals"
| "syntax_node_at"
| "syntax_structural_ranges"
| "syntax_support"
| "search_start"
| "search_validate"
| "nav_index_definitions"
| "nav_inheritance"
| "nav_resolve_module"
| "history_content"
| "history_list"
| "history_list_dir"
| "history_put_label"
| "history_restore"
| "spell_check"
| "spell_suggest"
| "analysis_locate_duplicates"
| "structural_languages"
| "structural_search"
| "structural_validate"
| "refactor_can_undo_file_move"
| "refactor_file_move_edits"
| "refactor_file_move_text_edits"
| "refactor_move_files"
| "refactor_undo_file_move"
| "window_close_context"
| "window_complete_launch"
| "window_cycle"
| "window_flash_taskbar"
| "window_group_cancel_close"
| "window_group_close"
| "window_group_close_tabs"
| "window_group_current"
| "window_group_detach"
| "window_group_merge"
| "window_group_reorder"
| "window_group_restore"
| "window_group_select"
| "window_is_fullscreen"
| "window_new"
| "window_open_comparison"
| "window_open_deployment"
| "window_open_diff"
| "window_open_file_in_new_window"
| "window_open_files"
| "window_open_project"
| "window_open_projects"
| "window_open_remote"
| "window_open_settings"
| "window_set_titlebar_height"
| "window_start_drag"
| "window_take_launch"
| "window_toggle_fullscreen"
| "window_toggle_zoom"
| "term_available_shells"
| "term_default_shell"
| "term_is_busy"
| "term_kill"
| "term_resize"
| "term_spawn"
| "term_store_image"
| "term_write"
| "settings_export"
| "settings_get"
| "settings_get_global"
| "settings_removed_theme"
| "settings_import"
| "settings_list_jetbrains_ides"
| "settings_read_jetbrains"
| "settings_set"
| "project_trust_add_location"
| "project_trust_list"
| "project_trust_remove_location"
| "project_trust_set"
| "project_trust_status"
// New Project writes only where the user chose and runs no code of an open project.
| "scaffold_catalog"
| "scaffold_create"
| "scaffold_options"
| "scaffold_requirements"
| "ssh_askpass_answer"
| "ssh_connected"
| "ssh_disconnect"
| "ssh_needs_secret"
| "ssh_open_terminal"
| "ssh_password_saved"
| "ssh_set_secret"
| "ssh_test"
| "ssh_trust_host"
| "git_credential_forget"
| "git_credentials"
| "app_info"
| "app_build_info"
| "app_cli_install"
| "app_cli_uninstall"
| "app_log_location"
| "app_check_update"
| "app_update_window_ready"
| "app_update_status"
| "app_update_announcement"
| "app_install_update"
| "caches_schedule_invalidation"
| "clear_caches"
| "clipboard_file_list"
| "clipboard_has_files"
| "clipboard_has_image"
| "clipboard_image"
| "clipboard_set_file_list"
| "clipboard_write_text"
| "jdk_download_vendors"
| "jdk_download_releases"
| "jdk_download_location"
| "jdk_download"
| "jdtls_required_java"
| "run_system_env"
| "run_gradle_jvm_args_script"
| "proxy_check_connection"
| "docker_settings"
| "docker_save_settings"
| "docker_set_registry_password"
| "docker_run_env"
| "db_console_path"
| "db_consoles"
| "db_export_file"
| "vcs_write_patch"
| "app_metrics"
| "app_quit"
| "app_cancel_quit"
| "app_restart"
| "languages"
| "menu_refresh"
| "menu_model"
| "menu_configure"
| "menu_set_disabled"
| "prepare_workspace_edit"
| "apply_workspace_edit"
| "undo_workspace_edit"
| "redo_workspace_edit"
| "lsp_servers"
| "lsp_resend_diagnostics"
| "recent_projects"
| "remove_recent_project"
| "recent_project_groups"
| "set_recent_project_groups"
| "open_project"
| "close_project"
| "project_current"
| "project_roots"
| "index_status"
| "index_file_extensions"
| "jvm_file_presentations"
| "deploy_coverage"
| "deploy_test_connection"
| "find_files"
| "find_files_named"
| "find_dirs"
| "find_symbols"
| "find_symbols_named"
| "mark_recent"
| "remove_recent"
| "recent_files"
| "web_goto"
| "path_completions"
| "web_unresolved_references"
| "project_rename"
| "light_edit_open"
| "light_edit_open_untitled"
| "workspace_create"
| "workspace_discover_projects"
| "workspace_update"
| "workspace_attach"
| "cancel_request"
| "cancel_task"
| "log_frontend"
| "env_reload"
| "remote_invoke"
| "remote_current"
| "remote_disconnect"
| "remote_connect"
| "remote_trust_status"
| "remote_trust_set"
| "remote_bootstrap_list"
| "wsl_distros"
| "wsl_resolve"
| "remote_list"
| "remote_open"
| "remote_of"
| "web_browsers"
| "web_url"
| "web_open"
| "debug_attachable_processes"
| "agent_subscribe"
| "agent_entries"
| "agent_commands"
| "agent_unqueue"
| "agent_cancel"
| "agent_stop_background"
| "agent_archive"
| "agent_unarchive"
| "agent_registry_list"
| "agent_registry_install"
| "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"
| "plugin_subscribe"
| "plugin_list"
| "plugin_set_active_file"
| "plugin_set_theme"
| "plugin_set_theme_frame"
| "plugin_catalog"
| "plugin_assets"
| "plugin_set_ui_locale"
| "plugin_market"
| "plugin_market_url"
| "plugin_set_market_url"
| "plugin_market_download"
| "plugin_unpack_package"
| "plugin_stage_package"
| "plugin_preview_install"
| "plugin_read_intellij_theme"
| "plugin_installed_intellij_themes"
| "notebook_open"
| "notebook_get"
| "notebook_edit"
| "notebook_save"
| "notebook_undo"
| "notebook_redo"
| "notebook_reload"
| "notebook_close"
| "notebook_interrupt"
| "run_stop"
| "run_list"
| "debug_stop"
| "debug_sessions"
| "vcs_clone"
| "vcs_init"
| "vcs_status"
| "vcs_status_paths"
| "vcs_roots"
| "vcs_branch_info"
| "vcs_line_hunks"
| "vcs_file_at"
| "vcs_blame"
| "vcs_block_history"
| "vcs_log"
| "vcs_log_refs"
| "vcs_log_users"
| "vcs_log_details"
| "vcs_log_details_batch"
| "vcs_revision_children"
| "vcs_revision_files"
| "vcs_open_external_log"
| "vcs_commit_files"
| "vcs_commits_changes"
| "vcs_branches"
| "vcs_stashes"
| "vcs_conflict_versions"
| "vcs_diff_text"
| "vcs_diff_hunks"
| "vcs_detected_git"
| "vcs_config_get"
| "vcs_tags"
| "vcs_remotes"
| "vcs_worktrees"
| "vcs_diff_with_worktree"
| "vcs_compare_scope"
| "vcs_compare_paths"
| "vcs_diff_revisions"
| "vcs_diff_numstat"
| "vcs_merge_base"
| "vcs_has_hook"
| "vcs_shelves"
| "vcs_shelf_patch"
| "vcs_changelists_load"
) || cmd.starts_with("plugin:")
}
/// Commands that change which plugin code runs: allowed where no project is open (the
/// welcome screen), otherwise only in a trusted project.
pub fn projectless_command_allowed(cmd: &str) -> bool {
matches!(
cmd,
"plugin_install_dir"
| "plugin_uninstall"
| "plugin_set_enabled"
| "plugin_grant"
| "plugin_set_capability"
| "plugin_revoke_net_host"
| "plugin_choose_program"
| "plugin_program"
| "plugin_roll_back"
| "plugin_reload"
)
}
impl crate::Host {
pub fn authorize_command(&self, window: &str, command: &str) -> IdeResult<()> {
if restricted_command_allowed(command) {
/// Whether `window` may run a command of class `trust`.
pub fn authorize(&self, window: &str, trust: TrustClass) -> IdeResult<()> {
if trust == TrustClass::Always {
return Ok(());
}
match self.project(window) {
Ok(project) => project.require_trust(),
Err(_) if projectless_command_allowed(command) => Ok(()),
Err(_) if trust == TrustClass::OutsideRestricted => Ok(()),
Err(error) => Err(error),
}
}
@@ -687,18 +337,6 @@ impl TrustStore {
#[cfg(test)]
mod tests {
#[test]
fn restricted_mode_allows_clipboard_write_text() {
assert!(super::restricted_command_allowed("clipboard_write_text"));
}
#[test]
fn restricted_mode_denies_new_commands_whatever_their_name() {
for cmd in ["fs_new_command", "term_new_command", "ssh_new_command", "settings_new_command", "git_credential_x"]
{
assert!(!super::restricted_command_allowed(cmd), "{cmd} is allowed without being listed");
}
}
#[test]
fn remote_project_decisions_are_kept_on_this_machine() {
+1 -1
Переглянути файл
@@ -19,7 +19,7 @@ fn remember_codex_modes(data: &Path) {
}
fn codex_mode(host: &Host) -> Option<String> {
let providers = ide_host::ops::agent::providers(host, "main").unwrap();
let providers = ide_host::ops::agent::agent_providers(host, "main").unwrap();
let codex = providers.into_iter().find(|p| p.id == "codex").expect("codex is listed");
codex.config.into_iter().find(|o| o.id == "mode").and_then(|o| o.current)
}
+3 -3
Переглянути файл
@@ -31,7 +31,7 @@ fn open(host: &Host, tmp: &tempfile::TempDir) {
}
fn env_of(host: &Host, id: &str) -> BTreeMap<String, String> {
let providers = ide_host::ops::agent::providers(host, "main").unwrap();
let providers = ide_host::ops::agent::agent_providers(host, "main").unwrap();
providers.into_iter().find(|p| p.id == id).unwrap_or_else(|| panic!("{id}")).env
}
@@ -42,7 +42,7 @@ async fn agent_environment_values_stay_out_of_agent_files() {
let host = host(tmp.path());
open(&host, &tmp);
let env = BTreeMap::from([("ANTHROPIC_API_KEY".to_owned(), VALUE.to_owned())]);
ide_host::ops::agent::set_env(&host, "main", "claude".into(), env.clone()).unwrap();
ide_host::ops::agent::agent_set_env(&host, "main", "claude".into(), env.clone()).unwrap();
ide_host::ops::agent::save_custom_agent(
&host,
"main",
@@ -63,7 +63,7 @@ async fn agent_environment_values_stay_out_of_agent_files() {
assert_eq!(env_of(&host, "claude"), env);
assert_eq!(env_of(&host, "mine"), env);
ide_host::ops::agent::remove_custom_agent(&host, "main", "mine".into()).unwrap();
ide_host::ops::agent::set_env(&host, "main", "claude".into(), BTreeMap::new()).unwrap();
ide_host::ops::agent::agent_set_env(&host, "main", "claude".into(), BTreeMap::new()).unwrap();
assert_eq!(host.agent_secrets.keys("agent/"), Vec::<String>::new());
host.close_project("main");
}
+4 -1
Переглянути файл
@@ -3,7 +3,10 @@
use ide_agent::{McpScope, McpServer, McpServerInput};
use ide_core::NullSink;
use ide_core::settings::McpTransport;
use ide_host::ops::agent::{mcp_import, mcp_list, mcp_save, mcp_set_enabled};
use ide_host::ops::agent::{
agent_mcp_import as mcp_import, agent_mcp_list as mcp_list, agent_mcp_save as mcp_save,
agent_mcp_set_enabled as mcp_set_enabled,
};
use ide_host::{Host, HostConfig};
use std::path::{Path, PathBuf};
use std::sync::Arc;
+2 -2
Переглянути файл
@@ -68,7 +68,7 @@ done
}
for _ in 0..20 {
for window in ["first", "second"] {
let state = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
let state = ops::agent::agent_refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
assert!(state.refreshing);
}
}
@@ -87,7 +87,7 @@ done
assert!(completed.is_ok(), "both windows must receive the completed catalog");
for _ in 0..20 {
for window in ["first", "second"] {
let catalog = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
let catalog = ops::agent::agent_refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
assert!(!catalog.refreshing);
assert!(catalog.retry_at_ms.is_some());
let models = catalog.config.iter().find(|o| o.category.as_deref() == Some("model")).unwrap();
+6 -3
Переглянути файл
@@ -40,9 +40,12 @@ fn closing_a_project_closes_its_terminals_and_keeps_other_windows() {
}));
host.trust.decide(&root, true, false).unwrap();
host.open_project("main", &root).unwrap();
let project_shell =
ops::term::spawn(&host, "main", options(&root), Arc::new(|_| {})).expect("project terminal");
let other_shell = ops::term::spawn(&host, "other", options(&root), Arc::new(|_| {})).expect("other terminal");
let project_shell = ops::term::term_spawn(&host, "main", options(&root), ops::Channel::new(|_| {}))
.await
.expect("project terminal");
let other_shell = ops::term::term_spawn(&host, "other", options(&root), ops::Channel::new(|_| {}))
.await
.expect("other terminal");
assert_eq!(host.terminals.list().len(), 2);
host.close_project("main");
+4 -3
Переглянути файл
@@ -101,7 +101,7 @@ async fn compose_target_is_the_python_interpreter() {
set("runTargets", serde_json::json!([{ "kind": "compose", "id": "web", "name": "Compose web", "service": "web" }]));
// A local interpreter: Django is only in the image.
ops::doc::open(&host, WINDOW, main.clone()).await.unwrap();
ops::doc::doc_open(&host, WINDOW, main.clone()).await.unwrap();
let before = diagnostics(&events, &main, Duration::from_secs(120), unresolved).await;
eprintln!("local interpreter: {before:?}");
@@ -140,15 +140,16 @@ async fn compose_target_is_the_python_interpreter() {
allow_parallel: false,
extras: Default::default(),
};
ops::run::start(
ops::run::run_start(
&host,
WINDOW,
config,
Arc::new(move |chunk| match chunk {
ide_host::ops::Channel::new(move |chunk| match chunk {
OutputChunk::Stdout { text } | OutputChunk::Stderr { text } | OutputChunk::System { text } => {
sink.lock().unwrap().push_str(&text)
}
}),
None,
)
.await
.unwrap();
+1 -4
Переглянути файл
@@ -22,10 +22,7 @@ async fn split_storage_keeps_user_history_and_uses_local_tools_and_caches() {
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
assert_eq!(
std::path::PathBuf::from(ops::tools::jdk_download_location(&host, "main").unwrap()),
local.join("tools/jdks")
);
assert_eq!(std::path::PathBuf::from(ops::tools::jdk_download_location(&host).unwrap()), local.join("tools/jdks"));
let light = host.open_light("main", &root.join("notes.txt")).unwrap();
assert!(light.cache_dir.starts_with(&local));
assert!(data.join("history").exists());
+8 -8
Переглянути файл
@@ -21,17 +21,17 @@ async fn new_query_consoles_are_numbered_after_the_default_one() {
let names = |paths: Vec<ide_core::IpcPath>| -> Vec<String> {
paths.iter().map(|p| p.0.file_name().unwrap().to_string_lossy().into_owned()).collect()
};
assert!(db::consoles(&host, "pg", false).unwrap().is_empty());
assert!(db::db_consoles(&host, "pg".into(), false).unwrap().is_empty());
// The first new console is the default one, then console_1, console_2…
assert_eq!(names(db::consoles(&host, "pg", true).unwrap()), ["console.sql"]);
assert_eq!(names(db::consoles(&host, "pg", true).unwrap()), ["console.sql", "console_1.sql"]);
let all = db::consoles(&host, "pg", true).unwrap();
assert_eq!(names(db::db_consoles(&host, "pg".into(), true).unwrap()), ["console.sql"]);
assert_eq!(names(db::db_consoles(&host, "pg".into(), true).unwrap()), ["console.sql", "console_1.sql"]);
let all = db::db_consoles(&host, "pg".into(), true).unwrap();
assert_eq!(names(all.clone()), ["console.sql", "console_1.sql", "console_2.sql"]);
// Numbers sort numerically, and the default console path is the first one.
std::fs::write(all[0].0.with_file_name("console_10.sql"), "").unwrap();
assert_eq!(names(db::consoles(&host, "pg", false).unwrap())[3], "console_10.sql");
assert_eq!(db::console_path(&host, "pg").unwrap().0, all[0].0);
assert_eq!(names(db::db_consoles(&host, "pg".into(), false).unwrap())[3], "console_10.sql");
assert_eq!(db::db_console_path(&host, "pg".into()).unwrap().0, all[0].0);
// Each database of a source has its own consoles.
assert!(db::consoles(&host, "pg:other", false).unwrap().is_empty());
assert!(db::consoles(&host, "../x", true).is_err());
assert!(db::db_consoles(&host, "pg:other".into(), false).unwrap().is_empty());
assert!(db::db_consoles(&host, "../x".into(), true).is_err());
}
+7 -5
Переглянути файл
@@ -1,4 +1,4 @@
//! Docker run targets through `ops::run::start`, with a stand-in `docker`
//! Docker run targets through `ops::run::run_start`, with a stand-in `docker`
//! (`OPENIDEA_DOCKER`) that prints what it was given.
#![cfg(unix)]
@@ -46,15 +46,16 @@ fn config(target: &str, root: &Path) -> RunConfig {
async fn output_of(host: &Host, config: RunConfig) -> String {
let out = Arc::new(Mutex::new(String::new()));
let sink = out.clone();
ops::run::start(
ops::run::run_start(
host,
"main",
config,
Arc::new(move |chunk| match chunk {
ide_host::ops::Channel::new(move |chunk| match chunk {
OutputChunk::Stdout { text } | OutputChunk::Stderr { text } | OutputChunk::System { text } => {
sink.lock().push_str(&text)
}
}),
None,
)
.await
.unwrap();
@@ -149,9 +150,10 @@ async fn docker_targets_run_through_the_docker_cli() {
"{out}"
);
debug.debug_adapter = Some("delve".into());
let err = ops::run::start(&host, "main", debug, Arc::new(|_| {})).await.unwrap_err();
let err = ops::run::run_start(&host, "main", debug, ops::Channel::new(|_| {}), None).await.unwrap_err();
assert!(err.message.contains("only Python"), "{}", err.message);
let err = ops::run::start(&host, "main", config("far", &root), Arc::new(|_| {})).await.unwrap_err();
let err =
ops::run::run_start(&host, "main", config("far", &root), ops::Channel::new(|_| {}), None).await.unwrap_err();
assert!(err.message.contains("another machine"), "{}", err.message);
}
+4 -3
Переглянути файл
@@ -50,15 +50,16 @@ type Output = Arc<Mutex<String>>;
async fn start(host: &Host, config: RunConfig) -> (ide_core::RunId, Output) {
let out: Output = Arc::default();
let sink = out.clone();
let info = ops::run::start(
let info = ops::run::run_start(
host,
"main",
config,
Arc::new(move |chunk| match chunk {
ide_host::ops::Channel::new(move |chunk| match chunk {
OutputChunk::Stdout { text } | OutputChunk::Stderr { text } | OutputChunk::System { text } => {
sink.lock().push_str(&text)
}
}),
None,
)
.await
.unwrap();
@@ -145,7 +146,7 @@ async fn runs_in_docker_and_compose_containers() {
tokio::time::sleep(Duration::from_millis(100)).await;
}
assert_ne!(containers("label=openidea.run=sleep"), "", "{}", out.lock());
ops::run::stop(&host, "main", id).unwrap();
ops::run::run_stop(&host, "main", id).unwrap();
let out = finished(&out, 30).await;
assert!(out.contains(" stop openidea-sleep-"), "{out}");
for _ in 0..100 {
+5 -5
Переглянути файл
@@ -231,8 +231,8 @@ impl Smoke {
}
async fn doc(&self, file: &str) -> (DocId, String) {
let info = ops::doc::open(&self.host, WINDOW, self.root.join(file)).await.unwrap();
let info = ops::doc::snapshot(&self.host, WINDOW, info.id).await.unwrap();
let info = ops::doc::doc_open(&self.host, WINDOW, self.root.join(file)).await.unwrap();
let info = ops::doc::doc_snapshot(&self.host, WINDOW, info.id).await.unwrap();
(info.id, info.text)
}
@@ -260,13 +260,13 @@ impl Smoke {
}
async fn replace(&self, doc: DocId, from: u32, to: u32, insert: &str) {
let version = ops::doc::snapshot(&self.host, WINDOW, doc).await.unwrap().version;
let version = ops::doc::doc_snapshot(&self.host, WINDOW, doc).await.unwrap().version;
let changes = ChangeSet { changes: vec![TextChange { from, to, insert: insert.into() }] };
ops::doc::edit(&self.host, WINDOW, doc, version, changes).unwrap();
ops::doc::doc_edit(&self.host, WINDOW, doc, version, changes).await.unwrap();
}
async fn restore(&self, doc: DocId, text: &str) {
let current = ops::doc::snapshot(&self.host, WINDOW, doc).await.unwrap().text;
let current = ops::doc::doc_snapshot(&self.host, WINDOW, doc).await.unwrap().text;
self.replace(doc, 0, utf16_len(&current), text).await;
}
+26 -24
Переглянути файл
@@ -1,7 +1,7 @@
//! LightEdit: a window editing loose files without a project.
use ide_core::{ChangeSet, NullSink, TextChange};
use ide_host::{Host, HostConfig, ops};
use ide_host::{Host, HostConfig, catalogue::TrustClass, ops};
use std::sync::Arc;
use std::time::Duration;
@@ -35,18 +35,18 @@ async fn edits_loose_files_without_project_services() {
assert_eq!(light.root, a_dir);
assert!(host.open_light("main", &b_dir).is_err(), "a folder is not opened for LightEdit");
let doc = ops::doc::open(&host, "main", a_dir.join("one.py")).await.unwrap();
let doc = ops::doc::doc_open(&host, "main", a_dir.join("one.py")).await.unwrap();
assert!(doc.text.starts_with("print"));
let changes = ChangeSet { changes: vec![TextChange { from: 0, to: 0, insert: "#\n".into() }] };
let version = ops::doc::edit(&host, "main", doc.id, doc.version, changes).unwrap();
let version = ops::doc::doc_edit(&host, "main", doc.id, doc.version, changes).await.unwrap();
assert!(version > doc.version);
ops::doc::save(&host, "main", doc.id).await.unwrap();
ops::doc::doc_save(&host, "main", doc.id).await.unwrap();
assert_eq!(std::fs::read_to_string(a_dir.join("one.py")).unwrap(), "#\nprint(1)\n");
// More files join the same session, wherever they are.
let again = host.open_light("main", &b_dir.join("two.rs")).unwrap();
assert!(Arc::ptr_eq(&light, &again));
ops::doc::open(&host, "main", b_dir.join("two.rs")).await.unwrap();
ops::doc::doc_open(&host, "main", b_dir.join("two.rs")).await.unwrap();
assert!(light.index.wait_idle(Duration::from_secs(10)));
assert_eq!(light.index.status().files, 0, "nothing is indexed");
@@ -106,11 +106,12 @@ async fn light_windows_stay_restricted_when_folder_trust_changes() {
host.set_project_trust(&root, true, true).await.unwrap();
assert!(!light.is_trusted());
assert!(!trusted_folder.is_trusted());
for command in ["sdk_detect", "sdk_locate_tools", "notebook_execute", "notebook_restart", "run_start"] {
assert!(host.authorize_command("main", command).is_err(), "{command}");
for class in [TrustClass::OutsideRestricted, TrustClass::Trusted] {
assert!(host.authorize("main", class).is_err(), "{class:?}");
}
assert!(host.authorize("main", TrustClass::Always).is_ok());
let doc = ops::doc::open(&host, "main", other.join("two.js")).await.unwrap();
let doc = ops::doc::doc_open(&host, "main", other.join("two.js")).await.unwrap();
let error = ops::lsp::lsp_format(
&host,
"main",
@@ -156,15 +157,15 @@ async fn light_notebooks_open_without_interpreter_detection_or_execution() {
.unwrap();
let host = host(&tmp.path().join("app"));
host.open_light("main", &file).unwrap();
let notebook = ops::notebook::open(&host, "main", file.to_string_lossy().into()).await.unwrap();
assert!(ops::notebook::save(&host, "main", notebook.id.clone()).await.is_ok());
let notebook = ops::notebook::notebook_open(&host, "main", file.to_string_lossy().into()).await.unwrap();
assert!(ops::notebook::notebook_save(&host, "main", notebook.id.clone()).await.is_ok());
let error = ops::sdk::sdk_detect(&host, "main", ide_sdk::SdkKind::Python).await.unwrap_err();
assert!(error.message.contains("Restricted Mode"));
assert!(ops::sdk::sdk_python_effective(&host, "main", None).is_err());
assert!(ops::sdk::sdk_locate_tools(&host, "main", vec!["prettier".into()], Some(root)).await.is_err());
let error = ops::notebook::restart(&host, "main", notebook.id.clone()).await.unwrap_err();
let error = ops::notebook::notebook_restart(&host, "main", notebook.id.clone()).await.unwrap_err();
assert!(error.message.contains("Restricted Mode"));
let error = ops::notebook::execute(
let error = ops::notebook::notebook_execute(
&host,
"main",
notebook.id,
@@ -191,23 +192,24 @@ async fn untitled_buffers_reach_the_disk_through_save_as() {
// home folder, no watcher yet, doc commands work.
let empty = host.open_light_empty("main").unwrap();
assert!(empty.light);
let untitled = ops::doc::open_untitled(&host, "main", None).await.unwrap();
let untitled = ops::doc::doc_open_untitled(&host, "main", None).await.unwrap();
assert_eq!(untitled.path, std::path::PathBuf::from("untitled:Untitled-1"));
assert_eq!(untitled.language.as_str(), "plaintext");
let version = ops::doc::edit(&host, "main", untitled.id, untitled.version, untitled_edit("# notes\n")).unwrap();
assert!(ops::doc::save(&host, "main", untitled.id).await.is_ok(), "saving nowhere is a no-op");
let version =
ops::doc::doc_edit(&host, "main", untitled.id, untitled.version, untitled_edit("# notes\n")).await.unwrap();
assert!(ops::doc::doc_save(&host, "main", untitled.id).await.is_ok(), "saving nowhere is a no-op");
assert!(host.project("main").unwrap().documents.is_dirty(untitled.id).unwrap());
// Save As: the buffer lands on the disk and turns into a file document.
let target = dir.join("deep/notes.md");
let saved = ops::doc::save_as(&host, "main", untitled.id, target.clone()).await.unwrap();
let saved = ops::doc::doc_save_as(&host, "main", untitled.id, target.clone()).await.unwrap();
assert_eq!(saved.path, target);
assert_eq!(saved.language.as_str(), "markdown");
assert!(!saved.dirty);
// The platform's default line separator applies to new buffers.
assert_eq!(std::fs::read_to_string(&target).unwrap().replace("\r\n", "\n"), "# notes\n");
ops::doc::edit(&host, "main", untitled.id, version, untitled_edit("x\n")).unwrap();
ops::doc::save(&host, "main", untitled.id).await.unwrap();
ops::doc::doc_edit(&host, "main", untitled.id, version, untitled_edit("x\n")).await.unwrap();
ops::doc::doc_save(&host, "main", untitled.id).await.unwrap();
assert_eq!(std::fs::read_to_string(&target).unwrap().replace("\r\n", "\n"), "x\n# notes\n");
// The saved file's folder is followed for external changes now.
@@ -226,9 +228,9 @@ async fn untitled_buffers_follow_the_window_into_a_project() {
// A LightEdit window with an edited untitled buffer (and a clean one).
host.open_light_empty("main").unwrap();
let draft = ops::doc::open_untitled(&host, "main", None).await.unwrap();
ops::doc::edit(&host, "main", draft.id, draft.version, untitled_edit("{\"draft\": true}")).unwrap();
let clean = ops::doc::open_untitled(&host, "main", None).await.unwrap();
let draft = ops::doc::doc_open_untitled(&host, "main", None).await.unwrap();
ops::doc::doc_edit(&host, "main", draft.id, draft.version, untitled_edit("{\"draft\": true}")).await.unwrap();
let clean = ops::doc::doc_open_untitled(&host, "main", None).await.unwrap();
// The window switches to a project: the buffers follow, contents and dirty flags kept.
let project_root = tmp_root.join("proj");
@@ -237,15 +239,15 @@ async fn untitled_buffers_follow_the_window_into_a_project() {
assert!(!project.light);
let carried =
ops::doc::open_untitled(&host, "main", Some(draft.path.to_string_lossy().into_owned())).await.unwrap();
ops::doc::doc_open_untitled(&host, "main", Some(draft.path.to_string_lossy().into_owned())).await.unwrap();
assert_eq!(carried.path, draft.path, "same key, fresh registry: a new doc id carries the content");
let snap = ops::doc::snapshot(&host, "main", carried.id).await.unwrap();
let snap = ops::doc::doc_snapshot(&host, "main", carried.id).await.unwrap();
assert_eq!(snap.text, "{\"draft\": true}");
assert!(host.project("main").unwrap().documents.is_dirty(carried.id).unwrap());
assert_eq!(snap.language.as_str(), "plaintext");
let clean_carried =
ops::doc::open_untitled(&host, "main", Some(clean.path.to_string_lossy().into_owned())).await.unwrap();
ops::doc::doc_open_untitled(&host, "main", Some(clean.path.to_string_lossy().into_owned())).await.unwrap();
assert!(!host.project("main").unwrap().documents.is_dirty(clean_carried.id).unwrap());
host.shutdown().await;
}
+5 -4
Переглянути файл
@@ -763,7 +763,8 @@ fn run_tool_window(h: &Harness) -> Arc<std::sync::Mutex<Vec<ide_run::RunConfig>>
config.extras.params.insert(ide_host::mcp::AGENT_PARAM.into(), name);
config.extras.target = Some(String::new());
out.lock().unwrap().push(config.clone());
let result = ide_host::ops::run::start(&host, "main", config, Arc::new(|_| {})).await;
let result =
ide_host::ops::run::run_start(&host, "main", config, ide_host::ops::Channel::new(|_| {}), None).await;
let error = result.err().map(|e| e.message);
let _ = host.mcp_requests.answer("main", id, error.is_none(), error);
}
@@ -835,7 +836,7 @@ async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
// What the user types (a line from the Run console's input) ends a wait at once, with advice for the agent.
let process = agent_process(&h, "_agent_check");
ide_host::ops::run::stdin(&h.host, process, "yes\n").unwrap();
ide_host::ops::run::run_stdin(&h.host, process, "yes\n".into()).unwrap();
let typed = h.json("wait_for_run", json!({"name": "check", "timeout": 10000})).await;
assert_eq!(typed["waitEnded"], "userIntervened", "{typed}");
assert_eq!(typed["interventions"][0]["message"], "User input: yes");
@@ -849,14 +850,14 @@ async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
// The user's Stop, rerun and closing the tab are reported with their time.
h.json("run_command", json!({"name": "server", "command": "sleep 30", "timeout": 0})).await;
ide_host::ops::run::stop(&h.host, "main", agent_process(&h, "_agent_server")).unwrap();
ide_host::ops::run::run_stop(&h.host, "main", agent_process(&h, "_agent_server")).unwrap();
let stop = h.json("wait_for_run", json!({"name": "server", "timeout": 10000})).await;
assert!(stop["interventions"][0]["message"].as_str().unwrap().starts_with("The user stopped this command at"));
let ended = h.json("wait_for_run", json!({"name": "server", "timeout": 10000})).await;
assert_eq!(ended["state"], "stoppedByUser", "{ended}");
let config = started.lock().unwrap().last().cloned().unwrap();
ide_host::ops::run::start(&h.host, "main", config, Arc::new(|_| {})).await.unwrap();
ide_host::ops::run::run_start(&h.host, "main", config, ide_host::ops::Channel::new(|_| {}), None).await.unwrap();
let status = h.json("get_run_status", json!({"name": "server"})).await;
assert_eq!(status["startedBy"], "user", "{status}");
assert!(status["interventions"][0]["message"].as_str().unwrap().starts_with("The user reran this command at"));
Loaded 100 of 381 files, more files were not shown because too many files have changed in this diff. Show more