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

...
Автор SHA1 Повідомлення Дата
l0ng-ai 0a03615988 feat(vcs): Deployment submenu in the changes tree's context menu
The Commit tool window's changes tree had no Deployment entries, so uploading changed
files meant finding them again in the Project view. Its context menu now takes other
features' groups through a new "changes" menu slot; Deployment contributes its submenu
there (Upload to, Download from, Sync with, Delete from Server, ...) for the selected
files that are still on disk.
2026-11-17 01:10:30 +08:00
xiaohuiduanтаxiaohuiduan 8b6c71095a feat(agents): add DeepSeek Harness as a built-in ACP agent (#3786)
Adds the deepseek-harness provider (dsh --profile acp) with its logo, resolved like the other CLI agents.

DeepSeek Harness advertises sessionCapabilities.resume instead of loadSession and does not implement session/load, so its saved tasks counted as non-reloadable and restarted fresh. The ACP client now treats a v1 resume-only agent as reloadable and sends session/load as session/resume; agents that advertise loadSession (or neither) are unchanged.

Co-authored-by: xiaohuiduan <[email protected]>
2026-11-17 01:03:51 +08:00
Yann abe7c58cb9 feat(vcs): View Options › Show Unversioned Files Separately (#3702)
Adds a View Options toggle, on by default. Turning it off lists untracked files under Changes (the active changelist), or Unstaged Changes when grouping by staging state. The files stay untracked and excluded from commits by default; the choice is remembered independently of Staging State.

Co-authored-by: YannABC <[email protected]>
2026-11-17 01:00:56 +08:00
zhangdagouтаPLZY d3d799b8fe feat(vcs): checkable directory tree in the Shelve, Unshelve and Create Patch dialogs (#3778)
The files of the Shelve, Unshelve and Create Patch dialogs were a flat list. They are now a tree under the repository node, grouped by directory with file counts; a directory's checkbox checks or clears every file below it and shows a dash when only some are included. Unshelve lists the shelved files too and applies only the checked ones.

Co-authored-by: PLZY <[email protected]>
2026-11-17 00:58:14 +08:00
l0ng-ai 122d7f3d0f fix(ui): show cut-off text whole in a tooltip (#3800)
Text shortened with an ellipsis gave no way to read it whole. The tooltip host now shows such text in full after the usual delay, only while it is actually cut off and when it has no native title. Inside an element with a tooltip of its own (an editor tab, a commit-panel file with its change kind) the whole text comes first and that tooltip beside it. The commit panel's change kind moves from title to the tooltip host.
2026-11-17 00:54:31 +08:00
l0ng-ai 6cdb2f1f1e fix(plugins): say why a marketplace download failed (#3798)
A failed plugin download, marketplace read or plugin network request reported only reqwest's top-level message, with the URL twice and no cause. These errors now carry their causes (DNS, connection refused, TLS, ...) as the HTTP client already does; the agent panel's MCP server requests too.
2026-11-17 00:43:05 +08:00
GuoYuтаguoyucode dbf6de6d24 feat(mcp): limit the query tools to a directory with scope (#3735)
The query tools take an optional scope: a directory of the project or of one of its content roots (attached projects included). Results are limited to the files in it; paths narrows within it. search_text, search_regex and search_file walk only that directory; search_symbol, find_references, get_project_problems and get_all_open_file_paths keep results inside it; git_status uses the repository holding it; get_run_configurations and list_runs keep those whose working directory is inside it.

Searching a directory of a content root walked it from the project root, so the project's exclusions met paths through the attachment's folder (an excluded '.*' hid every file of a worktree under .wt/). Such a directory is now searched from its content root, and the project-relative masks follow the root they search, so paths also reaches files of an attached project. This applies to Find in Files on a directory too.

Co-authored-by: guoyucode <[email protected]>
2026-11-17 00:41:16 +08:00
GuoYuтаguoyucode 80cb458395 fix(mcp): write to trusted attached projects, name them as projectPath, and give their files one path (#3736)
Writes over MCP were limited to the opened project's folder, projectPath only knew the windows' own folders, and files of a project attached outside the root were named three different ways.

- A write may land in the project folder or in a trusted attached project; untrusted attachments and other folders are still refused.
- A projectPath naming an attached project resolves to the window it is attached in.
- Every tool gives a file outside the project by its absolute path with '/'; search_symbol takes a match's path from the file rather than its display name.

Co-authored-by: guoyucode <[email protected]>
2026-11-17 00:38:19 +08:00
Vadim LazukтаInf1mum 612cca2ec9 fix(vue): resolve extension-less imports to .vue in the hybrid mode's tsserver (#3764)
In the Vue hybrid mode, @vue/typescript-plugin only resolves imports that name the .vue file, so a directory index.js re-exporting './ChildButton' left the component any, and in Vue 2.7 with data() every template event handler lost its type (VS Code patches tsserver for this). A companion tsserver plugin, written under the data dir and registered after the Vue plugin, retries what both left unresolved with the .vue extension and maps the result back to the SFC.

Fixes #3728

Co-authored-by: Inf1mum <[email protected]>
2026-11-17 00:35:07 +08:00
l0ng-ai 458286b046 fix(remote): say when a remote window loses its connection and reconnect it (#3795)
A remote window whose SSH link, host or server went away kept showing its project and failed every command with "connection closed". The desktop now tells the window when its connection ends on its own (RemoteConnectionLost); the window shows it in the status bar, reconnects after 2, 5 and 15 s (a new server, so the project opens again on it), then offers Reconnect; commands on the closed connection say "Lost the connection to <host>".

Fixes #3697
2026-11-17 00:32:31 +08:00
l0ng-ai 043584b7de chore(agents): drop a needless borrow that clippy rejects (#3793)
clippy's needless_borrow rejected `&prompt` in ide-agent since #3444.
2026-11-17 00:29:26 +08:00
l0ng-ai ab1a4db606 fix(vcs): render ANSI colours in the Git console and strip them from balloons (#3792)
Hook output showed raw escape sequences in the Git Console tab and the Commit failed balloon. Console lines keep their SGR runs (the Run console's AnsiStream, a colour carrying to the next line of the same output; a background without its own colour keeps the default text colour), and VCS balloons strip escapes.

Fixes #3762
2026-11-17 00:27:21 +08:00
l0ng-ai 2d85e745e7 fix(ui): unify close button icons and hover styling 2026-11-17 00:12:25 +08:00
l0ng-ai 741730b7e0 fix(window): match Islands project tabs and close hover styling 2026-11-17 00:06:50 +08:00
Gregor Zeitlinger 026b493e93 fix(vcs): complete File History revision actions (#3775)
File History offered the repository-wide Git Log actions only. Its commit menu now has Show File at Revision (the file as it was in that commit, following renames through historyPath), and Compare with Local / Compare Versions diff just that file instead of the whole tree. ⌘/Ctrl+D in the File History list diffs the selected revision of the file against its parent, or the two selected revisions, without changing Show Diff elsewhere.

Co-authored-by:  <{
  "message": "Not Found",
  "documentation_url": "https://docs.github.com/rest",
  "status": "404"
}[email protected]>
2026-11-17 00:03:26 +08:00
l0ng-ai 711ef3ec96 Revert "feat(agents): temporary side conversations from a selection (#3411)"
This reverts commit 396a8d4b26.
2026-11-16 23:59:35 +08:00
Mr0Bread b35bf882b5 refactor(vcs): split Git Log into per-component modules (#3761)
GitLog.tsx (3,129 lines) moves along its component seams into src/features/vcs/log/ (shared, logHooks, commitMenu, CommitMessage, GraphCell, ColumnHeaders, CommitRow, CommitList, FilterBar, BranchesPanel, CommitDetails). Declaration bodies, CSS, text and the lazy entry are unchanged; imports point at the new modules without re-export shims.

Part of #3589

Co-authored-by: Mr0Bread <[email protected]>
2026-11-16 23:56:02 +08:00
rohitkumardandaтаrohitdanda a816a57004 fix(terminal): quote dropped and pasted file paths for the shell that reads them (#3756)
Dropped paths were quoted by operating system rather than by shell, and only a few characters triggered quoting, so a file name such as a$(calc).txt or ;{curl,x}|sh;.txt could run a command when the user pressed Enter. Dropped and pasted-file paths now go through one quoting function per shell dialect (POSIX, fish, PowerShell including its typographic quotes, cmd, or a program's own argument rules when no shell is known); names with control characters, and cmd names it would expand inside quotes, are refused with a notification.

Co-authored-by: rohitdanda <+[email protected]>
2026-11-16 23:53:36 +08:00
zhangdagouтаPLZY 52017a1172 fix(vcs): show the ⌘-hover declaration info as a popup in diff views (#3783)
The ⌘/Ctrl-hover declaration info in a diff view used CodeMirror's default dark tooltip, clipped by the pane and covered by the tool window stripe. The hint is now styled in full by the LSP theme as a rounded popup with an arrow pointing at the word (same in the editor and diffs), and a diff side showing an open document parents its tooltips to the body with the editor's tooltip bounds.

Co-authored-by: PLZY <[email protected]>
2026-11-16 23:51:06 +08:00
Daniil Poliakovтаdan548 80f50ccdfa fix(editor): preserve rainbow brackets inside interpolated literals (#3773)
Rainbow brackets skipped whole string nodes, so brackets inside template-literal, f-string or PHP interpolations lost their colour, while markup attribute values could disturb nesting. Literal ranges are now computed with holes for interpolation nodes, and attribute values, CDATA, doctypes and markup text are skipped.

Closes #3768

Co-authored-by: dan548 <[email protected]>
2026-11-16 23:50:58 +08:00
rohitkumardandaтаrohitdanda ec76dcde7f fix(plugins): run only safe actions from keys a plugin web view passes on (#3763)
A plugin web view forwards shortcuts its page did not handle to the IDE keymap by posting a message, which page script could do at any time and so run any bound action without the ide.commands grant. A forwarded key now counts only while the frame has focus right after user activation, never starts a chord or a double Shift, and without ide.commands runs only an allowlist of navigation, save and settings actions.

Co-authored-by: rohitdanda <[email protected]>
2026-11-16 23:50:51 +08:00
Vadim LazukтаInf1mum 3c624ccb22 fix(terminal): fall back to any installed Nerd Font for prompt icons (#3754)
The terminal font stack only named ten known Nerd Font families, and the webview does no per-glyph system fallback, so prompt icons from any other installed Nerd Font (Maple Mono NF CN, Cascadia Code NF…) rendered as boxes. Nerd Font families found in the native font catalog now join the stack after the known ones, full faces before Mono and Propo, and open terminals re-apply their font once the catalog loads. The UI icon font uses the same discovery.

Fixes #3723

Co-authored-by: Inf1mum <[email protected]>
2026-11-16 23:50:42 +08:00
rohitkumardandaтаrohitdanda 5a000983c7 fix(terminal): keep a pasted ESC from ending bracketed paste early (#3753)
xterm.js 6.0 wraps pasted text in bracketed-paste markers without escaping an ESC inside it, so a pasted ESC[201~ ended the paste early and the rest was typed, Enter included. While the shell has bracketed paste on, each ESC in pasted text is shown as U+241B (as xterm.js 6.1 does); a Ctrl+V whose text holds an ESC is claimed before xterm's own listener. Covers the terminal tool window, embedded terminals and drops.

Co-authored-by: rohitdanda <[email protected]>
2026-11-16 23:50:34 +08:00
Ernstjan FreriksтаEjaYF 03ad6c12ca fix(menu): add the missing labels for Related Symbol and Extract Interface (#3765)
The menu items added by #3699 and #3707 had no catalog labels, so every_menu_item_has_a_catalog_label failed on main. Adds both labels to en.json and zh.json.

Co-authored-by: EjaYF <[email protected]>
2026-11-16 23:40:29 +08:00
l0ng-ai 1dbd2847b9 fix(diff): text typed into a blank diff survives switching to another tab (#3784) 2026-11-16 23:35:40 +08:00
l0ng-ai c9f5ac9cd5 fix(vcs): Push… from one repository stays available when its branch is up to date (#3782) 2026-11-16 23:35:34 +08:00
l0ng-ai 06c7127b6b fix(database): Compare Structure keeps string defaults exact and cross-schema foreign keys pointing at their schema (#3781) 2026-11-16 23:35:28 +08:00
l0ng-ai 635ec2d7bd fix(python): report circular inheritance again: a class may list itself once as its own ancestor 2026-11-16 22:28:13 +08:00
l0ng-ai ac3c564249 fix(python): visit a shared base or subclass once when walking inheritance 2026-11-16 20:58:50 +08:00
l0ng-ai f76ac263a0 fix(build): Rebuild never deletes an output folder over the project or its source roots 2026-11-16 20:58:49 +08:00
l0ng-ai 7a97fba491 chore: v0.1.46 2026-11-16 20:52:18 +08:00
l0ng-ai 205b4bcc5f perf(agents): keep the New Task page mounted while another tab shows
Switching back to it no longer rebuilds the composer and refetches the agent, models and commands; the branch and the agent probe are still read again each time it shows.
2026-11-16 20:51:42 +08:00
l0ng-ai cd574a3e28 fix(perf): align the memory popup's values across sections 2026-11-16 20:44:36 +08:00
l0ng-ai 8aed4156f4 fix(java): keep snapshotted module outputs off the Maven launch classpath (#3757)
A delegated Maven launch runs the module and its reactor siblings from a
snapshot of their target/classes. The Maven launch classpath merged in since
#2929 lists those target/classes too, so both copies were on the classpath and
every resource was found twice: MyBatis loads each mapper XML twice and stops
with "XML fragments parsed from previous mappers already contains value".
Entries that have a snapshot are now left out of the merged Maven classpath.

Fixes #3719
2026-11-16 20:37:28 +08:00
l0ng-ai 0221034936 fix(database): lighter result and console toolbars
- Toolbar pickers (row limit, Tx mode, data source, schema, extractor, page size) render as ghost dropdowns.
- Result toolbar: Submit and Revert are icon buttons; the data source label is gone.
- The pager shows only "N rows" (with the page size picker) when the result fits on one page.
- Column header names use the regular weight.
2026-11-16 20:34:53 +08:00
l0ng-ai 0d432bf1a6 feat(agents): simpler New Task page and composer controls
- New Task page: a narrower box with room for a few lines, a lighter heading, and the
  project, checkout and branch as one quiet line under the box. The agent shows as its
  icon (name and version in its tooltip); the probe line shows only when the agent fails.
- Composer: one + menu for referencing a file, attaching an image and MCP servers; the
  MCP popover opens from it or /mcp. The current-file chip turns IDE context on and off.
- Model and effort: the model button opens one searchable list of model names (pin on
  hover, context size above it); effort is its own picker beside the model.
- Session: the status line moves under the box as one line — branch and worktree on the
  left, changes, context use, time and terminal on the right; "Ready" is no longer shown.
2026-11-16 20:28:47 +08:00
l0ng-ai cbac930a6f fix(refactor): a dialog closed while editors sync never sends its request (#3752)
cancellable checked the dialog's signal before lspRequest's editor sync; cancellable now hands its sender a wanted check, which lspRequest applies after syncing (and applyEdit does the same).
2026-11-16 19:25:55 +08:00
l0ng-ai 33f082e32f fix(build): artifact layout never copies into an entry folder that is a link (#3751)
Only folders below an entry's own folder were checked for links. Every folder an entry goes into is now checked, from the output folder (excluded) down to the entry's own folder.
2026-11-16 19:25:50 +08:00
l0ng-ai 0bbf5568cd fix(tools): Cancel in Language Servers stops the install (#3750)
The progress row under a tool's details passed the tool's display name to
cancelInstall, which looks the install up by tool name. For every tool whose
display name differs (Eclipse JDT Language Server for jdtls, Delve for
delve, ...), Cancel found nothing and the install went on.

Fixes #3721
2026-11-16 19:25:29 +08:00
l0ng-ai 2277c1cdfd fix(vcs): translate commit message hints and offer Add blank line (#3749)
The commit message inspections were shown as untranslated English text with
no way to act on them, so the subject/body hint read like an error that
blocked line breaks. They now go through the text catalog, and the missing
blank line hint has an Add blank line fix that inserts it and keeps the caret.

Fixes #3732
2026-11-16 19:19:50 +08:00
l0ng-ai a537223233 fix(agents): deny the MCP servers off by default and the built-in one when off (#3748)
Session denials came only from explicit per-session false overrides. They now follow each configured server's effective state (workspace entries first), keep switched-off names the IDE doesn't configure, and add the built-in server's agent-facing name OpenIDEA when it is off.
2026-11-16 19:19:03 +08:00
l0ng-ai 19c7947fc4 fix(vcs): switching the all-in-one diff's layout keeps its blocks and their edits (#3747)
Block keys included the layout, so switching it remounted every block and a collapsed one released its document. Blocks are keyed by file; DiffEditor follows the layout the host asks for in place.
2026-11-16 19:16:39 +08:00
l0ng-ai 98f9fc0063 fix(app): window close and WSL open in place don't drop unsaved untitled buffers (#3746)
The window close path saved without checking that untitled buffers were saved, and WSL open in place asked the leave guard as if untitled buffers stayed with the window. The close path now shares the post-save untitled check, and WSL is resolved before the guard.
2026-11-16 19:13:00 +08:00
l0ng-ai 0d5ef48a94 fix(refactor): closed refactoring dialogs never apply or send their request (#3745)
applyEdit waited for editor sync and then applied regardless of the dialog's signal; cancellable sent its request even when the signal was already aborted. Both now check the signal.
2026-11-16 19:11:14 +08:00
l0ng-ai 444b620985 fix(agents): side conversations run in the agent's most careful mode (#3744)
A side conversation's denial of project changes only works in a mode that asks first, but Claude Code's Accept Edits and Codex's Ask were kept, and a refused switch still started the session. Side conversations now take the agent's most careful mode (Codex Read Only, Claude Code default, then plan/ask), don't start when the agent's settings don't end up there, and refuse a mode change that doesn't ask.
2026-11-16 19:09:27 +08:00
l0ng-ai 0c45a96d84 fix(build): artifact layout never goes through links in its output folder (#3743)
The cleanup of recorded files and the copy into a user-chosen artifact output folder followed links, so a folder of the output replaced by a link to the sources made the build delete or overwrite source files. Recorded paths through a link are skipped, a file link in an artifact file's place is replaced, and a folder that links elsewhere stops the layout.
2026-11-16 19:07:31 +08:00
l0ng-ai fd8f8d6dd0 fix(agents): an MCP server switched off for a Claude session stays off (#3742)
Switching a server off in the session's MCP picker only left it out of the servers passed to the session, so a server Claude Code also loads from its own configuration kept running. The session parameters now name the servers switched off (_meta.openidea.mcpServersOff) and the Claude Code session denies their tools with --disallowedTools mcp__<server>.
2026-11-16 18:51:59 +08:00
l0ng-ai c1bec5182c fix(navigation): Python super methods walk up from the class itself (#3741)
The graph walk behind a Python method's super-method icon started from the class name and continued by base names, so same-named classes elsewhere contributed unrelated super methods. It now walks concrete class declarations, resolving each base from the file that names it.
2026-11-16 18:47:43 +08:00
l0ng-ai dcb4835a87 fix(vcs): the staging area commits a staged addition deleted from disk (#3740)
A file added to the index and then deleted from disk is no change against HEAD, so the change lists leave it out; the staging area applied the same rule and listed it nowhere, keeping Commit disabled or silently leaving the staged addition out of the commit. With the staging area on, it is now listed under Staged (added) and Unstaged (deleted) and committed as staged.
2026-11-16 18:46:03 +08:00
l0ng-ai f74bc7abac fix(vcs): collapsing a file in the all-files diff keeps its unsaved edits (#3739)
Collapsing a block unmounted its diff editor and released the working-tree document, which with autosave off drops its unsaved edits. A loaded block now keeps its diff while collapsed, hidden.
2026-11-16 18:43:09 +08:00
l0ng-ai c871c164c1 fix(ui): editor hints and balloons stay inside the window (#3738)
An editor hint is the tooltip element itself, so the editor theme's .cm-tooltip max-width (same specificity, loaded later) replaced its 480 px limit and long messages ran past the window edge; the limit now applies to .cm-tooltip.cm-lsp-hint. The balloon stack keeps 16 px from the left as well and balloons narrow to fit, so they are no longer cut off in a narrow window.
2026-11-16 18:40:53 +08:00
l0ng-ai db65b12afe fix(app): Close Project asks about untitled buffers instead of dropping them (#3737)
The unsaved-changes guard left untitled buffers out because they follow the window into another project opened in place, but it also ran for Close Project, Disconnect from Remote Host, closing to Welcome and opening a remote project in place, where they don't follow, so they were dropped without a question. The guard now knows where the window goes; only another local project in place leaves them alone, otherwise they count, Save asks for their paths and a cancelled Save As keeps the project open.
2026-11-16 18:37:29 +08:00
l0ng-ai 0cc873565a fix(refactor): closing a Java refactoring dialog cancels it; identifiers in any script (#3734)
Closing Change Signature or Extract Interface while it was checking for conflicts left the check running, and its edit was applied (or its Problems Detected asked) after the dialog was gone; closing now cancels the request in flight and nothing is confirmed, previewed or applied afterwards. The identifier check was ASCII-only and rejected valid Java names in other scripts; it now follows Java's identifier rules.
2026-11-16 18:31:59 +08:00
l0ng-ai 7cc100367d fix(mcp): http_run_request sends the request the user approved (#3733)
The tool prepared the request to show its resolved URL in the confirmation, then prepared it again to send it, re-reading the environment files: changed in the meantime, they could send the private-environment headers to a destination the user never approved. ide_http::send now sends a prepared request as is, and the tool sends exactly the one it showed.
2026-11-16 18:30:06 +08:00
l0ng-ai 39c0f6676e fix(agents): side conversations never replay a mode that approves everything (#3731)
A side conversation's task config was moved to a mode that asks, but its session replayed the source task's choices unchanged, so one started from a Full Access / bypass-permissions task ran in that mode and wrote without asking. The replayed choices now drop values that approve everything and turn such a mode (including the agent's own starting mode) to one that asks; setting such a value in a side conversation is refused.
2026-11-16 18:27:22 +08:00
l0ng-ai f19d5dc3f9 fix(build): never wipe an artifact's chosen output folder (#3730)
Artifact layout deleted the whole output folder before copying, so an output folder set to the project folder (or one shared with other output) lost everything in it. A user-chosen folder is no longer cleared: the layout records the files it wrote (with the folder they were for) in the build cache and later removes only recorded files it no longer produces. The IDE's own staging folder is still laid out afresh.
2026-11-16 18:24:28 +08:00
LU XIANGRUIтаwildcatDownstairs 0a8df16941 fix(terminal): show URLs as links without hovering (#3720)
With Highlight hyperlinks on, terminal URLs only got their underline from xterm's link provider while hovered, so they looked like plain text. Visible URLs now get xterm decorations in the theme's link colour with an underline (viewport-only scan coalesced per frame, rebuilt on theme or setting changes, off in the alternate buffer), in the main and embedded terminals. Link hit ranges were computed from string offsets, so wide CJK characters before a link shifted its hover and click area; both now use cell columns.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 17:53:28 +08:00
Yann 6dcece3081 fix(agents): confirm Codex project trust before loading sessions (#3711)
Codex keeps its own project trust decision, so a project trusted in the IDE could still have its project-local .codex configuration (MCP servers, hooks, exec policies) disabled, and the Codex adapter dropped Codex's configWarning and warning notifications. Those warnings now reach the task, including ones sent before a session exists. When Codex reports the current project's .codex layer disabled, starting, resuming or forking a session first asks Trust Project in Codex / Keep Untrusted; only an explicit confirmation writes that project's trust entry through Codex's config API (with the user layer's version), Full Access doesn't bypass the question and side chats deny it.

Co-authored-by: YannABC <[email protected]>
2026-11-16 17:51:05 +08:00
Nc 5c59566897 fix(editor): autosave editable diff views when focus leaves (#3724)
Attached document views (the editable side of a diff, file previews) synchronized the buffer but never saved on blur, so an edit in a diff stayed unsaved on disk (e.g. removing an added final newline left Git reporting the file modified while the diff showed identical content). Attached views now autosave on blur with files.autoSave, sharing the regular editor's popup-aware delay (saveOnBlur), skip read-only views and cancel a pending save when destroyed or released.

Co-authored-by: qiany-sui <[email protected]>
2026-11-16 17:45:28 +08:00
SunZhiQiang 6b3edb6cf5 fix(agents): name the default model entry by the model it resolves to (#3716)
The Claude CLI's initialize response carries resolvedModel for the default entry, but Settings::from_cli kept only its display name, so the model picker and the composer chip showed "Default (recommended)" without the model that runs. The default entry is now named "Default (<resolved model>)"; without a resolved model it keeps the agent's own name.

Co-authored-by: panda-student <[email protected]>
2026-11-16 17:42:51 +08:00
l0ng-ai e598936529 fix(editor): gutter icons move with their line's text on Enter (#3726)
Line-start gutter icons were mapped with the default association, so Enter at the start of their line left them on the new empty line until each source placed them again. They now move with their line's text at once (mapLineStart), and HTTP endpoint markers are mapped through edits instead of cleared. Sibling of #3722.
2026-11-16 17:40:40 +08:00
l0ng-ai 8b7318e59a fix(vcs): merge toolbar and footer buttons act on their own merge editor (#3725)
The merge editor's toolbar and footer buttons ran global actions that only apply to the focused merge editor, so they did nothing while it lacked focus (e.g. right after opening). Each button now runs its command on its own merge editor; Previous/Next Change are disabled once no unresolved change is left.
2026-11-16 17:37:57 +08:00
LU XIANGRUIтаwildcatDownstairs faa9a91953 fix(editor): keep the gutter icon area's width while editing (#3722)
After an edit each icon source places its icons again on its own schedule (run icons before the language server's inheritance icons, plugin line markers cleared and refilled), so a line's icons briefly part and the shared icon area narrowed and widened again, shifting the code. The area now widens at once but narrows only after the text and the icon count stayed unchanged for 2 seconds, and its width follows the line with the most icons in the whole file.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 17:35:47 +08:00
l0ng-ai c805173467 fix(appearance): soften file colors on editor tabs and keep their hover feedback
Editor tabs tinted by File Colors used the data source tint strength (22%),
so they looked much stronger than the same file in the project view. They now
use --file-tint-strength like the project view, which drops from 14% to 9%,
and a tinted tab still shows the hover background on hover.
2026-11-16 16:28:06 +08:00
langxpтаkradme 94b72c271a fix(agents): restore native Codex slash commands (#3705)
After Codex moved from codex-acp to the native app-server driver, the composer kept the dynamic skills but lost the 11 builtin commands the adapter provided, and typing one sent it to the model as a prompt. The native adapter now owns a typed command table (/plan, /mcp, /skills, /status, /review, /review-branch, /review-commit, /compact, /goal, /rename, /logout), merged with skills/list, and routes each to its app-server operation (thread/compact/start, review/start, thread/goal/*, thread/name/set, config/mcpServer/reload, account/logout) or answers locally; /plan switches the collaboration mode, also offered in the config picker.

Co-authored-by: kradme <[email protected]>
2026-11-16 16:16:05 +08:00
misswellтаmisswell 610d68ee41 fix(java): go to implementation lands on the method in dependency classes (#3706)
jdtls answers textDocument/implementation for an implementation in a dependency at 0:0 of the decompiled class file (the search match has no source offset), so the gutter and Go to Implementation opened the class instead of the method. java-usages 1.15.0 adds openidea.java.implementationLocations, which finds the overriding method with MethodOverrideTester and returns its decompiled declaration; explicit Go to Implementation refines jdt 0:0 targets, and gutter markers resolve them lazily when opened (lsp_implementation_locations).

Co-authored-by: misswell <[email protected]>
2026-11-16 16:11:59 +08:00
l0ng-ai c6bd809d08 fix(run): Debug on a running configuration asks to stop it instead of starting another (#3710)
Debug skipped the single-instance check Run has, so each click started one more debug session of the same configuration. Debug now asks "not allowed to run in parallel" and stops the configuration's running and debugged instances first (unless it allows multiple instances); a click while the first Debug is still preparing is ignored. Run also counts the configuration's debug sessions as running instances.
2026-11-16 16:07:07 +08:00
l0ng-ai 401d66d850 fix(navigation): keep the keyboard in choosers and filter implementations by class (#3708)
A speed search that matched nothing replaced the focused list with a non-focusable empty state, so focus fell to the page and the chooser stopped taking keys. List now renders its empty state inside the focusable list (all list popups and choosers). Chooser rows whose targets share one name (a method's implementations, same-named declaration candidates) show the containing class as their text, so typing a class name filters them.
2026-11-16 16:03:30 +08:00
l0ng-ai 4561ae05b2 feat(refactor): Extract Interface for Java classes (#3707)
Refactor > Extract Interface… (also in Refactor This) opens a dialog for the class of the current Java file: interface name, package and members. jdtls checks the extraction and computes the edit, which creates the interface, makes the class implement it and uses it where possible; the new file opens afterwards.
2026-11-16 15:50:27 +08:00
l0ng-ai 34c81a61e4 feat(refactor): Java Move for classes, static members, nested types and instance methods (#3704)
Move… (F6, Refactor This) in Java now asks for the destination and moves:
a top-level class to another package (package declaration, imports and
references follow), a static member or nested type to another class (or a
nested type to a new file), an instance method to the class of one of its
fields or parameters. jdtls offers these only as client-side commands
(java.action.applyRefactoringCommand), now enabled with
moveRefactoringSupport; the IDE picks the destination from
java/getMoveDestinations or java/searchSymbols, then java/move checks the move
and computes the edit, confirmed in Problems Detected when it warns.

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

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

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

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

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

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

Closes #3608

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

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

Closes #3680

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Refs #901
2026-11-16 12:39:35 +08:00
450 змінених файлів з 29567 додано та 6355 видалено

No files matched your search

+7
Переглянути файл
@@ -0,0 +1,7 @@
# Link debug builds for the oldest system we support, so Launch Services
# accepts the bundle on macOS 11. Without this a newer SDK leaves
# LC_BUILD_VERSION.minos at 12.0 and the app is refused (-10825) before main
# can load a newer WebKit. An explicitly exported MACOSX_DEPLOYMENT_TARGET
# still wins: this is only the default for local builds and CI.
[env]
MACOSX_DEPLOYMENT_TARGET = "11.0"
Створено
+44 -44
Переглянути файл
@@ -4144,7 +4144,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
[[package]]
name = "ide-agent"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"blake3",
"dunce",
@@ -4169,7 +4169,7 @@ dependencies = [
[[package]]
name = "ide-analysis"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"ast-grep-core",
"ide-core",
@@ -4183,7 +4183,7 @@ dependencies = [
[[package]]
name = "ide-android"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"ide-core",
"serde",
@@ -4194,7 +4194,7 @@ dependencies = [
[[package]]
name = "ide-build"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"blake3",
"chardetng",
@@ -4212,7 +4212,7 @@ dependencies = [
[[package]]
name = "ide-cli"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"dirs 6.0.0",
"serde",
@@ -4226,7 +4226,7 @@ dependencies = [
[[package]]
name = "ide-clipboard"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"gtk",
"objc2 0.6.5",
@@ -4237,7 +4237,7 @@ dependencies = [
[[package]]
name = "ide-core"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"dunce",
"encoding_rs",
@@ -4254,7 +4254,7 @@ dependencies = [
[[package]]
name = "ide-coverage"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-run",
@@ -4268,7 +4268,7 @@ dependencies = [
[[package]]
name = "ide-dap"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"futures",
@@ -4297,7 +4297,7 @@ dependencies = [
[[package]]
name = "ide-db"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"bb8",
@@ -4333,7 +4333,7 @@ dependencies = [
[[package]]
name = "ide-docker"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"ide-core",
"serde",
@@ -4346,7 +4346,7 @@ dependencies = [
[[package]]
name = "ide-extension"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4367,7 +4367,7 @@ dependencies = [
[[package]]
name = "ide-fonts"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"objc2-core-foundation",
"objc2-core-text",
@@ -4379,7 +4379,7 @@ dependencies = [
[[package]]
name = "ide-github"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-vcs",
@@ -4392,7 +4392,7 @@ dependencies = [
[[package]]
name = "ide-heap"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"criterion",
"ide-core",
@@ -4410,7 +4410,7 @@ dependencies = [
[[package]]
name = "ide-host"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4481,7 +4481,7 @@ dependencies = [
[[package]]
name = "ide-http"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-vfs",
@@ -4500,7 +4500,7 @@ dependencies = [
[[package]]
name = "ide-index"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"blake3",
"criterion",
@@ -4522,7 +4522,7 @@ dependencies = [
[[package]]
name = "ide-jdwp"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"ide-jvm-inspect",
"proptest",
@@ -4534,7 +4534,7 @@ dependencies = [
[[package]]
name = "ide-jsonrpc"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"encoding_rs",
"futures",
@@ -4551,7 +4551,7 @@ dependencies = [
[[package]]
name = "ide-jvm-attach"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"libc",
"tempfile",
@@ -4560,7 +4560,7 @@ dependencies = [
[[package]]
name = "ide-jvm-inspect"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"futures",
"serde",
@@ -4571,7 +4571,7 @@ dependencies = [
[[package]]
name = "ide-language"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"blake3",
"criterion",
@@ -4629,7 +4629,7 @@ dependencies = [
[[package]]
name = "ide-lsp"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"dunce",
"encoding_rs",
@@ -4657,7 +4657,7 @@ dependencies = [
[[package]]
name = "ide-mcp"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"bytes",
"dunce",
@@ -4676,7 +4676,7 @@ dependencies = [
[[package]]
name = "ide-notebook"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"futures",
"ide-core",
@@ -4699,7 +4699,7 @@ dependencies = [
[[package]]
name = "ide-plugin"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"blake3",
"dunce",
@@ -4722,7 +4722,7 @@ dependencies = [
[[package]]
name = "ide-profiler"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-jvm-attach",
@@ -4736,7 +4736,7 @@ dependencies = [
[[package]]
name = "ide-remote"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"dunce",
"futures",
@@ -4756,7 +4756,7 @@ dependencies = [
[[package]]
name = "ide-run"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"dunce",
"encoding_rs",
@@ -4780,7 +4780,7 @@ dependencies = [
[[package]]
name = "ide-scaffold"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-tools",
@@ -4796,7 +4796,7 @@ dependencies = [
[[package]]
name = "ide-sdk"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"dunce",
"flate2",
@@ -4819,7 +4819,7 @@ dependencies = [
[[package]]
name = "ide-search"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"criterion",
"encoding_rs",
@@ -4840,7 +4840,7 @@ dependencies = [
[[package]]
name = "ide-spell"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"ide-core",
"parking_lot",
@@ -4853,7 +4853,7 @@ dependencies = [
[[package]]
name = "ide-ssh"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"dirs 6.0.0",
"flate2",
@@ -4878,7 +4878,7 @@ dependencies = [
[[package]]
name = "ide-syntax"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-language",
@@ -4893,7 +4893,7 @@ dependencies = [
[[package]]
name = "ide-terminal"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"ide-core",
"libc",
@@ -4906,7 +4906,7 @@ dependencies = [
[[package]]
name = "ide-text"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"criterion",
"ide-core",
@@ -4919,7 +4919,7 @@ dependencies = [
[[package]]
name = "ide-tools"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"flate2",
"hex",
@@ -4940,7 +4940,7 @@ dependencies = [
[[package]]
name = "ide-vcs"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"blake3",
"dunce",
@@ -4961,7 +4961,7 @@ dependencies = [
[[package]]
name = "ide-vfs"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"chardetng",
"dunce",
@@ -4987,7 +4987,7 @@ dependencies = [
[[package]]
name = "ide-web"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"dirs 6.0.0",
"ide-core",
@@ -5003,7 +5003,7 @@ dependencies = [
[[package]]
name = "ide-workspace"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"blake3",
"dunce",
@@ -6632,7 +6632,7 @@ dependencies = [
[[package]]
name = "openidea"
version = "0.1.45"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"blake3",
+1 -1
Переглянути файл
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
exclude = ["sdk", "plugins"]
[workspace.package]
version = "0.1.45"
version = "0.1.46"
edition = "2024"
rust-version = "1.96"
license = "Apache-2.0"
+1 -1
Переглянути файл
@@ -4,7 +4,7 @@
`src/ui/brands/*.svg` use the unmodified logo paths from
[Simple Icons](https://github.com/simple-icons/simple-icons), retrieved through
Iconify (`simple-icons:angular`, `simple-icons:astro`, `simple-icons:cplusplus`, `simple-icons:dart`, `simple-icons:django`, `simple-icons:dotnet`, `simple-icons:elixir`, `simple-icons:express`, `simple-icons:fastapi`, `simple-icons:flask`, `simple-icons:flutter`, `simple-icons:go`, `simple-icons:haskell`, `simple-icons:html5`, `simple-icons:kotlin`, `simple-icons:ktor`, `simple-icons:laravel`, `simple-icons:nestjs`, `simple-icons:nextdotjs`, `simple-icons:nodedotjs`, `simple-icons:nuxt`, `simple-icons:openjdk`, `simple-icons:phoenixframework`, `simple-icons:php`, `simple-icons:python`, `simple-icons:quarkus`, `simple-icons:ruby`, `simple-icons:rubyonrails`, `simple-icons:rust`, `simple-icons:scala`, `simple-icons:springboot`, `simple-icons:svelte`, `simple-icons:swift`, `simple-icons:symfony`, `simple-icons:vite`, `simple-icons:zig`) and filled with the brand colors (the standard icon grey for black logos). Licensed under [CC0 1.0 Universal](https://github.com/simple-icons/simple-icons/blob/develop/LICENSE.md).
Iconify (`simple-icons:angular`, `simple-icons:astro`, `simple-icons:cplusplus`, `simple-icons:dart`, `simple-icons:deepseek`, `simple-icons:django`, `simple-icons:dotnet`, `simple-icons:elixir`, `simple-icons:express`, `simple-icons:fastapi`, `simple-icons:flask`, `simple-icons:flutter`, `simple-icons:go`, `simple-icons:haskell`, `simple-icons:html5`, `simple-icons:kotlin`, `simple-icons:ktor`, `simple-icons:laravel`, `simple-icons:nestjs`, `simple-icons:nextdotjs`, `simple-icons:nodedotjs`, `simple-icons:nuxt`, `simple-icons:openjdk`, `simple-icons:phoenixframework`, `simple-icons:php`, `simple-icons:python`, `simple-icons:quarkus`, `simple-icons:ruby`, `simple-icons:rubyonrails`, `simple-icons:rust`, `simple-icons:scala`, `simple-icons:springboot`, `simple-icons:svelte`, `simple-icons:swift`, `simple-icons:symfony`, `simple-icons:vite`, `simple-icons:zig`) and filled with the brand colors (the standard icon grey for black logos). Licensed under [CC0 1.0 Universal](https://github.com/simple-icons/simple-icons/blob/develop/LICENSE.md).
## Project Lombok
+1
Переглянути файл
@@ -155,6 +155,7 @@ async fn a_task_runs_on_a_v2_agent_and_resumes_its_session() {
config: vec![AgentConfigChoice { id: "model".into(), value: "haiku".into() }],
isolation: Isolation::Local,
base: None,
..Default::default()
})
.await
.unwrap();
+23 -3
Переглянути файл
@@ -17,6 +17,8 @@
pub(crate) mod discover;
mod normalize;
pub(crate) use normalize::base64 as normalize_base64;
use ide_jsonrpc::{Handler, Peer, RpcError, codes};
use normalize::Normalizer;
use parking_lot::Mutex;
@@ -25,7 +27,7 @@ use serde::de::DeserializeOwned;
use serde_json::{Value, json};
use std::collections::HashMap;
use std::sync::Arc;
use std::sync::atomic::{AtomicU8, Ordering};
use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
use tokio::sync::oneshot;
/// ACP's error code for a request that needs the user to sign in.
@@ -160,9 +162,16 @@ impl Negotiated {
Self { generation: 2, capabilities, agent_info: response.get("info").cloned(), auth_methods, meta }
}
/// Whether a saved session can be reopened (`session/load` on v1, `session/resume` on v2).
/// Whether a saved session can be reopened: `loadSession`, or a v1 agent's
/// `sessionCapabilities.resume` (DeepSeek Harness), which stands in for it.
pub fn load_session(&self) -> bool {
self.capabilities.get("loadSession").and_then(Value::as_bool) == Some(true)
self.capabilities.get("loadSession").and_then(Value::as_bool) == Some(true) || self.session("resume")
}
/// Whether `session/load` must be sent as `session/resume`: a v1 agent that advertises
/// `sessionCapabilities.resume` instead of `loadSession` (DeepSeek Harness).
pub fn resume_instead_of_load(&self) -> bool {
self.capabilities.get("loadSession").and_then(Value::as_bool) != Some(true) && self.session("resume")
}
/// `promptCapabilities.<name>` (`image`, `audio`, `embeddedContext`).
@@ -203,6 +212,8 @@ pub(crate) struct Dialect {
inner: Arc<dyn Handler>,
/// 0 until `initialize` answers; then 1 or 2.
generation: AtomicU8,
/// Set by `initialize`: a v1 agent's `session/load` is sent as `session/resume`.
resume_load: AtomicBool,
normalizer: Mutex<Normalizer>,
/// Running v2 prompts, by session id.
turns: Mutex<HashMap<String, Turn>>,
@@ -220,6 +231,7 @@ impl Dialect {
Arc::new(Self {
inner,
generation: AtomicU8::new(0),
resume_load: AtomicBool::new(false),
normalizer: Mutex::new(Normalizer::default()),
turns: Mutex::new(HashMap::new()),
})
@@ -229,6 +241,10 @@ impl Dialect {
self.generation.load(Ordering::Acquire)
}
fn resume_load(&self) -> bool {
self.resume_load.load(Ordering::Acquire)
}
fn v2(&self) -> bool {
self.generation() == 2
}
@@ -378,6 +394,7 @@ impl Conn {
let response: Value = self.peer.request("initialize", initialize_params(client_info), None).await?;
let negotiated = Negotiated::from_initialize(&response);
self.dialect.generation.store(negotiated.generation, Ordering::Release);
self.dialect.resume_load.store(negotiated.resume_instead_of_load(), Ordering::Release);
Ok(negotiated)
}
@@ -391,6 +408,9 @@ impl Conn {
let params = serde_json::to_value(params).map_err(|e| RpcError::Protocol(e.to_string()))?;
let value = if self.dialect.v2() {
self.request_v2(method, params, cancel).await?
} else if method == "session/load" && self.dialect.resume_load() {
// Same request shape, without a replay and without v2's setup translation.
self.peer.request("session/resume", params, cancel).await?
} else {
self.peer.request(method, params, cancel).await?
};
+85
Переглянути файл
@@ -180,6 +180,7 @@ async fn discovery_reads_effort_and_fast_from_session_new_then_stops_the_agent()
fn a_v2_initialize_response_reads_as_v1_capabilities() {
let n = Negotiated::from_initialize(&result(TURN, 1));
assert_eq!(n.generation, 2);
assert!(!n.resume_instead_of_load(), "v2 maps `session/load` itself");
assert!(n.load_session());
assert!(n.prompt("image") && n.prompt("embeddedContext") && !n.prompt("audio"));
assert!(n.session("fork") && n.session("resume") && n.session("close") && n.session("delete"));
@@ -681,3 +682,87 @@ fn stdio_mcp_is_v1_baseline_and_negotiated_in_v2() {
.mcp_stdio()
);
}
/// A v1 agent that answers `initialize` with `init` and records every request it gets.
/// Keeps its own `Peer` so the duplex stays open while the client sends.
struct V1Agent {
init: Value,
peer: std::sync::OnceLock<Peer>,
requests: parking_lot::Mutex<Vec<(String, Value)>>,
}
impl Handler for V1Agent {
fn on_notification(&self, _: &str, _: Value) {}
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
self.requests.lock().push((method.to_owned(), params));
Ok(if method == "initialize" { self.init.clone() } else { json!({}) })
}
}
async fn connect_v1(agent: Arc<V1Agent>) -> (Conn, Negotiated) {
let (a, b) = tokio::io::duplex(1 << 20);
let (ar, aw) = tokio::io::split(a);
let (br, bw) = tokio::io::split(b);
let _ = agent.peer.set(Peer::connect_framed(br, bw, agent.clone(), Framing::Lines));
let dialect = Dialect::wrap(Arc::new(Recorder::default()));
let conn = Conn::new(Peer::connect_framed(ar, aw, dialect.clone(), Framing::Lines), dialect);
let n = conn.initialize(&json!({ "name": "OpenIDEA", "version": "0" })).await.unwrap();
assert_eq!((n.generation, conn.generation()), (1, 1));
(conn, n)
}
fn v1_agent(init: Value) -> Arc<V1Agent> {
Arc::new(V1Agent { init, peer: Default::default(), requests: Default::default() })
}
/// A v1 agent that advertises `sessionCapabilities.resume` instead of `loadSession`
/// (DeepSeek Harness) can reopen a saved session, but only through `session/resume`.
#[tokio::test(flavor = "multi_thread")]
async fn a_v1_agent_with_resume_instead_of_load_reopens_through_session_resume() {
let agent = v1_agent(json!({
"protocolVersion": 1,
"agentInfo": { "name": "deepseek-harness-acp", "version": "0.0.1" },
"agentCapabilities": { "sessionCapabilities": { "close": {}, "list": {}, "resume": {} } },
}));
let (conn, n) = connect_v1(agent.clone()).await;
assert!(n.load_session(), "a resume-only agent is reloadable");
assert!(n.resume_instead_of_load());
assert!(n.session("resume"));
let params = json!({ "sessionId": "s1", "cwd": "/p", "mcpServers": [] });
let _: Value = conn.request("session/load", params.clone(), None).await.unwrap();
let requests = agent.requests.lock().clone();
assert_eq!(requests.iter().map(|(m, _)| m.as_str()).collect::<Vec<_>>(), ["initialize", "session/resume"]);
assert_eq!(requests[1].1, params, "same request shape as `session/load`");
}
/// Every other v1 agent is untouched: `loadSession` still sends `session/load`, and an
/// agent advertising neither capability is not treated as loadable.
#[tokio::test(flavor = "multi_thread")]
async fn v1_agents_that_do_not_advertise_resume_keep_session_load() {
for (init, loadable) in [
(json!({ "protocolVersion": 1, "agentCapabilities": { "loadSession": true } }), true),
(json!({ "protocolVersion": 1, "agentCapabilities": { "loadSession": false } }), false),
(json!({ "protocolVersion": 1, "agentCapabilities": { "sessionCapabilities": { "resume": null } } }), false),
(json!({ "protocolVersion": 1 }), false),
] {
let agent = v1_agent(init);
let (conn, n) = connect_v1(agent.clone()).await;
assert_eq!(n.load_session(), loadable);
assert!(!n.resume_instead_of_load());
let _: Value = conn.request("session/load", json!({ "sessionId": "s1" }), None).await.unwrap();
let methods: Vec<String> = agent.requests.lock().iter().map(|(m, _)| m.clone()).collect();
assert_eq!(methods, ["initialize", "session/load"]);
}
// `loadSession: true` wins over a resume-only advertisement.
let agent = v1_agent(json!({
"protocolVersion": 1,
"agentCapabilities": { "loadSession": true, "sessionCapabilities": { "resume": {} } },
}));
let (conn, n) = connect_v1(agent.clone()).await;
assert!(n.load_session() && !n.resume_instead_of_load());
let _: Value = conn.request("session/load", json!({ "sessionId": "s1" }), None).await.unwrap();
let methods: Vec<String> = agent.requests.lock().iter().map(|(m, _)| m.clone()).collect();
assert_eq!(methods, ["initialize", "session/load"]);
}
+46
Переглянути файл
@@ -109,6 +109,7 @@ impl LaunchContext {
provider::Driver::Acp => b"acp",
provider::Driver::Codex => b"codex",
provider::Driver::Claude => b"claude",
provider::Driver::Copilot => b"copilot",
},
);
field(&mut hash, self.spec.command.as_bytes());
@@ -203,6 +204,14 @@ impl AgentCatalogs {
.unwrap_or_else(|| Self::fallback(shared, provider))
}
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
let key = Self::key(shared, provider);
let mut state = self.state.lock();
if state.entries.get(&key).is_some_and(|e| e.flight.is_none()) {
state.entries.remove(&key);
}
}
fn snapshot(&self, shared: &Shared, provider: &str, entry: &Entry) -> AgentModelCatalog {
let catalog = entry.catalog.clone().unwrap_or_else(|| Self::fallback(shared, provider));
AgentModelCatalog {
@@ -472,6 +481,43 @@ async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<
.collect(),
})
}
provider::Driver::Copilot => {
if shared.uses_copilot_acp_fallback(&spec) {
let acp_spec = native::copilot::acp_fallback_spec(&spec);
return acp::discover::run(shared, &acp_spec).await;
}
match native::copilot::discover(spec.clone(), shared.paths.project_root.clone()).await {
Ok(found) => Ok(Discovered {
commands: Some(config::commands_of(
&serde_json::json!({ "availableCommands": found.commands }),
&spec.id,
)),
config: config::options_of(&serde_json::json!({ "configOptions": found.options })),
levels: found
.per_model
.into_iter()
.map(|(model, opts)| {
let parsed = if opts.is_empty() {
Vec::new()
} else {
config::options_of(&serde_json::json!({ "configOptions": opts }))
};
(model, parsed)
})
.collect(),
}),
Err(err) if err.allow_acp_fallback => {
tracing::warn!(
"Copilot headless catalog discovery failed ({}); falling back to `copilot --acp`",
err.message
);
shared.mark_copilot_acp_fallback(&spec);
let acp_spec = native::copilot::acp_fallback_spec(&spec);
acp::discover::run(shared, &acp_spec).await
}
Err(err) => Err(err.message),
}
}
}
}
+12 -1
Переглянути файл
@@ -3,7 +3,7 @@
use crate::model::{
AgentCommand, AgentCommandSource, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit,
AgentUsage,
AgentModelPricing, AgentUsage,
};
use serde_json::{Value, json};
@@ -29,6 +29,7 @@ pub(crate) fn add_client_options(provider: &str, config: &mut Vec<AgentConfigOpt
description: Some("Show permission requests from Cursor".into()),
cost_category: None,
usage_multiplier: None,
pricing: None,
},
AgentConfigValue {
value: "bypass".into(),
@@ -36,6 +37,7 @@ pub(crate) fn add_client_options(provider: &str, config: &mut Vec<AgentConfigOpt
description: Some("Automatically approve tool requests in this conversation".into()),
cost_category: None,
usage_multiplier: None,
pricing: None,
},
],
});
@@ -288,6 +290,7 @@ fn legacy(
description: str_of(m, "description"),
cost_category: None,
usage_multiplier: None,
pricing: pricing_of(m),
value,
})
})
@@ -324,10 +327,18 @@ fn value_of(v: &Value) -> Option<AgentConfigValue> {
description: str_of(v, "description"),
cost_category,
usage_multiplier,
pricing: pricing_of(v),
value,
})
}
fn pricing_of(v: &Value) -> Option<Box<AgentModelPricing>> {
v.pointer("/_meta/pricing")
.or_else(|| v.get("pricing"))
.and_then(|p| serde_json::from_value(p.clone()).ok())
.map(Box::new)
}
fn str_of(v: &Value, key: &str) -> Option<String> {
v.get(key).and_then(Value::as_str).map(str::to_owned)
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+114 -6
Переглянути файл
@@ -45,17 +45,15 @@ pub struct AgentCapabilities {
pub steer: bool,
/// It reports its background tasks and stops them one by one.
pub background_tasks: bool,
/// The task runs read-only: it asks before anything, and requests that would change
/// the project are denied (a temporary side conversation).
pub read_only: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum Isolation {
/// A new git worktree on its own branch.
Worktree,
/// The project's own checkout.
#[default]
Local,
}
@@ -107,6 +105,9 @@ pub struct AgentTask {
// Boxed so that `AgentEvent::Task` stays within clippy's `large_enum_variant` bound on Windows.
#[serde(default)]
pub background: Box<Vec<AgentBackgroundTask>>,
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`), including `"openidea"`.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub mcp_overrides: BTreeMap<String, bool>,
}
/// A task the agent runs in the background while the conversation goes on.
@@ -132,6 +133,40 @@ pub struct AgentRetry {
pub error: Option<String>,
}
/// Token pricing (Credits per 1M tokens) and context window capacity for one tier.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentTokenPricing {
pub input: f64,
pub output: f64,
#[serde(default)]
#[specta(optional)]
pub cache_read: Option<f64>,
#[serde(default)]
#[specta(optional)]
pub cache_write: Option<f64>,
#[serde(default)]
#[specta(optional)]
pub context_tokens: Option<u32>,
}
/// Pricing and context-tier metadata attached to a model [`AgentConfigValue`].
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentModelPricing {
/// `"low"`, `"medium"`, `"high"`, or `"very_high"`.
#[serde(default)]
#[specta(optional)]
pub cost_tier: Option<String>,
/// Request-based billing multiplier (e.g. `1.0`, `0.33`, `3.0`), when applicable.
#[serde(default)]
#[specta(optional)]
pub multiplier: Option<f64>,
/// Token pricing keyed by context tier (`"default"`, `"long_context"`).
#[serde(default)]
pub tiers: BTreeMap<String, AgentTokenPricing>,
}
/// One value of a select-type session setting.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -147,6 +182,10 @@ pub struct AgentConfigValue {
#[serde(default)]
#[specta(optional)]
pub usage_multiplier: Option<String>,
/// Detailed per-tier token pricing from `_meta.pricing` when available.
#[serde(default)]
#[specta(optional)]
pub pricing: Option<Box<AgentModelPricing>>,
}
/// How a setting is changed.
@@ -554,7 +593,7 @@ pub struct AgentProbe {
pub error: Option<String>,
}
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct NewAgentTask {
/// Validated by the host; defaults to the window project root.
@@ -567,6 +606,9 @@ pub struct NewAgentTask {
pub isolation: Isolation,
/// Branch to start the worktree from; the current branch when `None`.
pub base: Option<String>,
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
#[serde(default)]
pub mcp_overrides: BTreeMap<String, bool>,
}
/// A file the task changed: against [`AgentTask::base_commit`], or against `HEAD` in the
@@ -638,7 +680,7 @@ pub struct AgentModelCatalog {
pub enum AgentEvent {
/// A task was created or its metadata changed.
Task {
task: AgentTask,
task: Box<AgentTask>,
},
Removed {
id: String,
@@ -718,6 +760,9 @@ pub struct McpServer {
/// Agent provider ids this server is enabled for; empty means enabled for all agents.
#[serde(default)]
pub agents: Vec<String>,
/// True when this Workspace server was added outside OpenIDEA and has not been approved yet.
#[serde(default)]
pub unapproved: bool,
}
/// Payload for creating or updating a user or workspace MCP server.
@@ -750,6 +795,69 @@ fn default_true() -> bool {
true
}
/// An external MCP configuration file discovered on disk (user CLI config or workspace file).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpExternalSource {
/// Stable source identifier (e.g. `"copilot-cli"`, `"jetbrains-air"`, `"claude-code"`, `"cursor"`, `"workspace-mcp"`, `"vscode-mcp"`).
pub id: String,
/// Human-readable source label (e.g. `"GitHub Copilot CLI"`).
pub label: String,
/// Absolute path of the discovered configuration file.
pub path: IpcPath,
/// Suggested target scope when importing this source into OpenIDEA settings.
pub suggested_scope: McpScope,
/// Agent provider ID this external CLI reads natively (`Some("copilot")`, `Some("claude")`, `Some("cursor")`, or `None`).
pub native_provider: Option<String>,
/// Servers found inside this external configuration file (values omitted for safety; imported directly on the host).
pub servers: Vec<McpDiscoveredServer>,
}
/// Summary of one server discovered inside an external MCP configuration file.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpDiscoveredServer {
pub name: String,
pub transport: McpTransport,
pub enabled: bool,
pub command: Option<String>,
pub args: Vec<String>,
pub url: Option<String>,
/// Environment variable names declared on this server (values stay on the host).
pub env_keys: Vec<String>,
/// HTTP header names declared on this server (values stay on the host).
pub header_keys: Vec<String>,
}
/// Selection of one server from an external MCP configuration source to import.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpImportSelection {
pub source_id: String,
pub name: String,
}
/// One tool advertised by an MCP server during `tools/list`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpToolSummary {
pub name: String,
pub description: Option<String>,
}
/// Result of testing/probing an MCP server (`initialize` + `tools/list`).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct McpProbeResult {
pub ok: bool,
pub server_name: Option<String>,
pub server_version: Option<String>,
pub protocol_version: Option<String>,
pub tools: Vec<McpToolSummary>,
pub duration_ms: u32,
pub error: Option<String>,
}
/// Payload for creating a custom ACP agent (always the ACP driver); the id
/// becomes the `<config>/agents/<id>.toml` file name.
#[derive(Clone, Debug, Deserialize, Type)]
+31 -11
Переглянути файл
@@ -170,6 +170,8 @@ struct Session {
id: String,
cwd: PathBuf,
mcp_config: Option<tempfile::TempPath>,
/// MCP servers switched off for this session (`--disallowedTools`), its own config's too.
mcp_off: Vec<String>,
shim: Weak<Shim>,
st: Mutex<State>,
/// Serializes (re)starting the process.
@@ -344,9 +346,10 @@ impl Shim {
cwd: PathBuf,
start: Start,
pending: bool,
mcp_config: Option<String>,
params: &Value,
) -> Arc<Session> {
let mcp_config = mcp_config.and_then(|json| match write_mcp_config(&json) {
let mcp_off = mcp_off(params);
let mcp_config = mcp_config(params).and_then(|json| match write_mcp_config(&json) {
Ok(path) => Some(path),
Err(e) => {
tracing::warn!("Claude Code session {id}: cannot write its MCP configuration: {e}");
@@ -356,6 +359,7 @@ impl Shim {
let session = Arc::new(Session {
id: id.to_owned(),
mcp_config,
mcp_off,
shim: Arc::downgrade(self),
st: Mutex::new(State {
proc: None,
@@ -411,13 +415,8 @@ impl Shim {
}
"session/new" => {
let id = new_uuid(false);
let session = self.add_session(
&id,
self.cwd_of(&params),
Start::New { id: id.clone() },
false,
mcp_config(&params),
);
let session =
self.add_session(&id, self.cwd_of(&params), Start::New { id: id.clone() }, false, &params);
rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
session.announce_commands();
Ok(json!({ "sessionId": id, "configOptions": session.st.lock().settings.options() }))
@@ -433,7 +432,7 @@ impl Shim {
None => return Err(invalid(format!("no Claude Code session {id} in {}", cwd.display()))),
};
let chain = self.base_chain(&cwd, &start).map_err(internal)?;
let session = self.add_session(id, cwd, start, pending, mcp_config(&params));
let session = self.add_session(id, cwd, start, pending, &params);
rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
if method == "session/load" {
session.replay(&chain);
@@ -459,7 +458,7 @@ impl Shim {
(start, st.settings.clone())
};
self.save_pending(&id, Some(&start));
let session = self.add_session(&id, source.cwd.clone(), start, true, mcp_config(&params));
let session = self.add_session(&id, source.cwd.clone(), start, true, &params);
session.st.lock().settings = settings;
let options = session.st.lock().settings.options();
Ok(json!({ "sessionId": id, "configOptions": options }))
@@ -666,6 +665,9 @@ impl Session {
if let Some(config) = &self.mcp_config {
args.extend(["--mcp-config".to_owned(), config.to_string_lossy().into_owned()]);
}
if !self.mcp_off.is_empty() {
args.extend(["--disallowedTools".to_owned(), self.mcp_off.join(",")]);
}
args.extend(start.args());
let launch =
Launch { program: shim.config.program.clone(), args, cwd: self.cwd.clone(), env: shim.config.env.clone() };
@@ -1497,6 +1499,24 @@ fn write_mcp_config(json: &str) -> std::io::Result<tempfile::TempPath> {
Ok(file.into_temp_path())
}
/// The servers switched off for the session (`_meta.openidea.mcpServersOff`) as Claude Code
/// permission rules that deny all of a server's tools (`mcp__<server>`), so a server of
/// Claude Code's own configuration stays off too.
fn mcp_off(params: &Value) -> Vec<String> {
params
.pointer("/_meta/openidea/mcpServersOff")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(Value::as_str)
.map(|name| {
let name: String =
name.chars().map(|c| if c.is_ascii_alphanumeric() || c == '_' || c == '-' { c } else { '_' }).collect();
format!("mcp__{name}")
})
.collect()
}
/// ACP `mcpServers` as Claude Code's `--mcp-config` JSON (`None` when there are none).
fn mcp_config(params: &Value) -> Option<String> {
let servers = params.get("mcpServers")?.as_array()?;
+22 -2
Переглянути файл
@@ -48,10 +48,17 @@ impl Settings {
.filter_map(|m| {
let s = |k: &str| m.get(k).and_then(Value::as_str).map(str::to_owned);
let value = s("value")?;
let resolved = s("resolvedModel");
// The default entry follows the account's default model, so "Default
// (recommended)" hides what actually runs: name the model it resolves to.
let name = match (value.as_str(), resolved.as_deref()) {
("default", Some(r)) if !r.is_empty() => format!("Default ({r})"),
_ => s("displayName").unwrap_or_else(|| value.clone()),
};
Some(Model {
name: s("displayName").unwrap_or_else(|| value.clone()),
name,
description: s("description"),
resolved: s("resolvedModel"),
resolved,
efforts: if m.get("supportsEffort").and_then(Value::as_bool) == Some(true) {
m.get("supportedEffortLevels")
.and_then(Value::as_array)
@@ -230,6 +237,19 @@ mod tests {
assert_eq!(s.model, "claude-x-1");
}
#[test]
fn the_default_entry_is_named_by_the_model_it_runs() {
let s = Settings::from_cli(&init(), &json!({"applied": {"model": "claude-sonnet-5-5"}}));
let names: Vec<_> = s.models.iter().map(|m| m.name.as_str()).collect();
assert_eq!(names, ["Default (claude-sonnet-5-5)", "Opus", "Haiku 4.5"]);
// Without a resolved model, the agent's own name stands.
let s = Settings::from_cli(
&json!({"models": [{"value": "default", "displayName": "Default (recommended)"}]}),
&json!({}),
);
assert_eq!(s.models[0].name, "Default (recommended)");
}
#[test]
fn options_follow_the_model() {
let mut s = Settings::from_cli(&init(), &json!({"applied": {"model": "claude-sonnet-5-5", "effort": "high"}}));
+7
Переглянути файл
@@ -1243,6 +1243,13 @@ async fn skipped_questions_have_no_answers() {
assert_eq!(cancelled, None);
}
#[test]
fn servers_switched_off_become_disallowed_tools() {
assert!(mcp_off(&json!({})).is_empty());
let off = mcp_off(&json!({ "_meta": { "openidea": { "mcpServersOff": ["github", "my server.v2"] } } }));
assert_eq!(off, ["mcp__github", "mcp__my_server_v2"]);
}
#[test]
fn mcp_servers_become_an_mcp_config() {
assert_eq!(mcp_config(&json!({ "mcpServers": [] })), None);
+155
Переглянути файл
@@ -0,0 +1,155 @@
//! Codex's built-in slash commands. `codex app-server` has no command-list API, so the
//! native adapter owns this stable compatibility table; skills stay dynamic via `skills/list`.
use serde_json::Value;
/// Menu metadata shared by agent_commands and the prompt dispatcher.
pub(crate) struct BuiltinCommandSpec {
pub name: &'static str,
pub description: &'static str,
pub hint: Option<&'static str>,
}
pub(crate) const BUILTIN_COMMANDS: &[BuiltinCommandSpec] = &[
BuiltinCommandSpec { name: "plan", description: "Turn plan mode on or off.", hint: None },
BuiltinCommandSpec {
name: "mcp",
description: "Show the status of the MCP servers, or reconnect them.",
hint: Some("[reconnect]"),
},
BuiltinCommandSpec { name: "skills", description: "List available skills.", hint: None },
BuiltinCommandSpec { name: "status", description: "Display session configuration and token usage.", hint: None },
BuiltinCommandSpec {
name: "review",
description: "Review uncommitted changes, or review with custom instructions.",
hint: Some("optional review instructions"),
},
BuiltinCommandSpec {
name: "review-branch",
description: "Review changes relative to a base branch.",
hint: Some("branch name"),
},
BuiltinCommandSpec { name: "review-commit", description: "Review a specific commit.", hint: Some("commit sha") },
BuiltinCommandSpec {
name: "compact",
description: "Summarize conversation to avoid hitting the context limit.",
hint: None,
},
BuiltinCommandSpec {
name: "goal",
description: "Set a goal to keep pursuing.",
hint: Some("[<objective>|clear|pause|resume]"),
},
BuiltinCommandSpec { name: "rename", description: "Rename the current session.", hint: Some("new name") },
BuiltinCommandSpec {
name: "logout",
description: "Sign out of Codex. This option is available when you are logged in via ChatGPT.",
hint: None,
},
];
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum BuiltinCommand {
Plan,
Mcp,
Skills,
Status,
Review,
ReviewBranch,
ReviewCommit,
Compact,
Goal,
Rename,
Logout,
}
impl BuiltinCommand {
fn from_name(name: &str) -> Option<Self> {
Some(match name {
"plan" => Self::Plan,
"mcp" => Self::Mcp,
"skills" => Self::Skills,
"status" => Self::Status,
"review" => Self::Review,
"review-branch" => Self::ReviewBranch,
"review-commit" => Self::ReviewCommit,
"compact" => Self::Compact,
"goal" => Self::Goal,
"rename" => Self::Rename,
"logout" => Self::Logout,
_ => return None,
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(super) struct ParsedCommand {
pub command: BuiltinCommand,
/// Everything after the command name, trimmed but otherwise unchanged.
pub rest: String,
}
impl ParsedCommand {
/// Commands that Codex completes as a turn. Missing review arguments stay local so the
/// adapter can print the command's usage without starting an unnecessary model request.
pub fn starts_turn(&self) -> bool {
matches!(self.command, BuiltinCommand::Compact | BuiltinCommand::Review)
|| (matches!(self.command, BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit)
&& !self.rest.is_empty())
}
}
/// A recognized Codex builtin at the start of the prompt. Unknown slash commands and
/// `$skill` invocations return `None`, so they continue through Codex as ordinary prompts.
pub(super) fn parse(prompt: &Value) -> Option<ParsedCommand> {
let text = prompt.as_array()?.first()?.get("text")?.as_str()?.trim();
let command_text = text.strip_prefix('/')?.trim();
let (name, rest) = command_text.split_once(char::is_whitespace).unwrap_or((command_text, ""));
let command = BuiltinCommand::from_name(&name.to_ascii_lowercase())?;
Some(ParsedCommand { command, rest: rest.trim().to_owned() })
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
fn text(value: &str) -> Value {
json!([{ "type": "text", "text": value }])
}
#[test]
fn every_builtin_is_registered_and_parsed() {
let expected = [
"plan",
"mcp",
"skills",
"status",
"review",
"review-branch",
"review-commit",
"compact",
"goal",
"rename",
"logout",
];
assert_eq!(BUILTIN_COMMANDS.iter().map(|c| c.name).collect::<Vec<_>>(), expected);
for name in expected {
assert!(parse(&text(&format!("/{name}"))).is_some(), "{name}");
}
}
#[test]
fn parsing_keeps_arguments_and_leaves_non_builtins_alone() {
let parsed = parse(&text(" /review-branch origin/main ")).unwrap();
assert_eq!(parsed.command, BuiltinCommand::ReviewBranch);
assert_eq!(parsed.rest, "origin/main");
assert!(parsed.starts_turn());
assert!(!parse(&text("/review-branch")).unwrap().starts_turn());
assert!(parse(&text("/$review check this")).is_none());
assert!(parse(&text("review")).is_none());
let prompt = json!([{ "type": "text", "text": "/compact" }, { "type": "image", "data": "AA==" }]);
assert_eq!(parse(&prompt).unwrap().command, BuiltinCommand::Compact);
}
}
+375 -21
Переглянути файл
@@ -2,7 +2,11 @@
//! translated to and from ACP. A codex thread is an ACP session; a subagent's thread is
//! a subagent session of the thread that spawned it.
mod commands;
mod translate;
mod trust;
pub(crate) use commands::BUILTIN_COMMANDS;
#[cfg(test)]
mod tests;
@@ -10,6 +14,8 @@ mod tests;
use super::Shim;
use crate::acp::AUTH_REQUIRED;
use crate::provider::ProviderSpec;
use crate::{AgentCommand, AgentCommandSource};
use commands::{BuiltinCommand, ParsedCommand};
use ide_jsonrpc::{Framing, Handler, Peer, RpcError, codes};
use parking_lot::Mutex;
use serde_json::{Value, json};
@@ -32,6 +38,19 @@ const EXIT_GRACE: Duration = Duration::from_millis(100);
const NAME_PROMPT: &str = "Name this conversation for a list of tasks: a short title of at most six words, in the \
language the user writes in. Reply with the title only, without quotes or a closing period.";
/// Slash-command metadata for provider discovery and sessions without an advertised list.
pub(crate) fn builtin_commands() -> Vec<AgentCommand> {
BUILTIN_COMMANDS
.iter()
.map(|command| AgentCommand {
name: command.name.to_owned(),
description: command.description.to_owned(),
hint: command.hint.map(str::to_owned),
source: AgentCommandSource::Command,
})
.collect()
}
pub(crate) fn connect(
spec: &ProviderSpec,
cwd: &Path,
@@ -183,6 +202,8 @@ struct State {
threads: HashMap<String, Thread>,
/// The last `account/rateLimits/updated` snapshot.
rate_limits: Option<Value>,
/// Project trust has been checked (and, when needed, asked about) on this connection.
trust_checked: HashSet<String>,
/// Codex exited.
gone: bool,
}
@@ -215,6 +236,8 @@ struct Thread {
early_cancel: Option<Instant>,
/// The latest agent message (a subagent's answer).
answer: String,
/// The latest `thread/tokenUsage/updated` payload, for the `/status` command.
token_usage: Option<Value>,
/// The thread has a name.
named: bool,
/// A name is being asked for.
@@ -320,6 +343,12 @@ impl CodexShim {
self.codex().request(method, params, None).await.map_err(from_codex)
}
fn warning(&self, message: impl Into<String>) {
if let Some(client) = self.client.get() {
let _ = client.notify(crate::WARNING_NOTIFICATION, json!({ "message": message.into() }));
}
}
async fn handle(&self, method: &str, params: Value) -> Result<Value, ResponseError> {
match method {
"initialize" => self.initialize().await,
@@ -403,6 +432,7 @@ impl CodexShim {
async fn new_session(&self, params: &Value) -> Result<Value, ResponseError> {
let models = self.models().await?;
self.prepare_project_trust(params).await;
let mut request = json!({ "cwd": params.get("cwd") });
if let Some(config) = translate::mcp_config(params) {
request["config"] = config;
@@ -420,6 +450,7 @@ impl CodexShim {
async fn load_session(&self, params: &Value) -> Result<Value, ResponseError> {
let id = str_param(params, "sessionId")?;
let models = self.models().await?;
self.prepare_project_trust(params).await;
let mut request = json!({ "threadId": id, "cwd": params.get("cwd") });
if let Some(config) = translate::mcp_config(params) {
request["config"] = config;
@@ -438,6 +469,7 @@ impl CodexShim {
async fn fork_session(&self, params: &Value) -> Result<Value, ResponseError> {
let source = str_param(params, "sessionId")?;
let models = self.models().await?;
self.prepare_project_trust(params).await;
let settings = self.state.lock().threads.get(source).and_then(|t| t.settings.clone());
let mut request = json!({ "threadId": source, "cwd": params.get("cwd") });
if let Some(config) = translate::mcp_config(params) {
@@ -471,11 +503,18 @@ impl CodexShim {
async fn prompt(&self, params: &Value) -> Result<Value, ResponseError> {
let session = str_param(params, "sessionId")?.to_owned();
let input = translate::user_input(params.get("prompt").unwrap_or(&Value::Null));
let prompt = params.get("prompt").unwrap_or(&Value::Null);
let command = commands::parse(prompt);
if let Some(command) = command.as_ref()
&& !command.starts_turn()
{
return self.local_command(&session, command).await;
}
let input = translate::user_input(prompt);
if input.is_empty() {
return Err(invalid("empty prompt"));
}
let models = self.models().await?;
let models = if command.is_none() { Some(self.models().await?) } else { None };
let (done, ended) = oneshot::channel();
let settings = {
let mut state = self.state.lock();
@@ -491,33 +530,213 @@ impl CodexShim {
t.error = None;
t.settings.clone()
};
let mut request = json!({ "threadId": session, "input": input, "summary": "auto" });
if let Some(s) = settings {
request["model"] = json!(s.model_slug(&models));
request["approvalPolicy"] = json!(s.mode.approval_policy());
request["sandboxPolicy"] = s.mode.sandbox_policy();
if let Some(effort) = &s.effort {
request["effort"] = json!(effort);
let started = match command.as_ref() {
Some(command) => match command.command {
BuiltinCommand::Compact => {
// Codex reports compaction as its own turn, using the same started/completed
// notifications that finish the pending session/prompt above.
self.call("thread/compact/start", json!({ "threadId": session })).await
}
BuiltinCommand::Review | BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit => {
self.call("review/start", json!({ "threadId": session, "target": review_target(command) })).await
}
_ => unreachable!("local commands return before a pending turn is created"),
},
None => {
let models = models.expect("ordinary prompts load the model catalog");
let mut request = json!({ "threadId": session, "input": input, "summary": "auto" });
if let Some(s) = &settings {
request["model"] = json!(s.model_slug(&models));
request["approvalPolicy"] = json!(s.mode.approval_policy());
request["sandboxPolicy"] = s.mode.sandbox_policy();
// Omit the default so older app-server versions keep accepting normal
// turns; selecting Plan opts into this newer request field.
if s.collaboration_mode == translate::PLAN_COLLABORATION_MODE
|| s.collaboration_mode_override.is_some()
{
request["collaborationMode"] = translate::collaboration_mode(s, &models);
}
if let Some(effort) = &s.effort {
request["effort"] = json!(effort);
}
}
self.call("turn/start", request).await
}
};
if let Ok(started) = &started
&& let Some(turn) = started.pointer("/turn/id").and_then(Value::as_str)
{
self.turn_known(&session, turn, false);
}
match self.call("turn/start", request).await {
Ok(started) => {
if let Some(turn) = started.pointer("/turn/id").and_then(Value::as_str) {
self.turn_known(&session, turn, false);
}
}
Err(e) => {
if let Some(t) = self.state.lock().threads.get_mut(&session) {
t.prompt = None;
}
return Err(e);
if started.is_ok()
&& command.is_none()
&& let Some(thread) = self.state.lock().threads.get_mut(&session)
&& let Some(settings) = thread.settings.as_mut()
{
// A Default override is needed only for the first turn that resets a resumed
// Plan thread; omitting it afterwards preserves compatibility with older Codex.
settings.collaboration_mode_override = None;
}
if let Err(e) = started {
if let Some(t) = self.state.lock().threads.get_mut(&session) {
t.prompt = None;
}
return Err(e);
}
let (turn, last_error) = ended.await.map_err(|_| error(codes::INTERNAL_ERROR, "Codex exited"))?;
let rate_limits = self.state.lock().rate_limits.clone();
stop_reason(&turn, last_error, rate_limits.as_ref())
}
/// Runs commands that codex-acp historically handled locally: configuration, status,
/// inventory, naming and account actions. They complete without starting a model turn.
async fn local_command(&self, session: &str, command: &ParsedCommand) -> Result<Value, ResponseError> {
let (settings, cwd, token_usage, rate_limits) = {
let state = self.state.lock();
if state.gone {
return Err(error(codes::INTERNAL_ERROR, "Codex exited"));
}
let thread = state.threads.get(session).ok_or_else(|| invalid(format!("no session {session}")))?;
if thread.prompt.is_some() || thread.turn.is_some() {
return Err(invalid("a turn is already running"));
}
(thread.settings.clone(), thread.cwd.clone(), thread.token_usage.clone(), state.rate_limits.clone())
};
match command.command {
BuiltinCommand::Plan => {
if !command.rest.is_empty() {
self.say(session, command_usage(BuiltinCommand::Plan));
return Ok(json!({ "stopReason": "end_turn" }));
}
let models = self.models().await?;
let options = {
let mut state = self.state.lock();
let thread =
state.threads.get_mut(session).ok_or_else(|| invalid(format!("no session {session}")))?;
let settings = thread.settings.as_mut().ok_or_else(|| invalid(format!("no session {session}")))?;
settings.collaboration_mode = if settings.collaboration_mode == translate::PLAN_COLLABORATION_MODE {
translate::DEFAULT_COLLABORATION_MODE.to_owned()
} else {
translate::PLAN_COLLABORATION_MODE.to_owned()
};
settings.collaboration_mode_override = Some(settings.collaboration_mode.clone());
translate::config_options(&models, settings)
};
self.emit(session, json!({ "sessionUpdate": "config_option_update", "configOptions": options }));
}
BuiltinCommand::Status => {
let text =
status_text(session, settings.as_ref(), cwd.as_deref(), token_usage.as_ref(), rate_limits.as_ref());
self.say(session, text);
}
BuiltinCommand::Skills => {
let cwd = cwd.ok_or_else(|| invalid(format!("no session {session}")))?;
let found = self.call("skills/list", json!({ "cwds": [cwd] })).await?;
self.say(session, skills_text(&found));
}
BuiltinCommand::Mcp => match command.rest.as_str() {
"" => self.say(session, self.mcp_text(session).await?),
rest if rest.eq_ignore_ascii_case("reconnect") => {
self.call("config/mcpServer/reload", json!({})).await?;
self.say(session, self.mcp_text(session).await?);
}
_ => self.say(session, command_usage(BuiltinCommand::Mcp)),
},
BuiltinCommand::Rename => {
if command.rest.is_empty() {
self.say(session, command_usage(BuiltinCommand::Rename));
} else {
self.call("thread/name/set", json!({ "threadId": session, "name": command.rest })).await?;
// User commands are authoritative over the automatic title, so the manager
// must retain this title through later generated-name updates.
self.emit(
session,
json!({ "sessionUpdate": "session_info_update", "title": command.rest, "userNamed": true }),
);
}
}
BuiltinCommand::Logout => {
self.call("account/logout", Value::Null).await?;
self.say(session, "Logged out from Codex account.");
}
BuiltinCommand::Goal => self.goal_command(session, &command.rest).await?,
BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit if command.rest.is_empty() => {
self.say(session, command_usage(command.command));
}
BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit => {
return Err(invalid("review command did not start a turn"));
}
BuiltinCommand::Review | BuiltinCommand::Compact => {
return Err(invalid("turn command reached the local command path"));
}
}
Ok(json!({ "stopReason": "end_turn" }))
}
async fn goal_command(&self, session: &str, rest: &str) -> Result<(), ResponseError> {
let argument = rest.trim();
if argument.is_empty() {
self.say(session, command_usage(BuiltinCommand::Goal));
return Ok(());
}
match argument.to_ascii_lowercase().as_str() {
"clear" => {
self.call("thread/goal/clear", json!({ "threadId": session })).await?;
self.say(session, "Goal cleared.");
}
"pause" => {
let response = self
.call("thread/goal/set", json!({ "threadId": session, "status": "paused", "origin": "user" }))
.await?;
self.say(
session,
format!(
"Goal is now {}.",
response.pointer("/goal/status").and_then(Value::as_str).unwrap_or("paused")
),
);
}
"resume" => {
let response = self
.call("thread/goal/set", json!({ "threadId": session, "status": "active", "origin": "user" }))
.await?;
self.say(
session,
format!(
"Goal is now {}.",
response.pointer("/goal/status").and_then(Value::as_str).unwrap_or("active")
),
);
}
_ if argument.chars().count() > 4000 => {
self.say(session, "Command \"/goal\" requires goal text of at most 4000 characters.");
}
_ => {
let response = self
.call(
"thread/goal/set",
json!({ "threadId": session, "objective": argument, "status": "active", "origin": "user" }),
)
.await?;
let status = response.pointer("/goal/status").and_then(Value::as_str).unwrap_or("active");
self.say(session, format!("Goal set and {status}."));
}
}
Ok(())
}
async fn mcp_text(&self, session: &str) -> Result<String, ResponseError> {
let response = self
.call("mcpServerStatus/list", json!({ "threadId": session, "detail": "toolsAndAuthOnly", "limit": 100 }))
.await?;
Ok(mcp_text(&response))
}
fn say(&self, session: &str, text: impl AsRef<str>) {
self.emit(session, translate::chunk("agent_message_chunk", text.as_ref()));
}
async fn steer(&self, params: &Value) -> Result<Value, ResponseError> {
let session = str_param(params, "sessionId")?;
let turn = self.state.lock().threads.get(session).and_then(|t| t.turn.clone());
@@ -643,6 +862,25 @@ impl CodexShim {
fn on_codex_notification(self: &Arc<Self>, method: &str, params: &Value) {
let thread = params.get("threadId").and_then(Value::as_str).unwrap_or_default();
match method {
"configWarning" => {
let Some(summary) = params.get("summary").and_then(Value::as_str).filter(|s| !s.trim().is_empty())
else {
return;
};
let mut message = summary.trim().to_owned();
for key in ["details", "path"] {
if let Some(value) = params.get(key).and_then(Value::as_str).filter(|s| !s.trim().is_empty()) {
message.push_str("\n\n");
message.push_str(value.trim());
}
}
self.warning(message);
}
"warning" => {
if let Some(message) = params.get("message").and_then(Value::as_str).filter(|s| !s.trim().is_empty()) {
self.warning(message);
}
}
"skills/changed" => {
let shim = self.clone();
let sessions: Vec<String> = self
@@ -693,7 +931,12 @@ impl CodexShim {
t.last_chunk = None;
Some(translate::plan(params))
}),
"thread/tokenUsage/updated" => self.with_thread(thread, |_, _| translate::usage(params)),
"thread/tokenUsage/updated" => self.with_thread(thread, |t, _| {
if let Some(usage) = params.get("tokenUsage") {
t.token_usage = Some(usage.clone());
}
translate::usage(params)
}),
"thread/name/updated" => self.with_thread(thread, |t, _| {
let title = params.get("threadName").and_then(Value::as_str)?;
t.named = true;
@@ -1182,3 +1425,114 @@ fn stop_reason(turn: &Value, last_error: Option<Value>, rate_limits: Option<&Val
};
Ok(json!({ "stopReason": stop }))
}
/// The `review/start` target of a parsed review command.
fn review_target(command: &ParsedCommand) -> Value {
match command.command {
BuiltinCommand::Review if command.rest.is_empty() => json!({ "type": "uncommittedChanges" }),
BuiltinCommand::Review => json!({ "type": "custom", "instructions": command.rest }),
BuiltinCommand::ReviewBranch => json!({ "type": "baseBranch", "branch": command.rest }),
BuiltinCommand::ReviewCommit => json!({ "type": "commit", "sha": command.rest, "title": null }),
_ => unreachable!("only review commands have review targets"),
}
}
fn command_usage(command: BuiltinCommand) -> String {
match command {
BuiltinCommand::Plan => "Command \"/plan\" accepts no arguments.".to_owned(),
BuiltinCommand::Mcp => "Command \"/mcp\" accepts no arguments, or `reconnect`.".to_owned(),
BuiltinCommand::ReviewBranch => "Command \"/review-branch\" requires branch name.".to_owned(),
BuiltinCommand::ReviewCommit => "Command \"/review-commit\" requires commit sha.".to_owned(),
BuiltinCommand::Goal => "Command \"/goal\" requires [<objective>|clear|pause|resume].".to_owned(),
BuiltinCommand::Rename => "Command \"/rename\" requires new name.".to_owned(),
_ => "This command does not accept arguments.".to_owned(),
}
}
fn status_text(
session: &str,
settings: Option<&Settings>,
cwd: Option<&str>,
token_usage: Option<&Value>,
rate_limits: Option<&Value>,
) -> String {
let mut lines = Vec::new();
if let Some(settings) = settings {
lines.push(format!("**Model:** {}", settings.model));
lines.push(format!("**Collaboration:** {}", settings.collaboration_mode));
lines.push(format!("**Approval:** {}", settings.mode.approval_policy()));
lines.push(format!("**Sandbox:** {}", settings.mode.sandbox_mode()));
}
if let Some(cwd) = cwd {
lines.push(format!("**Directory:** {cwd}"));
}
lines.push(format!("**Session:** `{session}`"));
if let Some(usage) = token_usage {
let total = usage.pointer("/total/totalTokens").and_then(Value::as_u64);
let used = usage.pointer("/last/totalTokens").and_then(Value::as_u64);
let window = usage.get("modelContextWindow").and_then(Value::as_u64).filter(|window| *window > 0);
if let (Some(total), Some(used), Some(window)) = (total, used, window) {
let percent = (used.saturating_mul(100) + window / 2) / window;
lines.push(format!("**Token usage:** {total} total"));
lines.push(format!("**Context window:** {used} / {window} ({percent}%)"));
}
}
if let Some(primary) = rate_limits.and_then(|r| r.get("primary"))
&& let Some(used) = primary.get("usedPercent").and_then(Value::as_f64)
{
lines.push(format!("**Rate limit:** {used:.0}% used"));
}
lines.join(" \n")
}
fn skills_text(response: &Value) -> String {
let mut seen = HashSet::new();
let names: Vec<String> = response
.get("data")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|entry| entry.get("skills").and_then(Value::as_array))
.flatten()
.filter(|skill| skill.get("enabled") != Some(&Value::Bool(false)))
.filter_map(|skill| {
let name = skill.get("name").and_then(Value::as_str)?.trim();
if name.is_empty() || !seen.insert(name.to_owned()) {
return None;
}
let description = skill
.pointer("/interface/shortDescription")
.or_else(|| skill.get("shortDescription"))
.or_else(|| skill.get("description"))
.and_then(Value::as_str)
.unwrap_or_default();
Some(if description.is_empty() { name.to_owned() } else { format!("{name}: {description}") })
})
.collect();
if names.is_empty() {
"No skills configured.".to_owned()
} else {
format!("Available skills:\n{}", names.iter().map(|name| format!("- {name}")).collect::<Vec<_>>().join("\n"))
}
}
fn mcp_text(response: &Value) -> String {
let servers = response.get("data").and_then(Value::as_array).map(Vec::as_slice).unwrap_or_default();
if servers.is_empty() {
return "No MCP servers configured.".to_owned();
}
let lines = servers
.iter()
.filter_map(|server| {
let name = server.get("name").and_then(Value::as_str)?;
let status = server
.get("runtimeStatus")
.and_then(Value::as_str)
.or_else(|| server.get("authStatus").and_then(Value::as_str))
.unwrap_or("unknown");
let tools = server.get("tools").and_then(Value::as_object).map_or(0, serde_json::Map::len);
Some(format!("- {name}: {status}, {tools} tools"))
})
.collect::<Vec<_>>();
format!("MCP servers:\n{}", lines.join("\n"))
}
+419 -6
Переглянути файл
@@ -180,24 +180,38 @@ fn settings_follow_the_thread_and_the_models() {
let result = json!({"model": "big", "reasoningEffort": null, "approvalPolicy": "untrusted",
"sandbox": {"type": "workspaceWrite"}});
let mut s = Settings::of(&result, &models);
assert_eq!(s, Settings { model: "big".into(), effort: Some("low".into()), mode: Mode::Ask });
assert_eq!(
s,
Settings {
model: "big".into(),
effort: Some("low".into()),
mode: Mode::Ask,
collaboration_mode: DEFAULT_COLLABORATION_MODE.into(),
collaboration_mode_override: None,
}
);
let options = config_options(&models, &s);
let ids: Vec<&str> = options.as_array().unwrap().iter().map(|o| o["id"].as_str().unwrap()).collect();
assert_eq!(ids, [MODEL, EFFORT, MODE]);
assert_eq!(ids, [MODEL, EFFORT, MODE, COLLABORATION_MODE]);
assert_eq!(options[0]["options"].as_array().unwrap().len(), 2, "hidden models are left out");
assert_eq!(options[1]["category"], "thought_level");
assert_eq!(options[1]["options"][1]["name"], "Extra high");
assert_eq!(options[2]["currentValue"], "ask");
assert_eq!(options[3]["currentValue"], "default");
// A model without efforts drops the option; its slug is what codex gets.
s.set(&models, MODEL, "plain").unwrap();
assert_eq!((s.effort.as_deref(), s.model_slug(&models).as_str()), (None, "plain-slug"));
assert_eq!(config_options(&models, &s).as_array().unwrap().len(), 2);
assert_eq!(config_options(&models, &s).as_array().unwrap().len(), 3);
assert!(s.set(&models, EFFORT, "low").is_err());
assert!(s.set(&models, MODEL, "nope").is_err());
s.set(&models, MODE, "full-access").unwrap();
assert_eq!((s.mode.approval_policy(), s.mode.sandbox_policy()), ("never", json!({"type": "dangerFullAccess"})));
s.set(&models, COLLABORATION_MODE, PLAN_COLLABORATION_MODE).unwrap();
assert_eq!(collaboration_mode(&s, &models)["mode"], PLAN_COLLABORATION_MODE);
s.set(&models, COLLABORATION_MODE, DEFAULT_COLLABORATION_MODE).unwrap();
assert_eq!(collaboration_mode(&s, &models)["mode"], DEFAULT_COLLABORATION_MODE);
// A model codex runs that it doesn't list is still offered.
let s = Settings::of(&json!({"model": "custom", "sandbox": {"type": "readOnly"}}), &models);
@@ -226,6 +240,18 @@ fn prompts_become_user_input() {
);
}
#[test]
fn compact_is_recognized_with_completion_whitespace_and_attachments() {
// Completion leaves trailing whitespace and images can remain in the prompt. The first
// text block still names the command; unknown slash-shaped text continues normally.
assert_eq!(commands::parse(&text("/compact")).unwrap().command, BuiltinCommand::Compact);
assert_eq!(commands::parse(&text(" /compact \n")).unwrap().command, BuiltinCommand::Compact);
assert_eq!(commands::parse(&text("/compact now")).unwrap().rest, "now");
let prompt = json!([{"type": "text", "text": "/compact"}, {"type": "image", "data": "AA=="}]);
assert_eq!(commands::parse(&prompt).unwrap().command, BuiltinCommand::Compact);
assert!(commands::parse(&text("x/compact")).is_none());
}
#[test]
fn commands_are_titled_by_what_they_do() {
let cmd = |actions: Value| {
@@ -453,6 +479,7 @@ fn history_replays_turns() {
#[derive(Default)]
struct Client {
updates: Mutex<Vec<Value>>,
warnings: Mutex<Vec<Value>>,
asked: Mutex<Vec<Value>>,
/// Option ids to choose; `None` (or none left) cancels.
answers: Mutex<VecDeque<Option<&'static str>>>,
@@ -462,6 +489,8 @@ impl Handler for Client {
fn on_notification(&self, method: &str, params: Value) {
if method == "session/update" {
self.updates.lock().push(params);
} else if method == "_openidea/warning" {
self.warnings.lock().push(params);
}
}
@@ -527,6 +556,10 @@ async fn questions_share_one_card_and_keep_their_ids() {
#[derive(Clone, Copy, Debug, PartialEq)]
enum Scenario {
AuthFailure,
Command(&'static str),
Compact,
PlanThenPrompt,
PlanToggleThenPrompt,
Interrupt,
Resume,
Steer,
@@ -541,6 +574,10 @@ impl Scenario {
fn file(self) -> &'static str {
match self {
Scenario::AuthFailure => "auth_failure",
Scenario::Command(_) => "simple",
Scenario::Compact => "simple",
Scenario::PlanThenPrompt => "simple",
Scenario::PlanToggleThenPrompt => "simple",
Scenario::Interrupt => "interrupt",
Scenario::Resume => "resume",
Scenario::Steer => "steer",
@@ -598,6 +635,21 @@ async fn drive(scenario: Scenario, acp: &Peer, client: &Client, cwd: &str, threa
Scenario::AuthFailure | Scenario::Simple | Scenario::UsageLimit | Scenario::Subagent => {
out.push(("prompt", request(acp, "session/prompt", prompt("Reply with the single word: hi")).await));
}
Scenario::Compact => {
out.push(("prompt", request(acp, "session/prompt", prompt("/compact")).await));
}
Scenario::Command(command) => {
out.push(("prompt", request(acp, "session/prompt", prompt(command)).await));
}
Scenario::PlanThenPrompt => {
out.push(("plan", request(acp, "session/prompt", prompt("/plan")).await));
out.push(("prompt", request(acp, "session/prompt", prompt("Reply with the single word: hi")).await));
}
Scenario::PlanToggleThenPrompt => {
out.push(("plan", request(acp, "session/prompt", prompt("/plan")).await));
out.push(("default", request(acp, "session/prompt", prompt("/plan")).await));
out.push(("prompt", request(acp, "session/prompt", prompt("Reply with the single word: hi")).await));
}
Scenario::Interrupt => {
out.push(("mode", request(acp, "session/set_config_option", set(MODE, "read-only")).await));
let running = {
@@ -665,6 +717,37 @@ fn load(name: &str) -> Transcript {
Transcript { meta, frames }
}
/// The simple fixture through session setup. Local commands add only the app-server calls
/// they need after it; turn commands keep the fixture's turn notifications.
fn command_transcript(calls: &[(&'static str, Value)]) -> Transcript {
let mut transcript = load(Scenario::Simple.file());
let prompt = transcript
.frames
.iter()
.position(|(out, frame)| *out && frame["method"] == "turn/start")
.expect("the scenario starts a turn");
transcript.frames.truncate(prompt);
transcript.frames.push((true, json!({ "id": 4, "method": "skills/list" })));
transcript.frames.push((false, json!({ "id": 4, "result": { "data": [] } })));
for (index, (method, result)) in calls.iter().enumerate() {
let id = 10 + index;
transcript.frames.push((true, json!({ "id": id, "method": method })));
transcript.frames.push((false, json!({ "id": id, "result": result })));
}
transcript
}
fn turn_command_transcript(method: &str) -> Transcript {
let mut transcript = load(Scenario::Simple.file());
let start = transcript
.frames
.iter_mut()
.find(|(out, frame)| *out && frame["method"] == "turn/start")
.expect("the scenario starts a turn");
start.1["method"] = json!(method);
transcript
}
/// Plays codex: waits for each frame the shim should send, sends what codex sent.
/// Returns the frames the shim sent.
async fn play<R: AsyncRead + Unpin, W: AsyncWrite + Unpin>(
@@ -684,10 +767,10 @@ async fn play<R: AsyncRead + Unpin, W: AsyncWrite + Unpin>(
.unwrap()
.unwrap_or_else(|| panic!("the shim closed before {frame}"));
let actual: Value = serde_json::from_str(&line).unwrap();
// Older recordings predate skill discovery and thread naming; play an
// Older recordings predate config inspection, skill discovery and thread naming; play an
// unsupported server.
let method = actual["method"].as_str().unwrap_or_default();
if matches!(method, "skills/list" | "thread/sample") && frame["method"] != method {
if matches!(method, "config/read" | "skills/list" | "thread/sample") && frame["method"] != method {
let reply = json!({ "id": actual["id"], "error": { "code": -32601, "message": "unsupported" } });
write.write_all(format!("{reply}\n").as_bytes()).await.unwrap();
continue;
@@ -760,6 +843,149 @@ fn session_of(results: &Results, label: &str) -> String {
result(results, label).as_ref().unwrap()["sessionId"].as_str().unwrap().to_owned()
}
#[tokio::test(flavor = "multi_thread")]
async fn configuration_warnings_before_a_session_and_runtime_warnings_reach_the_client() {
let mut transcript = load(Scenario::Simple.file());
transcript.frames.insert(
0,
(
false,
json!({"method": "configWarning", "params": {
"summary": "Project-local config is disabled until the project is trusted.",
"details": "Update the project's trust setting.", "path": "/work/.codex/config.toml"
}}),
),
);
let at = transcript.frames.iter().position(|(out, f)| *out && f["method"] == "turn/start").unwrap();
transcript
.frames
.insert(at, (false, json!({"method": "warning", "params": {"message": "MCP server unavailable"}})));
let (results, client, frames, _, _codex) = replay_transcript(Scenario::Simple, transcript).await;
assert!(result(&results, "new").is_ok());
assert_eq!(
*client.warnings.lock(),
[
json!({"message": "Project-local config is disabled until the project is trusted.\n\nUpdate the project's trust setting.\n\n/work/.codex/config.toml"}),
json!({"message": "MCP server unavailable"}),
]
);
assert!(sent(&frames, "config/value/write").is_empty());
assert!(sent(&frames, "config/batchWrite").is_empty());
}
struct TrustServer {
cwd: String,
disabled: bool,
other_project: bool,
write_error: bool,
overridden: bool,
calls: Mutex<Vec<(String, Value)>>,
}
impl Handler for TrustServer {
fn on_notification(&self, _: &str, _: Value) {}
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
self.calls.lock().push((method.to_owned(), params));
match method {
"initialize" => Ok(json!({})),
"model/list" => Ok(json!({"data": []})),
"config/read" => {
let cwd =
if self.other_project { Path::new(&self.cwd).join("other") } else { PathBuf::from(&self.cwd) };
Ok(json!({"layers": [
{"name": {"type": "user", "profile": null}, "version": "original"},
{"name": {"type": "project", "dotCodexFolder": cwd.join(".codex")},
"disabledReason": self.disabled.then_some("Project config is disabled until trusted.")}
]}))
}
"config/value/write" if self.write_error => Err((-32001, "Config changed concurrently".into())),
"config/value/write" => Ok(json!({"status": if self.overridden {"okOverridden"} else {"ok"}})),
"thread/start" | "thread/resume" | "thread/fork" => {
Ok(json!({"thread": {"id": "s", "turns": []}, "cwd": self.cwd}))
}
"skills/list" => Ok(json!({"data": []})),
_ => Err((codes::METHOD_NOT_FOUND, method.to_owned())),
}
}
}
#[tokio::test(flavor = "multi_thread")]
async fn project_trust_is_confirmed_before_new_resumed_and_forked_sessions() {
for method in ["session/new", "session/load", "session/fork"] {
for (answer, disabled, other_project, write_error, overridden) in [
(Some("codex-trust-project"), true, false, false, false),
(Some("codex-keep-untrusted"), true, false, false, false),
(None, true, false, false, false),
(Some("codex-trust-project"), false, false, false, false),
(Some("codex-trust-project"), true, true, false, false),
(Some("codex-trust-project"), true, false, true, false),
(Some("codex-trust-project"), true, false, false, true),
] {
let tmp = tempfile::tempdir().unwrap();
let cwd = tmp.path().join("project.with.dots-项目").to_string_lossy().into_owned();
let server = Arc::new(TrustServer {
cwd: cwd.clone(),
disabled,
other_project,
write_error,
overridden,
calls: Mutex::default(),
});
let client = Arc::new(Client::default());
client.answers.lock().push_back(answer);
let (ours, theirs) = tokio::io::duplex(1 << 16);
let (read, write) = tokio::io::split(theirs);
let native = Peer::connect_framed(read, write, server.clone(), Framing::Lines);
let acp = attach(client.clone(), |events| {
let (read, write) = tokio::io::split(ours);
Ok(Peer::connect_framed(read, write, events, Framing::Lines))
})
.unwrap();
request(&acp, "initialize", json!({})).await.unwrap();
let params = json!({"cwd": cwd, "sessionId": "source", "mcpServers": []});
request(&acp, method, params.clone()).await.unwrap();
// The same connection must not ask repeatedly after a decline.
request(&acp, method, params).await.unwrap();
let approved = answer == Some("codex-trust-project") && disabled && !other_project;
{
let asked = client.asked.lock();
assert_eq!(asked.len(), usize::from(disabled && !other_project));
if let Some(permission) = asked.first() {
assert!(permission["toolCall"]["title"].as_str().unwrap().contains(&cwd));
assert_eq!(
permission["toolCall"]["kind"], "edit",
"side conversations must deny persistent trust changes"
);
assert_eq!(
permission["options"][0]["kind"], "allow_always",
"task bypass must not grant permanent trust"
);
}
let calls = server.calls.lock();
let writes: Vec<_> = calls.iter().filter(|(m, _)| m == "config/value/write").collect();
assert_eq!(writes.len(), usize::from(approved));
if let Some((_, write)) = writes.first() {
assert_eq!(
*write,
json!({"keyPath": format!("projects.{}.trust_level", json!(cwd)), "value": "trusted", "mergeStrategy": "replace", "expectedVersion": "original"})
);
let written = calls.iter().position(|(m, _)| m == "config/value/write").unwrap();
let started = calls.iter().position(|(m, _)| m.starts_with("thread/")).unwrap();
assert!(written < started, "the session must load config after the write");
}
}
// Drain notifications sent before the last response.
tokio::time::sleep(Duration::from_millis(20)).await;
if approved && (write_error || overridden) {
assert!(!client.warnings.lock().is_empty());
}
acp.kill();
native.kill();
}
}
}
#[tokio::test(flavor = "multi_thread")]
async fn auth_failure_names_auth() {
let (results, _client, frames, _) = replay(Scenario::AuthFailure).await;
@@ -771,7 +997,7 @@ async fn auth_failure_names_auth() {
let categories: Vec<&str> =
new["configOptions"].as_array().unwrap().iter().map(|o| o["category"].as_str().unwrap()).collect();
// The model the user's codex config names; codex doesn't list it, so its efforts are unknown.
assert_eq!(categories, ["model", "mode"]);
assert_eq!(categories, ["model", "mode", "collaboration_mode"]);
let model = new["configOptions"][0]["currentValue"].as_str().unwrap();
assert_eq!(model, "gpt-6-luna");
assert!(new["configOptions"][0]["options"].as_array().unwrap().iter().any(|o| o["value"] == model));
@@ -1011,6 +1237,7 @@ async fn settings_apply_to_the_next_turn() {
(starts[0]["params"]["model"].as_str(), starts[0]["params"]["effort"].as_str()),
(Some("gpt-5.6-luna"), Some("medium"))
);
assert!(starts[0]["params"].get("collaborationMode").is_none());
assert_eq!(
(starts[1]["params"]["model"].as_str(), starts[1]["params"]["effort"].as_str()),
(Some("gpt-5.5"), Some("high"))
@@ -1019,6 +1246,192 @@ async fn settings_apply_to_the_next_turn() {
assert_eq!(client.text(&session, "agent_message_chunk"), "oneOn it.\n\ntwo");
}
#[tokio::test(flavor = "multi_thread")]
async fn compact_is_started_through_its_app_server_method() {
// Play the ordinary-turn fixture with the request swapped: the notifications are the
// same, while this pins the user-visible command to `thread/compact/start`, not a prompt.
let mut transcript = load(Scenario::Simple.file());
let start = transcript
.frames
.iter_mut()
.find(|(out, frame)| *out && frame["method"] == "turn/start")
.expect("the scenario starts a turn");
start.1["method"] = json!("thread/compact/start");
let (results, _client, frames, _meta, _codex) = replay_transcript(Scenario::Compact, transcript).await;
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({"stopReason": "end_turn"}));
assert!(sent(&frames, "turn/start").is_empty());
assert_eq!(sent(&frames, "thread/compact/start").len(), 1);
}
#[tokio::test(flavor = "multi_thread")]
async fn review_commands_start_the_matching_review_target() {
for (prompt, target) in [
("/review", json!({ "type": "uncommittedChanges" })),
("/review focus on errors", json!({ "type": "custom", "instructions": "focus on errors" })),
("/review-branch origin/main", json!({ "type": "baseBranch", "branch": "origin/main" })),
("/review-commit abc123", json!({ "type": "commit", "sha": "abc123", "title": null })),
] {
let (results, _client, frames, _meta, _codex) =
replay_transcript(Scenario::Command(prompt), turn_command_transcript("review/start")).await;
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }), "{prompt}");
assert!(sent(&frames, "turn/start").is_empty(), "{prompt}");
assert_eq!(sent(&frames, "review/start")[0]["params"]["target"], target, "{prompt}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn plan_toggles_collaboration_mode_and_updates_the_composer() {
let (results, client, _frames, _meta, _codex) =
replay_transcript(Scenario::Command("/plan"), command_transcript(&[])).await;
let session = session_of(&results, "new");
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
let update = client.of(&session).into_iter().find(|u| u["sessionUpdate"] == "config_option_update").unwrap();
let plan =
update["configOptions"].as_array().unwrap().iter().find(|o| o["category"] == "collaboration_mode").unwrap();
assert_eq!(plan["currentValue"], "plan");
}
#[tokio::test(flavor = "multi_thread")]
async fn plan_applies_to_the_next_normal_turn() {
let (results, _client, frames, _meta, _codex) =
replay_transcript(Scenario::PlanThenPrompt, load(Scenario::Simple.file())).await;
assert_eq!(result(&results, "plan").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
let start = sent(&frames, "turn/start")[0];
assert_eq!(start["params"]["collaborationMode"]["mode"], "plan");
assert_eq!(start["params"]["collaborationMode"]["settings"]["model"], "gpt-5.6-luna");
}
#[tokio::test(flavor = "multi_thread")]
async fn toggling_plan_off_sends_an_explicit_default_once() {
let (results, _client, frames, _meta, _codex) =
replay_transcript(Scenario::PlanToggleThenPrompt, load(Scenario::Simple.file())).await;
assert_eq!(result(&results, "default").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
let start = sent(&frames, "turn/start")[0];
assert_eq!(start["params"]["collaborationMode"]["mode"], "default");
}
#[tokio::test(flavor = "multi_thread")]
async fn informational_commands_report_skills_mcp_and_status() {
let skills = json!({ "data": [{ "skills": [
{ "name": "review", "enabled": true, "description": "Review changes" },
{ "name": "hidden", "enabled": false, "description": "Hidden" }
] }] });
let servers = json!({ "data": [
{ "name": "github", "runtimeStatus": "connected", "authStatus": "oAuth", "tools": { "search": {} } },
{ "name": "docs", "runtimeStatus": "failed", "authStatus": "unknown", "tools": {} }
] });
for (prompt, method, response, expected) in [
("/skills", "skills/list", skills, "Available skills:\n- review: Review changes"),
(
"/mcp",
"mcpServerStatus/list",
servers,
"MCP servers:\n- github: connected, 1 tools\n- docs: failed, 0 tools",
),
("/status", "", Value::Null, "**Session:**"),
] {
let calls: &[(&str, Value)] = if method.is_empty() { &[] } else { &[(method, response)] };
let calls: Vec<(&'static str, Value)> = calls
.iter()
.map(|(method, response)| {
let method = match *method {
"skills/list" => "skills/list",
"mcpServerStatus/list" => "mcpServerStatus/list",
other => panic!("unexpected method {other}"),
};
(method, response.clone())
})
.collect();
let (results, client, _frames, _meta, _codex) =
replay_transcript(Scenario::Command(prompt), command_transcript(&calls)).await;
let session = session_of(&results, "new");
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
assert!(client.text(&session, "agent_message_chunk").contains(expected), "{prompt}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn rename_and_logout_use_their_app_server_actions() {
let (results, client, frames, _meta, _codex) = replay_transcript(
Scenario::Command("/rename Better name"),
command_transcript(&[("thread/name/set", json!({}))]),
)
.await;
let session = session_of(&results, "new");
assert_eq!(sent(&frames, "thread/name/set")[0]["params"], json!({ "threadId": session, "name": "Better name" }));
let info = client.of(&session).into_iter().find(|u| u["sessionUpdate"] == "session_info_update").unwrap();
assert_eq!((info["title"].as_str(), info["userNamed"].as_bool()), (Some("Better name"), Some(true)));
let (results, client, frames, _meta, _codex) =
replay_transcript(Scenario::Command("/logout"), command_transcript(&[("account/logout", json!({}))])).await;
let session = session_of(&results, "new");
assert_eq!(sent(&frames, "account/logout").len(), 1);
assert_eq!(client.text(&session, "agent_message_chunk"), "Logged out from Codex account.");
}
#[tokio::test(flavor = "multi_thread")]
async fn goal_commands_set_pause_resume_and_clear_through_app_server() {
for (prompt, method, params, result) in [
(
"/goal fix the failing tests",
"thread/goal/set",
json!({ "threadId": "s", "objective": "fix the failing tests", "status": "active", "origin": "user" }),
json!({ "goal": { "status": "active" } }),
),
(
"/goal pause",
"thread/goal/set",
json!({ "threadId": "s", "status": "paused", "origin": "user" }),
json!({ "goal": { "status": "paused" } }),
),
(
"/goal resume",
"thread/goal/set",
json!({ "threadId": "s", "status": "active", "origin": "user" }),
json!({ "goal": { "status": "active" } }),
),
("/goal clear", "thread/goal/clear", json!({ "threadId": "s" }), json!({ "cleared": true })),
] {
let (results, _client, frames, _meta, _codex) =
replay_transcript(Scenario::Command(prompt), command_transcript(&[(method, result)])).await;
let session = session_of(&results, "new");
let sent = sent(&frames, method);
assert_eq!(sent.len(), 1, "{prompt}");
let mut expected = params;
expected["threadId"] = json!(session);
assert_eq!(sent[0]["params"], expected, "{prompt}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn missing_review_arguments_print_usage_without_starting_a_turn() {
for prompt in ["/review-branch", "/review-commit", "/rename", "/goal"] {
let (results, client, frames, _meta, _codex) =
replay_transcript(Scenario::Command(prompt), command_transcript(&[])).await;
let session = session_of(&results, "new");
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
assert!(sent(&frames, "turn/start").is_empty());
assert!(client.text(&session, "agent_message_chunk").starts_with("Command \""), "{prompt}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn mcp_reconnect_reloads_before_reporting_status() {
let servers =
json!({ "data": [{ "name": "github", "runtimeStatus": "connected", "authStatus": "oAuth", "tools": {} }] });
let (results, client, frames, _meta, _codex) = replay_transcript(
Scenario::Command("/mcp reconnect"),
command_transcript(&[("config/mcpServer/reload", json!({})), ("mcpServerStatus/list", servers)]),
)
.await;
let session = session_of(&results, "new");
assert_eq!(sent(&frames, "config/mcpServer/reload").len(), 1);
assert_eq!(sent(&frames, "mcpServerStatus/list").len(), 1);
assert!(client.text(&session, "agent_message_chunk").contains("github: connected"));
}
#[tokio::test(flavor = "multi_thread")]
async fn approvals_are_asked_and_answered() {
let (results, client, frames, _) = replay(Scenario::Approvals).await;
+45
Переглянути файл
@@ -138,6 +138,12 @@ pub(super) struct Settings {
pub model: String,
pub effort: Option<String>,
pub mode: Mode,
/// Codex's Default/Plan collaboration mode. It is sent with each turn because it is
/// part of the turn contract rather than the sandbox permission mode above.
pub collaboration_mode: String,
/// A mode just chosen by the user, sent once even when it is Default so a resumed Plan
/// thread is explicitly reset. Subsequent default turns can omit the field again.
pub collaboration_mode_override: Option<String>,
}
impl Settings {
@@ -156,6 +162,12 @@ impl Settings {
result.get("approvalPolicy").unwrap_or(&Value::Null),
result.get("sandbox").unwrap_or(&Value::Null),
),
collaboration_mode: result
.pointer("/collaborationMode/mode")
.and_then(Value::as_str)
.unwrap_or(DEFAULT_COLLABORATION_MODE)
.to_owned(),
collaboration_mode_override: None,
};
s.fit_effort(models);
s
@@ -194,6 +206,13 @@ impl Settings {
self.effort = Some(value.to_owned());
}
MODE => self.mode = Mode::parse(value).ok_or_else(|| format!("unknown mode {value}"))?,
COLLABORATION_MODE => {
if !matches!(value, DEFAULT_COLLABORATION_MODE | PLAN_COLLABORATION_MODE) {
return Err(format!("unknown collaboration mode {value}"));
}
self.collaboration_mode = value.to_owned();
self.collaboration_mode_override = Some(value.to_owned());
}
_ => return Err(format!("unknown setting {option}")),
}
Ok(())
@@ -203,6 +222,9 @@ impl Settings {
pub(super) const MODEL: &str = "model";
pub(super) const EFFORT: &str = "reasoning_effort";
pub(super) const MODE: &str = "mode";
pub(super) const COLLABORATION_MODE: &str = "collaboration_mode";
pub(super) const DEFAULT_COLLABORATION_MODE: &str = "default";
pub(super) const PLAN_COLLABORATION_MODE: &str = "plan";
/// ACP `configOptions`: model, reasoning effort (for models that have it) and mode.
pub(super) fn config_options(models: &[ModelInfo], s: &Settings) -> Value {
@@ -235,9 +257,32 @@ pub(super) fn config_options(models: &[ModelInfo], s: &Settings) -> Value {
"id": MODE, "name": "Mode", "category": "mode", "type": "select", "currentValue": s.mode.id(),
"options": Mode::ALL.iter().map(|m| select_value(m.id(), m.name(), Some(m.description()))).collect::<Vec<_>>(),
}));
out.push(json!({
"id": COLLABORATION_MODE,
"name": "Collaboration mode",
"category": "collaboration_mode",
"type": "select",
"currentValue": s.collaboration_mode,
"options": [
select_value(DEFAULT_COLLABORATION_MODE, "Default", Some("Execute changes directly")),
select_value(PLAN_COLLABORATION_MODE, "Plan", Some("Plan before making changes")),
],
}));
Value::Array(out)
}
/// `turn/start.collaborationMode`: the preset plus the selected model settings.
pub(super) fn collaboration_mode(settings: &Settings, models: &[ModelInfo]) -> Value {
json!({
"mode": settings.collaboration_mode_override.as_deref().unwrap_or(&settings.collaboration_mode),
"settings": {
"model": settings.model_slug(models),
"reasoning_effort": settings.effort,
"developer_instructions": null,
},
})
}
fn select_value(value: &str, name: &str, description: Option<&str>) -> Value {
let mut v = json!({ "value": value, "name": name });
if let Some(d) = description {
+93
Переглянути файл
@@ -0,0 +1,93 @@
//! A project trusted by the IDE may still be untrusted by Codex. Ask before changing
//! Codex's own decision; only its config API writes the current project's trust entry.
use super::*;
fn disabled_project<'a>(config: &'a Value, cwd: &str) -> Option<&'a Value> {
let folder = Path::new(cwd).join(".codex");
config.get("layers")?.as_array()?.iter().find(|layer| {
layer.pointer("/name/type").and_then(Value::as_str) == Some("project")
&& layer
.pointer("/name/dotCodexFolder")
.and_then(Value::as_str)
.is_some_and(|path| Path::new(path) == folder)
&& layer.get("disabledReason").and_then(Value::as_str).is_some_and(|reason| !reason.trim().is_empty())
})
}
impl CodexShim {
pub(super) async fn prepare_project_trust(&self, params: &Value) {
let Some(cwd) = params.get("cwd").and_then(Value::as_str) else { return };
if !self.state.lock().trust_checked.insert(cwd.to_owned()) {
return;
}
// Old app-servers may not expose config layers. Their warnings still reach the UI.
let Ok(Ok(config)) = tokio::time::timeout(
Duration::from_secs(5),
self.call("config/read", json!({ "cwd": cwd, "includeLayers": true })),
)
.await
else {
return;
};
let Some(layer) = disabled_project(&config, cwd) else { return };
let Some(client) = self.client.get() else { return };
let title = format!(
"Trust project in Codex: {cwd}? This saves trust in your Codex user configuration and allows \
this project's MCP servers, hooks and exec policies to load."
);
let permission = json!({
"sessionId": params.get("sessionId").and_then(Value::as_str).unwrap_or_default(),
"toolCall": {
"toolCallId": format!("codex-project-trust:{cwd}"),
"title": title, "kind": "edit",
"rawInput": { "project": cwd },
},
"options": [
// Permanent trust must never be auto-approved by the task's allow-once bypass.
{ "optionId": "codex-trust-project", "name": "Trust Project in Codex", "kind": "allow_always" },
{ "optionId": "codex-keep-untrusted", "name": "Keep Untrusted", "kind": "reject_once" },
],
});
let answer: Result<Value, RpcError> = client.request("session/request_permission", permission, None).await;
let approved = answer.as_ref().is_ok_and(|answer| {
answer.pointer("/outcome/outcome").and_then(Value::as_str) == Some("selected")
&& answer.pointer("/outcome/optionId").and_then(Value::as_str) == Some("codex-trust-project")
});
if !approved {
if let Some(reason) = layer.get("disabledReason").and_then(Value::as_str) {
self.warning(reason);
}
return;
}
// Quote the path as one key segment: dots and Windows backslashes are literal.
let mut write = json!({
"keyPath": format!("projects.{}.trust_level", json!(cwd)),
"value": "trusted", "mergeStrategy": "replace",
});
if let Some(version) = config["layers"]
.as_array()
.and_then(|layers| {
layers.iter().find(|layer| {
layer.pointer("/name/type").and_then(Value::as_str) == Some("user")
&& layer.pointer("/name/profile").is_none_or(Value::is_null)
})
})
.and_then(|layer| layer.get("version"))
.filter(|version| version.is_string())
{
write["expectedVersion"] = version.clone();
}
match self.call("config/value/write", write).await {
Err(error) => self.warning(format!("Codex could not save trust for {cwd}: {}", error.message)),
Ok(reply) if reply["status"] == "okOverridden" => {
self.warning(format!(
"Codex saved trust for {cwd}, but a higher-priority configuration overrides it. \
Project configuration may remain disabled; check the Codex configuration or contact your administrator."
));
}
_ => {}
}
// start/resume/fork now load the updated config before creating the thread.
}
}
File diff suppressed because it is too large. Load diff
+841
Переглянути файл
@@ -0,0 +1,841 @@
//! Model catalog, effort levels, context-window tiers, and token pricing from
//! `copilot --headless --stdio` (`models.list` + `models.listTokenPriceUnits`).
use crate::model::{AgentModelPricing, AgentTokenPricing};
use serde_json::{Value, json};
use std::collections::{BTreeMap, HashMap};
pub(super) const MODEL: &str = "model";
pub(super) const EFFORT: &str = "reasoning_effort";
pub(super) const CONTEXT_TIER: &str = "context_tier";
pub(super) const MODE: &str = "mode";
pub(super) const ALLOW_ALL: &str = "allow_all";
const BATCH_TOKENS: f64 = 1_000_000.0;
const NANO_AIU_PER_CREDIT: f64 = 1_000_000_000.0;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Mode {
Agent,
Plan,
Autopilot,
}
impl Mode {
pub const ALL: [Mode; 3] = [Mode::Agent, Mode::Plan, Mode::Autopilot];
pub fn id(self) -> &'static str {
match self {
Mode::Agent => "agent",
Mode::Plan => "plan",
Mode::Autopilot => "autopilot",
}
}
pub fn wire(self) -> &'static str {
match self {
Mode::Agent => "interactive",
Mode::Plan => "plan",
Mode::Autopilot => "autopilot",
}
}
pub fn name(self) -> &'static str {
match self {
Mode::Agent => "Agent",
Mode::Plan => "Plan",
Mode::Autopilot => "Autopilot",
}
}
pub fn description(self) -> &'static str {
match self {
Mode::Agent => "Default agent mode for conversational interactions",
Mode::Plan => "Plan mode for creating and executing multi-step plans",
Mode::Autopilot => "Autonomous mode that enables allow-all and runs until task completion",
}
}
pub fn parse(value: &str) -> Option<Mode> {
let short = value.rsplit(['#', '/']).next().unwrap_or(value);
match short {
"agent" | "interactive" => Some(Mode::Agent),
"plan" => Some(Mode::Plan),
"autopilot" => Some(Mode::Autopilot),
_ => None,
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub(super) struct ContextTierChoice {
pub id: &'static str,
pub label: String,
pub tokens: u32,
pub description: &'static str,
}
#[derive(Clone, Debug, PartialEq)]
pub(super) struct ModelEntry {
pub id: String,
pub name: String,
pub description: Option<String>,
pub is_default: bool,
pub default_effort: Option<String>,
pub efforts: Vec<String>,
pub context_tiers: Vec<ContextTierChoice>,
pub default_context_tokens: Option<u32>,
pub max_context_tokens: Option<u32>,
pub pricing: Option<AgentModelPricing>,
}
impl ModelEntry {
/// Copilot's default reasoning effort for this model: user setting (`effortLevel`) when
/// supported, otherwise the model's `defaultReasoningEffort`, `"medium"`, or first listed.
pub fn default_effort<'a>(&'a self, user_default: Option<&str>) -> Option<&'a str> {
if let Some(wanted) = user_default
&& let Some(found) = self.efforts.iter().find(|e| e.as_str() == wanted)
{
return Some(found.as_str());
}
if let Some(model_def) = self.default_effort.as_deref()
&& let Some(found) = self.efforts.iter().find(|e| e.as_str() == model_def)
{
return Some(found.as_str());
}
self.efforts.iter().find(|e| e.as_str() == "medium").or_else(|| self.efforts.first()).map(String::as_str)
}
/// Copilot's default context-window tier for this model: user setting (`contextTier`) when
/// supported, otherwise `"default"` (`200K`), or first listed.
pub fn default_context_tier(&self, user_default: Option<&str>) -> Option<&'static str> {
if let Some(wanted) = user_default
&& let Some(found) = self.context_tiers.iter().find(|t| t.id == wanted)
{
return Some(found.id);
}
self.context_tiers.iter().find(|t| t.id == "default").or_else(|| self.context_tiers.first()).map(|t| t.id)
}
/// Active context window capacity in tokens for `tier`.
pub fn context_tokens(&self, tier: Option<&str>) -> Option<u32> {
if let Some(tier) = tier
&& let Some(found) = self.context_tiers.iter().find(|t| t.id == tier)
{
return Some(found.tokens);
}
self.context_tiers
.iter()
.find(|t| t.id == "default")
.or_else(|| self.context_tiers.first())
.map(|t| t.tokens)
.or(self.default_context_tokens)
.or(self.max_context_tokens)
}
}
/// Copilot's own configured defaults from `user.settings.get` (`~/.copilot/config.json`)
/// and optional CLI launch flags (`--model`, `--effort`, `--context`, `--allow-all`).
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub(super) struct UserDefaults {
pub model: Option<String>,
pub effort: Option<String>,
pub context_tier: Option<String>,
pub mode: Option<Mode>,
pub allow_all: Option<bool>,
}
impl UserDefaults {
pub fn from_rpc_and_args(settings_rpc: Option<&Value>, args: &[String]) -> Self {
let mut out = Self::default();
if let Some(res) = settings_rpc {
out.model = setting_str(res, "model");
out.effort = setting_str(res, "effortLevel").or_else(|| setting_str(res, "reasoningEffort"));
out.context_tier = setting_str(res, "contextTier");
out.mode = setting_str(res, "defaultMode").and_then(|m| Mode::parse(&m));
out.allow_all = setting_str(res, "defaultPermissionMode").and_then(|p| match p.as_str() {
"allow-all" | "allow_all" | "bypass" | "autopilot" => Some(true),
"manual" => Some(false),
_ => None,
});
}
let mut iter = args.iter().peekable();
while let Some(arg) = iter.next() {
let s = arg.as_str();
if s == "--allow-all" || s == "--yolo" {
out.allow_all = Some(true);
} else if let Some(v) = flag_val(s, "--model", &mut iter) {
out.model = Some(v);
} else if let Some(v) =
flag_val(s, "--effort", &mut iter).or_else(|| flag_val(s, "--reasoning-effort", &mut iter))
{
out.effort = Some(v);
} else if let Some(v) = flag_val(s, "--context", &mut iter) {
out.context_tier = Some(v);
}
}
out
}
}
fn setting_str(res: &Value, key: &str) -> Option<String> {
let settings = res.get("settings");
let raw = settings
.and_then(|s| s.get(key))
.and_then(|entry| entry.get("value").or(Some(entry)))
.or_else(|| res.get(key))?;
raw.as_str().map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned)
}
fn flag_val<'a>(
arg: &'a str,
flag: &str,
iter: &mut std::iter::Peekable<std::slice::Iter<'a, String>>,
) -> Option<String> {
if arg == flag {
return iter.next().map(|v| v.trim()).filter(|v| !v.is_empty()).map(str::to_owned);
}
let prefix = format!("{flag}=");
arg.strip_prefix(&prefix).map(str::trim).filter(|v| !v.is_empty()).map(str::to_owned)
}
#[derive(Clone, Debug, PartialEq)]
pub(super) struct Settings {
pub model: String,
pub effort: Option<String>,
pub context_tier: Option<String>,
pub mode: Mode,
pub allow_all: bool,
defaults: UserDefaults,
/// Explicit per-session user overrides; `None` means track Copilot's default for each model.
explicit_effort: Option<String>,
explicit_context_tier: Option<String>,
}
impl Settings {
pub fn new(models: &[ModelEntry], defaults: &UserDefaults) -> Self {
let model = defaults
.model
.as_deref()
.filter(|id| models.iter().any(|m| m.id == *id))
.or_else(|| models.iter().find(|m| m.is_default && m.id != "auto").map(|m| m.id.as_str()))
.or_else(|| models.iter().find(|m| m.id != "auto").map(|m| m.id.as_str()))
.or_else(|| models.first().map(|m| m.id.as_str()))
.unwrap_or("auto")
.to_owned();
let mode = defaults.mode.unwrap_or(Mode::Agent);
let allow_all = defaults.allow_all.unwrap_or(false) || mode == Mode::Autopilot;
let mut s = Self {
model,
effort: None,
context_tier: None,
mode,
allow_all,
defaults: defaults.clone(),
explicit_effort: None,
explicit_context_tier: None,
};
s.fit_to_model(models);
s
}
pub fn fit_to_model(&mut self, models: &[ModelEntry]) {
let Some(m) = models.iter().find(|m| m.id == self.model) else {
self.effort = None;
self.context_tier = None;
return;
};
self.effort = if m.efforts.is_empty() {
None
} else if let Some(wanted) = self.explicit_effort.as_deref().filter(|w| m.efforts.iter().any(|e| e == *w)) {
Some(wanted.to_owned())
} else {
m.default_effort(self.defaults.effort.as_deref()).map(str::to_owned)
};
self.context_tier = if m.context_tiers.is_empty() {
None
} else if let Some(wanted) =
self.explicit_context_tier.as_deref().filter(|w| m.context_tiers.iter().any(|t| t.id == *w))
{
Some(wanted.to_owned())
} else {
m.default_context_tier(self.defaults.context_tier.as_deref()).map(str::to_owned)
};
}
pub fn set(&mut self, models: &[ModelEntry], option: &str, value: &str) -> Result<(), String> {
match option {
MODEL => {
if !models.is_empty() && !models.iter().any(|m| m.id == value) && value != self.model {
return Err(format!("unknown model {value}"));
}
self.model = value.to_owned();
self.fit_to_model(models);
}
EFFORT => {
let m = models.iter().find(|m| m.id == self.model);
if !m.is_some_and(|m| m.efforts.iter().any(|e| e == value)) {
return Err(format!("{} has no reasoning effort {value}", self.model));
}
self.effort = Some(value.to_owned());
self.explicit_effort = Some(value.to_owned());
}
CONTEXT_TIER => {
let m = models.iter().find(|m| m.id == self.model);
if !m.is_some_and(|m| m.context_tiers.iter().any(|t| t.id == value)) {
return Err(format!("{} has no context tier {value}", self.model));
}
self.context_tier = Some(value.to_owned());
self.explicit_context_tier = Some(value.to_owned());
}
MODE => {
let mode = Mode::parse(value).ok_or_else(|| format!("unknown mode {value}"))?;
self.mode = mode;
if mode == Mode::Autopilot {
self.allow_all = true;
}
}
ALLOW_ALL => match value {
"on" | "true" => self.allow_all = true,
"off" | "false" => self.allow_all = false,
_ => return Err(format!("unknown allow_all value {value}")),
},
_ => return Err(format!("unknown setting {option}")),
}
Ok(())
}
pub fn active_context_tokens(&self, models: &[ModelEntry]) -> Option<u32> {
models.iter().find(|m| m.id == self.model).and_then(|m| m.context_tokens(self.context_tier.as_deref()))
}
}
/// Parses `models.list` + optional `models.listTokenPriceUnits` into catalog entries,
/// prepending `"auto"` when not already in the list.
pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<ModelEntry> {
let units = parse_price_units(price_units);
let raw = list
.get("models")
.or_else(|| list.get("data"))
.and_then(Value::as_array)
.map(Vec::as_slice)
.unwrap_or_default();
let mut out = Vec::new();
if !raw.iter().any(|m| str_of(m, "id") == Some("auto")) && !raw.is_empty() {
out.push(ModelEntry {
id: "auto".into(),
name: "Auto".into(),
description: Some("Let Copilot pick the best model".into()),
is_default: false,
default_effort: None,
efforts: Vec::new(),
context_tiers: Vec::new(),
default_context_tokens: None,
max_context_tokens: None,
pricing: None,
});
}
for m in raw {
if let Some(entry) = parse_model(m, &units) {
out.push(entry);
}
}
out
}
fn parse_model(m: &Value, units: &HashMap<String, PriceUnit>) -> Option<ModelEntry> {
let id = str_of(m, "id")?.to_owned();
if m.get("model_picker_enabled").and_then(Value::as_bool) == Some(false)
|| m.get("modelPickerEnabled").and_then(Value::as_bool) == Some(false)
{
return None;
}
let name = str_of(m, "name")
.or_else(|| str_of(m, "label"))
.or_else(|| str_of(m, "displayName"))
.filter(|s| !s.is_empty())
.unwrap_or(&id)
.to_owned();
let mut efforts = parse_efforts(m);
efforts.sort_by_key(|e| effort_rank(e));
efforts.dedup();
let limits = m.pointer("/capabilities/limits");
let max_prompt =
limits.and_then(|l| u32_of(l, "max_prompt_tokens").or_else(|| u32_of(l, "maxPromptTokens"))).filter(|&n| n > 0);
let max_window = limits
.and_then(|l| u32_of(l, "max_context_window_tokens").or_else(|| u32_of(l, "maxContextWindowTokens")))
.filter(|&n| n > 0);
let billing = m.get("billing");
let multiplier = billing.and_then(|b| f64_of(b, "multiplier"));
let raw_category = str_of(m, "modelPickerPriceCategory")
.or_else(|| str_of(m, "model_picker_price_category"))
.or_else(|| str_of(m, "priceCategory"))
.or_else(|| str_of(m, "price_category"))
.or_else(|| billing.and_then(|b| str_of(b, "priceCategory").or_else(|| str_of(b, "price_category"))));
let mut cost_tier = raw_category.and_then(normalize_cost_tier).map(str::to_owned);
let token_prices = billing.and_then(|b| b.get("token_prices").or_else(|| b.get("tokenPrices")));
let unit = units.get(&id).copied().unwrap_or(PriceUnit::Credits);
let (mut tiers, default_max, long_max) = parse_token_prices(token_prices, max_prompt, max_window, unit);
let mut context_tiers = Vec::new();
if let (Some(def_tokens), Some(long_tokens)) = (default_max, long_max)
&& def_tokens < long_tokens
{
context_tiers.push(ContextTierChoice {
id: "default",
label: format_tokens(def_tokens),
tokens: def_tokens,
description: "Default recommended context size",
});
context_tiers.push(ContextTierChoice {
id: "long_context",
label: format_tokens(long_tokens),
tokens: long_tokens,
description: "Maximum context window for longer sessions",
});
}
if cost_tier.is_none()
&& let Some(def) = tiers.get("default")
{
cost_tier = Some(infer_cost_tier(def.output).to_owned());
}
if let Some(def_tokens) = default_max.or(max_window).or(max_prompt)
&& let Some(def) = tiers.get_mut("default")
&& def.context_tokens.is_none()
{
def.context_tokens = Some(def_tokens);
}
if let Some(long_tokens) = long_max
&& let Some(long) = tiers.get_mut("long_context")
{
long.context_tokens = Some(long_tokens);
}
let pricing = (!tiers.is_empty() || cost_tier.is_some() || multiplier.is_some()).then_some(AgentModelPricing {
cost_tier,
multiplier,
tiers,
});
let description = multiplier
.map(|mul| {
let clean = round6(mul);
if (clean - clean.round()).abs() < 1e-6 {
format!("{}x", clean.round() as i64)
} else {
format!("{clean}x")
}
})
.or_else(|| str_of(m, "description").filter(|d| !d.is_empty() && *d != name).map(str::to_owned))
.or_else(|| (id == "auto").then(|| "Let Copilot pick the best model".to_owned()));
let is_default = m
.get("is_chat_default")
.or_else(|| m.get("isChatDefault"))
.or_else(|| m.get("isDefault"))
.and_then(Value::as_bool)
.unwrap_or(false);
let default_effort = str_of(m, "defaultReasoningEffort")
.or_else(|| str_of(m, "default_reasoning_effort"))
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned);
Some(ModelEntry {
id,
name,
description,
is_default,
default_effort,
efforts,
context_tiers,
default_context_tokens: default_max.or(max_window).or(max_prompt),
max_context_tokens: long_max.or(default_max).or(max_window).or(max_prompt),
pricing,
})
}
fn parse_efforts(m: &Value) -> Vec<String> {
let arr = m
.get("supportedReasoningEfforts")
.or_else(|| m.get("supported_reasoning_efforts"))
.or_else(|| m.pointer("/capabilities/supports/reasoning_effort"))
.or_else(|| m.pointer("/capabilities/supports/reasoningEffort"));
arr.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|v| v.as_str().filter(|s| !s.is_empty()).map(str::to_owned))
.collect()
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum PriceUnit {
Credits,
NanoAiu,
}
fn parse_price_units(raw: Option<&Value>) -> HashMap<String, PriceUnit> {
let mut out = HashMap::new();
let Some(raw) = raw else { return out };
let unit_of = |s: &str| {
if s.eq_ignore_ascii_case("nano_aiu") || s.eq_ignore_ascii_case("nanoaiu") || s.contains("nano") {
Some(PriceUnit::NanoAiu)
} else if s.to_ascii_lowercase().contains("credit") || s.eq_ignore_ascii_case("aic") {
Some(PriceUnit::Credits)
} else {
None
}
};
if let Some(map) =
raw.get("units").or_else(|| raw.get("priceUnits")).or_else(|| raw.get("models")).and_then(Value::as_object)
{
for (k, v) in map {
let u = v
.as_str()
.and_then(unit_of)
.or_else(|| v.get("unit").or_else(|| v.get("priceUnit")).and_then(Value::as_str).and_then(unit_of));
if let Some(u) = u {
out.insert(k.clone(), u);
}
}
}
for key in ["units", "priceUnits", "models"] {
if let Some(arr) = raw.get(key).and_then(Value::as_array) {
for item in arr {
let id = str_of(item, "modelId").or_else(|| str_of(item, "id"));
let u = str_of(item, "unit").or_else(|| str_of(item, "priceUnit")).and_then(unit_of);
if let (Some(id), Some(u)) = (id, u) {
out.insert(id.to_owned(), u);
}
}
}
}
out
}
fn parse_token_prices(
tp: Option<&Value>,
max_prompt: Option<u32>,
max_window: Option<u32>,
unit: PriceUnit,
) -> (BTreeMap<String, AgentTokenPricing>, Option<u32>, Option<u32>) {
let mut tiers = BTreeMap::new();
let Some(tp) = tp else {
return (tiers, None, max_window.or(max_prompt));
};
let batch =
f64_of(tp, "batch_size").or_else(|| f64_of(tp, "batchSize")).filter(|&b| b > 0.0).unwrap_or(BATCH_TOKENS);
let batch_scale = BATCH_TOKENS / batch;
let unit_scale = match unit {
PriceUnit::Credits => 1.0,
PriceUnit::NanoAiu => 1.0 / NANO_AIU_PER_CREDIT,
};
let scale = batch_scale * unit_scale;
let parse_tier = |node: &Value| -> Option<(AgentTokenPricing, Option<u32>)> {
let input = f64_of(node, "input_price").or_else(|| f64_of(node, "inputPrice"))?;
let output = f64_of(node, "output_price").or_else(|| f64_of(node, "outputPrice"))?;
// Guard against raw nano-AIU numbers even if `listTokenPriceUnits` was unavailable.
let effective = if unit == PriceUnit::Credits && (input >= 10_000_000.0 || output >= 10_000_000.0) {
scale / NANO_AIU_PER_CREDIT
} else {
scale
};
let cache_read = f64_of(node, "cache_read_price")
.or_else(|| f64_of(node, "cacheReadPrice"))
.or_else(|| f64_of(node, "cache_price"))
.or_else(|| f64_of(node, "cachePrice"))
.map(|v| round6(v * effective));
let cache_write = f64_of(node, "cache_write_price")
.or_else(|| f64_of(node, "cacheWritePrice"))
.map(|v| round6(v * effective));
let ctx = u32_of(node, "max_prompt_tokens")
.or_else(|| u32_of(node, "maxPromptTokens"))
.or_else(|| u32_of(node, "context_max"))
.or_else(|| u32_of(node, "contextMax"))
.filter(|&n| n > 0);
Some((
AgentTokenPricing {
input: round6(input * effective),
output: round6(output * effective),
cache_read,
cache_write,
context_tokens: ctx,
},
ctx,
))
};
// Both CAPI `/models` (`token_prices.default` + `token_prices.long_context`) and
// `copilot --headless` `models.list` (top-level `tokenPrices` + `tokenPrices.longContext`)
// share the same per-tier fields.
let def_node = tp.get("default").unwrap_or(tp);
let mut def_max = None;
if let Some((def_pricing, ctx)) = parse_tier(def_node) {
def_max = ctx;
tiers.insert("default".into(), def_pricing);
}
let long_node = tp.get("longContext").or_else(|| tp.get("long_context"));
let mut long_max = None;
if let Some(long_node) = long_node
&& let Some((mut long_pricing, ctx)) = parse_tier(long_node)
{
// Use the full context window capacity (`1_000_000`) when available so models whose
// `max_prompt_tokens` deduct `max_output_tokens` (e.g. `872_000` = `1M - 128K` on
// GPT-6 Sol, `936_000` = `1M - 64K` on Gemini 4 Carbon) display cleanly as `1M`.
let cap = match (ctx, max_window) {
(Some(c), Some(w)) if w >= c => Some(w),
(Some(c), _) => Some(c),
(None, w) => w.or(max_prompt),
};
long_max = cap;
long_pricing.context_tokens = cap;
tiers.insert("long_context".into(), long_pricing);
} else if let (Some(d), Some(p)) = (def_max, max_prompt)
&& d < p
&& let Some(def) = tiers.get("default").cloned()
{
let cap = max_window.filter(|&w| w >= p).unwrap_or(p);
long_max = Some(cap);
tiers.insert("long_context".into(), AgentTokenPricing { context_tokens: Some(cap), ..def });
}
(tiers, def_max, long_max)
}
fn normalize_cost_tier(raw: &str) -> Option<&'static str> {
match raw.trim().to_ascii_lowercase().as_str() {
"lightweight" | "low" => Some("low"),
"versatile" | "medium" | "standard" => Some("medium"),
"powerful" | "high" | "premium" => Some("high"),
"very_high" | "veryhigh" => Some("very_high"),
_ => None,
}
}
fn infer_cost_tier(output_credits_per_1m: f64) -> &'static str {
if output_credits_per_1m < 300.0 {
"low"
} else if output_credits_per_1m <= 1500.0 {
"medium"
} else {
"high"
}
}
/// Formats token capacity matching VS Code (`200000` → `"200K"`, `1000000` → `"1M"`).
pub(super) fn format_tokens(tokens: u32) -> String {
if tokens >= 1_000_000 {
let m = (f64::from(tokens) / 1_000_000.0 * 10.0).floor() / 10.0;
if (m - m.round()).abs() < 1e-6 { format!("{}M", m.round() as u32) } else { format!("{m:.1}M") }
} else if tokens > 900_000 {
"1M".into()
} else if tokens >= 1_000 {
format!("{}K", (f64::from(tokens) / 1_000.0).round() as u32)
} else {
tokens.to_string()
}
}
pub(super) fn effort_rank(effort: &str) -> u8 {
match effort {
"none" => 0,
"minimal" => 1,
"low" => 2,
"medium" => 3,
"high" => 4,
"xhigh" | "extra_high" => 5,
"max" => 6,
_ => 3,
}
}
pub(super) fn effort_label(effort: &str) -> (&'static str, &'static str) {
match effort {
"none" => ("None", "No additional reasoning; fastest responses."),
"minimal" => ("Minimal", "Least reasoning; fastest responses."),
"low" => ("Low", "Minimal reasoning before responding."),
"medium" => ("Medium", "Balanced reasoning and speed."),
"high" => ("High", "More thorough reasoning; slower responses."),
"xhigh" => ("Extra High", "Extensive reasoning for the hardest problems."),
"max" => ("Max", "Maximum reasoning; slowest but most thorough."),
_ => ("Default", ""),
}
}
/// ACP `configOptions` for the active session settings.
pub(super) fn config_options(models: &[ModelEntry], s: &Settings) -> Value {
let mut model_values: Vec<Value> = models.iter().map(model_option_value).collect();
if !s.model.is_empty() && !models.iter().any(|m| m.id == s.model) {
model_values.push(json!({ "value": s.model, "name": s.model }));
}
let mut out = Vec::new();
if !model_values.is_empty() {
out.push(json!({
"id": MODEL,
"name": "Model",
"category": "model",
"type": "select",
"currentValue": s.model,
"options": model_values,
}));
}
if let Some(m) = models.iter().find(|m| m.id == s.model) {
if let (Some(opt), Some(current)) = (effort_option_for(m, s.effort.as_deref()), s.effort.as_deref()) {
let mut o = opt;
o["currentValue"] = json!(current);
out.push(o);
}
if let (Some(opt), Some(current)) =
(context_tier_option_for(m, s.context_tier.as_deref()), s.context_tier.as_deref())
{
let mut o = opt;
o["currentValue"] = json!(current);
out.push(o);
}
}
out.push(json!({
"id": MODE,
"name": "Mode",
"category": "mode",
"type": "select",
"currentValue": s.mode.id(),
"options": Mode::ALL.iter().map(|m| json!({
"value": m.id(),
"name": m.name(),
"description": m.description(),
})).collect::<Vec<_>>(),
}));
out.push(json!({
"id": ALLOW_ALL,
"name": "Allow All",
"category": "permissions",
"type": "select",
"currentValue": if s.allow_all { "on" } else { "off" },
"options": [
{ "value": "on", "name": "On", "description": "Automatically approve all tool, path, and URL requests" },
{ "value": "off", "name": "Off", "description": "Require approval for tool, path, and URL requests" },
],
}));
Value::Array(out)
}
/// Per-model options (`[reasoning_effort?, context_tier?]`) for every model in `models`,
/// each defaulted to Copilot's own defaults (respecting `user.settings.get` / CLI flags).
pub(super) fn per_model_options(models: &[ModelEntry], defaults: &UserDefaults) -> Vec<(String, Vec<Value>)> {
models
.iter()
.map(|m| {
let mut opts = Vec::new();
if let Some(effort) = effort_option_for(m, m.default_effort(defaults.effort.as_deref())) {
opts.push(effort);
}
if let Some(ctx) = context_tier_option_for(m, m.default_context_tier(defaults.context_tier.as_deref())) {
opts.push(ctx);
}
(m.id.clone(), opts)
})
.collect()
}
fn model_option_value(m: &ModelEntry) -> Value {
let mut v = json!({ "value": m.id, "name": m.name });
if let Some(d) = &m.description {
v["description"] = json!(d);
}
if let Some(pricing) = &m.pricing {
let mut meta = serde_json::Map::new();
meta.insert("pricing".into(), json!(pricing));
if let Some(cat) = &pricing.cost_tier {
meta.insert("copilotPriceCategory".into(), json!(cat));
}
v["_meta"] = Value::Object(meta);
}
v
}
fn effort_option_for(m: &ModelEntry, current: Option<&str>) -> Option<Value> {
if m.efforts.len() <= 1 && m.efforts.is_empty() {
return None;
}
let default = current.filter(|c| m.efforts.iter().any(|e| e == *c)).or_else(|| m.default_effort(None))?;
let options: Vec<Value> = m
.efforts
.iter()
.map(|e| {
let (label, desc) = effort_label(e);
let name = if label == "Default" { capitalize(e) } else { label.to_owned() };
let mut item = json!({ "value": e, "name": name });
if !desc.is_empty() {
item["description"] = json!(desc);
}
item
})
.collect();
Some(json!({
"id": EFFORT,
"name": "Effort Level",
"description": "How much reasoning the model performs before responding. Higher effort can improve quality at the cost of speed.",
"category": "thought_level",
"type": "select",
"currentValue": default,
"options": options,
}))
}
fn context_tier_option_for(m: &ModelEntry, current: Option<&str>) -> Option<Value> {
if m.context_tiers.len() < 2 {
return None;
}
let default =
current.filter(|c| m.context_tiers.iter().any(|t| t.id == *c)).or_else(|| m.default_context_tier(None))?;
let options: Vec<Value> = m
.context_tiers
.iter()
.map(|t| {
json!({
"value": t.id,
"name": t.label,
"description": t.description,
})
})
.collect();
Some(json!({
"id": CONTEXT_TIER,
"name": "Context Size",
"description": "Context window size for this model.",
"category": "model_config",
"type": "select",
"currentValue": default,
"options": options,
}))
}
fn capitalize(s: &str) -> String {
let mut chars = s.chars();
chars.next().map(|c| c.to_uppercase().chain(chars).collect()).unwrap_or_default()
}
fn round6(n: f64) -> f64 {
let r = (n * 1_000_000.0).round() / 1_000_000.0;
if r == 0.0 { 0.0 } else { r }
}
fn str_of<'a>(v: &'a Value, key: &str) -> Option<&'a str> {
v.get(key).and_then(Value::as_str)
}
fn f64_of(v: &Value, key: &str) -> Option<f64> {
v.get(key).and_then(Value::as_f64).filter(|n| n.is_finite())
}
fn u32_of(v: &Value, key: &str) -> Option<u32> {
v.get(key).and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok())
}
+540
Переглянути файл
@@ -0,0 +1,540 @@
use super::models::{self, CONTEXT_TIER, EFFORT, MODEL, Mode, Settings, UserDefaults};
use super::{acp_args, acp_fallback_spec, attach, headless_args};
use crate::config;
use crate::provider::Driver;
use ide_jsonrpc::{Framing, Handler, Peer, codes};
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::sync::{Arc, OnceLock};
fn sample_models_list() -> Value {
json!({
"models": [
{
"id": "gemini-4-carbon",
"name": "Gemini 4 Carbon",
"priceCategory": "versatile",
"supportedReasoningEfforts": ["low", "medium", "high"],
"defaultReasoningEffort": "medium",
"capabilities": {
"supports": { "vision": true, "reasoningEffort": true },
"limits": {
"max_context_window_tokens": 1_000_000,
"max_prompt_tokens": 1_000_000,
"max_output_tokens": 64_000
}
},
"billing": {
"is_premium": true,
"multiplier": 1.0,
"token_prices": {
"batch_size": 1_000_000,
"preferred_tier": "default",
"default": {
"input_price": 100.0,
"output_price": 500.0,
"cache_read_price": 10.0,
"cache_write_price": 0.0,
"max_prompt_tokens": 200_000
},
"long_context": {
"input_price": 200.0,
"output_price": 1000.0,
"cache_read_price": 10.0,
"cache_write_price": 0.0,
"max_prompt_tokens": 1_000_000
}
}
}
},
{
"id": "gpt-5.6-sol",
"name": "GPT-5.6 Sol",
"priceCategory": "powerful",
"supportedReasoningEfforts": ["none", "low", "medium", "high", "xhigh", "max"],
"defaultReasoningEffort": "medium",
"capabilities": {
"supports": { "vision": true },
"limits": {
"max_context_window_tokens": 1_000_000,
"max_prompt_tokens": 1_000_000
}
},
"billing": {
"multiplier": 2.0,
"token_prices": {
"batch_size": 1_000_000,
"default": {
"input_price": 250_000_000_000.0,
"output_price": 1_500_000_000_000.0,
"cache_read_price": 25_000_000_000.0,
"cache_write_price": 0.0,
"max_prompt_tokens": 200_000
},
"long_context": {
"input_price": 500_000_000_000.0,
"output_price": 3_000_000_000_000.0,
"cache_read_price": 50_000_000_000.0,
"cache_write_price": 0.0,
"max_prompt_tokens": 1_000_000
}
}
}
},
{
"id": "mai-experimental-internal",
"name": "MAI Experimental",
"priceCategory": "lightweight",
"supportedReasoningEfforts": ["low", "medium"],
"capabilities": {
"limits": {
"max_context_window_tokens": 131_072,
"max_prompt_tokens": 131_072
}
},
"billing": {
"multiplier": 0.33
}
}
]
})
}
fn sample_price_units() -> Value {
json!({
"units": {
"gemini-4-carbon": "ai_credits",
"gpt-5.6-sol": "nano_aiu"
}
})
}
#[test]
fn parses_tiered_context_windows_pricing_and_uses_copilots_own_defaults() {
let catalog = models::parse_catalog(&sample_models_list(), Some(&sample_price_units()));
assert_eq!(
catalog.iter().map(|m| m.id.as_str()).collect::<Vec<_>>(),
["auto", "gemini-4-carbon", "gpt-5.6-sol", "mai-experimental-internal"]
);
let gemini = catalog.iter().find(|m| m.id == "gemini-4-carbon").unwrap();
assert_eq!(gemini.default_effort(None), Some("medium"));
assert_eq!(gemini.default_context_tier(None), Some("default"));
assert_eq!(
gemini.context_tiers.iter().map(|t| (t.id, t.label.as_str(), t.tokens)).collect::<Vec<_>>(),
[("default", "200K", 200_000), ("long_context", "1M", 1_000_000)]
);
let pricing = gemini.pricing.as_ref().unwrap();
assert_eq!(pricing.cost_tier.as_deref(), Some("medium"));
let long_p = &pricing.tiers["long_context"];
assert_eq!(
(long_p.input, long_p.output, long_p.cache_read, long_p.cache_write),
(200.0, 1000.0, Some(10.0), Some(0.0))
);
let def_p = &pricing.tiers["default"];
assert_eq!((def_p.input, def_p.output), (100.0, 500.0));
// Nano-AIU conversion (10^9 nano-AIU = 1 AI Credit).
let sol = catalog.iter().find(|m| m.id == "gpt-5.6-sol").unwrap();
assert_eq!(sol.default_effort(None), Some("medium"));
assert_eq!(sol.default_context_tier(None), Some("default"));
let sol_long = &sol.pricing.as_ref().unwrap().tiers["long_context"];
assert_eq!((sol_long.input, sol_long.output, sol_long.cache_read), (500.0, 3000.0, Some(50.0)));
// Single-window model has no multi-tier `context_tier` toggle.
let mai = catalog.iter().find(|m| m.id == "mai-experimental-internal").unwrap();
assert!(mai.context_tiers.is_empty());
assert_eq!(mai.default_effort(None), Some("medium"));
// Initial settings pick Copilot's own defaults (`medium` effort + `default` 200K context).
let mut s = Settings::new(&catalog, &UserDefaults::default());
assert_eq!(s.model, "gemini-4-carbon");
assert_eq!(s.effort.as_deref(), Some("medium"));
assert_eq!(s.context_tier.as_deref(), Some("default"));
assert_eq!(s.active_context_tokens(&catalog), Some(200_000));
// Switching to GPT-5.6 Sol without an explicit override stays on Copilot's defaults (`medium` + `default`).
s.set(&catalog, MODEL, "gpt-5.6-sol").unwrap();
assert_eq!(s.effort.as_deref(), Some("medium"));
assert_eq!(s.context_tier.as_deref(), Some("default"));
// Explicit session overrides (`xhigh` + `long_context`) stick across models that support them,
// and fall back to Copilot's default when switching to a model that does not.
s.set(&catalog, EFFORT, "xhigh").unwrap();
s.set(&catalog, CONTEXT_TIER, "long_context").unwrap();
assert_eq!(s.active_context_tokens(&catalog), Some(1_000_000));
s.set(&catalog, MODEL, "mai-experimental-internal").unwrap();
assert_eq!(s.effort.as_deref(), Some("medium"));
assert_eq!(s.context_tier, None);
// User settings from `user.settings.get` (1.0.112+ `{ value, default, isDefault }` shape) and CLI flags are honored.
let rpc_settings = json!({
"settings": {
"model": { "value": "gpt-5.6-sol", "default": null, "isDefault": false },
"effortLevel": { "value": "high", "default": null, "isDefault": false },
"contextTier": { "value": "long_context", "default": null, "isDefault": false },
"defaultMode": { "value": "plan", "default": "interactive", "isDefault": false },
}
});
let user_defs = UserDefaults::from_rpc_and_args(Some(&rpc_settings), &[]);
let configured = Settings::new(&catalog, &user_defs);
assert_eq!(configured.model, "gpt-5.6-sol");
assert_eq!(configured.effort.as_deref(), Some("high"));
assert_eq!(configured.context_tier.as_deref(), Some("long_context"));
assert_eq!(configured.mode, Mode::Plan);
// Per-model discovery options preserve pricing on `model` values and emit Copilot's defaults.
let raw = models::config_options(&catalog, &Settings::new(&catalog, &UserDefaults::default()));
let parsed = config::parse_options(&raw);
let model_opt = parsed.iter().find(|o| o.id == MODEL).unwrap();
let gem_val = model_opt.values.iter().find(|v| v.value == "gemini-4-carbon").unwrap();
assert_eq!(gem_val.pricing.as_ref().unwrap().cost_tier.as_deref(), Some("medium"));
assert_eq!(parsed.iter().find(|o| o.id == EFFORT).unwrap().current.as_deref(), Some("medium"));
assert_eq!(parsed.iter().find(|o| o.id == CONTEXT_TIER).unwrap().current.as_deref(), Some("default"));
}
#[test]
fn parses_headless_sdk_models_list_flat_token_prices_and_single_tier_models() {
let sdk_list = json!({
"models": [
{ "id": "auto", "name": "Auto" },
{
"id": "gemini-4-carbon",
"name": "Gemini 4 Carbon",
"modelPickerCategory": "powerful",
"modelPickerPriceCategory": "medium",
"supportedReasoningEfforts": ["low", "medium", "high"],
"capabilities": {
"limits": {
"max_context_window_tokens": 1_000_000,
"max_output_tokens": 64_000,
"max_prompt_tokens": 936_000
}
},
"billing": {
"tokenPrices": {
"inputPrice": 200,
"outputPrice": 1000,
"cachePrice": 10,
"cacheReadPrice": 10,
"cacheWritePrice": 0,
"contextMax": 200_000,
"maxPromptTokens": 200_000,
"batchSize": 1_000_000,
"longContext": {
"inputPrice": 200,
"outputPrice": 1000,
"cachePrice": 10,
"cacheReadPrice": 10,
"cacheWritePrice": 0,
"contextMax": 936_000,
"maxPromptTokens": 936_000
}
}
}
},
{
"id": "gpt-6-sol",
"name": "GPT-6 Sol",
"modelPickerPriceCategory": "medium",
"supportedReasoningEfforts": ["none", "low", "medium", "high", "xhigh", "max"],
"capabilities": {
"limits": {
"max_context_window_tokens": 1_000_000,
"max_output_tokens": 128_000,
"max_prompt_tokens": 872_000
}
},
"billing": {
"tokenPrices": {
"inputPrice": 250,
"outputPrice": 1250,
"contextMax": 272_000,
"maxPromptTokens": 272_000,
"batchSize": 1_000_000,
"longContext": {
"inputPrice": 500,
"outputPrice": 2500,
"contextMax": 872_000,
"maxPromptTokens": 872_000
}
}
}
},
{
"id": "gpt-5.3-codex",
"name": "GPT-5.3-Codex",
"modelPickerPriceCategory": "medium",
"supportedReasoningEfforts": ["low", "medium", "high", "xhigh"],
"capabilities": {
"limits": {
"max_context_window_tokens": 400_000,
"max_output_tokens": 128_000,
"max_prompt_tokens": 272_000
}
},
"billing": {
"tokenPrices": {
"inputPrice": 150,
"outputPrice": 600,
"contextMax": 272_000,
"maxPromptTokens": 272_000,
"batchSize": 1_000_000
}
}
}
]
});
let units = json!({
"units": [
{ "modelId": "gemini-4-carbon", "unit": "ai_credits" },
{ "modelId": "gpt-6-sol", "unit": "ai_credits" },
{ "modelId": "gpt-5.3-codex", "unit": "ai_credits" }
]
});
let catalog = models::parse_catalog(&sdk_list, Some(&units));
let carbon = catalog.iter().find(|m| m.id == "gemini-4-carbon").unwrap();
assert_eq!(
carbon.context_tiers.iter().map(|t| (t.id, t.label.as_str())).collect::<Vec<_>>(),
[("default", "200K"), ("long_context", "1M")]
);
let cp = carbon.pricing.as_ref().unwrap();
assert_eq!(cp.cost_tier.as_deref(), Some("medium"));
assert_eq!((cp.tiers["long_context"].input, cp.tiers["long_context"].output), (200.0, 1000.0));
let sol = catalog.iter().find(|m| m.id == "gpt-6-sol").unwrap();
assert_eq!(
sol.context_tiers.iter().map(|t| (t.id, t.label.as_str())).collect::<Vec<_>>(),
[("default", "272K"), ("long_context", "1M")]
);
let codex = catalog.iter().find(|m| m.id == "gpt-5.3-codex").unwrap();
assert!(codex.context_tiers.is_empty(), "single-tier model must not get a synthetic long_context tier");
}
#[test]
fn headless_and_acp_args_roundtrip_while_preserving_user_flags() {
assert_eq!(headless_args(&["--acp".into()]), vec!["--headless", "--no-auto-update", "--stdio"]);
assert_eq!(
headless_args(&["--log-level".into(), "debug".into(), "--headless".into(), "--stdio".into()]),
vec!["--log-level", "debug", "--headless", "--stdio", "--no-auto-update"]
);
assert_eq!(
acp_args(&[
"--headless".into(),
"--no-auto-update".into(),
"--stdio".into(),
"--context".into(),
"long_context".into()
]),
vec!["--acp", "--context", "long_context"]
);
let spec = crate::provider::builtin_spec("copilot").unwrap();
assert_eq!(spec.driver, Driver::Copilot);
let fallback = acp_fallback_spec(&spec);
assert_eq!(fallback.driver, Driver::Acp);
assert_eq!(fallback.args, vec!["--acp"]);
}
struct FakeCopilotServer {
peer: OnceLock<Peer>,
calls: Mutex<Vec<(String, Value)>>,
}
impl Handler for FakeCopilotServer {
fn on_notification(&self, _method: &str, _params: Value) {}
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
self.calls.lock().push((method.to_owned(), params.clone()));
match method {
"connect" => Ok(json!({ "ok": true, "protocolVersion": 3, "version": "1.0.112" })),
"models.list" => Ok(sample_models_list()),
"models.listTokenPriceUnits" => Ok(sample_price_units()),
"user.settings.get" => Ok(json!({ "settings": { "model": "gemini-4-carbon" } })),
"commands.list" => Ok(json!({ "commands": [{ "name": "compact", "description": "Compact context" }] })),
"skills.discover" => Ok(json!({ "skills": [] })),
"session.create" => Ok(json!({ "sessionId": "cop-sess-1" })),
"session.model.switchTo" => Ok(json!({ "modelId": params["modelId"] })),
"session.mode.set" => Ok(json!({})),
"session.permissions.setApproveAll" => {
assert!(params.get("enabled").and_then(Value::as_bool).is_some());
Ok(json!({ "success": true }))
}
"session.send" => {
if let Some(peer) = self.peer.get().cloned() {
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
std::thread::spawn(move || {
let _ = peer.notify(
"session.event",
json!({
"sessionId": sid,
"event": {
"id": "e1",
"type": "session.usage_info",
"data": { "currentTokens": 42_000, "tokenLimit": 1_000_000 }
}
}),
);
let _ = peer.notify(
"session.event",
json!({
"sessionId": sid,
"event": {
"id": "e2",
"type": "assistant.message_delta",
"data": { "messageId": "m1", "deltaContent": "Hello from 1M context!" }
}
}),
);
let _ = peer.notify(
"session.event",
json!({
"sessionId": sid,
"event": {
"id": "e3",
"type": "session.idle",
"data": { "aborted": false, "mode": "interactive" }
}
}),
);
});
}
Ok(json!({ "messageId": "msg-1" }))
}
_ => Err((codes::METHOD_NOT_FOUND, format!("unexpected {method}"))),
}
}
}
struct CollectUpdates(Mutex<Vec<Value>>);
impl Handler for CollectUpdates {
fn on_notification(&self, method: &str, params: Value) {
if method == "session/update" {
self.0.lock().push(params["update"].clone());
}
}
fn on_request(&self, method: &str, _params: Value) -> Result<Value, (i64, String)> {
Err((codes::METHOD_NOT_FOUND, format!("unexpected {method}")))
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_turns() {
let server = Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()) });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates.clone(), move |events| {
let (a, b) = tokio::io::duplex(1 << 16);
let (ar, aw) = tokio::io::split(a);
let (br, bw) = tokio::io::split(b);
let srv_peer = Peer::connect_framed(br, bw, server_clone.clone(), Framing::ContentLength);
let _ = server_clone.peer.set(srv_peer);
Ok(Peer::connect_framed(ar, aw, events, Framing::ContentLength))
})
.unwrap();
let init: Value = client.request("initialize", json!({}), None).await.unwrap();
assert_eq!(init["agentInfo"]["version"], "1.0.112");
assert_eq!(init["agentCapabilities"]["_meta"]["openidea"]["steer"], true);
let created: Value = client.request("session/new", json!({ "cwd": "/tmp", "mcpServers": [] }), None).await.unwrap();
assert_eq!(created["sessionId"], "cop-sess-1");
// Verify `session.create` sent `"trustWorkingDirectory": "session"`, `gemini-4-carbon`,
// and Copilot's own defaults (`reasoningEffort: "medium"` and `contextTier: "default"`).
{
let calls = server.calls.lock();
let (_, create_params) = calls.iter().find(|(m, _)| m == "session.create").unwrap();
assert_eq!(create_params["trustWorkingDirectory"], "session");
assert_eq!(create_params["model"], "gemini-4-carbon");
assert_eq!(create_params["reasoningEffort"], "medium");
assert_eq!(create_params["contextTier"], "default");
}
// Switch Context Size up to 1M (`long_context`) and Effort to `high` live via `session/set_config_option`.
let _: Value = client
.request(
"session/set_config_option",
json!({
"sessionId": "cop-sess-1",
"configId": "reasoning_effort",
"value": "high"
}),
None,
)
.await
.unwrap();
let switched_1m: Value = client
.request(
"session/set_config_option",
json!({
"sessionId": "cop-sess-1",
"configId": "context_tier",
"value": "long_context"
}),
None,
)
.await
.unwrap();
let opts_1m = config::options_of(&switched_1m);
assert_eq!(opts_1m.iter().find(|o| o.id == "context_tier").unwrap().current.as_deref(), Some("long_context"));
// Run a turn and verify 1M usage_update + streamed message chunk.
let prompt_res: Value = client
.request(
"session/prompt",
json!({
"sessionId": "cop-sess-1",
"prompt": [{ "type": "text", "text": "Explain architecture" }]
}),
None,
)
.await
.unwrap();
assert_eq!(prompt_res["stopReason"], "end_turn");
{
let seen = updates.0.lock();
assert!(
seen.iter().any(|u| u["sessionUpdate"] == "usage_update" && u["size"] == 1_000_000 && u["used"] == 42_000)
);
assert!(
seen.iter().any(
|u| u["sessionUpdate"] == "agent_message_chunk" && u["content"]["text"] == "Hello from 1M context!"
)
);
}
// Switch Context Size back down to 200K (`default`) live via `session/set_config_option`.
let switched: Value = client
.request(
"session/set_config_option",
json!({
"sessionId": "cop-sess-1",
"configId": "context_tier",
"value": "default"
}),
None,
)
.await
.unwrap();
let opts = config::options_of(&switched);
assert_eq!(opts.iter().find(|o| o.id == "context_tier").unwrap().current.as_deref(), Some("default"));
{
let calls = server.calls.lock();
let (_, sw_params) = calls.iter().rfind(|(m, _)| m == "session.model.switchTo").unwrap();
assert_eq!(sw_params["modelId"], "gemini-4-carbon");
assert_eq!(sw_params["reasoningEffort"], "high");
assert_eq!(sw_params["contextTier"], "default");
}
// Switching context_tier immediately emits an updated `usage_update` with `size: 200_000`.
assert!(
updates
.0
.lock()
.iter()
.any(|u| u["sessionUpdate"] == "usage_update" && u["size"] == 200_000 && u["used"] == 42_000)
);
}
+583
Переглянути файл
@@ -0,0 +1,583 @@
//! Pure translations between Copilot headless JSON-RPC payloads (`session.event`,
//! permissions, slash commands, MCP servers) and ACP v1.
use crate::LIMITS_UPDATE;
use serde_json::{Map, Value, json};
use std::collections::{HashMap, HashSet};
use std::path::Path;
const MAX_OUTPUT: usize = 64 * 1024;
#[derive(Default)]
pub(super) struct EventTranslator {
/// Assistant message IDs that already streamed deltas, so final `assistant.message` won't duplicate them.
streamed_messages: HashSet<String>,
/// Tool call metadata captured on `tool.execution_start`, keyed by `toolCallId`.
tools: HashMap<String, ToolInfo>,
/// Subagents started in this session (`toolCallId` → subagent session id).
subagents: HashMap<String, String>,
/// Last reported prompt token count, used when updating context size.
pub last_used_tokens: Option<u32>,
}
#[derive(Clone, Debug)]
struct ToolInfo {
kind: &'static str,
title: String,
locations: Vec<Value>,
output: String,
diffs: Vec<Value>,
}
/// An ACP notification `(session_id, update)` produced from a Copilot `session.event`.
pub(super) struct Translated {
pub updates: Vec<(String, Value)>,
pub terminal: Option<TurnTerminal>,
}
#[derive(Debug, Clone, PartialEq)]
pub(super) enum TurnTerminal {
Idle { aborted: bool },
Error { message: String, data: Option<Value> },
}
impl EventTranslator {
pub fn reset_turn(&mut self) {
self.streamed_messages.clear();
}
pub fn translate(&mut self, main_session: &str, event: &Value, fallback_limit: Option<u32>) -> Translated {
let mut out = Translated { updates: Vec::new(), terminal: None };
let event_type = str_of(event, "type").unwrap_or_default();
let data = event.get("data").unwrap_or(&Value::Null);
let agent_id = str_of(event, "agentId").filter(|s| !s.is_empty());
let target_session =
agent_id.map(|id| format!("{main_session}:sub:{id}")).unwrap_or_else(|| main_session.to_owned());
match event_type {
"assistant.reasoning_delta" => {
let delta = str_of(data, "deltaContent").or_else(|| str_of(data, "content")).unwrap_or_default();
if !delta.is_empty() {
out.updates.push((
target_session,
json!({ "sessionUpdate": "agent_thought_chunk", "content": { "type": "text", "text": delta } }),
));
}
}
"assistant.message_delta" => {
if data.get("parentToolCallId").and_then(Value::as_str).is_some() && agent_id.is_none() {
return out;
}
if let Some(mid) = str_of(data, "messageId") {
self.streamed_messages.insert(mid.to_owned());
}
let delta = str_of(data, "deltaContent").unwrap_or_default();
if !delta.is_empty() {
out.updates.push((
target_session,
json!({ "sessionUpdate": "agent_message_chunk", "content": { "type": "text", "text": delta } }),
));
}
}
"assistant.message" => {
if data.get("parentToolCallId").and_then(Value::as_str).is_some() && agent_id.is_none() {
return out;
}
let already = str_of(data, "messageId").is_some_and(|mid| self.streamed_messages.contains(mid));
if !already && let Some(content) = str_of(data, "content").filter(|c| !c.is_empty()) {
out.updates.push((
target_session,
json!({ "sessionUpdate": "agent_message_chunk", "content": { "type": "text", "text": content } }),
));
}
}
"tool.execution_start" => {
let tool_name = str_of(data, "toolName").unwrap_or_default();
if matches!(tool_name, "report_intent" | "tool_search_tool" | "tool_search_tool_regex") {
return out;
}
let Some(call_id) = str_of(data, "toolCallId").filter(|s| !s.is_empty()) else { return out };
let args = data.get("arguments").unwrap_or(&Value::Null);
if tool_name == "task" && agent_id.is_none() {
let sub_id = format!("{main_session}:task:{call_id}");
self.subagents.insert(call_id.to_owned(), sub_id.clone());
let title = str_of(args, "name").or_else(|| str_of(args, "agent_type")).unwrap_or("Subagent");
let desc = str_of(args, "description");
let prompt = str_of(args, "prompt");
out.updates.push((
main_session.to_owned(),
json!({
"sessionUpdate": "subagent_update",
"subagentId": sub_id,
"title": title,
"description": desc,
"prompt": prompt,
"status": "running",
"cancellable": false,
}),
));
return out;
}
let info = describe_tool(tool_name, args);
let mut update = json!({
"sessionUpdate": "tool_call",
"toolCallId": call_id,
"title": info.title,
"kind": info.kind,
"status": "in_progress",
});
if !info.locations.is_empty() {
update["locations"] = Value::Array(info.locations.clone());
}
if !info.diffs.is_empty() {
update["content"] = Value::Array(info.diffs.clone());
}
self.tools.insert(call_id.to_owned(), info);
out.updates.push((target_session, update));
}
"tool.execution_partial_result" | "tool.shell_output" => {
let Some(call_id) = str_of(data, "toolCallId") else { return out };
let chunk = str_of(data, "partialOutput")
.or_else(|| str_of(data, "output"))
.or_else(|| str_of(data, "chunk"))
.unwrap_or_default();
if chunk.is_empty() {
return out;
}
if let Some(info) = self.tools.get_mut(call_id) {
info.output.push_str(chunk);
trim_tail(&mut info.output);
let content = tool_content(&info.output, &info.diffs);
out.updates.push((
target_session,
json!({
"sessionUpdate": "tool_call_update",
"toolCallId": call_id,
"content": content,
}),
));
}
}
"tool.execution_complete" => {
let Some(call_id) = str_of(data, "toolCallId") else { return out };
let success = data.get("success").and_then(Value::as_bool).unwrap_or(true);
let result_text = extract_tool_result_text(data);
if let Some(sub_id) = self.subagents.remove(call_id) {
out.updates.push((
main_session.to_owned(),
json!({
"sessionUpdate": "subagent_update",
"subagentId": sub_id,
"status": if success { "done" } else { "failed" },
"reply": result_text,
"error": (!success).then(|| result_text.clone()).flatten(),
}),
));
return out;
}
let Some(mut info) = self.tools.remove(call_id) else { return out };
if info.output.is_empty()
&& let Some(t) = result_text
&& info.kind != "edit"
{
info.output = t;
trim_tail(&mut info.output);
}
let mut update = json!({
"sessionUpdate": "tool_call_update",
"toolCallId": call_id,
"status": if success { "completed" } else { "failed" },
});
let content = tool_content(&info.output, &info.diffs);
if !content.is_empty() {
update["content"] = Value::Array(content);
}
out.updates.push((target_session, update));
}
"subagent.started" => {
if let Some(call_id) = str_of(data, "toolCallId") {
let sub_id = self
.subagents
.entry(call_id.to_owned())
.or_insert_with(|| format!("{main_session}:task:{call_id}"))
.clone();
let title = str_of(data, "agentDisplayName").or_else(|| str_of(data, "agentName"));
let desc = str_of(data, "agentDescription");
out.updates.push((
main_session.to_owned(),
json!({
"sessionUpdate": "subagent_update",
"subagentId": sub_id,
"title": title,
"description": desc,
"status": "running",
}),
));
}
}
"subagent.failed" => {
if let Some(call_id) = str_of(data, "toolCallId")
&& let Some(sub_id) = self.subagents.get(call_id).cloned()
{
out.updates.push((
main_session.to_owned(),
json!({
"sessionUpdate": "subagent_update",
"subagentId": sub_id,
"status": "failed",
"error": str_of(data, "error").or_else(|| str_of(data, "message")),
}),
));
}
}
"session.title_changed" => {
if let Some(title) = str_of(data, "title").map(str::trim).filter(|t| !t.is_empty()) {
out.updates.push((
main_session.to_owned(),
json!({ "sessionUpdate": "session_info_update", "title": title }),
));
}
}
"session.usage_info" => {
let used = data.get("currentTokens").and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok());
let limit = data
.get("tokenLimit")
.and_then(Value::as_u64)
.and_then(|n| u32::try_from(n).ok())
.filter(|&n| n > 0)
.or(fallback_limit);
if let (Some(used), Some(size)) = (used, limit) {
self.last_used_tokens = Some(used);
out.updates.push((
main_session.to_owned(),
json!({ "sessionUpdate": "usage_update", "used": used, "size": size }),
));
}
}
"assistant.usage" => {
if agent_id.is_none() {
let used = data.get("inputTokens").and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok());
if let (Some(used), Some(size)) = (used, fallback_limit.filter(|&s| s > 0)) {
self.last_used_tokens = Some(used);
out.updates.push((
main_session.to_owned(),
json!({ "sessionUpdate": "usage_update", "used": used, "size": size }),
));
}
}
if let Some(limits) = quota_limits(data.get("quotaSnapshots")) {
out.updates.push((main_session.to_owned(), limits));
}
}
"session.idle" if agent_id.is_none() => {
let mode = str_of(data, "mode").unwrap_or_default();
if mode != "autopilot" {
let aborted = data.get("aborted").and_then(Value::as_bool).unwrap_or(false);
out.terminal = Some(TurnTerminal::Idle { aborted });
}
}
"session.autopilot_stopped" if agent_id.is_none() => {
let reason = str_of(data, "reason").unwrap_or_default();
if reason == "error" {
out.terminal = Some(TurnTerminal::Error { message: "Autopilot request failed".into(), data: None });
} else {
out.terminal = Some(TurnTerminal::Idle { aborted: reason == "aborted" });
}
}
"session.error" if agent_id.is_none() => {
let message = str_of(data, "message").unwrap_or("Copilot reported an error.").to_owned();
out.terminal = Some(TurnTerminal::Error { message, data: Some(data.clone()) });
}
_ => {}
}
out
}
}
fn describe_tool(name: &str, args: &Value) -> ToolInfo {
let mut locations = Vec::new();
let mut diffs = Vec::new();
if let Some(p) = str_of(args, "path").or_else(|| str_of(args, "filePath")).filter(|p| !p.is_empty()) {
locations.push(json!({ "path": p }));
}
let (kind, title) = match name {
"bash" | "powershell" | "shell" => {
let cmd = str_of(args, "command").or_else(|| str_of(args, "description")).unwrap_or("Run command");
("execute", cmd.to_owned())
}
"view" | "read_file" => {
let label = str_of(args, "path")
.and_then(|p| Path::new(p).file_name().and_then(|n| n.to_str()))
.unwrap_or("Read file");
("read", format!("Read {label}"))
}
"grep" | "glob" | "semantic_search" => {
let pat = str_of(args, "pattern").or_else(|| str_of(args, "query")).unwrap_or(name);
("search", format!("Search {pat}"))
}
"edit" => {
let path = str_of(args, "path").unwrap_or_default();
let old = str_of(args, "old_str").unwrap_or_default();
let new = str_of(args, "new_str").unwrap_or_default();
if !path.is_empty() {
diffs.push(json!({ "type": "diff", "path": path, "oldText": old, "newText": new }));
}
let label = Path::new(path).file_name().and_then(|n| n.to_str()).unwrap_or("file");
("edit", format!("Edit {label}"))
}
"create" => {
let path = str_of(args, "path").unwrap_or_default();
let new = str_of(args, "file_text").unwrap_or_default();
if !path.is_empty() {
diffs.push(json!({ "type": "diff", "path": path, "oldText": "", "newText": new }));
}
let label = Path::new(path).file_name().and_then(|n| n.to_str()).unwrap_or("file");
("edit", format!("Create {label}"))
}
"web_fetch" => {
let url = str_of(args, "url").unwrap_or("URL");
("fetch", format!("Fetch {url}"))
}
_ => ("other", str_of(args, "description").unwrap_or(name).to_owned()),
};
ToolInfo { kind, title, locations, output: String::new(), diffs }
}
fn extract_tool_result_text(data: &Value) -> Option<String> {
if let Some(err) = data.pointer("/error/message").and_then(Value::as_str).filter(|s| !s.is_empty()) {
return Some(err.to_owned());
}
let result = data.get("result")?;
if let Some(s) = result.as_str() {
return (!s.is_empty()).then(|| s.to_owned());
}
str_of(result, "content")
.or_else(|| str_of(result, "detailedContent"))
.or_else(|| str_of(result, "textResultForLlm"))
.filter(|s| !s.is_empty())
.map(str::to_owned)
}
fn tool_content(output: &str, diffs: &[Value]) -> Vec<Value> {
let mut out = diffs.to_vec();
if !output.is_empty() {
out.push(json!({ "type": "content", "content": { "type": "text", "text": output } }));
}
out
}
fn quota_limits(snapshots: Option<&Value>) -> Option<Value> {
let map = snapshots?.as_object()?;
let mut limits = Vec::new();
for (window, snap) in map {
let used_pct = snap
.get("percentageUsed")
.and_then(Value::as_f64)
.or_else(|| snap.get("remainingPercentage").and_then(Value::as_f64).map(|rem| 100.0 - rem));
let Some(used_pct) = used_pct.filter(|p| p.is_finite()) else { continue };
let resets_ms = snap.get("resetsAt").and_then(Value::as_f64);
let mut entry = json!({
"window": window,
"usedPercent": used_pct.clamp(0.0, 100.0),
});
if let Some(ms) = resets_ms {
entry["resetsMs"] = json!(ms);
}
limits.push(entry);
}
(!limits.is_empty()).then(|| json!({ "sessionUpdate": LIMITS_UPDATE, "limits": limits }))
}
/// Builds an ACP `session/request_permission` payload from Copilot's `permission.requested` data.
pub(super) fn permission_request(session_id: &str, perm: &Value) -> Value {
let kind = str_of(perm, "kind").unwrap_or("other");
let tool_call_id = str_of(perm, "toolCallId").unwrap_or("permission");
let (acp_kind, title, raw_input) = match kind {
"shell" => {
let cmd = str_of(perm, "fullCommandText").or_else(|| str_of(perm, "command")).unwrap_or_default();
let title = str_of(perm, "intention")
.filter(|s| !s.is_empty())
.map(str::to_owned)
.unwrap_or_else(|| if cmd.is_empty() { "Run shell command".into() } else { format!("Run {cmd}") });
("execute", title, json!({ "command": cmd }))
}
"write" => {
let path = str_of(perm, "fileName").or_else(|| str_of(perm, "path")).unwrap_or("file");
("edit", format!("Edit {path}"), json!({ "path": path }))
}
"read" => {
let path = str_of(perm, "path").unwrap_or("file");
("read", format!("Read {path}"), json!({ "path": path }))
}
"url" => {
let url = str_of(perm, "url").unwrap_or("URL");
("fetch", format!("Allow network access to {url}"), json!({ "url": url }))
}
"mcp" => {
let server = str_of(perm, "serverName").unwrap_or("MCP");
let tool = str_of(perm, "toolName").unwrap_or("tool");
("other", format!("Run {server}: {tool}"), perm.clone())
}
_ => {
let t = str_of(perm, "intention").or_else(|| str_of(perm, "message")).unwrap_or("Allow action");
("other", t.to_owned(), perm.clone())
}
};
json!({
"sessionId": session_id,
"toolCall": {
"toolCallId": tool_call_id,
"kind": acp_kind,
"title": title,
"rawInput": raw_input,
},
"options": [
{ "optionId": "approve-once", "name": "Allow once", "kind": "allow_once" },
{ "optionId": "approved", "name": "Always allow", "kind": "allow_always" },
{ "optionId": "denied", "name": "Reject", "kind": "reject_once" },
],
})
}
/// Builds an ACP `session/request_permission` question card for Copilot's `userInput.request`.
pub(super) fn user_input_permission_request(session_id: &str, req: &Value) -> Value {
let question = str_of(req, "question").unwrap_or("Provide input");
let choices: Vec<Value> = req
.get("choices")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|c| c.as_str().map(|label| json!({ "label": label, "description": "" })))
.collect();
json!({
"sessionId": session_id,
"toolCall": {
"toolCallId": str_of(req, "toolCallId").unwrap_or("ask_user"),
"kind": "other",
"title": question,
"_meta": {
"questions": [{
"header": "Question",
"question": question,
"multiSelect": false,
"options": choices,
}]
}
},
"options": [
{ "optionId": "submit", "name": "Submit", "kind": "allow_once" },
{ "optionId": "cancel", "name": "Cancel", "kind": "reject_once" },
],
})
}
/// Converts ACP `mcpServers` array into Copilot's `mcpServers` object map.
pub(super) fn wire_mcp_servers(acp_servers: Option<&Value>) -> Option<Value> {
let list = acp_servers?.as_array()?;
let mut out = Map::new();
for item in list {
let Some(name) = str_of(item, "name").filter(|n| !n.is_empty()) else { continue };
let transport = str_of(item, "type").unwrap_or("stdio");
match transport {
"http" | "sse" => {
let Some(url) = str_of(item, "url").filter(|u| !u.is_empty()) else { continue };
let mut headers = Map::new();
for kv in item.get("headers").and_then(Value::as_array).into_iter().flatten() {
if let (Some(k), Some(v)) = (str_of(kv, "name"), str_of(kv, "value")) {
headers.insert(k.to_owned(), json!(v));
}
}
out.insert(
name.to_owned(),
json!({
"type": transport,
"url": url,
"headers": headers,
"tools": ["*"],
}),
);
}
_ => {
let Some(cmd) = str_of(item, "command").filter(|c| !c.is_empty()) else { continue };
let args: Vec<Value> = item.get("args").and_then(Value::as_array).cloned().unwrap_or_default();
let mut env = Map::new();
for kv in item.get("env").and_then(Value::as_array).into_iter().flatten() {
if let (Some(k), Some(v)) = (str_of(kv, "name"), str_of(kv, "value")) {
env.insert(k.to_owned(), json!(v));
}
}
out.insert(
name.to_owned(),
json!({
"type": "local",
"command": cmd,
"args": args,
"env": env,
"tools": ["*"],
}),
);
}
}
}
(!out.is_empty()).then_some(Value::Object(out))
}
/// Converts `commands.list` + `skills.discover` results into ACP `availableCommands`.
pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Option<&Value>) -> Vec<Value> {
let mut seen = HashSet::new();
let mut out = Vec::new();
for cmd in commands_res.and_then(|v| v.get("commands")).and_then(Value::as_array).into_iter().flatten() {
let Some(name) = str_of(cmd, "name").map(|n| n.trim_start_matches('/')).filter(|n| !n.is_empty()) else {
continue;
};
if !seen.insert(name.to_owned()) {
continue;
}
let hint = cmd.pointer("/input/hint").and_then(Value::as_str).filter(|h| !h.is_empty());
out.push(json!({
"name": name,
"description": str_of(cmd, "description").unwrap_or_default(),
"source": "command",
"input": hint.map(|h| json!({ "hint": h })),
}));
}
for skill in skills_res.and_then(|v| v.get("skills")).and_then(Value::as_array).into_iter().flatten() {
if skill.get("enabled").and_then(Value::as_bool) == Some(false)
|| skill.get("userInvocable").and_then(Value::as_bool) == Some(false)
{
continue;
}
let Some(name) = str_of(skill, "commandName")
.or_else(|| str_of(skill, "name"))
.map(|n| n.trim_start_matches('/'))
.filter(|n| !n.is_empty())
else {
continue;
};
if !seen.insert(name.to_owned()) {
continue;
}
let hint = str_of(skill, "argumentHint").filter(|h| !h.is_empty());
out.push(json!({
"name": name,
"description": str_of(skill, "description").unwrap_or_default(),
"source": "skill",
"input": hint.map(|h| json!({ "hint": h })),
}));
}
out
}
fn trim_tail(text: &mut String) {
if text.len() > MAX_OUTPUT {
let mut cut = text.len() - MAX_OUTPUT;
while !text.is_char_boundary(cut) {
cut += 1;
}
text.replace_range(..cut, "");
}
}
fn str_of<'a>(v: &'a Value, key: &str) -> Option<&'a str> {
v.get(key).and_then(Value::as_str)
}
+1
Переглянути файл
@@ -13,6 +13,7 @@
pub(crate) mod claude;
pub(crate) mod codex;
pub(crate) mod copilot;
use ide_jsonrpc::{Framing, Handler, Peer};
use std::path::{Path, PathBuf};
+34 -4
Переглянути файл
@@ -20,6 +20,8 @@ pub(crate) enum Driver {
Codex,
/// `claude` in stream-json mode.
Claude,
/// `copilot --headless --no-auto-update --stdio`.
Copilot,
}
#[derive(Clone, Debug, PartialEq)]
@@ -54,8 +56,21 @@ const BUILTIN: &[(&str, &str, Driver, &[&str], &str)] = &[
&["npx", "-y", "@agentclientprotocol/[email protected]"],
"Run `codex login` in a terminal.",
),
(
"deepseek-harness",
"DeepSeek Harness",
Driver::Acp,
&["dsh", "--profile", "acp"],
"Run `dsh` in a terminal and sign in.",
),
("gemini", "Gemini CLI", Driver::Acp, &["gemini", "--experimental-acp"], "Run `gemini` in a terminal and sign in."),
("copilot", "GitHub Copilot", Driver::Acp, &["copilot", "--acp"], "Run `copilot` in a terminal and sign in."),
(
"copilot",
"GitHub Copilot",
Driver::Copilot,
&["copilot", "--headless", "--no-auto-update", "--stdio"],
"Run `copilot` in a terminal and sign in.",
),
("cursor", "Cursor", Driver::Acp, &["cursor-agent", "acp"], "Run `cursor-agent login` in a terminal."),
("opencode", "OpenCode", Driver::Acp, &["opencode", "acp"], "Run `opencode auth login` in a terminal."),
("qwen", "Qwen Code", Driver::Acp, &["qwen", "--experimental-acp"], "Run `qwen` in a terminal and sign in."),
@@ -242,10 +257,13 @@ fn render_login_command<'a>(program: &Path, args: impl IntoIterator<Item = &'a s
}
/// Whether `id` names a built-in agent that needs no registry install (native drivers
/// and `npx -y` adapters). CLI built-ins (`copilot`, `gemini`, …) can be installed and
/// updated from the ACP Registry into `<config>/agents/<id>.toml`.
/// other than `copilot`, and `npx -y` adapters). CLI built-ins (`copilot`, `gemini`, …)
/// can be installed and updated from the ACP Registry into `<config>/agents/<id>.toml`.
pub(crate) fn is_builtin(id: &str) -> bool {
BUILTIN.iter().any(|&(bid, _, driver, cmd, _)| bid == id && (driver != Driver::Acp || cmd.first() == Some(&"npx")))
id != "copilot"
&& BUILTIN
.iter()
.any(|&(bid, _, driver, cmd, _)| bid == id && (driver != Driver::Acp || cmd.first() == Some(&"npx")))
}
/// Display name of a built-in agent, when `id` is one.
@@ -618,6 +636,10 @@ pub(crate) fn load(custom_dir: Option<&Path>, secrets: Option<&dyn EnvSecrets>)
files.sort();
for path in files {
let Some(id) = path.file_stem().and_then(|s| s.to_str()).map(str::to_owned) else { continue };
let explicit_driver = std::fs::read_to_string(&path)
.ok()
.and_then(|t| toml::from_str::<toml::Table>(&t).ok())
.is_some_and(|t| t.contains_key("driver"));
let agent = match CustomAgent::read_with(&path, &id, secrets) {
Ok(a) => a,
Err(e) => {
@@ -643,6 +665,14 @@ pub(crate) fn load(custom_dir: Option<&Path>, secrets: Option<&dyn EnvSecrets>)
match specs.iter_mut().find(|s| s.id == spec.id) {
Some(existing) => {
spec.login_hint = existing.login_hint.clone();
if !explicit_driver && existing.driver == Driver::Copilot && spec.driver == Driver::Acp {
// Registry installs (`github-copilot-cli`) record `args = ["--acp"]` with no
// `driver`; upgrade them in place to the native headless driver (which
// automatically falls back to `--acp`) while keeping the installed executable
// path and registry version tracking. Explicit `driver = "acp"` stays ACP.
spec.driver = Driver::Copilot;
spec.args = crate::native::copilot::headless_args(&spec.args);
}
if spec.source == AgentSource::Custom {
spec.source = AgentSource::Builtin;
}
+1
Переглянути файл
@@ -64,6 +64,7 @@ async fn create(mgr: &AgentManager, provider: &str, prompt: &str) -> String {
config: config(provider),
isolation: Isolation::Local,
base: None,
..Default::default()
};
mgr.create(req).await.unwrap().id
}
File diff suppressed because it is too large. Load diff
+1 -1
Переглянути файл
@@ -548,7 +548,7 @@ impl PathMap {
}
/// Removes `.` and resolvable `..` components without touching the file system.
fn normalize(p: &Path) -> PathBuf {
pub(crate) fn normalize(p: &Path) -> PathBuf {
use std::path::Component;
let mut out = PathBuf::new();
for c in p.components() {
+218 -24
Переглянути файл
@@ -40,6 +40,18 @@ pub fn structure_outputs(root: &Path, ps: &ProjectStructureSettings) -> (PathBuf
(main, test)
}
/// Whether Rebuild may delete the output folder `dir`: never the project folder or one above
/// it, nor a folder that holds or lies inside a source, test or resource root.
fn deletable_output(dir: &Path, root: &Path, roots: &StructureRoots) -> bool {
let dir = normalize(dir);
let overlaps = |r: &PathBuf| {
let r = normalize(r);
r.starts_with(&dir) || dir.starts_with(&r)
};
!normalize(root).starts_with(&dir)
&& !roots.sources.iter().chain(&roots.tests).chain(&roots.resources).chain(&roots.test_resources).any(overlaps)
}
fn module_name(root: &Path) -> String {
root.file_name().map_or_else(|| "project".to_owned(), |n| n.to_string_lossy().into_owned())
}
@@ -207,7 +219,11 @@ pub fn structure_plan(
let mut steps = Vec::new();
if kind == BuildKind::Rebuild {
steps.push(BuildStep::action(Action::Clean(vec![main_out.clone(), test_out.clone()]), root));
let dirs: Vec<PathBuf> =
[&main_out, &test_out].into_iter().filter(|d| deletable_output(d, root, roots)).cloned().collect();
if !dirs.is_empty() {
steps.push(BuildStep::action(Action::Clean(dirs), root));
}
}
let main_cp = library_entries(root, ps, false);
let compile = |name: &str, sources: &[PathBuf], out: &Path, cp: &[String]| -> IdeResult<BuildStep> {
@@ -310,6 +326,8 @@ fn artifact_steps(
.find(|f| f.module == artifact.module || f.module.is_empty() && artifact.module == ".")
.or_else(|| ps.facets.iter().find(|f| f.kind == "web"));
let staging = cache.join("artifacts").join(file_name(&artifact.name));
// What the last build laid out in a folder the user chose, so the next one replaces only that.
let record = cache.join("artifacts").join(format!("{}.files", file_name(&artifact.name)));
let mut steps = Vec::new();
match (artifact.kind, war) {
(ArtifactKind::Jar, None) => {
@@ -324,7 +342,11 @@ fn artifact_steps(
manifest.push_str(&format!("Class-Path: {}\r\n", names.join(" ")));
}
steps.push(BuildStep::action(
Action::Layout { into: staging.clone(), entries: vec![(classes.to_path_buf(), PathBuf::new())] },
Action::Layout {
into: staging.clone(),
entries: vec![(classes.to_path_buf(), PathBuf::new())],
record: None,
},
root,
));
// The jar's Class-Path names the libraries next to it.
@@ -332,6 +354,7 @@ fn artifact_steps(
Action::Layout {
into: out.clone(),
entries: libraries.iter().map(|l| (l.clone(), file_of(l))).collect(),
record: Some(record),
},
root,
));
@@ -353,7 +376,9 @@ fn artifact_steps(
for lib in &libraries {
entries.push((lib.clone(), Path::new("WEB-INF/lib").join(file_of(lib))));
}
steps.push(BuildStep::action(Action::Layout { into: exploded.clone(), entries }, root));
// The exploded output may be a folder the user chose; the staging folder is the IDE's own.
let record = (exploded != staging).then_some(record);
steps.push(BuildStep::action(Action::Layout { into: exploded.clone(), entries, record }, root));
let archive = war
.map(Path::to_path_buf)
.or_else(|| (kind != ArtifactKind::WarExploded).then(|| artifact_file(root, artifact)));
@@ -407,15 +432,17 @@ pub(crate) enum Action {
/// relative paths; files that are already up to date are left alone.
CopyResources { from: Vec<PathBuf>, to: PathBuf },
/// Lays out an artifact in `into`: each folder's content or file goes to its relative
/// place (`""` = the top). What is no longer laid out is removed.
Layout { into: PathBuf, entries: Vec<(PathBuf, PathBuf)> },
/// place (`""` = the top). What is no longer laid out is removed: without `record`, `into`
/// is the IDE's own folder and is laid out afresh; with it, `into` is a folder the user chose
/// and only the files the previous layout recorded there are removed, never anything else.
Layout { into: PathBuf, entries: Vec<(PathBuf, PathBuf)>, record: Option<PathBuf> },
/// Zips the folder `from` into the archive `to`, with this manifest first.
Archive { from: PathBuf, to: PathBuf, manifest: Option<String> },
}
impl Action {
pub(crate) fn display(&self, root: &Path) -> String {
let rel = |p: &Path| p.strip_prefix(root).unwrap_or(p).to_string_lossy().into_owned();
let rel = |p: &Path| p.strip_prefix(root).unwrap_or(p).to_string_lossy().replace('\\', "/");
match self {
Action::Clean(dirs) => format!("Clean {}", dirs.iter().map(|d| rel(d)).collect::<Vec<_>>().join(", ")),
Action::CopyResources { to, .. } => format!("Copy resources to {}", rel(to)),
@@ -441,29 +468,39 @@ impl Action {
}
Ok(format!("{copied} resource file(s) copied"))
}
Action::Layout { into, entries } => {
// A fresh layout: files dropped from the sources must not linger in the artifact.
Action::Layout { into, entries, record } => {
if entries.iter().any(|(from, _)| from.starts_with(into)) {
return Err(IdeError::invalid(format!(
"The artifact output folder {} holds files the artifact is made of",
into.display()
)));
}
if into.exists() {
if record.is_none() && into.exists() {
fs::remove_dir_all(into)
.map_err(|e| IdeError::internal(format!("cannot delete {} ({e})", into.display())))?;
}
let mut copied = 0;
let mut written = Vec::new();
for (from, to) in entries {
let target = into.join(to);
// The folders of the output it goes into (and a folder entry's own) are
// never links; a file in a link's place replaces the link.
let mut at = into.to_path_buf();
let folders = to.components().count().saturating_sub(usize::from(!from.is_dir()));
for c in to.components().take(folders) {
at.push(c);
refuse_link(&at)?;
}
if from.is_dir() {
copied += copy_tree(from, &target, cancel)?;
copy_tree(from, &target, &mut written, cancel)?;
} else if from.is_file() {
copy_file(from, &target)?;
copied += 1;
written.push(target);
}
}
Ok(format!("{copied} file(s) laid out"))
if let Some(record) = record {
replace_recorded(into, record, &written)?;
}
Ok(format!("{} file(s) laid out", written.len()))
}
Action::Archive { from, to, manifest } => {
archive(from, to, manifest.as_deref(), cancel)?;
@@ -474,6 +511,10 @@ impl Action {
}
fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
// A link in the artifact's place is replaced, not written through.
if fs::symlink_metadata(to).is_ok_and(|m| m.file_type().is_symlink()) {
fs::remove_file(to).map_err(|e| IdeError::internal(format!("cannot replace {} ({e})", to.display())))?;
}
if let Some(parent) = to.parent() {
fs::create_dir_all(parent)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
@@ -482,23 +523,80 @@ fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
Ok(())
}
fn copy_tree(from: &Path, to: &Path, cancel: &CancellationToken) -> IdeResult<usize> {
fn refuse_link(folder: &Path) -> IdeResult<()> {
if fs::symlink_metadata(folder).is_ok_and(|m| m.file_type().is_symlink()) {
return Err(IdeError::invalid(format!(
"{} links to another folder; the artifact is not laid out through it",
folder.display()
)));
}
Ok(())
}
fn copy_tree(from: &Path, to: &Path, written: &mut Vec<PathBuf>, cancel: &CancellationToken) -> IdeResult<()> {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Ok(entries) = fs::read_dir(from) else { return Ok(0) };
let mut copied = 0;
let Ok(entries) = fs::read_dir(from) else { return Ok(()) };
for e in entries.flatten() {
let Ok(t) = e.file_type() else { continue };
let target = to.join(e.file_name());
if t.is_dir() {
copied += copy_tree(&e.path(), &target, cancel)?;
refuse_link(&target)?;
copy_tree(&e.path(), &target, written, cancel)?;
} else if t.is_file() {
copy_file(&e.path(), &target)?;
copied += 1;
written.push(target);
}
}
Ok(copied)
Ok(())
}
/// Removes the files the previous layout recorded in `into` that this one didn't write
/// (and the folders that leaves empty), then records `written` for the next layout.
fn replace_recorded(into: &Path, record: &Path, written: &[PathBuf]) -> IdeResult<()> {
let now: std::collections::HashSet<PathBuf> =
written.iter().filter_map(|p| p.strip_prefix(into).ok().map(Path::to_path_buf)).collect();
let before = fs::read_to_string(record).unwrap_or_default();
let mut lines = before.lines();
// The record names its folder first: one made for another output folder removes nothing.
let same = lines.next().is_some_and(|dir| Path::new(dir) == into);
for rel in lines.filter(|_| same).map(PathBuf::from) {
// Only plain relative paths inside `into`: a damaged record must not reach elsewhere.
if rel.as_os_str().is_empty()
|| now.contains(&rel)
|| rel.components().any(|c| !matches!(c, std::path::Component::Normal(_)))
{
continue;
}
let file = into.join(&rel);
// Never through a link: a folder of the output that now links elsewhere (or a file that
// is a link) leads out of what the layout wrote.
let mut at = into.to_path_buf();
let linked = rel.components().any(|c| {
at.push(c);
fs::symlink_metadata(&at).is_ok_and(|m| m.file_type().is_symlink())
});
if !linked && file.is_file() {
let _ = fs::remove_file(&file);
let mut dir = file.parent();
while let Some(d) = dir.filter(|d| *d != into && d.starts_with(into)) {
if fs::remove_dir(d).is_err() {
break;
}
dir = d.parent();
}
}
}
let mut list: Vec<String> = now.iter().map(|p| p.to_string_lossy().into_owned()).collect();
list.sort();
list.insert(0, into.to_string_lossy().into_owned());
if let Some(parent) = record.parent() {
fs::create_dir_all(parent)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
}
fs::write(record, list.join("\n"))
.map_err(|e| IdeError::internal(format!("cannot write {} ({e})", record.display())))
}
fn archive(from: &Path, to: &Path, manifest: Option<&str>, cancel: &CancellationToken) -> IdeResult<()> {
@@ -646,15 +744,15 @@ mod tests {
let main_cp = cp(javac);
let entries: Vec<&str> = main_cp.split(sep).collect();
assert_eq!(entries.len(), 2, "{main_cp}");
assert!(entries[0].ends_with("lib/*"));
assert!(entries[1].ends_with("WEB-INF/lib/*"));
assert!(Path::new(entries[0]).ends_with("lib/*"));
assert!(Path::new(entries[1]).ends_with("WEB-INF/lib/*"));
assert!(javac.args.windows(2).any(|w| w == ["--release", "17"]));
let args = fs::read_to_string(tmp.path().join("cache/javac/production.args")).unwrap();
assert!(args.contains("A.java") && !args.contains("ATest.java"));
assert_eq!(shown[2], "Copy resources to out/production/shop");
let test = &plan.steps[3];
let test_cp = cp(test);
assert!(test_cp.starts_with(&root.join("out/production/shop").to_string_lossy().into_owned()));
assert_eq!(Path::new(test_cp.split(sep).next().unwrap()), root.join("out/production/shop"));
assert!(test_cp.contains("junit.jar"));
}
@@ -693,7 +791,40 @@ mod tests {
let javac = &plan.steps[0];
assert!(!javac.args.iter().any(|a| a == "-cp"), "{:?}", javac.args);
assert!(javac.args.windows(4).any(|w| w == ["-source", "1.8", "-target", "1.8"]));
assert!(javac.args.windows(2).any(|w| w[0] == "-d" && w[1].ends_with("build/classes/production/p")));
assert!(
javac.args.windows(2).any(|w| w[0] == "-d" && Path::new(&w[1]).ends_with("build/classes/production/p"))
);
}
#[test]
fn rebuild_never_cleans_an_output_folder_over_the_project_or_its_sources() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("p");
write(&root.join("src/A.java"), "class A {}");
let roots = StructureRoots { sources: vec![root.join("src")], ..Default::default() };
for (main, test) in [(".", "bin"), ("src", "src/../test-out"), ("src/classes", ".."), ("", "")] {
let mut ps = ProjectStructureSettings::default();
ps.modules.insert(
".".into(),
ModuleStructureSettings {
compiler_output: main.into(),
test_compiler_output: test.into(),
..Default::default()
},
);
let plan = structure_plan(&root, &ps, &roots, None, "17", BuildKind::Rebuild, &tmp.path().join("c"))
.unwrap()
.unwrap();
let clean: Vec<String> =
plan.steps.iter().map(BuildStep::display).filter(|s| s.starts_with("Clean")).collect();
let expected: &[&str] = match main {
"." => &["Clean bin"],
"src" => &["Clean src/../test-out"],
"src/classes" => &[],
_ => &["Clean out/production/p, out/test/p"],
};
assert_eq!(clean, expected, "{main} / {test}");
}
}
#[test]
@@ -810,8 +941,71 @@ mod tests {
let tmp = tempfile::tempdir().unwrap();
let web = tmp.path().join("WebRoot");
write(&web.join("a.jsp"), "");
let action = Action::Layout { into: tmp.path().to_path_buf(), entries: vec![(web.clone(), PathBuf::new())] };
let action = Action::Layout {
into: tmp.path().to_path_buf(),
entries: vec![(web.clone(), PathBuf::new())],
record: None,
};
assert!(action.run(&CancellationToken::new()).is_err());
assert!(web.join("a.jsp").is_file());
}
#[test]
fn a_chosen_output_folder_keeps_what_the_artifact_did_not_put_there() {
let tmp = tempfile::tempdir().unwrap();
let project = tmp.path().join("project");
write(&project.join("src/A.java"), "class A {}");
write(&project.join(".git/HEAD"), "ref: refs/heads/main");
let libs = tmp.path().join("libs");
write(&libs.join("a.jar"), "a");
write(&libs.join("b.jar"), "b");
let record = tmp.path().join("cache/artifacts/app.files");
let layout = |names: &[&str]| Action::Layout {
into: project.clone(),
entries: names.iter().map(|n| (libs.join(n), PathBuf::from(n))).collect(),
record: Some(record.clone()),
};
layout(&["a.jar", "b.jar"]).run(&CancellationToken::new()).unwrap();
assert!(project.join("a.jar").is_file() && project.join("b.jar").is_file());
// A library dropped from the artifact goes; the project's own files stay.
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
assert!(project.join("a.jar").is_file() && !project.join("b.jar").exists());
assert!(project.join("src/A.java").is_file() && project.join(".git/HEAD").is_file());
// A damaged record never reaches outside the folder.
write(&record, &format!("{}\n../outside.txt", project.display()));
write(&tmp.path().join("outside.txt"), "x");
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
assert!(tmp.path().join("outside.txt").is_file());
// Nor through a folder of the output that now links elsewhere.
#[cfg(unix)]
{
write(&project.join("assets/x.txt"), "laid out");
write(&record, &format!("{}\nassets/x.txt", project.display()));
fs::remove_dir_all(project.join("assets")).unwrap();
std::os::unix::fs::symlink(project.join("src"), project.join("assets")).unwrap();
write(&project.join("src/x.txt"), "source");
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
assert!(project.join("src/x.txt").is_file());
}
// An entry's own folder that links elsewhere stops the layout instead of copying through it.
#[cfg(unix)]
{
fs::remove_file(project.join("assets")).unwrap();
std::os::unix::fs::symlink(project.join("src"), project.join("classes")).unwrap();
write(&tmp.path().join("out/A.class"), "compiled");
let into_link = Action::Layout {
into: project.clone(),
entries: vec![(tmp.path().join("out"), PathBuf::from("classes"))],
record: Some(record.clone()),
};
assert!(into_link.run(&CancellationToken::new()).is_err());
assert!(!project.join("src/A.class").exists());
fs::remove_file(project.join("classes")).unwrap();
}
// Nor does one made for another output folder.
write(&project.join("c.jar"), "mine");
write(&record, "/elsewhere\nc.jar");
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
assert!(project.join("c.jar").is_file());
}
}
+1 -1
Переглянути файл
@@ -1463,7 +1463,7 @@ dependencies {
model.projects.push(project);
}
assert!(build_files(root, &model).contains(&root.join("included/deps.gradle")));
let model = crate::BuildModel { maven: None, gradle: vec![model] };
let model = crate::BuildModel { maven: None, gradle: vec![model], sbt: Vec::new() };
assert_eq!(crate::dependency_coordinates(root, &model)[0].artifact_id, "included");
}
+10 -5
Переглянути файл
@@ -1,4 +1,4 @@
//! Build tool models for the Maven and Gradle tool windows, and Build › Build
//! Build tool models for the Maven, Gradle and sbt tool windows, and Build › Build
//! Project ([`compile`]) for Maven, Gradle, Cargo, Go and TypeScript projects.
//!
//! [`load`] reads the project's build files (instant, no build tool involved)
@@ -13,6 +13,7 @@ pub mod kotlin_bridge;
pub mod maven;
pub mod pom_edit;
mod process;
pub mod sbt;
mod sync;
pub mod web;
mod xml;
@@ -20,6 +21,7 @@ mod xml;
pub use gradle::{GradleModel, GradleProject, GradleTask};
pub use gradle_deps::{GradleDependency, gradle_dependencies};
pub use maven::{MavenDependency, MavenModel, MavenPlugin, MavenProfile, MavenProject, Omission};
pub use sbt::{SbtBuild, SbtProject};
pub use sync::{
SyncOptions, SyncProgress, maven_profiles, save_maven_profiles, sync_gradle, sync_gradle_model, sync_maven,
};
@@ -42,6 +44,9 @@ pub struct BuildModel {
pub maven: Option<MavenModel>,
#[serde(default)]
pub gradle: Vec<GradleModel>,
/// sbt builds, read from their `build.sbt` (sbt is not started).
#[serde(default)]
pub sbt: Vec<SbtBuild>,
}
impl BuildModel {
@@ -96,7 +101,7 @@ pub fn load_linked(
g
})
.collect();
BuildModel { maven, gradle }
BuildModel { maven, gradle, sbt: sbt::load(root) }
}
/// Gradle project folders outside `root` as of the last sync (`includeFlat` siblings):
@@ -329,7 +334,7 @@ mod tests {
..Default::default()
};
let gradle = gradle::load(root).into_iter().collect();
let model = BuildModel { maven: Some(maven), gradle };
let model = BuildModel { maven: Some(maven), gradle, sbt: Vec::new() };
let names: Vec<String> = dependency_coordinates(root, &model)
.into_iter()
.map(|c| format!("{}{}:{}:{}", if c.gradle { "G " } else { "M " }, c.group_id, c.artifact_id, c.version))
@@ -348,7 +353,7 @@ mod tests {
"ext { gson = '2.8.9' }\ndependencies { implementation \"com.google.code.gson:gson:${gson}\" }\n",
)
.unwrap();
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect() };
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect(), sbt: Vec::new() };
let names: Vec<String> = dependency_coordinates(root, &model)
.into_iter()
.map(|c| format!("{}:{}:{}", c.group_id, c.artifact_id, c.version))
@@ -367,7 +372,7 @@ mod tests {
)
.unwrap();
std::fs::write(root.join("gradle.properties"), "# versions\nv = 1.2\nonlyInProperties: 2.3\n").unwrap();
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect() };
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect(), sbt: Vec::new() };
let versions: Vec<_> = dependency_coordinates(root, &model).into_iter().map(|c| c.version).collect();
assert_eq!(versions, ["1.2", "2.3"]);
}
+301
Переглянути файл
@@ -0,0 +1,301 @@
//! sbt builds for the sbt tool window: each `build.sbt` build under the project root
//! with the projects its definition declares (`lazy val core = project`,
//! `(project in file("core"))`, `Project("core", file("core"))`), read statically —
//! sbt itself is not started.
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct SbtBuild {
/// Folder of `build.sbt`, relative to the project root (`""` for the root itself).
pub dir: String,
/// The launcher: a `sbt` / `sbtx` script in the build folder, else `sbt` on `PATH`.
pub command: String,
/// `sbt.version` of `project/build.properties`.
pub version: Option<String>,
/// The root project first, then the declared projects in source order.
pub projects: Vec<SbtProject>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct SbtProject {
/// The project id tasks are scoped with (`core/compile`).
pub id: String,
/// Base folder relative to the build folder (`""` for the build's own).
pub dir: String,
/// The build's root project: its tasks run unscoped (and aggregate when sbt does).
pub root: bool,
}
/// The sbt builds under `root` (outermost `build.sbt` folders).
pub fn load(root: &Path) -> Vec<SbtBuild> {
ide_core::project_roots::discover(root, &["build.sbt"])
.into_iter()
.filter_map(|dir| {
let text = std::fs::read_to_string(dir.join("build.sbt")).ok()?;
let rel = dir.strip_prefix(root).unwrap_or(&dir).to_string_lossy().replace('\\', "/");
let name = dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| "root".to_owned());
Some(SbtBuild {
dir: rel,
command: launcher(&dir),
version: build_version(&dir),
projects: projects(&text, &name),
})
})
.collect()
}
fn launcher(dir: &Path) -> String {
for script in ["sbt", "sbtx"] {
if !cfg!(windows) && dir.join(script).is_file() {
return format!("./{script}");
}
}
if cfg!(windows) && dir.join("sbt.bat").is_file() {
return "sbt.bat".to_owned();
}
"sbt".to_owned()
}
fn build_version(dir: &Path) -> Option<String> {
let text = std::fs::read_to_string(dir.join("project/build.properties")).ok()?;
text.lines().find_map(|line| {
let (key, value) = line.split_once('=')?;
(key.trim() == "sbt.version").then(|| value.trim().to_owned())
})
}
/// `text` with comments and the contents of string literals blanked (quotes kept),
/// byte for byte, so offsets into it are offsets into `text`.
fn mask(text: &str) -> String {
let mut out = String::with_capacity(text.len());
let blank = |out: &mut String, c: char| {
if c == '\n' {
out.push('\n');
} else {
out.extend(std::iter::repeat_n(' ', c.len_utf8()));
}
};
let mut chars = text.chars().peekable();
while let Some(c) = chars.next() {
match c {
'"' => {
out.push('"');
let mut ahead = chars.clone();
if ahead.next() == Some('"') && ahead.next() == Some('"') {
// `"""…"""`: no escapes inside.
chars.next();
chars.next();
out.push_str("\"\"");
let mut quotes = 0;
for c in chars.by_ref() {
quotes = if c == '"' { quotes + 1 } else { 0 };
if quotes > 0 {
out.push('"')
} else {
blank(&mut out, c)
}
if quotes == 3 {
break;
}
}
continue;
}
while let Some(c) = chars.next() {
if c == '"' || c == '\n' {
out.push(c);
break;
}
blank(&mut out, c);
if c == '\\'
&& let Some(n) = chars.next()
{
blank(&mut out, n);
}
}
}
'/' if chars.peek() == Some(&'/') => {
blank(&mut out, c);
for c in chars.by_ref() {
blank(&mut out, c);
if c == '\n' {
break;
}
}
}
'/' if chars.peek() == Some(&'*') => {
blank(&mut out, c);
let mut prev = ' ';
for c in chars.by_ref() {
blank(&mut out, c);
if prev == '*' && c == '/' {
break;
}
prev = c;
}
}
_ => out.push(c),
}
}
out
}
fn identifier(s: &str) -> Option<(&str, &str)> {
let s = s.trim_start();
if let Some(rest) = s.strip_prefix('`') {
let end = rest.find('`')?;
return Some((&rest[..end], &rest[end + 1..]));
}
let end = s.find(|c: char| !(c.is_alphanumeric() || c == '_')).unwrap_or(s.len());
(end > 0).then(|| (&s[..end], &s[end..]))
}
/// The string literal at the start of `s` (after spaces), and the rest.
fn string_literal(s: &str) -> Option<(&str, &str)> {
let rest = s.trim_start().strip_prefix('"')?;
let end = rest.find('"')?;
Some((&rest[..end], &rest[end + 1..]))
}
/// The folder of a `file("x")` / `new File("x")` at the start of `s`.
fn file_arg(s: &str) -> Option<&str> {
let s = s.trim_start();
let s = s.strip_prefix("file").or_else(|| s.strip_prefix("new File"))?;
let s = s.trim_start().strip_prefix('(')?;
string_literal(s).map(|(dir, _)| dir)
}
fn normalize_dir(dir: &str) -> String {
let dir = dir.trim_start_matches("./").trim_end_matches('/');
if dir == "." { String::new() } else { dir.to_owned() }
}
/// What a `lazy val <id> = <rhs>` declares: a project and its base folder. `rhs` is
/// masked (see [`mask`]); `original` is the same text unmasked, for the folder names.
fn project_of(id: &str, rhs: &str, original: &str) -> Option<String> {
let at = |s: &str| original.get(rhs.len() - s.len()..).unwrap_or_default();
let rhs = rhs.trim_start().trim_start_matches('(').trim_start();
if let Some(rest) = rhs.strip_prefix("Project") {
// `Project("id", file("dir"))` / `Project(id = "x", base = file("dir"))`.
let args = rest.trim_start().strip_prefix('(')?;
let base = args.find("file(").or_else(|| args.find("new File("))?;
return file_arg(at(&args[base..])).map(normalize_dir);
}
let rest = rhs.strip_prefix("project")?;
if rest.starts_with(|c: char| c.is_alphanumeric() || c == '_') {
return None;
}
let rest = rest.trim_start();
let located = rest
.strip_prefix(".in")
.and_then(|r| r.trim_start().strip_prefix('('))
.or_else(|| rest.strip_prefix("in ").or_else(|| rest.strip_prefix("in\t")));
Some(match located.and_then(|l| file_arg(at(l))) {
Some(dir) => normalize_dir(dir),
None => id.to_owned(),
})
}
/// The projects a build definition declares; `name` is the build folder's name, the id
/// sbt gives an implicit root project.
pub fn projects(text: &str, name: &str) -> Vec<SbtProject> {
let masked = mask(text);
let mut out: Vec<SbtProject> = Vec::new();
let mut from = 0;
while let Some(found) = masked[from..].find("val ") {
let at = from + found;
from = at + 4;
if masked[..at].chars().last().is_some_and(|c| c.is_alphanumeric() || c == '_') {
continue;
}
let Some((id, tail)) = identifier(&masked[from..]) else { continue };
let Some(rhs) = tail.trim_start().strip_prefix('=') else { continue };
if rhs.starts_with('=') || rhs.starts_with('>') {
continue;
}
let Some(dir) = project_of(id, rhs, &text[masked.len() - rhs.len()..]) else { continue };
if !out.iter().any(|p| p.id == id) {
out.push(SbtProject { id: id.to_owned(), root: dir.is_empty(), dir });
}
}
match out.iter().position(|p| p.root) {
Some(i) => {
let root = out.remove(i);
out.insert(0, root);
}
None => out.insert(0, SbtProject { id: name.to_owned(), dir: String::new(), root: true }),
}
out
}
#[cfg(test)]
mod tests {
use super::*;
fn ids(text: &str) -> Vec<(String, String, bool)> {
projects(text, "shop").into_iter().map(|p| (p.id, p.dir, p.root)).collect()
}
#[test]
fn single_project_builds_have_an_implicit_root() {
assert_eq!(
ids("ThisBuild / scalaVersion := \"3.3.4\"\nname := \"shop\"\n"),
[("shop".into(), "".into(), true)]
);
}
#[test]
fn declared_projects_and_their_folders() {
let text = r#"
// lazy val commented = project
lazy val root = (project in file("."))
.aggregate(core, `web-app`, util)
.settings(name := "shop")
lazy val core = project
lazy val `web-app` = (project in file("modules/web")).dependsOn(core)
lazy val util = project.in(file("libs/util/"))
lazy val legacy = Project("legacy", file("old"))
/* lazy val hidden = project */
val description = "lazy val fake = project"
lazy val projectSettings = Seq(scalacOptions += "-deprecation")
"#;
assert_eq!(
ids(text),
[
("root".into(), "".into(), true),
("core".into(), "core".into(), false),
("web-app".into(), "modules/web".into(), false),
("util".into(), "libs/util".into(), false),
("legacy".into(), "old".into(), false),
]
);
}
#[test]
fn a_root_declared_last_is_listed_first() {
let text = "lazy val api = project\nlazy val all = (project in file(\".\")).aggregate(api)\n";
assert_eq!(ids(text), [("all".into(), "".into(), true), ("api".into(), "api".into(), false)]);
}
#[test]
fn builds_are_found_with_their_launcher_and_version() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
std::fs::create_dir_all(root.join("svc/project")).unwrap();
std::fs::create_dir_all(root.join("svc/core")).unwrap();
std::fs::write(root.join("svc/build.sbt"), "lazy val core = project\n").unwrap();
// A project's own build.sbt is part of the outer build.
std::fs::write(root.join("svc/core/build.sbt"), "libraryDependencies += \"a\" % \"b\" % \"1\"\n").unwrap();
std::fs::write(root.join("svc/project/build.properties"), "sbt.version = 1.10.7\n").unwrap();
let builds = load(root);
assert_eq!(builds.len(), 1);
let b = &builds[0];
assert_eq!((b.dir.as_str(), b.command.as_str(), b.version.as_deref()), ("svc", "sbt", Some("1.10.7")));
assert_eq!(b.projects.iter().map(|p| p.id.as_str()).collect::<Vec<_>>(), ["svc", "core"]);
}
}
+5
Переглянути файл
@@ -38,6 +38,11 @@ pub enum IdeEvent {
WindowGroupsChanged,
/// A window entered or left full screen, itself or as a member of a full-screen window group.
WindowFullscreenChanged,
/// This remote window's connection to its host ended on its own (network loss, the host or
/// its server went away); the window's project is unreachable until it reconnects.
RemoteConnectionLost {
host: String,
},
ProjectTrustChanged {
root: crate::IpcPath,
trusted: bool,
+3 -1
Переглянути файл
@@ -14,7 +14,8 @@ pub fn inside_git_repo(dir: &Path) -> bool {
dir.ancestors().any(|d| d.join(".git").exists() || d.join(".jj").exists())
}
/// IDEA's default list, plus `.jj` and the Windows shell files.
/// IDEA's default list, plus `.jj`, rope's `.ropeproject` (pylsp-rope creates it in the
/// project root) and the Windows shell files.
pub const DEFAULT_IGNORED_NAMES: &[&str] = &[
"*.pyc",
"*.pyo",
@@ -25,6 +26,7 @@ pub const DEFAULT_IGNORED_NAMES: &[&str] = &[
".git",
".hg",
".jj",
".ropeproject",
".svn",
"CVS",
"__pycache__",
+13 -2
Переглянути файл
@@ -279,6 +279,18 @@ type Session = Arc<tokio::sync::Mutex<Option<Held>>>;
const MAX_META_ROWS: usize = 100_000;
/// Rows of catalog query `q`, run again as [`sql::postgres_legacy`] when a PostgreSQL server's
/// catalog lacks a column it reads (openGauss, PostgreSQL 9).
async fn catalog_rows(pool: &Pool, q: &str) -> IdeResult<Vec<Vec<Option<String>>>> {
match pool.rows(q, MAX_META_ROWS).await {
Err(e) if pool.driver() == DbDriver::Postgres => match sql::postgres_legacy(q) {
Some(legacy) => pool.rows(&legacy, MAX_META_ROWS).await.map_err(|_| e),
None => Err(e),
},
rows => rows,
}
}
fn flag(v: &Option<String>) -> bool {
matches!(v.as_deref(), Some("1" | "t" | "true" | "YES"))
}
@@ -1079,8 +1091,7 @@ impl DbManager {
let driver = pool.driver();
let mut out = SchemaObjects::default();
if let Some(q) = sql::routines(driver, schema) {
out.routines = pool
.rows(&q, MAX_META_ROWS)
out.routines = catalog_rows(&pool, &q)
.await?
.into_iter()
.filter_map(|r| {
+51 -7
Переглянути файл
@@ -219,6 +219,9 @@ pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {
}
/// Rows: `index name, unique (0/1), column` (one row per indexed column, in order).
// Key columns are paired from one series up to `max_index_keys` (the server's INDEX_MAX_KEYS, the
// most columns an index or key has): unlike a series per catalog row, it lets the planner find the
// table's rows through the catalog's index first.
pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
match driver {
@@ -236,8 +239,8 @@ pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
"SELECT i.relname, CASE WHEN ix.indisunique THEN 1 ELSE 0 END, a.attname \
FROM pg_index ix JOIN pg_class t ON t.oid = ix.indrelid JOIN pg_class i ON i.oid = ix.indexrelid \
JOIN pg_namespace n ON n.oid = t.relnamespace \
JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord) ON true \
JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum \
JOIN generate_series(0, current_setting('max_index_keys')::int - 1) AS k(ord) ON k.ord < ix.indnatts \
JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ix.indkey[k.ord] \
WHERE n.nspname = {s} AND t.relname = {t} ORDER BY i.relname, k.ord"
),
DbDriver::Mysql => format!(
@@ -284,12 +287,15 @@ pub fn completion_columns(driver: DbDriver) -> &'static str {
FROM sqlite_master m JOIN pragma_table_info(m.name) p \
WHERE m.type IN ('table', 'view') AND m.name NOT LIKE 'sqlite\\_%' ESCAPE '\\' ORDER BY m.name, p.cid"
}
// Identity columns own their sequence through an internal dependency (`attidentity` is PostgreSQL 10+).
DbDriver::Postgres => {
"SELECT n.nspname, c.relname, CASE c.relkind WHEN 'v' THEN 'view' WHEN 'm' THEN 'materialized view' ELSE 'table' END, a.attname, \
format_type(a.atttypid, a.atttypmod), CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END, \
CASE WHEN EXISTS (SELECT 1 FROM pg_index i WHERE i.indrelid = c.oid AND i.indisprimary \
AND a.attnum = ANY(i.indkey)) THEN 1 ELSE 0 END, \
CASE WHEN a.atthasdef OR a.attidentity <> '' THEN 1 ELSE 0 END \
CASE WHEN a.atthasdef OR EXISTS (SELECT 1 FROM pg_depend d WHERE d.refclassid = 'pg_class'::regclass \
AND d.refobjid = c.oid AND d.refobjsubid = a.attnum AND d.classid = 'pg_class'::regclass \
AND d.deptype = 'i') THEN 1 ELSE 0 END \
FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace JOIN pg_attribute a ON a.attrelid = c.oid \
WHERE c.relkind IN ('r', 'v', 'm', 'p', 'f') AND a.attnum > 0 AND NOT a.attisdropped \
AND n.nspname NOT IN ('pg_catalog', 'information_schema') \
@@ -363,9 +369,9 @@ pub fn foreign_keys(driver: DbDriver) -> &'static str {
FROM pg_constraint con \
JOIN pg_class sc ON sc.oid = con.conrelid JOIN pg_namespace sn ON sn.oid = sc.relnamespace \
JOIN pg_class tc ON tc.oid = con.confrelid JOIN pg_namespace tn ON tn.oid = tc.relnamespace \
CROSS JOIN LATERAL unnest(con.conkey, con.confkey) WITH ORDINALITY AS k(s, t, ord) \
JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = k.s \
JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = k.t \
JOIN generate_series(1, current_setting('max_index_keys')::int) AS k(ord) ON k.ord <= array_upper(con.conkey, 1) \
JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = con.conkey[k.ord] \
JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = con.confkey[k.ord] \
WHERE con.contype = 'f' AND sn.nspname NOT IN ('pg_catalog', 'information_schema') \
ORDER BY 1, 2, 3, k.ord LIMIT 20000"
}
@@ -408,7 +414,7 @@ pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String
"SELECT {s}, {t}, f.id, f.\"from\", {s}, f.\"table\", f.\"to\" FROM pragma_foreign_key_list({t}, {s}) f ORDER BY f.id, f.seq"
),
DbDriver::Postgres => format!(
"SELECT sn.nspname, sc.relname, con.conname, sa.attname, tn.nspname, tc.relname, ta.attname FROM pg_constraint con JOIN pg_class sc ON sc.oid = con.conrelid JOIN pg_namespace sn ON sn.oid = sc.relnamespace JOIN pg_class tc ON tc.oid = con.confrelid JOIN pg_namespace tn ON tn.oid = tc.relnamespace CROSS JOIN LATERAL unnest(con.conkey, con.confkey) WITH ORDINALITY AS k(s, t, ord) JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = k.s JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = k.t WHERE con.contype = 'f' AND sn.nspname = {s} AND sc.relname = {t} ORDER BY 3, k.ord"
"SELECT sn.nspname, sc.relname, con.conname, sa.attname, tn.nspname, tc.relname, ta.attname FROM pg_constraint con JOIN pg_class sc ON sc.oid = con.conrelid JOIN pg_namespace sn ON sn.oid = sc.relnamespace JOIN pg_class tc ON tc.oid = con.confrelid JOIN pg_namespace tn ON tn.oid = tc.relnamespace JOIN generate_series(1, current_setting('max_index_keys')::int) AS k(ord) ON k.ord <= array_upper(con.conkey, 1) JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = con.conkey[k.ord] JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = con.confkey[k.ord] WHERE con.contype = 'f' AND sn.nspname = {s} AND sc.relname = {t} ORDER BY 3, k.ord"
),
DbDriver::Mysql => format!(
"SELECT table_schema, table_name, constraint_name, column_name, referenced_table_schema, referenced_table_name, referenced_column_name FROM information_schema.key_column_usage WHERE referenced_table_name IS NOT NULL AND table_schema = {s} AND table_name = {t} ORDER BY constraint_name, ordinal_position"
@@ -671,6 +677,16 @@ pub fn sqlite_trigger_event(sql: &str) -> (String, String) {
(timing.to_owned(), event.to_ascii_lowercase())
}
/// PostgreSQL catalog query `sql` of this module for servers whose catalog predates a column
/// it reads: PostgreSQL before 11 (`prokind`), and the servers built on an older PostgreSQL
/// (openGauss, GaussDB). `None` when it reads none.
pub fn postgres_legacy(sql: &str) -> Option<String> {
let legacy = sql
.replace("CASE WHEN p.prokind = 'p' THEN 'procedure' ELSE 'function' END", "'function'")
.replace("p.prokind IN ('f', 'p')", "NOT p.proisagg AND NOT p.proiswindow");
(legacy != sql).then_some(legacy)
}
/// Rows: `name, kind (function/procedure), arguments, result` of a schema's routines (none in SQLite).
pub fn routines(driver: DbDriver, schema: &str) -> Option<String> {
let s = quote_literal(driver, schema);
@@ -1172,4 +1188,32 @@ mod tests {
assert_eq!(crate::conn::begin_statement(driver), "BEGIN");
assert_eq!(crate::plan::explain_statement(driver, "select 1;"), "EXPLAIN USING TABULAR select 1");
}
#[test]
fn postgres_catalog_queries_run_on_older_servers() {
let pg = DbDriver::Postgres;
// Neither LATERAL (9.3), WITH ORDINALITY (9.4) nor attidentity (10) in any metadata query:
// openGauss / GaussDB parse 9.2's grammar and catalog. `prokind` (11) has its legacy rerun.
let queries = [
schemas(pg, false).to_owned(),
schemas(pg, true).to_owned(),
tables(pg, "s"),
columns(pg, "s", "t"),
indexes(pg, "s", "t"),
completion_columns(pg).to_owned(),
foreign_keys(pg).to_owned(),
table_foreign_keys(pg, "s", "t"),
triggers(pg, "s", "t"),
routines(pg, "s").unwrap(),
sequences(pg, "s").unwrap(),
];
for q in queries {
let upper = q.to_uppercase();
assert!(!["LATERAL", "ORDINALITY", "ATTIDENTITY"].iter().any(|w| upper.contains(w)), "{q}");
}
assert_eq!(postgres_legacy(completion_columns(pg)), None);
let routines = postgres_legacy(&routines(pg, "s").unwrap()).unwrap();
assert!(!routines.contains("prokind") && routines.contains("NOT p.proisagg"));
assert_eq!(postgres_legacy(&indexes(pg, "s", "t")), None);
}
}
+95
Переглянути файл
@@ -133,3 +133,98 @@ async fn a_reused_physical_connection_restores_the_full_default_path() -> IdeRes
);
Ok(())
}
/// Indexes, foreign keys, routines and completion read the catalog with queries every
/// PostgreSQL-protocol server answers, back to the 9.2 core of openGauss / GaussDB (#3637).
#[tokio::test]
async fn table_details_routines_and_completion_on_older_catalogs() -> IdeResult<()> {
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let c = CancellationToken::new();
for stmt in [
"DROP SCHEMA IF EXISTS oi_meta CASCADE",
"CREATE SCHEMA oi_meta",
"CREATE TABLE oi_meta.orders (region INT, id INT, note TEXT DEFAULT 'x', PRIMARY KEY (region, id))",
"CREATE TABLE oi_meta.lines (n INT PRIMARY KEY, o_region INT, o_id INT, \
FOREIGN KEY (o_region, o_id) REFERENCES oi_meta.orders (region, id))",
"CREATE INDEX lines_order ON oi_meta.lines (o_id, o_region)",
"CREATE FUNCTION oi_meta.twice(v INT) RETURNS INT AS 'SELECT v * 2' LANGUAGE sql",
] {
db.execute("p", stmt, 10, &c).await?;
}
let details = db.table_details("p", "oi_meta", "lines").await?;
let index = details.indexes.iter().find(|i| i.name == "lines_order").expect("lines_order");
assert_eq!(index.columns, ["o_id", "o_region"]);
assert!(!index.unique);
assert_eq!(details.foreign_keys.len(), 1, "{:?}", details.foreign_keys);
assert_eq!(details.foreign_keys[0].columns, ["o_region", "o_id"]);
assert_eq!(details.foreign_keys[0].ref_columns, ["region", "id"]);
let orders = db.table_details("p", "oi_meta", "orders").await?;
let key = orders.indexes.iter().find(|i| i.unique).expect("primary key index");
assert_eq!(key.columns, ["region", "id"]);
let objects = db.schema_objects("p", "oi_meta").await?;
assert!(objects.routines.iter().any(|r| r.name == "twice"), "{:?}", objects.routines);
let completion = db.completion("p").await?;
assert!(completion.tables.iter().any(|t| t.schema == "oi_meta" && t.name == "orders"));
db.execute("p", "DROP SCHEMA oi_meta CASCADE", 10, &c).await?;
Ok(())
}
/// Opening a table pairs the columns of composite keys in order, also when a foreign key lists
/// them in another order than the key it references; its data page and DDL read the same catalog,
/// and completion tells identity columns apart in one query (#3637).
#[tokio::test]
async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let c = CancellationToken::new();
for stmt in [
"DROP SCHEMA IF EXISTS oi_keys CASCADE",
"CREATE SCHEMA oi_keys",
"CREATE TABLE oi_keys.pairs (a INT, b INT, PRIMARY KEY (b, a))",
"CREATE TABLE oi_keys.refs (id INT PRIMARY KEY, x INT, y INT, FOREIGN KEY (y, x) REFERENCES oi_keys.pairs (b, a))",
"CREATE UNIQUE INDEX refs_yx ON oi_keys.refs (y, x)",
"INSERT INTO oi_keys.pairs VALUES (1, 2)",
"INSERT INTO oi_keys.refs VALUES (7, 1, 2)",
] {
db.execute("p", stmt, 10, &c).await?;
}
let details = db.table_details("p", "oi_keys", "refs").await?;
let indexes: Vec<_> = details.indexes.iter().map(|i| (i.name.as_str(), i.unique, i.columns.join(","))).collect();
assert_eq!(indexes, [("refs_pkey", true, "id".into()), ("refs_yx", true, "y,x".into())]);
let key = |k: &ide_db::ForeignKey| (k.columns.join(","), k.ref_table.clone(), k.ref_columns.join(","));
assert_eq!(
details.foreign_keys.iter().map(key).collect::<Vec<_>>(),
[("y,x".into(), "pairs".into(), "b,a".into())]
);
let pairs = db.table_details("p", "oi_keys", "pairs").await?;
assert_eq!(pairs.indexes[0].columns, ["b", "a"]);
let page = db.table_page("p", "oi_keys", "refs", None, &[], 0, 10, &c).await?;
assert_eq!(page.result.rows.len(), 1);
// Identity columns (PostgreSQL 10+; openGauss has none) are optional in INSERT.
let identity =
db.execute("p", "CREATE TABLE oi_keys.ids (n INT GENERATED ALWAYS AS IDENTITY, v INT)", 10, &c).await;
let completion = db.completion("p").await?;
if identity.is_ok() {
let ids = completion.tables.iter().find(|t| t.schema == "oi_keys" && t.name == "ids").expect("ids");
let defaults: Vec<_> = ids.columns.iter().map(|c| (c.name.as_str(), c.has_default)).collect();
assert_eq!(defaults, [("n", true), ("v", false)]);
}
assert!(
completion.foreign_keys.iter().any(|k| k.table == "refs" && key(k).2 == "b,a"),
"{:?}",
completion.foreign_keys
);
// The other catalog reads of the tree and its DDL actions, on the same server.
assert!(db.schemas("p").await?.iter().any(|s| s == "oi_keys"));
assert_eq!(db.tables("p", "oi_keys").await?.len(), if identity.is_ok() { 3 } else { 2 });
db.execute("p", "CREATE SEQUENCE oi_keys.seq", 10, &c).await?;
let objects = db.schema_objects("p", "oi_keys").await?;
assert_eq!(objects.sequences.len(), 1);
assert!(db.ddl("p", "oi_keys", "refs").await?.contains("FOREIGN KEY"));
db.execute("p", "DROP SCHEMA oi_keys CASCADE", 10, &c).await?;
Ok(())
}
+3 -1
Переглянути файл
@@ -320,7 +320,8 @@ fn rename_failure(error: &io::Error) -> RenameFailure {
}
/// Only Windows splits these paths. Renames are cheap; cross-volume copies run in
/// the background. Consumers always use Local, even when migration fails.
/// the background. Consumers always use Local, even when migration fails. On every
/// system, tool virtual environments moved from elsewhere are dropped (#3581).
pub fn migrate(data: &Path, local: &Path) {
if cfg!(target_os = "windows") && data != local {
migrate_entries(data, local);
@@ -328,6 +329,7 @@ pub fn migrate(data: &Path, local: &Path) {
if cfg!(target_os = "windows") {
relative_tool_shims(&local.join("tools"));
}
ide_tools::drop_moved_venvs(&local.join("tools"));
}
/// Wrappers written before they named their tool relative to themselves hold its absolute
+8 -8
Переглянути файл
@@ -532,6 +532,14 @@ impl Host {
}
}
impl Host {
/// Lists the JDKs added by hand (global Settings › SDKs) with the detected ones.
pub fn apply_added_jdks(&self) {
let homes = self.global_settings.effective().languages.java.added_jdks;
ide_sdk::java::set_added_jdks(homes.into_iter().map(PathBuf::from));
}
}
#[cfg(test)]
mod tests {
use super::*;
@@ -565,11 +573,3 @@ mod tests {
host.close_project("main");
}
}
impl Host {
/// Lists the JDKs added by hand (global Settings › SDKs) with the detected ones.
pub fn apply_added_jdks(&self) {
let homes = self.global_settings.effective().languages.java.added_jdks;
ide_sdk::java::set_added_jdks(homes.into_iter().map(PathBuf::from));
}
}
+1 -1
Переглянути файл
@@ -331,7 +331,7 @@ targetIndex, or narrow the call with a contextSnippet that shows the one you mea
FileEdit::Rename { from, to } => vec![from, to],
};
for p in paths {
if let Err(e) = super::super::tool::ensure_inside(call.root(), p) {
if let Err(e) = call.ensure_writable_place(p) {
let hint = format!(
"{}. Nothing was renamed. A rename that must change a file outside the project cannot run here.",
e.message
+9 -3
Переглянути файл
@@ -1,4 +1,5 @@
use super::page::{OFFSET, Page};
use super::scope::{self, Scope};
use super::tool::{Call, Output, Param, ParamType, Tool};
use ide_core::{Diagnostic, IdeResult, Severity};
use serde_json::{Map, Value, json};
@@ -14,7 +15,8 @@ pub fn tools() -> Vec<Tool> {
Use this tool to explore current open editors.",
open_editors,
),
)
.param(scope::param()),
Tool::new(
"get_current_file",
"Returns the focused editor's file and selection reported by the IDE.
@@ -43,18 +45,20 @@ Lines and UTF-16 columns are 1-based.",
project_problems,
)
.param(Param::optional("errorsOnly", ParamType::Boolean, "Only errors (default) or warnings too"))
.param(scope::param())
.param(Param::optional("limit", ParamType::Integer, "Problems to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET)),
]
}
async fn open_editors(call: Call) -> IdeResult<Output> {
let dir = Scope::of(&call)?;
let windows = call.host.mcp_windows(call.root());
let open = call.host.mcp_reports.editors(&windows);
let active = call.host.mcp_reports.focused(call.window());
let active = call.host.mcp_reports.focused(call.window()).filter(|e| dir.contains(&e.path.0));
Output::json(json!({
"activeFilePath": active.map(|e| call.display(&e.path.0)),
"openFiles": open.iter().map(|p| call.display(p)).collect::<Vec<_>>(),
"openFiles": open.iter().filter(|p| dir.contains(p)).map(|p| call.display(p)).collect::<Vec<_>>(),
}))
}
@@ -99,9 +103,11 @@ async fn file_problems(call: Call) -> IdeResult<Output> {
async fn project_problems(call: Call) -> IdeResult<Output> {
let page = Page::of(&call, PROBLEMS_LIMIT)?;
let errors_only = call.flag("errorsOnly", true)?;
let dir = Scope::of(&call)?;
let files = call.host.mcp_reports.problems(&call.host.mcp_windows(call.root()));
let problems: Vec<(String, Value)> = files
.into_iter()
.filter(|f| dir.contains(&f.path.0))
.flat_map(|f| {
let path = call.display(&f.path.0);
let wanted = f.items.into_iter().filter(|d| !errors_only || d.severity == Severity::Error);
+5 -2
Переглянути файл
@@ -167,7 +167,10 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
}
call.confirm(&subject, Some(detail)).await?;
let exchange = ide_http::run(input, &call.cancel).await?;
// Exactly the request the user approved: preparing it again would read the
// environment files again, which may name another destination by now.
let redact_url = prepared.url.clone();
let exchange = ide_http::send(prepared, Some(&path), &call.cancel).await?;
let history = call.project().http_history.clone();
let saved = exchange.clone();
let _ = call.host().blocking(move || history.add(&saved)).await;
@@ -188,7 +191,7 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
"status": response.map(|r| r.status),
"statusText": response.map(|r| r.status_text.clone()),
"totalMs": response.map(|r| r.total_ms).or(exchange.entry.total_ms),
"error": redact_transport_error(exchange.entry.error.clone(), &prepared.url),
"error": redact_transport_error(exchange.entry.error.clone(), &redact_url),
"body": body,
"bodyTruncated": body_truncated,
}))
+16 -15
Переглянути файл
@@ -10,6 +10,7 @@ mod files;
mod http;
mod page;
mod reports;
mod scope;
mod search;
mod symbols;
mod tool;
@@ -54,14 +55,17 @@ impl Registry {
if self.0.mcp_reports.remote_roots().iter().any(|p| p == root) {
return Err("not supported for remote projects yet".into());
}
let mut windows: Vec<_> = self
.0
.projects
.read()
.iter()
.filter(|(_, p)| p.root == root && !p.light)
.map(|(w, p)| (w.clone(), p.clone()))
.collect();
let projects = self.0.projects.read();
let open = || projects.iter().filter(|(_, p)| !p.light);
let mut windows: Vec<_> = open().filter(|(_, p)| p.root == root).map(|(w, p)| (w.clone(), p.clone())).collect();
if windows.is_empty() {
// A project attached to an open one: the window it is attached in.
windows = open()
.filter(|(_, p)| tool::attached_projects(&p.root).iter().any(|a| a == root))
.map(|(w, p)| (w.clone(), p.clone()))
.collect();
}
drop(projects);
let focused = self.0.mcp_reports.focused_window();
windows.sort_by(|a, b| {
(Some(&b.0) == focused.as_ref()).cmp(&(Some(&a.0) == focused.as_ref())).then(a.0.cmp(&b.0))
@@ -71,13 +75,10 @@ impl Registry {
}
impl ToolRegistry for Registry {
fn projects(&self) -> Vec<PathBuf> {
self.0
.projects()
.into_iter()
.filter(|p| !p.light)
.map(|p| p.root.clone())
.chain(self.0.mcp_reports.remote_roots())
.collect()
let open: Vec<_> = self.0.projects().into_iter().filter(|p| !p.light).collect();
// Attached projects are listed too, so a `projectPath` inside one names it.
let attached: Vec<_> = open.iter().flat_map(|p| tool::attached_projects(&p.root)).collect();
open.into_iter().map(|p| p.root.clone()).chain(attached).chain(self.0.mcp_reports.remote_roots()).collect()
}
fn tools(&self, root: &Path) -> Result<Vec<ide_mcp::Tool>, String> {
let (_, project) = self.target(root)?;
+17 -4
Переглянути файл
@@ -128,9 +128,11 @@ pub fn run_command() -> Tool {
&format!(
"Runs a shell command line in a new or reused tab of OpenIDEA's Run tool window, with the shell of \
Settings › Tools › Terminal. The user is asked first (unless the IDE runs tools without \
confirmation). Waits up to `timeout` milliseconds (default {RUN_TIMEOUT_MS}) for the command to finish; a command \
still running then keeps running, and `wait_for_run`, `read_run_output`, `get_run_status`, `send_run_input` and \
`stop_run` follow it up by name. Returns the tab's status (`state`: starting, running, stopping, succeeded, failed, \
confirmation). Waits up to `timeout` milliseconds (default {RUN_TIMEOUT_MS}) for the command to finish, or until its \
output matches `pattern`; a command still running then keeps running, and `wait_for_run`, `read_run_output`, \
`get_run_status`, `send_run_input` and `stop_run` follow it up by name. A server, watcher or app never finishes: to \
start one, pass `pattern` for the line it prints once ready (e.g. `Listening on|Started .* in|ready in`) rather than \
a long `timeout`, so the call returns as soon as it is up. Returns the tab's status (`state`: starting, running, stopping, succeeded, failed, \
crashed, stoppedByAgent, stoppedByUser or startFailed; `exitCode`; `crash` with the signal or exception of a crashed \
process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
),
@@ -152,6 +154,7 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
};
let env = call.args.get("envs").filter(|v| !v.is_null()).map(|_| call.str_map("envs")).transpose()?;
let deadline = deadline(&call, RUN_TIMEOUT_MS)?;
let ready = pattern(&call)?;
let host = call.host();
let runs = &host.mcp_agent_runs;
if let Some(run) = runs.get(call.root(), &name).filter(|r| r.running()) {
@@ -185,7 +188,7 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
return Err(IdeError::invalid(format!("`{name}` did not start: {error}")));
}
let from = run.process_offset();
let end = run.wait(deadline, None, from, &call.cancel).await?;
let end = run.wait(deadline, ready.as_ref(), from, &call.cancel).await?;
let mut extra = output_view(&call, &run, from)?;
extra.insert("waitEnded".into(), end.as_str().into());
result(&run, extra)
@@ -209,6 +212,12 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
ParamType::Integer,
"Milliseconds to wait for the command to finish before returning (0 returns once it started); the command \
keeps running after it",
))
.param(Param::optional(
"pattern",
ParamType::String,
"Regular expression that ends the wait when the command's output matches it: the ready line of a server or \
watcher. `waitEnded` is then `matched`",
))
.param(Param::optional("maxLinesCount", ParamType::Integer, MAX_LINES))
.param(Param::optional("truncateMode", ParamType::String, TRUNCATE_MODE))
@@ -296,6 +305,7 @@ pub fn list_runs() -> Tool {
start of the command, exit code and times. `get_run_status` gives a tab's whole status.",
|call| async move {
let page = Page::of(&call, LIST_LIMIT)?;
let dir = crate::mcp::scope::Scope::of(&call)?;
let wanted = call.opt_str("state")?.filter(|s| s != "all");
let states = match wanted.as_deref() {
None => None,
@@ -316,6 +326,8 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
.iter()
.rev()
.map(|r| r.status())
// A tab belongs where its command runs.
.filter(|s| dir.contains_shown(call.root(), s["workingDirectory"].as_str().unwrap_or_default()))
.filter(|s| {
states.as_ref().is_none_or(|states| s["state"].as_str().is_some_and(|v| states.contains(&v)))
})
@@ -332,6 +344,7 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
ParamType::String,
"all (default), running, idle (not running), error (failed, crashed, startFailed), or one state",
))
.param(crate::mcp::scope::param())
.param(Param::optional("limit", ParamType::Integer, "Tabs to return at most (default 10)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
+6
Переглянути файл
@@ -139,8 +139,13 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
}
let page = Page::of(&call, CONFIGURATIONS_LIMIT)?;
let query = call.opt_str("query")?.map(|q| q.to_lowercase());
let dir = crate::mcp::scope::Scope::of(&call)?;
let list: Vec<Value> = configs
.iter()
// A configuration belongs where it runs.
.filter(|c| {
dir.contains(&c.cwd.as_deref().map_or_else(|| call.root().to_path_buf(), |d| call.root().join(d)))
})
.filter(|c| {
query.as_ref().is_none_or(|q| {
[c.name.as_str(), c.kind.as_str(), command_line(c).as_str()]
@@ -164,6 +169,7 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
in the file instead of project-wide run configurations.",
))
.param(Param::optional("query", ParamType::String, "Only configurations whose name, type or command contains it"))
.param(crate::mcp::scope::param())
.param(Param::optional("limit", ParamType::Integer, "Configurations to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
+51
Переглянути файл
@@ -0,0 +1,51 @@
//! The `scope` argument of the query tools: the directory their results are limited to, a
//! folder of the project or a project attached to it.
use crate::mcp::tool::{Call, Param, ParamType};
use ide_core::{IdeError, IdeResult};
use std::path::{Path, PathBuf};
pub fn param() -> Param {
Param::optional(
"scope",
ParamType::String,
"Directory to limit results to: relative to the project root, or absolute",
)
}
/// No `scope`: everything.
pub struct Scope(Option<PathBuf>);
impl Scope {
pub fn of(call: &Call) -> IdeResult<Self> {
let Some(raw) = call.opt_str("scope")?.filter(|s| !s.trim().is_empty()) else { return Ok(Self(None)) };
let given = Path::new(raw.trim());
let path = crate::mcp::tool::normalize(&if given.is_absolute() {
given.to_path_buf()
} else {
call.root().join(given)
});
let path = dunce::canonicalize(&path).unwrap_or(path);
if !path.is_dir() {
return Err(IdeError::not_found(format!("scope {raw} is not a directory")));
}
let roots = std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots());
if !roots.into_iter().any(|root| path.starts_with(root)) {
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
}
Ok(Self(Some(path)))
}
pub fn dir(&self) -> Option<&Path> {
self.0.as_deref()
}
pub fn contains(&self, path: &Path) -> bool {
self.0.as_ref().is_none_or(|dir| path.starts_with(dir))
}
/// For a path the tools return: project-relative with `/`, or absolute.
pub fn contains_shown(&self, root: &Path, path: &str) -> bool {
self.0.is_none() || self.contains(&root.join(path))
}
}
+45 -15
Переглянути файл
@@ -6,6 +6,7 @@
//! the editor (one per character except emoji and other astral characters).
use crate::mcp::page::{OFFSET, Page};
use crate::mcp::scope::{self, Scope};
use crate::mcp::tool::{Call, Output, Param, ParamType, Tool};
use crate::mcp::util::{INDEXING_PARTIAL_RESULT_REASON, MEDIUM_TIMEOUT};
use crate::ops::search::SearchEvent;
@@ -67,6 +68,7 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|call| async move { text_search(call, false).await },
)
.param(Param::required("q", ParamType::String, "Text to search for"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
@@ -89,6 +91,7 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|call| async move { text_search(call, true).await },
)
.param(Param::required("q", ParamType::String, "Regex pattern to search for"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
@@ -110,6 +113,7 @@ If you don't find a suitable result, try again with include_external=true to sea
|call| async move { symbol_search(call).await },
)
.param(Param::required("q", ParamType::String, "Symbol query text"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(Param::optional(
"include_external",
@@ -136,6 +140,7 @@ Paths are optional additional glob filters relative to the project root.",
|call| async move { file_search(call).await },
)
.param(Param::required("q", ParamType::String, "Glob pattern to search for"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(Param::optional(
"includeExcluded",
@@ -539,6 +544,7 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
let pattern = query(&call, if is_regex { "Regex pattern is empty" } else { "Search text is empty" })?;
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
let around = context(&call)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
// Globs Find in Files cannot take are applied afterwards, so the engine must not
// stop at `limit` matches the filter may drop.
@@ -559,7 +565,8 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
whole_word: false,
include,
exclude,
scope: SearchScope::Project,
// Only `scope` is walked.
scope: dir.dir().map_or(SearchScope::Project, |d| SearchScope::Directory { path: d.to_path_buf().into() }),
max_matches,
context: Default::default(),
};
@@ -568,8 +575,12 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
}
let (files, summary, timed_out) = run_search(&call, query.clone()).await?;
// Content roots outside the project are reported by absolute path.
let mut files: Vec<(String, FileMatches)> =
files.into_iter().map(|f| (call.display(&f.path.0), f)).filter(|(path, _)| scope.matches(path)).collect();
let mut files: Vec<(String, FileMatches)> = files
.into_iter()
.filter(|f| dir.contains(&f.path.0))
.map(|f| (call.display(&f.path.0), f))
.filter(|(path, _)| scope.matches(path))
.collect();
files.sort_by(|a, b| a.0.cmp(&b.0));
// Only these can match a line break.
let may_span = is_regex || pattern.contains('\n');
@@ -739,6 +750,7 @@ async fn run_search(call: &Call, query: SearchQuery) -> IdeResult<(Vec<FileMatch
async fn file_search(call: Call) -> IdeResult<Output> {
let q = query(&call, "Glob pattern is empty")?;
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
let include_excluded = call.flag("includeExcluded", false)?;
let glob = GlobSetBuilder::new()
@@ -748,10 +760,19 @@ async fn file_search(call: Call) -> IdeResult<Output> {
// Ignored names and "Exclude files" patterns, which `read_dir` does not flag.
let excludes = if include_excluded { None } else { Some(FileMask::new(&[], &call.project().search_excludes())?) };
let root = call.root().to_path_buf();
// The project folder and the content roots outside it.
let roots: Vec<PathBuf> = std::iter::once(root.clone())
.chain(call.project().content_roots().into_iter().filter(|r| relative_to_root(&root, r).is_none()))
.collect();
// `scope`, or the project folder and the content roots its walk does not cover: those
// outside it and those inside it that it skips as ignored.
let roots: Vec<PathBuf> = match dir.dir() {
Some(dir) => vec![dir.to_path_buf()],
None => std::iter::once(root.clone())
.chain(
call.project()
.content_roots()
.into_iter()
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r)),
)
.collect(),
};
let host = call.host();
let walk = Walk {
host: host.clone(),
@@ -832,9 +853,9 @@ impl Walk {
}
}
EntryKind::File => {
// Files of content roots outside the project go by absolute path.
// Files of content roots outside the project go by absolute path, with `/` as elsewhere.
let path = relative_to_root(&self.root, &entry.path)
.unwrap_or_else(|| entry.path.to_string_lossy().into_owned());
.unwrap_or_else(|| entry.path.to_string_lossy().replace('\\', "/"));
if self.glob.is_match(&path) && self.scope.matches(&path) {
if found.len() == self.limit {
return true;
@@ -856,23 +877,32 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
let q = query(&call, "Search query is empty")?;
let (page, limit) = page(&call, SYMBOL_SEARCH_DEFAULT_LIMIT)?;
let around = context(&call)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
let external = call.flag("include_external", false)?;
let host = call.host();
let project = call.project().clone();
let indexing_before = project.index.status().indexing;
let pool = if scope.is_all() { limit + 1 } else { ((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL) };
let pool = if scope.is_all() && dir.dir().is_none() {
limit + 1
} else {
((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL)
};
let found = {
let (project, q) = (project.clone(), q.clone());
host.blocking(move || Ok(project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool))).await?
};
let mut items: Vec<SearchItem> = found
.into_iter()
.filter(|s| scope.matches(&s.rel_path))
.map(|s| SearchItem {
// By the path the other tools give: the index shows a root outside the project by its
// folder name, which is no path to read.
.filter(|s| dir.contains(&s.path.0))
.map(|s| (call.display(&s.path.0), s))
.filter(|(path, _)| scope.matches(path))
.map(|(path, s)| SearchItem {
name: Some(s.name),
container: s.container.filter(|c| !c.is_empty()),
..SearchItem::at(s.rel_path, s.range)
..SearchItem::at(path, s.range)
})
.collect();
let mut timed_out = false;
@@ -882,9 +912,9 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
timed_out = out_of_time;
for (name, container, location) in symbols {
let path = location.uri.clone().unwrap_or_else(|| call.display(&location.path));
// Project files obey `paths`; library symbols are what was asked for.
// Project files obey `scope` and `paths`; library symbols are what was asked for.
let inside = location.uri.is_none() && !Path::new(&path).is_absolute();
if inside && !scope.matches(&path) {
if inside && !(dir.contains_shown(call.root(), &path) && scope.matches(&path)) {
continue;
}
let item = SearchItem {
+8 -1
Переглянути файл
@@ -211,6 +211,7 @@ pub fn find_references() -> Tool {
Tool::new("find_references", "Find references using the language service and the IDE's project index. Positions are 1-based UTF-16. Reports incomplete results when analysis is still running.", |call| async move {
let path = call.resolve_readable(&call.str("filePath")?).await?;
let page = super::page::Page::of(&call, REFERENCES_LIMIT)?;
let dir = super::scope::Scope::of(&call)?;
let line = call.opt_i64("line")?.ok_or_else(|| IdeError::invalid("missing line"))?;
let column = call.opt_i64("column")?.ok_or_else(|| IdeError::invalid("missing column"))?;
let project = call.project.clone();
@@ -248,7 +249,12 @@ pub fn find_references() -> Tool {
// `classified`, when there, goes with `locations` one to one.
if let serde_json::Value::Object(map) = &mut value {
let mut list = |key: &str| match map.remove(key) { Some(serde_json::Value::Array(items)) => items, _ => Vec::new() };
let (locations, classified) = (list("locations"), list("classified"));
let (mut locations, mut classified) = (list("locations"), list("classified"));
if dir.dir().is_some() {
let inside = |l: &serde_json::Value| l["path"].as_str().is_some_and(|p| dir.contains(std::path::Path::new(p)));
locations.retain(inside);
classified.retain(|c| inside(&c["location"]));
}
let classified = page.take(classified, &mut serde_json::Map::new());
let locations = page.take(locations, map);
map.insert("locations".into(), locations.into());
@@ -260,6 +266,7 @@ pub fn find_references() -> Tool {
.param(Param::required("line", ParamType::Integer, "1-based line"))
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
.param(Param::optional("includeDeclaration", ParamType::Boolean, "Include declarations (default true)"))
.param(super::scope::param())
.param(Param::optional("limit", ParamType::Integer, "References to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
}
+33 -2
Переглянути файл
@@ -37,7 +37,12 @@ impl Call {
.collect()
}
pub fn resolve_inside(&self, path: &str) -> IdeResult<PathBuf> {
resolve_inside(self.root(), path)
resolve_inside(self.root(), path).or_else(|e| {
// An absolute path may name a trusted attached project, wherever it is.
let absolute = path.starts_with("file://") || Path::new(path).is_absolute();
let attached = if absolute { self.trusted_attachments() } else { Vec::new() };
attached.iter().find_map(|root| resolve_inside(root, path).ok()).ok_or(e)
})
}
pub async fn resolve_writable(&self, path: &str) -> IdeResult<PathBuf> {
let path = self.resolve_inside(path)?;
@@ -46,7 +51,24 @@ impl Call {
}
pub async fn check_writable(&self, path: &Path) -> IdeResult<()> {
self.project.require_trust()?;
ensure_inside(self.root(), path)
self.ensure_writable_place(path)
}
/// `path` is inside the project or a trusted project attached to it.
pub fn ensure_writable_place(&self, path: &Path) -> IdeResult<()> {
ensure_inside(self.root(), path).or_else(|e| {
if self.trusted_attachments().iter().any(|root| ensure_inside(root, path).is_ok()) {
Ok(())
} else {
Err(e)
}
})
}
/// The projects attached to this one that the user trusts (each is trusted on its own).
fn trusted_attachments(&self) -> Vec<PathBuf> {
attached_projects(self.root())
.into_iter()
.filter(|root| self.host.trust.trusted(root).unwrap_or(false))
.collect()
}
pub async fn ask(&self, request: ide_core::event::McpUiRequest) -> IdeResult<()> {
self.host.mcp_requests.ask(self, request).await
@@ -300,3 +322,12 @@ pub fn resolve_inside(root: &Path, raw: &str) -> IdeResult<PathBuf> {
pub fn ensure_inside(root: &Path, path: &Path) -> IdeResult<()> {
resolve_inside(root, &path.to_string_lossy()).map(|_| ())
}
/// The projects attached to the one at `root` (its workspace members), `root` itself left out.
pub(crate) fn attached_projects(root: &Path) -> Vec<PathBuf> {
ide_workspace::workspace::Workspace::load(root)
.ok()
.flatten()
.map(|w| w.projects.into_iter().filter(|p| p != root).collect())
.unwrap_or_default()
}
+14 -6
Переглянути файл
@@ -29,7 +29,7 @@ fn relative_to(root: &Path, path: &Path) -> String {
};
match rel {
Some(rel) => rel.to_string_lossy().replace('\\', "/"),
None => path.to_string_lossy().into_owned(),
None => path.to_string_lossy().replace('\\', "/"),
}
}
@@ -266,11 +266,16 @@ By default all Git repositories are returned.",
.map(|r| (r.root.into_path_buf(), r.head))
.collect();
let wanted = call.opt_str("repositoryPathRelativeToProject")?;
let scope = super::scope::Scope::of(&call)?;
let git = git_executable(&call);
let mut roots: Vec<(PathBuf, Option<String>)> = match &wanted {
// A repository asked for, or the one holding `scope`.
let target = match &wanted {
Some(wanted) => Some(call.resolve_inside(wanted)?),
None => scope.dir().map(Path::to_path_buf),
};
let mut roots: Vec<(PathBuf, Option<String>)> = match target {
None => repos,
Some(wanted) => {
let path = call.resolve_inside(wanted)?;
Some(path) => {
// The innermost repository containing the path.
match innermost_repo(repos, &path) {
Some(repo) => vec![repo],
@@ -282,7 +287,8 @@ By default all Git repositories are returned.",
vec![(root, branch)]
}
None => {
return Err(IdeError::not_found(format!("No git repository found for path: {wanted}")));
let shown = wanted.unwrap_or_else(|| call.display(&path));
return Err(IdeError::not_found(format!("No git repository found for path: {shown}")));
}
},
}
@@ -293,12 +299,13 @@ By default all Git repositories are returned.",
for (root, branch) in roots {
let rel = relative_to_project(&call, &root);
let (git, dir) = (git.clone(), root.clone());
let entries = host
let mut entries = host
.blocking(move || read_status(&git, &dir, include_untracked, include_ignored))
.await
.map_err(|e| {
IdeError::internal(format!("Failed to get git status for repository '{rel}': {}", e.message))
})?;
entries.retain(|e| scope.contains(&root.join(e.path.trim_end_matches('/'))));
let count = |f: fn(&StatusEntry) -> bool| entries.iter().filter(|e| f(e)).count();
let listed: Vec<Value> = entries
.iter()
@@ -345,6 +352,7 @@ By default all Git repositories are returned.",
))
.param(Param::optional("includeUntracked", ParamType::Boolean, "Whether to include untracked files"))
.param(Param::optional("includeIgnored", ParamType::Boolean, "Whether to include ignored files"))
.param(super::scope::param())
.param(Param::optional("limit", ParamType::Integer, "Entries to return per repository at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
+300 -33
Переглянути файл
@@ -8,7 +8,8 @@ use ide_agent::registry::{AgentRegistry, RegistryPaths};
use ide_agent::{
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentEntry,
AgentEvent, AgentModelCatalog, AgentProbe, AgentPrompt, AgentProvider, AgentQueued, AgentTask, CustomAgentInput,
ExternalSession, McpScope, McpServer, McpServerInput, NewAgentTask,
ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput,
McpTransport, NewAgentTask,
};
use ide_core::error::ErrorKind;
use ide_core::{IdeError, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
@@ -261,18 +262,6 @@ pub async fn fork(host: &Host, window: &str, task: String, turns: Option<u32>) -
host.project(window)?.agents.fork(&task, turns).await
}
/// Creates a temporary side conversation of `source`: lives in memory only, never
/// persisted, not listed.
pub async fn create_ephemeral(
host: &Host,
window: &str,
request: NewAgentTask,
source: String,
) -> IdeResult<AgentTask> {
host.require_trust(window)?;
host.project(window)?.agents.create_ephemeral(request, &source).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>> {
host.require_trust(window)?;
@@ -477,19 +466,21 @@ fn persist_mcp_map(
Ok(())
}
fn update_mcp_maps<F>(host: &Host, window: &str, approve: Option<&str>, f: F) -> IdeResult<Vec<McpServer>>
fn update_mcp_maps<F>(host: &Host, window: &str, approve: &[String], f: F) -> IdeResult<Vec<McpServer>>
where
F: FnOnce(&mut McpServerMap, &mut McpServerMap, Option<&std::path::Path>) -> Result<(), String>,
F: FnOnce(&mut McpServerMap, &mut McpServerMap, Option<&std::path::Path>) -> Result<Vec<String>, String>,
{
let (mut user, mut workspace, project) = mcp_maps(host, window);
let prev_user = user.clone();
let prev_workspace = workspace.clone();
let project_root = project.as_ref().map(|p| p.root.as_path());
f(&mut user, &mut workspace, project_root).map_err(IdeError::invalid)?;
if let (Some(name), Some(p)) = (approve, &project)
&& let Some(server) = workspace.get(name)
{
host.mcp_approvals.approve(&p.root, name, server)?;
let extra_approved = f(&mut user, &mut workspace, project_root).map_err(IdeError::invalid)?;
if let Some(p) = &project {
for name in approve.iter().chain(extra_approved.iter()) {
if let Some(server) = workspace.get(name.as_str()) {
host.mcp_approvals.approve(&p.root, name, server)?;
}
}
}
if workspace != prev_workspace {
persist_mcp_map(host, project.as_ref(), McpScope::Workspace, &workspace)?;
@@ -507,11 +498,22 @@ fn listed(
user: &McpServerMap,
workspace: McpServerMap,
) -> Vec<McpServer> {
let raw_workspace = workspace.clone();
let workspace = match project {
Some(p) => host.mcp_approvals.apply(&p.root, workspace),
None => workspace,
};
ide_agent::mcp::servers_from_settings(user, &workspace)
let mut out = ide_agent::mcp::servers_from_settings(user, &workspace);
if let Some(p) = project {
for srv in &mut out {
if srv.scope == McpScope::Workspace
&& let Some(raw) = raw_workspace.get(&srv.name)
{
srv.unapproved = !host.mcp_approvals.approved(&p.root, &srv.name, raw);
}
}
}
out
}
/// The MCP servers agent sessions of the project at `root` get: the user's, values filled in, and
@@ -525,7 +527,8 @@ pub(crate) fn session_mcp_servers(
use ide_workspace::settings::SettingsScope;
let mut user = settings.layer(SettingsScope::Global).agents.mcp_servers;
fill_mcp_values(secrets, &mut user);
let workspace = approvals.apply(root, settings.layer(SettingsScope::Project).agents.mcp_servers);
let mut workspace = settings.layer(SettingsScope::Project).agents.mcp_servers;
workspace.retain(|name, srv| approvals.approved(root, name, srv));
ide_agent::mcp::servers_from_settings(&user, &workspace)
}
@@ -538,39 +541,292 @@ pub fn mcp_list(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
/// Creates or updates a User or Workspace MCP server and returns the updated list. A Workspace
/// server saved here is one the user turned on.
pub fn mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<Vec<McpServer>> {
let approve = (input.scope == McpScope::Workspace).then(|| input.name.trim().to_owned());
update_mcp_maps(host, window, approve.as_deref(), |user, workspace, project_root| {
ide_agent::mcp::apply_save(user, workspace, project_root.is_some(), input)
let approve: Vec<String> =
(input.scope == McpScope::Workspace).then(|| input.name.trim().to_owned()).into_iter().collect();
update_mcp_maps(host, window, &approve, |user, workspace, project_root| {
ide_agent::mcp::apply_save(user, workspace, project_root.is_some(), input).map(|()| Vec::new())
})
}
/// Parses and saves one or more MCP servers from a pasted JSON snippet (`{"mcpServers": {...}}` or
/// single server object). Workspace servers explicitly saved here by the user are approved.
pub fn mcp_save_json(
host: &Host,
window: &str,
scope: McpScope,
raw_json: String,
fallback_name: Option<String>,
agents: Vec<String>,
) -> IdeResult<Vec<McpServer>> {
update_mcp_maps(host, window, &[], |user, workspace, project_root| {
let saved = ide_agent::mcp::apply_save_json(
user,
workspace,
project_root.is_some(),
scope,
&raw_json,
fallback_name.as_deref(),
agents,
)?;
Ok(if scope == McpScope::Workspace { saved } else { Vec::new() })
})
}
/// Enables or disables an MCP server and returns the updated list.
pub fn mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) -> IdeResult<Vec<McpServer>> {
let approve = ide_agent::mcp::parse_server_id(&id)
let approve: Vec<String> = ide_agent::mcp::parse_server_id(&id)
.filter(|(scope, _)| enabled && *scope == McpScope::Workspace)
.map(|(_, name)| name.to_owned());
update_mcp_maps(host, window, approve.as_deref(), |user, workspace, _| {
ide_agent::mcp::apply_set_enabled(user, workspace, &id, enabled).map(|_| ())
.map(|(_, name)| name.to_owned())
.into_iter()
.collect();
update_mcp_maps(host, window, &approve, |user, workspace, _| {
ide_agent::mcp::apply_set_enabled(user, workspace, &id, enabled).map(|_| Vec::new())
})
}
/// Removes a User or Workspace MCP server and returns the updated list.
pub fn mcp_remove(host: &Host, window: &str, id: String) -> IdeResult<Vec<McpServer>> {
update_mcp_maps(host, window, None, |user, workspace, _| {
ide_agent::mcp::apply_remove(user, workspace, &id).map(|_| ())
update_mcp_maps(host, window, &[], |user, workspace, _| {
ide_agent::mcp::apply_remove(user, workspace, &id).map(|_| Vec::new())
})
}
/// Copies MCP servers from `.mcp.json` and `.vscode/mcp.json` into the workspace settings once;
/// they stay off until the user turns them on.
pub fn mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
update_mcp_maps(host, window, None, |_, workspace, project_root| {
update_mcp_maps(host, window, &[], |_, workspace, project_root| {
let root = project_root.ok_or_else(|| "Open a project to import workspace MCP servers".to_string())?;
ide_agent::mcp::apply_import(workspace, root);
Ok(())
Ok(Vec::new())
})
}
/// Discovers external MCP configuration files on disk (CLI user configs + workspace `.mcp.json`).
pub async fn mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<McpExternalSource>> {
let project_root = host.project(window).ok().filter(|p| !p.light).map(|p| p.root.clone());
let home = dirs::home_dir();
tokio::task::spawn_blocking(move || {
ide_agent::mcp::discover_external_sources(home.as_deref(), project_root.as_deref())
})
.await
.map_err(|e| IdeError::internal(e.to_string()))
}
/// Imports selected servers from discovered external MCP configuration files into User or Workspace scope.
/// Imported Workspace entries remain unapproved (disabled) until the user explicitly enables them.
pub async fn mcp_import_selected(
host: &Host,
window: &str,
scope: McpScope,
selections: Vec<McpImportSelection>,
overwrite: bool,
) -> IdeResult<Vec<McpServer>> {
let home = dirs::home_dir();
update_mcp_maps(host, window, &[], move |user, workspace, project_root| {
ide_agent::mcp::apply_import_selected(
user,
workspace,
home.as_deref(),
project_root,
scope,
&selections,
overwrite,
)?;
Ok(Vec::new())
})
}
/// Tests an MCP server by connecting (`initialize`) and listing its tools (`tools/list`).
pub async fn mcp_test(host: &Host, window: &str, id: String) -> IdeResult<McpProbeResult> {
host.require_trust(window)?;
let (user, workspace, project) = mcp_maps(host, window);
let (scope, name) = ide_agent::mcp::parse_server_id(&id)
.ok_or_else(|| IdeError::not_found(format!("MCP server `{id}` not found")))?;
let server = match scope {
McpScope::User => user.get(name),
McpScope::Workspace => workspace.get(name),
}
.cloned()
.ok_or_else(|| IdeError::not_found(format!("MCP server `{name}` not found")))?;
if scope == McpScope::Workspace {
let p = project.as_ref().ok_or_else(|| IdeError::invalid("Open a project to test workspace MCP servers"))?;
if !host.mcp_approvals.approved(&p.root, name, &server) {
return Err(IdeError::invalid("Enable this workspace MCP server first before testing it"));
}
}
let cwd = project.as_ref().map(|p| p.root.clone()).or_else(dirs::home_dir).unwrap_or_else(std::env::temp_dir);
match server.transport {
McpTransport::Stdio => Ok(ide_agent::mcp::probe_stdio_server(&server, &cwd).await),
McpTransport::Http | McpTransport::Sse => Ok(probe_http_mcp_server(&server).await),
}
}
async fn probe_http_mcp_server(server: &ide_core::settings::AgentMcpServer) -> McpProbeResult {
let started = std::time::Instant::now();
let elapsed_ms = || u32::try_from(started.elapsed().as_millis()).unwrap_or(u32::MAX);
let Some(url) = server.url.as_deref().map(str::trim).filter(|u| !u.is_empty()) else {
return McpProbeResult {
ok: false,
server_name: None,
server_version: None,
protocol_version: None,
tools: Vec::new(),
duration_ms: elapsed_ms(),
error: Some("URL is empty".into()),
};
};
let mut headers = reqwest::header::HeaderMap::new();
headers.insert(
reqwest::header::ACCEPT,
reqwest::header::HeaderValue::from_static("application/json, text/event-stream"),
);
for (k, v) in &server.headers {
if let (Ok(name), Ok(val)) =
(reqwest::header::HeaderName::from_bytes(k.as_bytes()), reqwest::header::HeaderValue::from_str(v))
{
headers.insert(name, val);
}
}
let client =
match reqwest::Client::builder().default_headers(headers).timeout(std::time::Duration::from_secs(12)).build() {
Ok(c) => c,
Err(e) => {
return McpProbeResult {
ok: false,
server_name: None,
server_version: None,
protocol_version: None,
tools: Vec::new(),
duration_ms: elapsed_ms(),
error: Some(format!("HTTP client error: {e}")),
};
}
};
let post_rpc = |session_id: Option<String>, body: serde_json::Value| {
let client = client.clone();
let url = url.to_owned();
async move {
let mut req =
client.post(&url).header(reqwest::header::CONTENT_TYPE, "application/json").body(body.to_string());
if let Some(sid) = session_id.as_deref() {
req = req.header("Mcp-Session-Id", sid);
}
let resp = req
.send()
.await
.map_err(|e| format!("Request to `{url}` failed: {}", ide_http::client::describe(&e.without_url())))?;
let status = resp.status();
let next_session =
resp.headers().get("mcp-session-id").and_then(|v| v.to_str().ok()).map(str::to_owned).or(session_id);
let text = resp.text().await.map_err(|e| format!("Failed reading response: {e}"))?;
if !status.is_success() {
let detail = text.trim();
let msg = if detail.is_empty() {
format!("HTTP {status}")
} else {
format!("HTTP {status}: {}", detail.chars().take(240).collect::<String>())
};
return Err(msg);
}
Ok((next_session, parse_mcp_http_response(&text)?))
}
};
let init_req = serde_json::json!({
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "2024-11-05",
"capabilities": {},
"clientInfo": { "name": "OpenIDEA", "version": env!("CARGO_PKG_VERSION") },
}
});
let (session_id, init_res) = match post_rpc(None, init_req).await {
Ok(v) => v,
Err(err) => {
return McpProbeResult {
ok: false,
server_name: None,
server_version: None,
protocol_version: None,
tools: Vec::new(),
duration_ms: elapsed_ms(),
error: Some(err),
};
}
};
// Best-effort `notifications/initialized` + `tools/list`.
let mut not_req = client.post(url).header(reqwest::header::CONTENT_TYPE, "application/json").body(
serde_json::json!({
"jsonrpc": "2.0",
"method": "notifications/initialized",
"params": {},
})
.to_string(),
);
if let Some(sid) = session_id.as_deref() {
not_req = not_req.header("Mcp-Session-Id", sid);
}
let _ = not_req.send().await;
let tools_res = post_rpc(
session_id,
serde_json::json!({
"jsonrpc": "2.0",
"id": 2,
"method": "tools/list",
"params": {},
}),
)
.await
.map(|(_, v)| v)
.unwrap_or_else(|_| serde_json::json!({}));
ide_agent::mcp::parse_probe_payloads(&init_res, &tools_res, elapsed_ms())
}
fn parse_mcp_http_response(body: &str) -> Result<serde_json::Value, String> {
let trimmed = body.trim();
if trimmed.is_empty() {
return Ok(serde_json::json!({}));
}
if let Ok(msg) = serde_json::from_str::<serde_json::Value>(trimmed) {
if let Some(err) = msg.get("error") {
let em = err.get("message").and_then(serde_json::Value::as_str).unwrap_or("JSON-RPC error");
return Err(em.to_owned());
}
return Ok(msg.get("result").cloned().unwrap_or(msg));
}
// Streamable HTTP SSE frames (`data: {...}`).
for line in trimmed.lines() {
if let Some(rest) = line.strip_prefix("data:")
&& let Ok(msg) = serde_json::from_str::<serde_json::Value>(rest.trim())
&& (msg.get("result").is_some() || msg.get("error").is_some())
{
if let Some(err) = msg.get("error") {
let em = err.get("message").and_then(serde_json::Value::as_str).unwrap_or("JSON-RPC error");
return Err(em.to_owned());
}
return Ok(msg.get("result").cloned().unwrap_or(msg));
}
}
Err("Unexpected non-JSON MCP response".into())
}
/// Updates per-session MCP server enable/disable overrides on task `task`.
pub fn set_mcp_overrides(
host: &Host,
window: &str,
task: String,
overrides: std::collections::BTreeMap<String, bool>,
) -> IdeResult<AgentTask> {
host.project(window)?.agents.set_mcp_overrides(&task, overrides)
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("agent_subscribe", |c| async move { subscribe(&c.host, &c.window, c.channel("onEvent")?) });
@@ -587,12 +843,23 @@ pub(crate) fn register(d: &mut Dispatcher) {
d.add("agent_registry_remove", |c| async move { registry_remove(&c.host, &c.window, c.arg("id")?).await });
d.add("agent_mcp_list", |c| async move { mcp_list(&c.host, &c.window) });
d.add("agent_mcp_save", |c| async move { mcp_save(&c.host, &c.window, c.arg("input")?) });
d.add("agent_mcp_save_json", |c| async move {
mcp_save_json(&c.host, &c.window, c.arg("scope")?, c.arg("rawJson")?, c.arg("fallbackName")?, c.arg("agents")?)
});
d.add(
"agent_mcp_set_enabled",
|c| async move { mcp_set_enabled(&c.host, &c.window, c.arg("id")?, c.arg("enabled")?) },
);
d.add("agent_mcp_remove", |c| async move { mcp_remove(&c.host, &c.window, c.arg("id")?) });
d.add("agent_mcp_import", |c| async move { mcp_import(&c.host, &c.window) });
d.add("agent_mcp_discover_sources", |c| async move { mcp_discover_sources(&c.host, &c.window).await });
d.add("agent_mcp_import_selected", |c| async move {
mcp_import_selected(&c.host, &c.window, c.arg("scope")?, c.arg("selections")?, c.arg("overwrite")?).await
});
d.add("agent_mcp_test", |c| async move { mcp_test(&c.host, &c.window, c.arg("id")?).await });
d.add("agent_set_mcp_overrides", |c| async move {
set_mcp_overrides(&c.host, &c.window, c.arg("task")?, c.arg("overrides")?)
});
d.add("agent_commands", |c| async move { commands(&c.host, &c.window, c.arg("provider")?, c.arg("task")?).await });
d.add("agent_entries", |c| async move { entries(&c.host, &c.window, c.arg("task")?, c.arg("subagent")?) });
d.add("agent_create", |c| async move { create(&c.host, &c.window, c.arg("request")?).await });
+115
Переглянути файл
@@ -0,0 +1,115 @@
//! Cucumber sources: the project's `.feature` files and the JavaScript / TypeScript files
//! (`@cucumber/cucumber`, `playwright-bdd`) and Java / Kotlin files (cucumber-jvm's
//! `@Given("…")` annotations and Java 8 lambdas) that could define steps, with their text. The UI
//! owns the Gherkin and step-expression parsing and the index it feeds (as for `routes`),
//! so this side stays a cheap scan.
use crate::Host;
use ide_core::IdeResult;
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
use std::sync::Mutex;
use std::sync::atomic::{AtomicUsize, Ordering};
/// Files handed out at most, and bytes in total: a test suite's features and step
/// files fit well inside these, and the UI indexes them once.
const MAX_FILES: usize = 4096;
const MAX_BYTES: usize = 64 << 20;
/// A single source bigger than this is a bundle, not a step file.
const MAX_FILE_BYTES: u64 = 2 << 20;
/// What a step definition call starts with (`Given('…'`, `defineStep(/…/`).
const STEP_CALLS: [&str; 5] = ["Given(", "When(", "Then(", "Step(", "defineStep("];
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct StepSource {
pub path: ide_core::IpcPath,
pub text: String,
/// A Gherkin `.feature` file; otherwise a script defining steps.
pub feature: bool,
}
fn is_feature(path: &Path) -> bool {
path.extension().and_then(|e| e.to_str()).is_some_and(|e| e.eq_ignore_ascii_case("feature"))
}
fn is_script(path: &Path) -> bool {
matches!(
path.extension().and_then(|e| e.to_str()),
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt")
)
}
/// The feature files and step definition files under `root`.
pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
let found: Mutex<Vec<StepSource>> = Mutex::new(Vec::new());
let bytes = AtomicUsize::new(0);
ide_vfs::walk_files(root, excludes, |path| {
let feature = is_feature(path);
if !(feature || is_script(path)) || bytes.load(Ordering::Relaxed) >= MAX_BYTES {
return;
}
if std::fs::metadata(path).map_or(true, |m| m.len() > MAX_FILE_BYTES) {
return;
}
let Ok(text) = std::fs::read_to_string(path) else { return };
if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) {
return;
}
let Ok(mut found) = found.lock() else { return };
if found.len() >= MAX_FILES {
return;
}
bytes.fetch_add(text.len(), Ordering::Relaxed);
found.push(StepSource { path: path.to_path_buf().into(), text, feature });
});
let mut files = found.into_inner().unwrap_or_default();
files.sort_by(|a, b| a.path.cmp(&b.path));
files
}
/// Every Cucumber source of the project (its folder and the content roots outside it).
pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>> {
let project = host.project(window)?;
let mut excludes = project.search_excludes();
// Cucumber's own sources (and every other package's) are not the project's steps.
excludes.push("node_modules".to_owned());
let mut out = Vec::new();
for root in std::iter::once(project.root.clone()).chain(project.content_roots()) {
out.extend(sources_in(&root, &excludes));
}
out.sort_by(|a, b| a.path.cmp(&b.path));
out.dedup_by(|a, b| a.path == b.path);
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn features_and_step_files_are_read_and_nothing_else() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
for dir in ["features", "steps", "src", "node_modules/@cucumber/cucumber/lib"] {
std::fs::create_dir_all(root.join(dir)).unwrap();
}
std::fs::write(root.join("features/cart.feature"), "Feature: Cart\n").unwrap();
std::fs::write(root.join("steps/cart.steps.ts"), "Given('an empty cart', () => {});").unwrap();
std::fs::write(root.join("steps/bdd.mjs"), "const { When } = createBdd();\nWhen(/^I add (\\d+)$/, f);")
.unwrap();
std::fs::write(root.join("src/app.ts"), "export const app = 1;").unwrap();
std::fs::write(root.join("src/CartSteps.java"), "@Given(\"an empty cart\")\npublic void empty() {}").unwrap();
std::fs::write(root.join("src/App.java"), "class App {}").unwrap();
std::fs::write(root.join("src/notes.md"), "Given('x')").unwrap();
std::fs::write(root.join("node_modules/@cucumber/cucumber/lib/index.js"), "Given('x')").unwrap();
let files = sources_in(root, &["node_modules".to_owned()]);
let names: Vec<String> =
files.iter().map(|f| f.path.0.strip_prefix(root).unwrap().to_string_lossy().replace('\\', "/")).collect();
assert_eq!(names, ["features/cart.feature", "src/CartSteps.java", "steps/bdd.mjs", "steps/cart.steps.ts"]);
assert!(files[0].feature && !files[1].feature);
assert!(files[3].text.contains("an empty cart"));
}
}
+4
Переглянути файл
@@ -88,6 +88,10 @@ pub(super) fn load_scopes(root: &Path, scopes: &[Scope]) -> BuildModel {
}
}
combined.gradle.extend(model.gradle);
for b in model.sbt.iter_mut().filter(|_| scope.root != root) {
b.dir = absolute(&scope.root, &b.dir);
}
combined.sbt.extend(model.sbt);
}
combined
}
+41 -6
Переглянути файл
@@ -97,6 +97,8 @@ async fn resolve_launch(
tokio::task::spawn_blocking(move || {
let _external_build = external_build;
let local_repo = ide_sdk::apply::maven_local_repository(&project.root, &settings);
// Module outputs the launch runs from a snapshot of: the originals must not come back.
let mut snapshotted = Vec::new();
let built = if delegated {
let rebuild_on_jdt_errors = rebuild_on_jdt_errors(policy, prefer_maven, info.error_count);
let outputs = project.java_launch_snapshots.lock().build(
@@ -109,6 +111,7 @@ async fn resolve_launch(
)?;
let copies = use_snapshot(&mut info, &outputs.originals, &outputs.snapshot);
apply_external_build_result(&mut info, outputs.failure, outputs.authoritative);
snapshotted = outputs.originals;
copies
} else if external {
let built = compile::build_for_launch(&project.root, &model, &module, test, build_kind, &cancel)?;
@@ -137,7 +140,7 @@ async fn resolve_launch(
&project.build_cache_dir(),
&cancel,
);
merge_maven_launch_classpath(&mut class_paths, &mut info, maven_cp)?;
merge_maven_launch_classpath(&mut class_paths, &mut info, maven_cp, &snapshotted)?;
} else {
append_unique_class_paths(&mut class_paths, std::mem::take(&mut info.class_paths));
}
@@ -298,17 +301,23 @@ fn same_entry(a: &str, b: &str, windows: bool) -> bool {
/// Merge the Maven launch classpath without turning a recoverable probe failure into a
/// failed launch. Cancellation still propagates; ordinary failures keep jdtls' classpath
/// and leave the reason in the run console.
/// and leave the reason in the run console. Maven lists the module's and its reactor
/// siblings' `target/classes`; those in `snapshotted` already run from their snapshot,
/// and listing both would make every resource (MyBatis mapper XML) load twice.
fn merge_maven_launch_classpath(
class_paths: &mut Vec<String>,
info: &mut JavaLaunchInfo,
classpath: IdeResult<String>,
snapshotted: &[PathBuf],
) -> IdeResult<()> {
match classpath {
Ok(classpath) => {
let snapshotted: Vec<_> = snapshotted.iter().map(|p| p.to_string_lossy()).collect();
append_unique_class_paths(
class_paths,
std::env::split_paths(&classpath).map(|path| path.to_string_lossy().into_owned()),
std::env::split_paths(&classpath)
.map(|path| path.to_string_lossy().into_owned())
.filter(|path| !snapshotted.iter().any(|original| same_entry(path, original, cfg!(windows)))),
);
Ok(())
}
@@ -471,20 +480,46 @@ mod tests {
let mut class_paths = vec!["snapshot.jar".to_owned()];
let mut info =
JavaLaunchInfo { class_paths: vec!["snapshot.jar".into(), "jdtls.jar".into()], ..Default::default() };
merge_maven_launch_classpath(&mut class_paths, &mut info, Ok(maven)).unwrap();
merge_maven_launch_classpath(&mut class_paths, &mut info, Ok(maven), &[]).unwrap();
assert_eq!(class_paths, ["snapshot.jar", "maven.jar"]);
merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::internal("offline dependency")))
merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::internal("offline dependency")), &[])
.unwrap();
assert_eq!(class_paths, ["snapshot.jar", "maven.jar", "jdtls.jar"]);
assert!(info.hints[0].contains("offline dependency"), "{:?}", info.hints);
}
/// Maven's launch classpath lists the module's and its reactor siblings' outputs, which
/// the launch already runs from a snapshot: listed twice, MyBatis loads each mapper XML
/// twice and fails with "XML fragments parsed from previous mappers already contains value".
#[test]
fn maven_classpath_leaves_out_outputs_the_launch_runs_from_a_snapshot() {
let web = PathBuf::from("/work/haoke/haoke-web/target/classes");
let service = PathBuf::from("/work/haoke/haoke-service/target/classes");
let maven = std::env::join_paths([
"/work/haoke/haoke-web/target/classes/",
"/work/haoke/haoke-service/target/classes",
"/work/haoke/haoke-api/target/classes",
"/m2/mybatis.jar",
])
.unwrap()
.to_string_lossy()
.into_owned();
let mut class_paths = vec!["/cache/launch-x/0".to_owned(), "/cache/launch-x/1".to_owned()];
let mut info = JavaLaunchInfo::default();
merge_maven_launch_classpath(&mut class_paths, &mut info, Ok(maven), &[web, service]).unwrap();
assert_eq!(
class_paths,
["/cache/launch-x/0", "/cache/launch-x/1", "/work/haoke/haoke-api/target/classes", "/m2/mybatis.jar"]
);
}
#[test]
fn cancelled_maven_classpath_probe_propagates_without_fallback() {
let mut class_paths = vec!["snapshot.jar".to_owned()];
let mut info = JavaLaunchInfo { class_paths: vec!["jdtls.jar".into()], ..Default::default() };
let error = merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::cancelled())).unwrap_err();
let error =
merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::cancelled()), &[]).unwrap_err();
assert_eq!(error.kind, ErrorKind::Cancelled);
assert_eq!(class_paths, ["snapshot.jar"]);
assert!(info.hints.is_empty());
+241
Переглянути файл
@@ -550,6 +550,24 @@ pub async fn lsp_implementations(
result
}
/// 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)`.
pub async fn lsp_implementation_locations(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
pos: Pos,
targets: Vec<Location>,
) -> IdeResult<Vec<Location>> {
let lsp = host.project(window)?.lsp.clone();
let (_, cancel) = begin_position_request(host, window, request, doc, pos).await?;
let result = lsp.implementation_locations(doc, pos, targets, cancel).await;
host.end_request(request);
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)`.
@@ -1173,6 +1191,166 @@ pub async fn lsp_hierarchy_refactor(
.await
}
/// The signature of the method at `pos`, for Change Signature.
pub async fn lsp_signature_info(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
pos: Pos,
) -> IdeResult<MethodSignature> {
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.change_signature_info(doc, pos, cancel).await;
host.end_request(request);
result
}
/// Checks changing the method at `pos` to `signature` and computes the edit without applying it.
#[allow(clippy::too_many_arguments)]
pub async fn lsp_change_signature(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
pos: Pos,
signature: MethodSignature,
delegate: bool,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
let project = host.project(window)?;
let documents = project.documents.clone();
let version = blocking(move || documents.version(doc)).await?;
let cancel = host.begin_request(request);
let result = project.lsp.change_signature(doc, pos, signature, delegate, confirmation, cancel).await;
host.end_request(request);
let mut changed = result?;
blocking(move || {
if project.documents.version(doc)? != version {
return Err(ide_core::IdeError::new(
ide_core::error::ErrorKind::OutOfSync,
"document changed while computing the refactoring; request it again",
));
}
if let Some(edit) = &mut changed.edit {
project.documents.prepare_workspace_edit(edit)?;
}
Ok(changed)
})
.await
}
fn json_argument(args: &str) -> IdeResult<serde_json::Value> {
serde_json::from_str(args).map_err(|e| IdeError::invalid(format!("invalid refactoring arguments: {e}")))
}
fn json_strings(values: Vec<serde_json::Value>) -> Vec<String> {
values.iter().map(serde_json::Value::to_string).collect()
}
/// Where a Java Move code action of `kind` can go; `args` (JSON) carries the code action's own
/// arguments back unchanged, and each destination comes back as JSON.
pub async fn lsp_java_move_destinations(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
kind: String,
args: String,
) -> IdeResult<Vec<String>> {
let args = json_argument(&args)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.java_move_destinations(doc, kind, args, cancel).await;
host.end_request(request);
result.map(json_strings)
}
/// The project's Java source types, for moving a member or type into a class.
pub async fn lsp_java_source_types(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
project_name: Option<String>,
) -> IdeResult<Vec<String>> {
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.java_source_types(doc, project_name, cancel).await;
host.end_request(request);
result.map(json_strings)
}
/// Checks a Java move and computes its edit without applying it.
#[allow(clippy::too_many_arguments)]
pub async fn lsp_java_move(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
kind: String,
args: String,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
let args = json_argument(&args)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.java_move(doc, kind, args, confirmation, cancel).await;
host.end_request(request);
let mut moved = result?;
blocking(move || {
if let Some(edit) = &mut moved.edit {
project.documents.prepare_workspace_edit(edit)?;
}
Ok(moved)
})
.await
}
/// The Java class to extract an interface from: its members and the packages for the interface.
pub async fn lsp_extract_interface_info(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
pos: Pos,
) -> IdeResult<ExtractInterfaceInfo> {
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.extract_interface_info(doc, pos, cancel).await;
host.end_request(request);
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)]
pub async fn lsp_extract_interface(
host: &Host,
window: &str,
request: RequestId,
doc: DocId,
pos: Pos,
members: Vec<String>,
name: String,
destination: String,
confirmation: Option<String>,
) -> IdeResult<ServerRefactored> {
let destination = json_argument(&destination)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = project.lsp.extract_interface(doc, pos, members, name, destination, confirmation, cancel).await;
host.end_request(request);
let mut extracted = result?;
blocking(move || {
if let Some(edit) = &mut extracted.edit {
project.documents.prepare_workspace_edit(edit)?;
}
Ok(extracted)
})
.await
}
pub async fn lsp_rename(
host: &Host,
window: &str,
@@ -1827,6 +2005,17 @@ pub(crate) fn register(d: &mut Dispatcher) {
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 },
@@ -1896,6 +2085,58 @@ pub(crate) fn register(d: &mut Dispatcher) {
)
.await
});
d.add("lsp_signature_info", |c| async move {
lsp_signature_info(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?).await
});
d.add("lsp_change_signature", |c| async move {
lsp_change_signature(
&c.host,
&c.window,
c.arg("request")?,
c.arg("doc")?,
c.arg("pos")?,
c.arg("signature")?,
c.arg("delegate")?,
c.arg("confirmation")?,
)
.await
});
d.add("lsp_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
});
+1
Переглянути файл
@@ -4,6 +4,7 @@
pub mod agent;
pub mod analysis;
pub mod bdd;
pub mod build;
pub mod bytes;
pub mod coverage;
+66 -6
Переглянути файл
@@ -62,13 +62,25 @@ pub(crate) fn search_project(
_ => None,
};
let workspace = ide_workspace::workspace::Workspace::load(root)?.is_some_and(|w| w.is_container(root));
let include_root = !workspace
|| matches!(query.scope, ide_search::SearchScope::Directory { .. } | ide_search::SearchScope::Files { .. });
// A directory inside a content root is searched from that root, so that the project's
// exclusions (a `.*` name) meet the paths there as in a whole-project search.
let within = match &query.scope {
ide_search::SearchScope::Directory { path } => {
project.content_roots().into_iter().filter(|r| path.0.starts_with(r)).max_by_key(|r| r.components().count())
}
_ => None,
};
let include_root = within.is_none()
&& (!workspace
|| matches!(
query.scope,
ide_search::SearchScope::Directory { .. } | ide_search::SearchScope::Files { .. }
));
let content_roots = match query.scope {
ide_search::SearchScope::Project
| ide_search::SearchScope::FileSet { .. }
| ide_search::SearchScope::Pattern { .. } => project.content_roots(),
_ => Vec::new(),
_ => within.into_iter().collect(),
};
let filter = |rel: &str| match set {
Some(ProjectFileSet::Production) => !roots.is_test(rel),
@@ -84,6 +96,19 @@ pub(crate) fn search_project(
let mut total = SearchSummary::default();
for dir in std::iter::once(root).filter(|_| include_root).chain(&content_roots) {
let mut remaining = query.clone();
// A root inside the project (one its walk skips) goes by its path there.
let prefix = (dir != root).then(|| match dir.strip_prefix(root) {
Ok(rel) if !workspace => rel.to_string_lossy().replace('\\', "/"),
_ => dir.file_name().unwrap_or_default().to_string_lossy().into_owned(),
});
if let Some(prefix) = &prefix {
remaining.include = rebase_masks(&query.include, prefix);
remaining.exclude = rebase_masks(&query.exclude, prefix);
// Only paths elsewhere were asked for.
if remaining.include.is_empty() && !query.include.is_empty() {
continue;
}
}
let max = if query.max_matches == 0 { 10_000 } else { query.max_matches };
remaining.max_matches = max.saturating_sub(total.matches).max(1);
let summary = ide_search::search_in_context(
@@ -94,9 +119,8 @@ pub(crate) fn search_project(
ide_search::TextSource { overlay: &|p| project.documents.search_text_of(p), decode: &decode },
cancel,
&|mut file| {
if dir != root {
let name = dir.file_name().unwrap_or_default().to_string_lossy();
file.rel_path = format!("{name}/{}", file.rel_path);
if let Some(prefix) = &prefix {
file.rel_path = format!("{prefix}/{}", file.rel_path);
}
emit(file);
},
@@ -113,5 +137,41 @@ pub(crate) fn search_project(
Ok(total)
}
/// Project-relative `masks` (each a comma-separated list) for a search from the content root
/// shown as `prefix`: paths below it lose the prefix, other paths can match nothing there and
/// are dropped, names and `**/` patterns (`*.rs`, `**/build/**`) stay as they are.
fn rebase_masks(masks: &[String], prefix: &str) -> Vec<String> {
let prefix = format!("{}/", prefix.trim_end_matches('/'));
masks
.iter()
.filter_map(|group| {
let kept: Vec<String> = group
.split(',')
.map(str::trim)
.filter(|m| !m.is_empty())
.filter_map(|mask| {
let (negated, body) = mask.strip_prefix('!').map_or(("", mask), |b| ("!", b.trim()));
let body = body.trim_start_matches("./").trim_start_matches('/');
if !body.contains('/') || body.starts_with("**/") {
return Some(mask.to_owned());
}
body.strip_prefix(&prefix).map(|rest| format!("{negated}{rest}"))
})
.collect();
(!kept.is_empty()).then(|| kept.join(","))
})
.collect()
}
#[cfg(test)]
mod tests {
#[test]
fn masks_follow_the_root_they_search() {
let masks = vec![".wt/a/src/**, src/**".into(), "*.rs".into(), "!.wt/a/out/**".into(), "**/build/**".into()];
assert_eq!(super::rebase_masks(&masks, ".wt/a"), ["src/**", "*.rs", "!out/**", "**/build/**"]);
assert_eq!(super::rebase_masks(&["src/**".into()], ".wt/a"), Vec::<String>::new());
}
}
mod commands;
pub use commands::*;
+2 -2
Переглянути файл
@@ -234,7 +234,7 @@ fn network_error(error: reqwest::Error) -> HostError {
}
source = e.source();
}
HostError::Failed(error.to_string())
HostError::Failed(ide_http::client::describe(&error))
}
fn redirect_capability(from: &reqwest::Url, to: &reqwest::Url) -> Result<Capability, String> {
@@ -2831,7 +2831,7 @@ impl HostApi for PluginApi {
}
fn post_view_message(&self, view: &str, message: String) -> Result<(), HostError> {
let declared = [super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
let declared = super::ui_points::WEB_POINTS
.iter()
.any(|point| self.shared.ui.items(point, Some(self.id())).iter().any(|i| i.key == view));
if !declared {
+12 -1
Переглянути файл
@@ -134,7 +134,8 @@ fn read_remote(url: &str, max: usize, deadline: Duration) -> Result<Vec<u8>, Str
super::api::net_runtime().block_on(async move {
let failed = |e: reqwest::Error| match e.is_timeout() {
true => format!("{url}: no answer in time"),
false => format!("{url}: {e}"),
// With its cause: "error sending request" alone does not say what failed.
false => format!("{url}: {}", ide_http::client::describe(&e.without_url())),
};
let too_large = || format!("{url}: larger than {} MiB", max >> 20);
let mut response = client.get(url).timeout(deadline).send().await.map_err(failed)?;
@@ -587,6 +588,16 @@ mod tests {
assert!(reachable_from("/srv/market/index.json", "/srv/market/a.oiplugin"));
}
#[test]
fn a_failed_read_says_why() {
// A port nothing listens on: refused.
let port = std::net::TcpListener::bind("127.0.0.1:0").unwrap().local_addr().unwrap().port();
let url = format!("http://127.0.0.1:{port}/a.oiplugin");
let err = read_url(&url, 1 << 20).unwrap_err();
assert_eq!(err.matches(&url).count(), 1, "{err}");
assert!(err.to_lowercase().contains("refused"), "{err}");
}
#[test]
fn a_server_that_stops_answering_does_not_hold_the_read() {
use std::io::{BufRead, BufReader, Write};
+2 -3
Переглянути файл
@@ -1489,9 +1489,8 @@ impl PluginHost {
}
fn declared_view(&self, id: &str, view: &str) -> IdeResult<()> {
let declared = [ui_points::VIEWS, ui_points::CUSTOM_EDITORS]
.iter()
.any(|point| self.ui.items(point, Some(id)).iter().any(|i| i.key == view));
let declared =
ui_points::WEB_POINTS.iter().any(|point| self.ui.items(point, Some(id)).iter().any(|i| i.key == view));
if declared { Ok(()) } else { Err(IdeError::not_found(format!("plugin {id:?} declares no view {view:?}"))) }
}
+1
Переглянути файл
@@ -89,6 +89,7 @@ pub fn register_builtin_points(
registry.register(Arc::new(UiPoint::new(p::SETTINGS, ui.clone(), p::settings)))?;
registry.register(Arc::new(UiPoint::new(p::VIEWS, ui.clone(), p::view)))?;
registry.register(Arc::new(UiPoint::new(p::CUSTOM_EDITORS, ui.clone(), p::custom_editor)))?;
registry.register(Arc::new(UiPoint::new(p::EDITOR_PANELS, ui.clone(), p::editor_panel)))?;
registry.register(Arc::new(UiPoint::new(p::MARKER_ICONS, ui.clone(), p::marker_icon)))?;
registry.register(Arc::new(UiPoint::new(p::FILE_ICONS, ui.clone(), p::file_icon)))?;
registry.register(Arc::new(UiPoint::new(p::FILE_TEMPLATES, ui.clone(), p::file_template)))?;
+84
Переглянути файл
@@ -36,6 +36,12 @@
//! layout = "tab" # or "split" / "preview": beside the text editor
//! web = "web/index.html" # a web page from the package instead of rendered content
//!
//! [[contributes.editorPanels]]
//! id = "minimap"
//! web = "web/index.html" # beside each editor group's text editor; needs `editor.read`
//! width = 110 # pixels, 40–400
//! when = "plugin.<id>.enabled" # optional
//!
//! [[contributes.fileIcons]]
//! id = "drawing"
//! patterns = ["*.excalidraw"]
@@ -73,6 +79,9 @@ pub const STATUS_BAR: &str = "statusBar";
pub const SETTINGS: &str = "settings";
pub const VIEWS: &str = "views";
pub const CUSTOM_EDITORS: &str = "customEditors";
pub const EDITOR_PANELS: &str = "editorPanels";
/// The points whose declarations can name a `web` page (served, messaged, sent view events).
pub const WEB_POINTS: [&str; 3] = [VIEWS, CUSTOM_EDITORS, EDITOR_PANELS];
pub const FILE_ICONS: &str = "fileIcons";
pub const MARKER_ICONS: &str = "markerIcons";
pub const FILE_TEMPLATES: &str = "fileTemplates";
@@ -745,6 +754,41 @@ pub(super) fn custom_editor(pkg: &Package, decl: toml::Value) -> Result<UiDecl,
Ok(out)
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
struct EditorPanelDecl {
id: String,
web: String,
width: u32,
#[serde(default, skip_serializing_if = "Option::is_none")]
when: Option<String>,
}
const EDITOR_PANEL_WIDTH: std::ops::RangeInclusive<u32> = 40..=400;
/// `[[contributes.editorPanels]]` (API 1.9): a web page at the right edge of every
/// editor group, beside its text editor. It sees each file the group shows, so it
/// needs `editor.read`.
pub(super) fn editor_panel(pkg: &Package, decl: toml::Value) -> Result<UiDecl, String> {
let d: EditorPanelDecl = decode(EDITOR_PANELS, decl)?;
pkg.manifest.needs_api(&format!("contributes.{EDITOR_PANELS}"), 9)?;
validate_item_id(&d.id, "editor panel id")?;
let what = format!("editor panel {:?}", d.id);
if !EDITOR_PANEL_WIDTH.contains(&d.width) {
return Err(format!("{what}: `width` is {}–{} pixels", EDITOR_PANEL_WIDTH.start(), EDITOR_PANEL_WIDTH.end()));
}
if let Some(when) = &d.when {
validate_when(when).map_err(|e| format!("{what}: {e}"))?;
}
if !pkg.manifest.capabilities.all().any(|c| *c == ide_extension::Capability::EditorRead) {
return Err(format!("{what}: needs the `editor.read` capability (the page sees the files editors show)"));
}
let files = super::web::web_files(pkg, &d.web, &what)?;
let mut out = UiDecl::new(d.id.clone(), d.id.clone(), json(&d)?);
out.files = files;
Ok(out)
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
struct FileIconDecl {
@@ -1196,6 +1240,46 @@ mod tests {
}
}
#[test]
fn editor_panels_validate_api_width_when_capability_and_page() {
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/editor-panel");
let source = std::fs::read_to_string(root.join("plugin.toml")).unwrap();
let check = |source: &str| {
let manifest = ide_extension::Manifest::parse(source)?;
let decl = manifest.declarations(EDITOR_PANELS).into_iter().next().unwrap();
editor_panel(&Package::new(manifest, root.clone()), decl)
};
let valid = check(&source).unwrap();
assert_eq!(valid.key, "minimap");
assert_eq!(valid.json, serde_json::json!({ "id": "minimap", "web": "web/index.html", "width": 110 }));
assert_eq!(valid.files, [PathBuf::from("web/index.html")]);
let when = source.replace("width = 110", "width = 110\nwhen = \"plugin.editor-panel.enabled\"");
assert_eq!(check(&when).unwrap().json["when"], "plugin.editor-panel.enabled");
for width in ["40", "400"] {
assert!(check(&source.replace("width = 110", &format!("width = {width}"))).is_ok(), "{width}");
}
for (bad, error) in [
(source.replace("^1.9", "^1.8"), "1.9"),
(source.replace("width = 110", "width = 39"), "40–400"),
(source.replace("width = 110", "width = 401"), "40–400"),
(source.replace("width = 110", "width = -1"), "u32"),
(source.replace("width = 110\n", ""), "width"),
(source.replace("width = 110", "width = 110\nwhen = \"a &&\""), "when"),
(source.replace("width = 110", "width = 110\nside = \"left\""), "side"),
(source.replace(r#"required = ["editor.read"]"#, "required = []"), "editor.read"),
(source.replace("web/index.html", "index.html"), "directory of its own"),
(source.replace("web/index.html", "web/missing.html"), "no such file"),
(source.replace("web/index.html", "../web/index.html"), "web"),
(source.replace(r#"id = "minimap""#, r#"id = "Mini Map""#), "id"),
] {
let err = check(&bad).unwrap_err();
assert!(err.contains(error), "{bad}\n→ {err}");
}
// Declared as optional, the capability is still shown at install.
let optional = source.replace("required = [", "optional = [");
assert!(check(&optional).is_ok());
}
fn package_with_catalogs(files: &[(&str, &str)]) -> (tempfile::TempDir, Package) {
let dir = tempfile::tempdir().unwrap();
std::fs::create_dir(dir.path().join(LOCALES_DIR)).unwrap();
+2 -2
Переглянути файл
@@ -335,7 +335,7 @@ impl PluginHost {
/// The web roots `plugin` declares (entry directories, package-relative, `/`-terminated).
fn web_dirs(&self, plugin: &str) -> Vec<String> {
[super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
super::ui_points::WEB_POINTS
.iter()
.flat_map(|point| self.ui.items(point, Some(plugin)))
.filter_map(|item| item.decl.get("web").and_then(|w| w.as_str()).map(str::to_owned))
@@ -356,7 +356,7 @@ impl PluginHost {
if !plugin.status().is_live() {
return Err(IdeError::unavailable(format!("plugin {plugin_id:?} is not enabled")));
}
let entry = [super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
let entry = super::ui_points::WEB_POINTS
.iter()
.flat_map(|point| self.ui.items(point, Some(plugin_id)))
.find(|item| item.key == view)
+10 -4
Переглянути файл
@@ -177,6 +177,7 @@ impl Host {
let root = member.as_ref().unwrap_or(window_root);
ide_sdk::apply::server_launch_overrides(cfg, &effective);
ide_sdk::apply::configure_server(cfg, root, server_root, &effective);
ide_sdk::apply::configure_vue_module_resolution(cfg, &data_dir);
crate::ops::sdk::container_python::configure_server(cfg, &data_dir, root, &effective);
if cfg.name == "jdtls" {
// A workspace member keeps its build model under its own key (Build Project).
@@ -1350,15 +1351,20 @@ pub(crate) fn workspace_member_roots(root: &Path) -> Vec<PathBuf> {
.unwrap_or_default()
}
/// Workspace members in manifest order, or extra Project Structure directories, Gradle
/// project folders outside the project, and directories of Maven POMs linked from
/// outside it (`build_cache` is the Gradle sync cache).
/// Workspace members in manifest order, or the attached projects outside the project and
/// those inside it that its walk skips as ignored (a git worktree under an ignored folder),
/// extra Project Structure directories, Gradle project folders outside the project, and
/// directories of Maven POMs linked from outside it (`build_cache` is the Gradle sync cache).
fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cache: &Path) -> Vec<PathBuf> {
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root) {
if workspace.is_container(root) {
return workspace.projects;
}
let mut roots = workspace.projects.into_iter().filter(|p| !p.starts_with(root)).collect::<Vec<_>>();
let mut roots = workspace
.projects
.into_iter()
.filter(|p| !p.starts_with(root) || ide_index::walk_skips(root, p))
.collect::<Vec<_>>();
for path in extra_content_roots(settings, root, build_cache) {
if !roots.contains(&path) {
roots.push(path);
+2 -1
Переглянути файл
@@ -309,13 +309,14 @@ pub fn event_sink(peer: Arc<OnceLock<Peer>>, window: Option<String>) -> ide_core
/// Whether a desktop shows an `event` notification of its server in the window. A server reports
/// on its project; what this machine answers or owns itself (MCP approvals, app updates, window
/// groups) never comes from it.
/// groups, its own connection to the server) never comes from it.
pub fn client_accepts(event: &IdeEvent) -> bool {
match event {
IdeEvent::McpRequest { .. }
| IdeEvent::McpRequestClosed { .. }
| IdeEvent::WindowGroupsChanged
| IdeEvent::WindowFullscreenChanged
| IdeEvent::RemoteConnectionLost { .. }
| IdeEvent::UpdateStatusChanged { .. }
| IdeEvent::UpdateAvailable { .. } => false,
IdeEvent::DbSourcesChanged
+4
Переглянути файл
@@ -547,9 +547,13 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
| "agent_registry_remove"
| "agent_mcp_list"
| "agent_mcp_save"
| "agent_mcp_save_json"
| "agent_mcp_set_enabled"
| "agent_mcp_remove"
| "agent_mcp_import"
| "agent_mcp_discover_sources"
| "agent_mcp_import_selected"
| "agent_set_mcp_overrides"
| "coverage_import"
| "system_font_families"
| "user_font_data"
+187
Переглянути файл
@@ -213,6 +213,79 @@ async fn project_path_argument_routes_to_another_open_project() {
assert_eq!(reply["result"]["content"][0]["text"], "L1: second project");
}
#[tokio::test(flavor = "multi_thread")]
async fn trusted_attached_projects_are_writable_and_reach_the_window_they_are_attached_in() {
let h = Harness::new();
h.trust().await;
let base = dunce::canonicalize(h.tmp.path()).unwrap();
let (attached, untrusted, other) = (base.join("attached"), base.join("untrusted"), base.join("other"));
for dir in [&attached, &untrusted, &other] {
std::fs::create_dir_all(dir).unwrap();
}
ide_workspace::workspace::Workspace::attach(
&h.root,
"project",
vec![h.root.clone(), attached.clone(), untrusted.clone()],
)
.unwrap();
h.host.trust.decide(&attached, true, false).unwrap();
// Outside the project folder, by absolute path.
let file = attached.join("new.txt");
h.call("create_new_file", json!({"pathInProject": file, "text": "hello"})).await;
assert_eq!(std::fs::read_to_string(&file).unwrap(), "hello");
let shown = file.to_string_lossy().replace('\\', "/");
let patch = format!("*** Begin Patch\n*** Update File: {shown}\n@@\n-hello\n+patched\n*** End Patch");
let output = h.call("apply_patch", json!({ "input": patch })).await;
assert!(output.starts_with("1 out of 1"), "{output}");
assert!(std::fs::read_to_string(&file).unwrap().starts_with("patched"));
for dir in [&untrusted, &other] {
let e = h.error("create_new_file", json!({"pathInProject": dir.join("x.txt"), "text": "no"})).await;
assert!(e.contains("outside"), "{}: {e}", dir.display());
assert!(!dir.join("x.txt").exists());
}
// A `projectPath` naming the attached project reaches the window it is attached in.
let registry = Registry::new(h.host.clone());
assert!(registry.projects().contains(&attached));
let read = tokio::task::spawn_blocking(move || {
registry.call(&attached, "read_file", &json!({"file_path": "src/b.txt"}).to_string(), CancellationToken::new())
})
.await
.unwrap()
.unwrap();
assert!(read.starts_with("L1: needle"), "{read}");
}
#[tokio::test(flavor = "multi_thread")]
async fn files_of_a_project_attached_outside_go_by_their_absolute_path_everywhere() {
let h = Harness::new();
h.trust().await;
let attached = dunce::canonicalize(h.tmp.path()).unwrap().join("attached");
std::fs::create_dir_all(attached.join("src")).unwrap();
std::fs::write(attached.join("src/lib.rs"), "pub fn attached_marker() {}\n").unwrap();
let git = std::process::Command::new("git").current_dir(&attached).args(["init", "-q"]).status().unwrap();
assert!(git.success());
h.host.trust.decide(&attached, true, false).unwrap();
ide_host::ops::project::attach_workspace(&h.host, "main", &attached).unwrap();
assert!(h.host.project("main").unwrap().index.wait_idle(std::time::Duration::from_secs(10)));
let shown = |rel: &str| attached.join(rel).to_string_lossy().replace('\\', "/");
let files = h.json("search_file", json!({"q":"**/lib.rs"})).await;
assert_eq!(files["items"], json!([{ "filePath": shown("src/lib.rs") }]));
let symbols = h.json("search_symbol", json!({"q":"attached_marker"})).await;
assert_eq!(symbols["items"][0]["filePath"], shown("src/lib.rs"), "{symbols}");
assert_eq!(symbols["items"][0]["lineText"], "pub fn attached_marker() {}");
let status = h.json("git_status", json!({})).await;
let repos: Vec<&str> = status["repositories"]
.as_array()
.unwrap()
.iter()
.map(|r| r["repositoryPathRelativeToProject"].as_str().unwrap())
.collect();
assert!(repos.contains(&shown("").trim_end_matches('/')), "{repos:?}");
}
#[tokio::test(flavor = "multi_thread")]
async fn mutations_preserve_unsaved_text_and_reject_metadata_and_escapes() {
let h = Harness::new();
@@ -368,6 +441,95 @@ async fn git_status_and_diff_on_a_temporary_repository() {
assert!(!h.tmp.path().join("executed").exists());
}
#[tokio::test(flavor = "multi_thread")]
async fn scope_limits_the_query_tools_to_a_directory() {
let h = Harness::new();
std::fs::create_dir_all(h.root.join("lib")).unwrap();
std::fs::write(h.root.join("lib/c.txt"), "needle\n").unwrap();
let paths = |v: &Value| -> Vec<String> {
let mut out: Vec<String> =
v["items"].as_array().unwrap().iter().map(|i| i["filePath"].as_str().unwrap().to_owned()).collect();
out.dedup();
out
};
assert_eq!(paths(&h.json("search_text", json!({"q":"needle","scope":"lib"})).await), ["lib/c.txt"]);
assert_eq!(paths(&h.json("search_regex", json!({"q":"need.e","scope":"lib/"})).await), ["lib/c.txt"]);
let absolute = h.root.join("src").to_string_lossy().into_owned();
assert_eq!(paths(&h.json("search_file", json!({"q":"*.txt","scope":absolute})).await), ["src/a.txt", "src/b.txt"]);
// Within the scope, `paths` narrows further.
assert_eq!(
paths(&h.json("search_text", json!({"q":"needle","scope":"src","paths":["**/b.txt"]})).await),
["src/b.txt"]
);
assert!(h.error("search_text", json!({"q":"needle","scope":"missing"})).await.contains("is not a directory"));
assert!(h.error("search_text", json!({"q":"needle","scope":".."})).await.contains("outside the project"));
let git = |args: &[&str]| {
let output = std::process::Command::new("git").current_dir(&h.root).args(args).output().unwrap();
assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
};
git(&["init"]);
git(&["add", "."]);
git(&["-c", "user.name=Test", "-c", "[email protected]", "commit", "-m", "Initial"]);
std::fs::write(h.root.join("src/a.txt"), "changed\n").unwrap();
std::fs::write(h.root.join("lib/c.txt"), "changed\n").unwrap();
let status = h.json("git_status", json!({"scope":"lib"})).await;
assert_eq!(status["repositories"].as_array().unwrap().len(), 1);
assert_eq!(
status["repositories"][0]["entries"],
json!([{"pathRelativeToRepository":"lib/c.txt","indexStatus":" ","workTreeStatus":"M"}])
);
}
#[tokio::test(flavor = "multi_thread")]
async fn scope_reaches_an_attached_worktree_the_repository_ignores() {
let h = Harness::new();
h.trust().await;
let git = |dir: &Path, args: &[&str]| {
let output = std::process::Command::new("git").current_dir(dir).args(args).output().unwrap();
assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
};
git(&h.root, &["init"]);
git(&h.root, &["add", "."]);
git(&h.root, &["-c", "user.name=Test", "-c", "[email protected]", "commit", "-m", "Initial"]);
std::fs::write(h.root.join(".git/info/exclude"), "/.wt/\n").unwrap();
git(&h.root, &["worktree", "add", "-q", ".wt/feature"]);
let worktree = h.root.join(".wt/feature");
h.host.trust.decide(&worktree, true, false).unwrap();
ide_host::ops::project::attach_workspace(&h.host, "main", &worktree).unwrap();
// Hidden folders excluded by name: `.wt` is one, the worktree's own files are not.
ide_host::ops::project::set_settings(
&h.host,
"main",
ide_workspace::settings::SettingsScope::Project,
"projectStructure.excludeFiles",
"\".*\"",
)
.unwrap();
let found = |args: Value| {
let h = &h;
async move {
let v = h.json("search_text", args).await;
let mut out: Vec<String> = v["items"]
.as_array()
.cloned()
.unwrap_or_default()
.iter()
.map(|i| i["filePath"].as_str().unwrap().to_owned())
.collect();
out.dedup();
out
}
};
let everywhere = found(json!({"q":"needle"})).await;
assert!(everywhere.contains(&".wt/feature/src/b.txt".to_owned()), "{everywhere:?}");
assert_eq!(
found(json!({"q":"needle","scope":".wt/feature/src"})).await,
[".wt/feature/src/a.txt", ".wt/feature/src/b.txt"]
);
assert_eq!(found(json!({"q":"needle","paths":[".wt/feature/src/b.txt"]})).await, [".wt/feature/src/b.txt"]);
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread")]
async fn reformat_uses_the_formatter_chain_and_preserves_a_dirty_buffer() {
@@ -594,6 +756,31 @@ fn agent_process(h: &Harness, name: &str) -> ide_core::RunId {
h.host.processes.list().into_iter().filter(|r| r.config_id == id && r.running).map(|r| r.id).max().unwrap()
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread")]
async fn run_command_returns_once_a_server_prints_its_ready_line() {
let h = Harness::new();
h.trust().await;
h.host.mcp_requests.set_ready("main", true);
h.host
.global_settings
.set(ide_workspace::SettingsScope::Global, "mcpServer.runWithoutConfirmation", json!(true))
.unwrap();
let _started = run_tool_window(&h);
// A server started with its ready line returns once it prints it, long before the timeout.
let started_at = std::time::Instant::now();
let up = h
.json(
"run_command",
json!({"name": "web", "command": "sleep 1; echo Listening on 8080; sleep 30", "pattern": "Listening on", "timeout": 60000}),
)
.await;
assert_eq!((up["waitEnded"].as_str(), up["state"].as_str()), (Some("matched"), Some("running")), "{up}");
assert!(up["output"].as_str().unwrap().contains("Listening on 8080"), "{up}");
assert!(started_at.elapsed() < std::time::Duration::from_secs(20), "returned after {:?}", started_at.elapsed());
h.json("stop_run", json!({"name": "web", "force": true, "timeout": 10000})).await;
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread")]
async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
+64
Переглянути файл
@@ -105,6 +105,70 @@ async fn linked_projects_share_navigation_but_keep_files_repositories_and_run_di
host.close_project("main");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn a_project_attached_inside_the_root_is_searched_and_indexed_once() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("app");
// `.wt/feature` is its own repository, which the outer one ignores; `lib` is not ignored.
let (ignored, covered) = (root.join(".wt/feature"), root.join("lib"));
for dir in [&root, &ignored, &covered] {
std::fs::create_dir_all(dir).unwrap();
}
for repo in [&root, &ignored] {
assert!(std::process::Command::new("git").args(["init", "-q"]).current_dir(repo).status().unwrap().success());
}
std::fs::write(root.join(".git/info/exclude"), "/.wt/\n").unwrap();
std::fs::write(root.join("main.txt"), "needle\n").unwrap();
std::fs::write(ignored.join("feature.txt"), "needle\n").unwrap();
std::fs::write(covered.join("lib.txt"), "needle\n").unwrap();
let host = Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("data"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(NullSink)),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
for dir in [&root, &ignored, &covered] {
host.trust.decide(dir, true, false).unwrap();
}
let project = host.open_project("main", &root).unwrap();
ops::project::attach_workspace(&host, "main", &ignored).unwrap();
ops::project::attach_workspace(&host, "main", &covered).unwrap();
assert_eq!(project.content_roots(), vec![ignored.clone()], "the root's walk covers `lib`");
assert!(project.index.wait_idle(Duration::from_secs(10)));
let files = project.index.find_files(".txt", 100);
let mut indexed = files.iter().map(|f| f.rel_path.clone()).collect::<Vec<_>>();
indexed.sort();
assert_eq!(indexed, [".wt/feature/feature.txt", "lib/lib.txt", "main.txt"]);
let hits = Arc::new(Mutex::new(Vec::new()));
let out = hits.clone();
let query = serde_json::from_value(serde_json::json!({"pattern":"needle", "isRegex":false, "caseSensitive":false,"wholeWord":false,"include":[],"exclude":[],"scope":{"kind":"project"},"maxMatches":100})).unwrap();
ops::search::start(
&host,
"main",
RequestId::next(),
query,
Arc::new(move |event| {
if let ops::search::SearchEvent::File { file } = event {
out.lock().unwrap().push(file.rel_path);
}
}),
)
.await
.unwrap();
let mut found = hits.lock().unwrap().clone();
found.sort();
assert_eq!(found, [".wt/feature/feature.txt", "lib/lib.txt", "main.txt"]);
host.close_project("main");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn python_effective_interpreter_falls_back_to_the_primary_project() {
let temp = tempfile::tempdir().unwrap();
+1 -1
Переглянути файл
@@ -109,7 +109,7 @@ pub async fn check_connection(proxy: &ProxySettings, url: &str, cancel: &Cancell
}
/// reqwest errors with their causes ("error sending request: … connection refused").
pub(crate) fn describe(e: &reqwest::Error) -> String {
pub fn describe(e: &reqwest::Error) -> String {
use std::error::Error;
let mut msg = e.to_string();
let mut source = e.source();
+11 -1
Переглянути файл
@@ -34,6 +34,16 @@ pub struct RunInput<'a> {
/// variables, missing includes) fail; transport errors are part of the exchange.
pub async fn run(input: RunInput<'_>, cancel: &CancellationToken) -> IdeResult<HttpExchange> {
let request = prepare(&input)?;
send(request, input.file, cancel).await
}
/// Sends an already prepared request (one the user approved as shown); `file` is the
/// request file it came from, for the history.
pub async fn send(
request: PreparedRequest,
file: Option<&Path>,
cancel: &CancellationToken,
) -> IdeResult<HttpExchange> {
let time_ms = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs_f64() * 1000.0)
@@ -57,7 +67,7 @@ pub async fn run(input: RunInput<'_>, cancel: &CancellationToken) -> IdeResult<H
url: request.url.clone(),
status: response.as_ref().map(|r| r.status),
total_ms: response.as_ref().map(|r| r.total_ms),
file: input.file.map(IpcPath::from),
file: file.map(IpcPath::from),
error,
},
request,
+67 -9
Переглянути файл
@@ -52,6 +52,29 @@ fn root_ignores(root: &Path) -> Gitignore {
gi.build().unwrap_or_else(|_| Gitignore::empty())
}
/// Whether walking `root` leaves out `dir`, a folder below it: `dir` or a folder between
/// them is ignored (`.gitignore`, `.ignore`, `info/exclude`, the global excludes). Such a
/// folder can be a root of its own, with its own rules, without its files being walked twice.
pub fn walk_skips(root: &Path, dir: &Path) -> bool {
if dir == root || !dir.starts_with(root) || !dir.is_dir() {
return false;
}
let target = dir.to_path_buf();
let walker = WalkBuilder::new(root)
.hidden(false)
.parents(true)
.ignore(true)
.git_ignore(true)
.git_global(true)
.git_exclude(true)
.require_git(ide_core::ignored::inside_git_repo(root))
.follow_links(false)
// Only the folders on the way down to `dir`.
.filter_entry(move |e| target.starts_with(e.path()))
.build();
!walker.flatten().any(|e| e.path() == dir)
}
fn rel_string(rel: &Path) -> String {
let mut out = String::new();
for c in rel.components() {
@@ -115,12 +138,18 @@ impl PathFilter {
let mut extra: Vec<ExtraRoot> = Vec::new();
for r in &extra_roots.folders {
let path = dunce::canonicalize(r).unwrap_or_else(|_| r.clone());
let nested = (extra_roots.include_root && (path.starts_with(root) || root.starts_with(&path)))
// A folder inside the root is a root of its own only when the root's walk skips it.
let inside = path.starts_with(root) && !walk_skips(root, &path);
let nested = (extra_roots.include_root && (inside || root.starts_with(&path)))
|| extra.iter().any(|e| path.starts_with(&e.path) || e.path.starts_with(&path));
if nested || !path.is_dir() {
continue;
}
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
// Inside the root it goes by its path there, elsewhere by its folder name.
let name = match path.strip_prefix(root) {
Ok(rel) if extra_roots.include_root => rel_string(rel),
_ => path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),
};
extra.push(ExtraRoot { gitignore: root_ignores(&path), name, path });
}
Self {
@@ -176,13 +205,11 @@ impl PathFilter {
/// The root containing `path`, its display prefix (`None` for the project root) and ignore rules.
fn base_of(&self, path: &Path) -> Option<(&Path, Option<&str>, &Gitignore)> {
if self.include_root && path.starts_with(&self.root) {
return Some((&self.root, None, &self.gitignore));
// An extra root inside the project root wins: its own rules apply below it.
if let Some(e) = self.extra.iter().find(|e| path.starts_with(&e.path)) {
return Some((e.path.as_path(), Some(e.name.as_str()), &e.gitignore));
}
self.extra
.iter()
.find(|e| path.starts_with(&e.path))
.map(|e| (e.path.as_path(), Some(e.name.as_str()), &e.gitignore))
(self.include_root && path.starts_with(&self.root)).then_some((self.root.as_path(), None, &self.gitignore))
}
/// Whether `path` is (at or) below one of the roots.
@@ -207,7 +234,7 @@ impl PathFilter {
/// Key of `path` in the persistent store: only files below the project root
/// are persisted (extra content roots are rescanned when the project opens).
pub(crate) fn store_key(&self, path: &Path) -> Option<String> {
if !self.include_root {
if !self.include_root || self.extra.iter().any(|e| path.starts_with(&e.path)) {
return None;
}
let rel = rel_string(path.strip_prefix(&self.root).ok()?);
@@ -537,4 +564,35 @@ src/local/
assert!(filter.same_config(&vec![shared.clone(), root.join("src")].into(), &["target".into()]));
assert!(!filter.same_config(&vec![shared].into(), &["target".into()]));
}
#[test]
fn an_ignored_folder_inside_the_root_is_a_root_with_its_own_rules() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
let nested = root.join(".wt/feature");
for f in ["src/a.rs", "lib/d.rs", ".wt/feature/src/b.rs", ".wt/feature/out/c.rs"] {
touch(&root, f);
}
// A git worktree kept inside the repository it belongs to, which ignores it.
std::fs::create_dir_all(root.join(".git/info")).unwrap();
std::fs::write(root.join(".git/info/exclude"), "/.wt/\n").unwrap();
std::fs::write(nested.join(".git"), "gitdir: ../../.git/worktrees/feature\n").unwrap();
std::fs::write(nested.join(".gitignore"), "out/\n").unwrap();
assert!(walk_skips(&root, &nested));
assert!(!walk_skips(&root, &root.join("lib")));
let filter = PathFilter::new(&root, &vec![nested.clone(), root.join("lib")].into(), &[]);
assert_eq!(filter.roots().count(), 2, "a folder the root's walk covers is not a root of its own");
let mut found: Vec<String> = filter
.roots()
.flat_map(|r| filter.walk(r, &AtomicBool::new(false)))
.filter_map(|f| filter.rel(&f.path))
.collect();
found.sort();
assert_eq!(found, [".wt/feature/.gitignore", ".wt/feature/src/b.rs", "lib/d.rs", "src/a.rs"]);
assert_eq!(filter.store_key(&nested.join("src/b.rs")), None, "extra roots are not persisted");
assert!(!filter.is_excluded(&nested.join("src/new.rs"), false));
assert!(filter.is_excluded(&nested.join("out/new.rs"), false));
assert!(filter.is_excluded(&root.join(".wt/other/x.rs"), false));
}
}
+1
Переглянути файл
@@ -21,6 +21,7 @@ mod matching;
mod store;
mod worker;
pub use filter::walk_skips;
pub use worker::MAX_SYMBOL_FILE;
use worker::{Job, MAX_RECENT, Shared};
+33 -2
Переглянути файл
@@ -627,6 +627,7 @@ mod tests {
"Vue",
"Angular Template",
"Angular TypeScript",
"Thymeleaf",
"ERB",
"JSP",
"Astro",
@@ -679,7 +680,7 @@ mod tests {
let got: Vec<(&str, bool)> = cfg
.language_servers
.iter()
.filter(|s| !s.require_root_marker)
.filter(|s| !s.require_root_marker && s.features.is_empty())
.map(|s| (s.name.as_str(), s.fallback))
.collect();
let expected: Vec<(&str, bool)> = servers.iter().enumerate().map(|(i, name)| (*name, i > 0)).collect();
@@ -779,13 +780,26 @@ mod tests {
assert_eq!(served("lib/src/Parser.php"), None);
}
#[test]
fn pylsp_adds_only_rope_refactorings_to_python() {
let reg = reg();
let cfg = reg.get(&LanguageId::new("python")).unwrap();
let pylsp = cfg.language_servers.iter().find(|s| s.name == "pylsp").unwrap();
assert!(!pylsp.fallback && !pylsp.require_root_marker);
assert_eq!(pylsp.features, ["code-action"]);
assert_eq!(pylsp.code_action_kinds, ["refactor"]);
let plugins = pylsp.initialization_options.as_ref().unwrap()["pylsp"]["plugins"].as_table().unwrap();
assert_eq!(plugins["jedi_completion"]["enabled"].as_bool(), Some(false));
assert!(plugins.values().all(|p| p["enabled"].as_bool() == Some(false)));
}
#[test]
fn ruff_serves_python_files_only_below_its_config() {
let reg = reg();
let cfg = reg.get(&LanguageId::new("python")).unwrap();
let names: Vec<&str> = cfg.language_servers.iter().map(|s| s.name.as_str()).collect();
// After the fallbacks: hover, rename and symbols stay with the type checker.
assert_eq!(names, ["basedpyright", "pyright", "ty", "pyrefly", "ruff"]);
assert_eq!(names, ["basedpyright", "pyright", "ty", "pyrefly", "ruff", "pylsp"]);
let ruff = cfg.language_servers.iter().find(|s| s.name == "ruff").unwrap();
assert_eq!((ruff.command.as_str(), ruff.args.as_slice()), ("ruff", ["server".to_string()].as_slice()));
assert!(ruff.require_root_marker && !ruff.fallback);
@@ -827,6 +841,23 @@ mod tests {
assert!(!reg.is_framework_marker(&root.join("apps/admin/package.json")));
}
#[test]
fn spring_template_folders_make_html_thymeleaf() {
let reg = reg();
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
let mode = |file: &str| reg.framework_ui_mode(&LanguageId::new("html"), &root.join(file), Some(root));
std::fs::create_dir_all(root.join("web/src/main/resources/templates/fragments")).unwrap();
std::fs::create_dir_all(root.join("docs")).unwrap();
for file in
["web/src/main/resources/templates/index.html", "web/src/main/resources/templates/fragments/nav.html"]
{
assert_eq!(mode(file).as_deref(), Some("Thymeleaf"), "{file}");
}
assert_eq!(mode("docs/index.html"), None);
assert!(reg.is_framework_marker(&root.join("web/src/main/resources/templates")));
}
#[test]
fn django_projects_make_html_in_templates_folders_templates() {
let reg = reg();
+3
Переглянути файл
@@ -19,10 +19,13 @@ use std::time::{Duration, Instant};
pub(crate) const SERVER: &str = "jdtls";
pub(crate) mod configuration;
mod extract_interface;
mod formatter;
mod hierarchy;
pub(crate) mod jvm_inspect;
mod move_refactoring;
pub(crate) mod reserved_names;
mod signature;
pub use formatter::configure_formatter;
/// First start imports the Maven / Gradle model, which can take minutes.
const READY_TIMEOUT: Duration = Duration::from_secs(240);
+128
Переглянути файл
@@ -0,0 +1,128 @@
//! Extract Interface through jdtls' own requests: `java/checkExtractInterfaceStatus` lists the
//! members of the file's class an interface can declare and the packages it can go to,
//! `java/getRefactorEdit` (`extractInterface`) creates the interface, makes the class implement
//! it and uses it where possible. The UI picks the name, package and members and applies the edit.
use super::COMMAND_TIMEOUT;
use super::signature::{RefactorEdit, changed};
use crate::types::{ExtractInterfaceInfo, InterfaceMember, ProblemSeverity, RefactoringProblem, ServerRefactored};
use crate::{LspManager, convert};
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, Pos};
use serde::Deserialize;
use serde_json::{Value, json};
const FEATURE: &str = "Extract Interface";
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Status {
#[serde(default)]
members: Vec<InterfaceMember>,
#[serde(default)]
sub_type_name: String,
#[serde(default)]
destination_response: Destinations,
}
#[derive(Default, Deserialize)]
#[serde(rename_all = "camelCase")]
struct Destinations {
#[serde(default)]
destinations: Vec<Value>,
}
fn info_of(status: Option<Status>) -> IdeResult<ExtractInterfaceInfo> {
let status = status
.filter(|s| !s.sub_type_name.is_empty())
.ok_or_else(|| IdeError::invalid("The file should declare a class"))?;
Ok(ExtractInterfaceInfo {
class_name: status.sub_type_name,
members: status.members,
packages: status.destination_response.destinations.iter().map(Value::to_string).collect(),
})
}
impl LspManager {
/// The class of the file at `doc`, its members and the packages for the interface.
pub async fn extract_interface_info(
&self,
doc: DocId,
pos: Pos,
cancel: CancellationToken,
) -> IdeResult<ExtractInterfaceInfo> {
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
let params = Self::signature_context(&snap, &t, pos);
let status: Option<Status> =
self.call(&t, "java/checkExtractInterfaceStatus", params, Some(&cancel), COMMAND_TIMEOUT).await?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
info_of(status)
}
/// Checks extracting `members` into the interface `name` in `package` (a package from
/// [`Self::extract_interface_info`]) and computes the edit without applying it.
#[allow(clippy::too_many_arguments)]
pub async fn extract_interface(
&self,
doc: DocId,
pos: Pos,
members: Vec<String>,
name: String,
package: Value,
confirmation: Option<String>,
cancel: CancellationToken,
) -> IdeResult<ServerRefactored> {
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
let mut params = json!({
"command": "extractInterface",
"context": Self::signature_context(&snap, &t, pos),
"options": { "tabSize": 4, "insertSpaces": true },
"commandArguments": [members, name, package],
});
if let Some(token) = confirmation {
params["confirmationToken"] = json!(token);
}
let answer: Option<RefactorEdit> =
self.call(&t, "java/getRefactorEdit", params, Some(&cancel), COMMAND_TIMEOUT).await?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
// jdtls answers nothing when its checks fail, and reports why in a message of its own.
let Some(answer) = answer else {
return Ok(ServerRefactored {
problems: vec![RefactoringProblem {
severity: ProblemSeverity::Fatal,
message: "The interface could not be extracted".to_owned(),
}],
edit: None,
confirmation: None,
});
};
let conv = self.conv(t.enc());
Ok(changed(answer, |e| convert::workspace_edit(&conv, e)))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reads_the_members_and_packages() {
let status: Status = serde_json::from_value(json!({
"members": [
{ "name": "area", "typeName": "double", "parameters": [], "handleIdentifier": "=p/src<a{Shape.java[Shape~area" },
{ "name": "UNIT", "typeName": "int", "handleIdentifier": "=p/src<a{Shape.java[Shape^UNIT" },
],
"subTypeName": "Shape",
"destinationResponse": { "destinations": [{ "displayName": "a", "isParentOfSelectedFile": true }] },
}))
.unwrap();
let info = info_of(Some(status)).unwrap();
assert_eq!(info.class_name, "Shape");
assert_eq!(info.members[0].parameters.as_deref(), Some(&[][..]));
assert_eq!(info.members[1].parameters, None);
assert_eq!(serde_json::from_str::<Value>(&info.packages[0]).unwrap()["displayName"], "a");
assert!(info_of(None).is_err());
}
}
+116
Переглянути файл
@@ -0,0 +1,116 @@
//! Move (F6) through jdtls' own requests. jdtls offers Move as code actions whose command the
//! client runs (`java.action.applyRefactoringCommand` with `moveFile`, `moveType`,
//! `moveStaticMember` or `moveInstanceMethod`); the UI picks the destination from
//! `java/getMoveDestinations` or `java/searchSymbols` and `java/move` checks the move and
//! computes the edit, which the UI applies itself. Requests carry the code action's own
//! arguments back unchanged.
use super::COMMAND_TIMEOUT;
use super::signature::{RefactorEdit, changed};
use crate::types::ServerRefactored;
use crate::{LspManager, convert};
use ide_core::{CancellationToken, DocId, IdeError, IdeResult};
use serde_json::{Value, json};
const FEATURE: &str = "Move";
/// What `java/getMoveDestinations` and `java/move` accept as `moveKind`.
const KINDS: [&str; 6] =
["moveResource", "moveInstanceMethod", "moveStaticMember", "moveTypeToNewFile", "moveTypeToClass", "moveType"];
fn move_params(kind: &str, request: &Value) -> IdeResult<Value> {
if !KINDS.contains(&kind) {
return Err(IdeError::invalid(format!("unknown move kind `{kind}`")));
}
let mut params = json!({
"moveKind": kind,
"sourceUris": request.get("sourceUris").cloned().unwrap_or(json!([])),
"params": request.get("params").cloned().unwrap_or(Value::Null),
});
if let Some(destination) = request.get("destination").filter(|d| !d.is_null()) {
params["destination"] = destination.clone();
}
Ok(params)
}
impl LspManager {
/// Where the move of `kind` can go (packages, or the fields and parameters an instance
/// method can move to); an invalid-input error carries jdtls' reason when there is none.
pub async fn java_move_destinations(
&self,
doc: DocId,
kind: String,
request: Value,
cancel: CancellationToken,
) -> IdeResult<Vec<Value>> {
let (_, t) = self.jdtls_target(doc, FEATURE).await?;
let params = move_params(&kind, &request)?;
let answer: Value = self.call(&t, "java/getMoveDestinations", params, Some(&cancel), COMMAND_TIMEOUT).await?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
if let Some(message) = answer.get("errorMessage").and_then(Value::as_str).filter(|m| !m.is_empty()) {
return Err(IdeError::invalid(message.to_owned()));
}
Ok(answer.get("destinations").and_then(Value::as_array).cloned().unwrap_or_default())
}
/// The project's source types (`java/searchSymbols`), for moving a member or type into a class.
pub async fn java_source_types(
&self,
doc: DocId,
project: Option<String>,
cancel: CancellationToken,
) -> IdeResult<Vec<Value>> {
let (_, t) = self.jdtls_target(doc, FEATURE).await?;
let params = json!({ "query": "*", "projectName": project, "sourceOnly": true });
let answer: Option<Vec<Value>> =
self.call(&t, "java/searchSymbols", params, Some(&cancel), COMMAND_TIMEOUT).await?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
Ok(answer.unwrap_or_default())
}
/// Checks the move and computes the edit without applying it; `confirmation` accepts the
/// warnings an earlier check returned with it.
pub async fn java_move(
&self,
doc: DocId,
kind: String,
request: Value,
confirmation: Option<String>,
cancel: CancellationToken,
) -> IdeResult<ServerRefactored> {
let (_, t) = self.jdtls_target(doc, FEATURE).await?;
let mut params = move_params(&kind, &request)?;
params["updateReferences"] = json!(true);
if let Some(token) = confirmation {
params["confirmationToken"] = json!(token);
}
let answer: Option<RefactorEdit> = self.call(&t, "java/move", params, Some(&cancel), COMMAND_TIMEOUT).await?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let conv = self.conv(t.enc());
Ok(changed(answer.unwrap_or_default(), |e| convert::workspace_edit(&conv, e)))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn passes_the_code_action_arguments_back_for_known_kinds_only() {
let request = json!({
"sourceUris": ["file:///p/A.java"],
"params": { "textDocument": { "uri": "file:///p/A.java" } },
"destination": { "displayName": "com.example" },
});
let params = move_params("moveResource", &request).unwrap();
assert_eq!(params["moveKind"], "moveResource");
assert_eq!(params["sourceUris"][0], "file:///p/A.java");
assert_eq!(params["destination"]["displayName"], "com.example");
assert!(move_params("moveResource", &json!({})).unwrap().get("destination").is_none());
assert!(move_params("deleteEverything", &request).is_err());
}
}
+181
Переглянути файл
@@ -0,0 +1,181 @@
//! Change Signature through jdtls' own requests: `java/getChangeSignatureInfo` reads the method at
//! a position, `java/getRefactorEdit` (`changeSignature`) checks the new signature and computes the
//! edit. The UI edits the signature and applies the edit itself.
use super::{COMMAND_TIMEOUT, SERVER};
use crate::types::{MethodSignature, ProblemSeverity, RefactoringProblem, ServerRefactored};
use crate::{DocSnap, LspManager, Target, convert};
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, Pos};
use serde::Deserialize;
use serde_json::{Value, json};
const FEATURE: &str = "Change Signature";
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Info {
#[serde(flatten)]
signature: Option<MethodSignature>,
error_message: Option<String>,
}
#[derive(Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(super) struct RefactorEdit {
edit: Option<lsp_types::WorkspaceEdit>,
error_message: Option<String>,
confirmation_token: Option<String>,
}
/// A `java/getRefactorEdit` or `java/move` answer as the result: an error message alone is fatal;
/// with a confirmation token it lists warnings to accept before the edit is computed.
pub(super) fn changed(
answer: RefactorEdit,
convert_edit: impl FnOnce(lsp_types::WorkspaceEdit) -> ide_core::WorkspaceEdit,
) -> ServerRefactored {
let problem = |severity| {
answer
.error_message
.as_deref()
.filter(|m| !m.trim().is_empty())
.map(|message| RefactoringProblem { severity, message: message.trim().to_owned() })
};
if let Some(token) = answer.confirmation_token {
return ServerRefactored {
problems: problem(ProblemSeverity::Warning).into_iter().collect(),
edit: None,
confirmation: Some(token),
};
}
match answer.edit {
Some(edit) if answer.error_message.is_none() => {
ServerRefactored { problems: Vec::new(), edit: Some(convert_edit(edit)), confirmation: None }
}
_ => ServerRefactored {
problems: problem(ProblemSeverity::Fatal).into_iter().collect(),
edit: None,
confirmation: None,
},
}
}
impl LspManager {
pub(super) async fn jdtls_target(&self, doc: DocId, feature: &str) -> IdeResult<(DocSnap, Target)> {
let (snap, targets) = self.doc_targets(doc, feature, |_| true).await?;
let t = targets
.into_iter()
.find(|t| t.server.name == SERVER)
.ok_or_else(|| IdeError::unavailable(format!("{feature} needs the Java language server (jdtls)")))?;
Ok((snap, t))
}
pub(super) fn signature_context(snap: &DocSnap, t: &Target, pos: Pos) -> Value {
let at = snap.position(t, pos);
json!({
"textDocument": { "uri": snap.uri },
"range": { "start": at, "end": at },
"context": { "diagnostics": [] },
})
}
/// The signature of the method at `pos`; an invalid-input error says why it can't be changed.
pub async fn change_signature_info(
&self,
doc: DocId,
pos: Pos,
cancel: CancellationToken,
) -> IdeResult<MethodSignature> {
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
let params = Self::signature_context(&snap, &t, pos);
let info: Option<Info> =
self.call(&t, "java/getChangeSignatureInfo", params, Some(&cancel), COMMAND_TIMEOUT).await?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
match info {
Some(Info { error_message: Some(message), .. }) => Err(IdeError::invalid(message)),
Some(Info { signature: Some(signature), .. }) => Ok(signature),
_ => Err(IdeError::invalid("Caret should be on a method declaration")),
}
}
/// Checks changing the method at `pos` to `signature` and computes the edit without applying it.
/// `confirmation` accepts the warnings an earlier check returned with it.
pub async fn change_signature(
&self,
doc: DocId,
pos: Pos,
signature: MethodSignature,
delegate: bool,
confirmation: Option<String>,
cancel: CancellationToken,
) -> IdeResult<ServerRefactored> {
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
let MethodSignature { method_identifier, modifier, return_type, method_name, parameters, exceptions } =
signature;
let mut params = json!({
"command": "changeSignature",
"context": Self::signature_context(&snap, &t, pos),
"options": { "tabSize": 4, "insertSpaces": true },
"commandArguments": [
method_identifier, delegate, method_name, modifier, return_type, parameters, exceptions, false
],
});
if let Some(token) = confirmation {
params["confirmationToken"] = json!(token);
}
let answer: Option<RefactorEdit> =
self.call(&t, "java/getRefactorEdit", params, Some(&cancel), COMMAND_TIMEOUT).await?;
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let answer = answer.unwrap_or_default();
let conv = self.conv(t.enc());
Ok(changed(answer, |e| convert::workspace_edit(&conv, e)))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn answer(v: Value) -> RefactorEdit {
serde_json::from_value(v).unwrap()
}
fn no_edit(_: lsp_types::WorkspaceEdit) -> ide_core::WorkspaceEdit {
ide_core::WorkspaceEdit::default()
}
#[test]
fn reads_the_signature_or_why_there_is_none() {
let info: Info = serde_json::from_value(json!({
"methodIdentifier": "=p/src<p{A.java[A~m~I",
"modifier": "public",
"returnType": "void",
"methodName": "m",
"parameters": [{ "type": "int", "name": "a", "defaultValue": "null", "originalIndex": 0 }],
"exceptions": [{ "type": "java.io.IOException", "typeHandleIdentifier": "=x" }],
"errorMessage": null,
}))
.unwrap();
let s = info.signature.unwrap();
assert_eq!((s.method_name.as_str(), s.parameters[0].type_name.as_str()), ("m", "int"));
assert_eq!(s.exceptions[0].type_name, "java.io.IOException");
let refused: Info = serde_json::from_value(json!({ "errorMessage": "Cannot change signature." })).unwrap();
assert!(refused.signature.is_none());
assert_eq!(refused.error_message.as_deref(), Some("Cannot change signature."));
}
#[test]
fn errors_are_fatal_and_tokens_ask_for_confirmation() {
let fatal = changed(answer(json!({ "errorMessage": "Duplicate parameter name" })), no_edit);
assert_eq!(fatal.problems[0].severity, ProblemSeverity::Fatal);
assert!(fatal.edit.is_none() && fatal.confirmation.is_none());
let warn = changed(answer(json!({ "errorMessage": "Overrides a method", "confirmationToken": "t1" })), no_edit);
assert_eq!(warn.problems[0].severity, ProblemSeverity::Warning);
assert_eq!(warn.confirmation.as_deref(), Some("t1"));
let ok = changed(answer(json!({ "edit": { "changes": {} } })), no_edit);
assert!(ok.problems.is_empty() && ok.edit.is_some());
}
}
+96
Переглянути файл
@@ -434,6 +434,11 @@ async fn library_sources(snap: &DocSnap, root: &Path, pos: Pos, locs: Vec<Locati
const JAVA_IMPLEMENTATIONS: &str = "openidea.java.implementations";
/// jdtls' locations of the implementations of the method at a position in the classes named
/// with it, for implementation classes in dependencies: its standard request puts those at the
/// start of the decompiled class instead of at the method.
const JAVA_IMPLEMENTATION_LOCATIONS: &str = "openidea.java.implementationLocations";
/// The answer of [`JAVA_IMPLEMENTATIONS`]: `complete` when the type is declared in the
/// sources, so no dependency can implement it.
#[derive(serde::Deserialize)]
@@ -442,6 +447,13 @@ struct SourceImplementations {
complete: bool,
}
/// The answer of [`JAVA_IMPLEMENTATION_LOCATIONS`]: one entry per requested class, `None` when
/// it has no implementation of the method.
#[derive(serde::Deserialize)]
struct TargetImplementations {
locations: Vec<Option<lsp::Location>>,
}
/// Receives the implementations found so far, before a slower search for the rest.
type Partial<'a> = Option<&'a (dyn Fn(Vec<Location>) + Send + Sync)>;
@@ -1810,6 +1822,84 @@ impl LspManager {
out
}
/// jdtls: where the implementation methods of the method at `pos` are declared in the
/// dependency classes `locs` point at. Its standard request answers those with `0:0`, the
/// start of the class file's decompiled source; [`JAVA_IMPLEMENTATION_LOCATIONS`] resolves
/// the declaration itself.
async fn java_implementation_locations(
&self,
snap: &DocSnap,
t: &Target,
pos: Pos,
locs: Vec<Location>,
cancel: Option<&CancellationToken>,
) -> Vec<Location> {
if t.server.name != "jdtls" || !t.caps().commands().iter().any(|c| c == JAVA_IMPLEMENTATION_LOCATIONS) {
return locs;
}
let targets: Vec<(usize, String)> = locs
.iter()
.enumerate()
.filter_map(|(i, l)| {
let uri = l.uri.as_deref()?;
(virtual_doc::scheme(uri) == "jdt" && l.range.start.line == 0).then(|| (i, uri.to_owned()))
})
.collect();
if targets.is_empty() {
return locs;
}
let params = snap.pos_params(t, pos);
let arguments = json!([
params["textDocument"]["uri"],
params["position"]["line"],
params["position"]["character"],
targets.iter().map(|(_, uri)| uri).collect::<Vec<_>>(),
]);
let result: IdeResult<TargetImplementations> = self
.call(
t,
"workspace/executeCommand",
json!({ "command": JAVA_IMPLEMENTATION_LOCATIONS, "arguments": arguments }),
cancel,
LONG_TIMEOUT,
)
.await;
let found = match result {
Ok(found) if found.locations.len() == targets.len() => found,
Ok(_) => return locs,
Err(e) => {
tracing::debug!("{JAVA_IMPLEMENTATION_LOCATIONS}: {}", e.message);
return locs;
}
};
let mut out = locs;
for ((i, _), loc) in targets.into_iter().zip(found.locations) {
if let Some(loc) = loc.as_ref().and_then(|l| self.conv(t.enc()).location(l)) {
out[i] = loc;
}
}
out
}
/// Refines the implementation `locs` of the method at `pos`: jdtls puts an implementation in
/// a dependency at the start of its decompiled class instead of at the method, which matters
/// when the gutter marker's targets are opened one by one.
pub async fn implementation_locations(
&self,
doc: DocId,
pos: Pos,
locs: Vec<Location>,
cancel: CancellationToken,
) -> IdeResult<Vec<Location>> {
let (_, cap, feature) = goto_method(GotoKind::Implementation);
let (snap, targets) = self.doc_targets(doc, feature, |c| c.has(cap)).await?;
let mut out = locs;
for t in &targets {
out = self.java_implementation_locations(&snap, t, pos, out, Some(&cancel)).await;
}
Ok(out)
}
async fn goto_in(
&self,
snap: &DocSnap,
@@ -1849,6 +1939,12 @@ impl LspManager {
Ok(Some(r)) => {
let locs = convert::goto_response(&self.conv(t.enc()), r);
let locs = library_sources(snap, &self.project_root, pos, locs).await;
// Only explicit Go to Implementation: gutter markers ask for every line.
let locs = if method == "textDocument/implementation" && partial.is_some() {
self.java_implementation_locations(snap, t, pos, locs, cancel).await
} else {
locs
};
self.note_virtual(&t.server, locs.iter().map(|l| l.uri.as_deref()));
self.note_arduino_sources(&t.server, &locs);
let locs = self.jdt_library_classes(snap, pos, locs).await;
+68
Переглянути файл
@@ -504,6 +504,74 @@ pub struct HierarchyRefactored {
pub edit: Option<WorkspaceEdit>,
}
/// A parameter in Change Signature: its type, name, the value passed at existing calls when it is
/// added, and its index in the current signature (-1 for an added one).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct SignatureParameter {
#[serde(rename = "type")]
pub type_name: String,
pub name: String,
pub default_value: String,
pub original_index: i32,
}
/// A declared exception (`throws`), with the server's handle of its type.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct SignatureException {
#[serde(rename = "type")]
pub type_name: String,
pub type_handle_identifier: String,
}
/// The signature of the method at a position, as Change Signature edits it.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct MethodSignature {
/// The server's handle of the method, passed back unchanged.
pub method_identifier: String,
/// `public`, `protected`, `private`, or empty for package-private.
pub modifier: String,
pub return_type: String,
pub method_name: String,
pub parameters: Vec<SignatureParameter>,
pub exceptions: Vec<SignatureException>,
}
/// A member Extract Interface can declare in the new interface.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct InterfaceMember {
pub name: String,
/// The method's return type or the field's type.
pub type_name: String,
/// The method's parameter types; `None` for a field.
pub parameters: Option<Vec<String>>,
/// The server's handle of the member, passed back unchanged.
pub handle_identifier: String,
}
/// What Extract Interface starts from: the file's class, the members the interface can declare and
/// the packages it can go to (as JSON, passed back unchanged).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct ExtractInterfaceInfo {
pub class_name: String,
pub members: Vec<InterfaceMember>,
pub packages: Vec<String>,
}
/// A refactoring checked by the server (Change Signature, Move, Extract Interface): problems to show, the edit when
/// none is fatal, and the token that confirms going on despite warnings.
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct ServerRefactored {
pub problems: Vec<RefactoringProblem>,
pub edit: Option<WorkspaceEdit>,
pub confirmation: Option<String>,
}
#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct CallHierarchy {
+46
Переглянути файл
@@ -3483,6 +3483,52 @@ async fn java_implementations_come_from_sources_first() {
assert_eq!(s.requested("textDocument/implementation").len(), 3);
}
#[tokio::test(flavor = "multi_thread")]
async fn java_dependency_implementations_point_at_the_method() {
let caps = json!({
"textDocumentSync": 1,
"implementationProvider": true,
"executeCommandProvider": { "commands": ["openidea.java.implementations", "openidea.java.implementationLocations"] },
});
let h = harness_for("java", "java", &[("jdtls", caps)], &[]);
let (doc, _) = h.open("Repo.java", "interface Repo {\n void save(String item);\n}\n");
h.wait_status("jdtls", ServerStatus::Ready).await;
let s = h.launcher.state("jdtls");
let class_uri = "jdt://contents/lib.jar/zoo/RepoImpl.java?=p/lib.jar%3Czoo%28RepoImpl.class";
let method = json!({
"uri": class_uri,
"range": {"start":{"line":4,"character":4},"end":{"line":6,"character":5}},
});
let at_zero = json!({
"uri": class_uri,
"range": {"start":{"line":0,"character":0},"end":{"line":0,"character":0}},
});
let refined = method.clone();
*s.responder.lock() = Some(Arc::new(move |_, method, params| match method {
"workspace/executeCommand" if params["command"] == "openidea.java.implementations" => {
Some(json!({ "locations": [], "complete": false }))
}
"workspace/executeCommand" if params["command"] == "openidea.java.implementationLocations" => {
assert_eq!(params["arguments"][3], json!([class_uri]));
Some(json!({ "locations": [refined] }))
}
"textDocument/implementation" => Some(json!([at_zero])),
_ => None,
}));
let partial = Mutex::new(Vec::new());
let found = h
.mgr
.goto_implementation(doc, Pos::new(1, 9), Default::default(), &|locs| partial.lock().push(locs.to_vec()))
.await
.unwrap();
assert_eq!(found.len(), 1);
assert_eq!(found[0].uri.as_deref(), Some(class_uri));
assert_eq!(found[0].range.start.line, 4);
assert_eq!(s.requested("textDocument/implementation").len(), 1);
let commands = s.requested("workspace/executeCommand");
assert!(commands.iter().any(|r| r["command"] == "openidea.java.implementationLocations"));
}
#[tokio::test(flavor = "multi_thread")]
async fn navigation_rename_format_and_decorations() {
let h = harness(&[("mock", incremental_caps())]);
+13
Переглянути файл
@@ -0,0 +1,13 @@
id = "editor-panel"
name = "Editor Panel Probe"
version = "0.1.0"
description = "Test fixture for [[contributes.editorPanels]]: a minimal minimap page, no code."
engines.openidea = "^1.9"
[capabilities]
required = ["editor.read"]
[[contributes.editorPanels]]
id = "minimap"
web = "web/index.html"
width = 110
+196
Переглянути файл
@@ -0,0 +1,196 @@
<!doctype html>
<html>
<head>
<meta charset="utf-8" />
<title>Minimap probe</title>
<style>
html,
body {
margin: 0;
height: 100%;
overflow: hidden;
}
canvas {
display: block;
width: 100%;
height: 100%;
cursor: default;
}
</style>
</head>
<body>
<canvas id="map"></canvas>
<script>
// A minimal minimap over `openidea.editor`: each line 2px high, each character 1px wide,
// in its highlight colour; the visible area as a frame that can be dragged; the wheel
// scrolls the editor.
const editor = window.openidea.editor;
const canvas = document.getElementById("map");
const ctx = canvas.getContext("2d");
const LINE = 2;
const CHUNK = 2000;
let text = [];
let colors = new Map();
let loading = new Set();
let view = null;
let drag = null;
let queued = false;
const grey = (color) => {
const m = /rgba?\((\d+),\s*(\d+),\s*(\d+)/.exec(color);
return !!m && Math.max(m[1], m[2], m[3]) - Math.min(m[1], m[2], m[3]) < 24;
};
const cssVar = (name) => (window.openidea.theme && window.openidea.theme.vars[name]) || "";
function layout() {
const H = canvas.clientHeight;
if (!view) return { H, offset: 0, top: 0, height: 0, range: 1, visible: 0 };
const L = Math.max(1, view.lineCount);
const visible = Math.max(0, view.lastLine - view.firstLine);
const scrollable = Math.max(1, view.scrollHeight - view.clientHeight);
const p = Math.min(1, Math.max(0, view.scrollTop / scrollable));
const mapH = L * LINE;
const offset = p * Math.max(0, mapH - H);
const range = Math.max(1, Math.min(H, mapH) - visible * LINE);
return { H, offset, top: view.firstLine * LINE - offset, height: visible * LINE, range, visible, L };
}
function redraw() {
if (queued) return;
queued = true;
requestAnimationFrame(draw);
}
function draw() {
queued = false;
const dpr = window.devicePixelRatio || 1;
const W = canvas.clientWidth;
const { H, offset, top, height } = layout();
if (canvas.width !== Math.round(W * dpr) || canvas.height !== Math.round(H * dpr)) {
canvas.width = Math.round(W * dpr);
canvas.height = Math.round(H * dpr);
}
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
ctx.clearRect(0, 0, W, H);
if (!view) return;
const first = Math.floor(offset / LINE);
const last = Math.min(text.length, Math.ceil((offset + H) / LINE));
const missing = [];
const muted = cssVar("--openidea-fg-muted");
for (let i = first; i < last; i++) {
const y = i * LINE - offset;
const line = text[i] || "";
// Text without a syntax colour: faint, so the coloured spans stand out.
ctx.globalAlpha = 0.2;
ctx.fillStyle = muted;
for (const m of line.matchAll(/\S+/g)) ctx.fillRect(m.index, y, m[0].length, LINE - 0.5);
ctx.globalAlpha = 1;
const spans = colors.get(i);
if (!spans) missing.push(i);
else
for (const s of spans) {
// Greys (the plain text colour, comments) stay as faint as uncoloured text.
if (grey(s.color)) continue;
ctx.fillStyle = s.color;
ctx.fillRect(s.from, y, s.to - s.from, LINE - 0.5);
}
}
// The visible area: a light accent tint and a 1px border, stronger while dragged.
const frameH = Math.max(height, 4);
ctx.fillStyle = cssVar("--openidea-accent");
ctx.globalAlpha = drag ? 0.16 : 0.08;
ctx.fillRect(0, top, W, frameH);
ctx.strokeStyle = ctx.fillStyle;
ctx.globalAlpha = drag ? 0.9 : 0.5;
ctx.lineWidth = 1;
ctx.strokeRect(0.5, top + 0.5, W - 1, frameH - 1);
ctx.globalAlpha = 1;
if (missing.length) load(missing[0], missing[missing.length - 1] + 1);
}
async function load(from, to) {
const key = `${from}:${to}`;
if (loading.has(key)) return;
loading.add(key);
const target = view && view.version;
try {
for (let at = from; at < to; at += CHUNK) {
const lines = await editor.highlights(at, Math.min(to, at + CHUNK));
lines.forEach((spans, i) => colors.set(at + i, spans));
}
} finally {
loading.delete(key);
}
if (view && view.version === target) redraw();
}
async function reload() {
const target = await editor.get();
colors = new Map();
text = [];
if (!target) {
view = null;
return redraw();
}
const doc = await editor.document.get();
text = doc.text.split("\n");
view = Object.assign(await editor.viewport(), { version: target.version });
redraw();
}
editor.onTarget(() => void reload());
editor.document.onChange((doc) => {
text = doc.text.split("\n");
redraw();
});
editor.onViewport((v) => {
view = Object.assign(v, { version: view ? view.version : 0 });
redraw();
});
editor.onHighlights(({ fromLine, toLine }) => {
for (const k of [...colors.keys()]) if (k >= fromLine && k < toLine) colors.delete(k);
redraw();
});
window.openidea.onThemeChange(redraw);
new ResizeObserver(redraw).observe(canvas);
// Dragging the frame (or pressing beside it, which centres it there) scrolls the editor.
const scrollToFrameTop = (frameTop) => {
const { range, visible, L } = layout();
const p = Math.min(1, Math.max(0, frameTop / range));
void editor.scrollTo(p * Math.max(0, L - visible));
};
canvas.addEventListener("pointerdown", (e) => {
if (!view) return;
const { top, height } = layout();
const grab = e.offsetY >= top && e.offsetY <= top + height ? e.offsetY - top : height / 2;
drag = { grab };
try {
canvas.setPointerCapture(e.pointerId);
} catch {
// A pointer that isn't down (an event a test dispatched).
}
scrollToFrameTop(e.offsetY - grab);
});
canvas.addEventListener("pointermove", (e) => {
if (drag) scrollToFrameTop(e.offsetY - drag.grab);
});
const stop = () => {
drag = null;
redraw();
};
canvas.addEventListener("pointerup", stop);
canvas.addEventListener("pointercancel", stop);
canvas.addEventListener(
"wheel",
(e) => {
e.preventDefault();
void editor.scrollBy(e.deltaY);
},
{ passive: false },
);
void reload();
</script>
</body>
</html>
+18
Переглянути файл
@@ -56,6 +56,16 @@ pub(crate) fn detect_with_profiles(
detect_projects_matching(root, ruby_project, detect_ruby, &mut out);
detect_projects(root, &["rebar.config"], detect_rebar, &mut out);
detect_projects(root, &["mix.exs"], detect_mix, &mut out);
// A project's own `build.sbt` belongs to the build above it.
detect_projects_matching(
root,
|dir| {
dir.join("build.sbt").is_file()
&& !dir.ancestors().skip(1).take_while(|a| a.starts_with(root)).any(|a| a.join("build.sbt").is_file())
},
detect_sbt,
&mut out,
);
for dir in ide_core::project_roots::discover(root, &["CMakeLists.txt"]) {
let start = out.len();
cmake::detect(&dir, if dir == root { profiles } else { None }, &mut out);
@@ -1362,6 +1372,14 @@ fn detect_mix(root: &Path, out: &mut Vec<RunConfig>) {
out.push(config("mix:test", "mix test", "mix", "mix", &["test"]).test());
}
/// sbt (Scala): `sbt run` and `sbt test` on the build's root project, with the build's
/// own launcher script when it has one. Other tasks run from the sbt tool window.
fn detect_sbt(root: &Path, out: &mut Vec<RunConfig>) {
let sbt = wrapper(root, "sbt", "sbt.bat", "sbt");
out.push(config("sbt:run", "sbt run", "sbt", &sbt, &["run"]));
out.push(config("sbt:test", "sbt test", "sbt", &sbt, &["test"]).test());
}
/// Godot projects (`project.godot`) at the root or one level down: "Godot Project"
/// runs the main scene (`godot --path .`), debuggable through the editor's adapter.
fn detect_godot(root: &Path, out: &mut Vec<RunConfig>) {
+18
Переглянути файл
@@ -1206,3 +1206,21 @@ fn mix_projects() {
let dir = project(&[("mix.exs", "defp deps do\n [{:phoenix, \"~> 1.7\"}]\nend\n")]);
assert_eq!(cmdline(&detect(dir.path())[0]), "iex -S mix phx.server");
}
#[test]
fn sbt_projects() {
let dir = project(&[
("build.sbt", "lazy val core = project\n"),
("core/build.sbt", "libraryDependencies += \"a\" % \"b\" % \"1\"\n"),
("core/src/main/scala/App.scala", "object App\n"),
]);
let c = detect(dir.path());
assert_eq!(ids(&c), ["sbt:run", "sbt:test"]);
assert_eq!(cmdline(&c[0]), "sbt run");
assert!(c[1].is_test && c.iter().all(|c| c.kind == "sbt"));
let dir = project(&[("build.sbt", ""), ("sbt", "#!/bin/sh\n")]);
if !cfg!(windows) {
assert_eq!(cmdline(&detect(dir.path())[1]), "./sbt test");
}
}
+53 -1
Переглянути файл
@@ -745,7 +745,8 @@ pub fn native_tsdk(root: &Path, s: &Settings) -> Option<PathBuf> {
}
}
const PYTHON_SERVERS: [&str; 7] = ["basedpyright", "pyright", "ty", "pyrefly", "pylsp", "jedi-language-server", "ruff"];
const PYTHON_SERVERS: [&str; 8] =
["basedpyright", "pyright", "ty", "pyrefly", "pylsp", "jedi-language-server", "ruff", "djlsp"];
pub(crate) fn merge(base: &mut Value, layer: Value) {
match (base, layer) {
@@ -979,6 +980,16 @@ pub fn resolve_run_command(config: &mut RunConfig, root: &Path, s: &Settings) {
}
}
/// The environment folder holding `python` (`<env>/bin/python`, `<env>/Scripts/python.exe`):
/// a virtualenv, or a conda or pixi environment.
fn environment_of(python: &Path) -> Option<PathBuf> {
venv_of(python).or_else(|| {
let bin = python.parent()?;
let env = bin.parent()?;
matches!(bin.file_name()?.to_str()?, "bin" | "Scripts").then(|| env.to_path_buf())
})
}
pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root: &Path, s: &Settings) {
let mut path_dirs: Vec<PathBuf> = Vec::new();
if let Some(custom) = tool_command(root, s, &cfg.command) {
@@ -1002,6 +1013,13 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
"basedpyright" | "pyright" => merge_init_options(cfg, json!({ "python": { "pythonPath": p } })),
"pylsp" => merge_init_options(cfg, json!({ "pylsp": { "plugins": { "jedi": { "environment": p } } } })),
"jedi-language-server" => merge_init_options(cfg, json!({ "workspace": { "environmentPath": p } })),
// Django's template tags, filters and template folders are read by running a script
// with the interpreter in one of these environment folders.
"djlsp" => {
if let Some(env) = environment_of(&python) {
merge_init_options(cfg, json!({ "env_directories": [env.to_string_lossy()] }));
}
}
_ => {}
}
if let Some(venv) = venv_of(&python) {
@@ -1259,6 +1277,40 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
}
}
/// Registers the companion module-resolution plugin for the Vue hybrid mode's tsserver.
/// The Vue plugin only resolves imports that name the
/// `.vue` file: a directory `index.js` re-exporting a sibling `.vue`
/// (`import ChildButton from './ChildButton'`) leaves the component `any`, and with it every
/// `@event="method"` handler type in the project's templates (#3728; VS Code patches tsserver
/// itself for this). The companion plugin retries only what tsserver and the Vue plugin left
/// unresolved, so it is registered after theirs. No-op without it (no Vue language server).
pub fn configure_vue_module_resolution(cfg: &mut LanguageServerConfig, data_dir: &Path) -> bool {
let Some(vue_at) = cfg.initialization_options.as_ref().and_then(|v| serde_json::to_value(v).ok()).and_then(|v| {
v.pointer("/vtsls/tsserver/globalPlugins")
.and_then(Value::as_array)
.and_then(|plugins| plugins.iter().position(|p| p.get("name").and_then(Value::as_str) == Some(vue::PLUGIN)))
}) else {
return false;
};
let Some(plugin) = vue::module_resolution_plugin(data_dir) else {
return false;
};
let mut current =
cfg.initialization_options.as_ref().and_then(|v| serde_json::to_value(v).ok()).unwrap_or_else(|| json!({}));
let Some(plugins) = current.pointer_mut("/vtsls/tsserver/globalPlugins").and_then(Value::as_array_mut) else {
return false;
};
match plugins.iter().position(|p| p.get("name").and_then(Value::as_str) == Some(vue::MODULE_RESOLUTION_PLUGIN)) {
Some(at) => plugins[at] = plugin,
None => plugins.insert(vue_at + 1, plugin),
}
match toml::Value::try_from(current) {
Ok(v) => cfg.initialization_options = Some(v),
Err(e) => tracing::warn!("{}: cannot apply settings to initialization options: {e}", cfg.name),
}
true
}
/// The servers `language` uses after Settings › Language Servers: the
/// definition's ones that aren't disabled, then the ones defined in settings for it.
pub fn language_servers(language: &str, defined: &[LanguageServerConfig], s: &Settings) -> Vec<LanguageServerConfig> {
+1 -1
Переглянути файл
@@ -1588,7 +1588,7 @@ pub fn usages_bundle(data_dir: &Path) -> Option<PathBuf> {
install_bundle(
data_dir,
"java-usages",
"1.14.0",
"1.15.0",
include_bytes!("../../../java/java-usages/openidea-java-usages.jar"),
)
}
+62 -3
Переглянути файл
@@ -1,7 +1,7 @@
use crate::apply::{
apply_to_run_configs, apply_to_run_configs_in, configure_server, jdtls_jdk, maven_command, maven_options,
project_jdk, python_interpreter, ruff_configuration, terminal_activation, tool_install_environment, tsdk,
without_derived, without_derived_in,
apply_to_run_configs, apply_to_run_configs_in, configure_server, configure_vue_module_resolution, jdtls_jdk,
maven_command, maven_options, project_jdk, python_interpreter, ruff_configuration, terminal_activation,
tool_install_environment, tsdk, without_derived, without_derived_in,
};
use crate::python::parse_pip_list;
use crate::{bin_dir, exe, venv_of};
@@ -190,6 +190,18 @@ fn pyright_gets_python_path_and_venv_env() {
assert!(cfg.env["PATH"].starts_with(&*tmp.path().join(".venv").join(bin_dir()).to_string_lossy()));
}
#[test]
fn djlsp_reads_django_from_the_project_environment() {
let tmp = tempfile::tempdir().unwrap();
let python = fake_venv(tmp.path(), "venvs/web");
let mut s = Settings::default();
s.languages.python.interpreter = python.to_string_lossy().into_owned();
let mut cfg = server("djlsp");
configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
let opts = serde_json::to_value(cfg.initialization_options.unwrap()).unwrap();
assert_eq!(opts["env_directories"], serde_json::json!([tmp.path().join("venvs/web").to_string_lossy()]));
}
#[test]
fn a_run_target_interpreter_hides_local_pythons() {
let tmp = tempfile::tempdir().unwrap();
@@ -2723,3 +2735,50 @@ fn tool_installs_resolve_project_relative_sdks_and_leave_path_fallback_unconfigu
s.languages.python.interpreter = real.to_string_lossy().into_owned();
assert_eq!(tool_install_environment(root, &s).commands["python"], real);
}
#[test]
fn vue_module_resolution_plugin_follows_the_vue_plugin() {
let tmp = tempfile::tempdir().unwrap();
let mut cfg = server("vtsls");
crate::apply::merge_init_options(
&mut cfg,
serde_json::json!({ "vtsls": { "tsserver": { "globalPlugins": [crate::vue::tsserver_plugin(Path::new("/vue"))] } } }),
);
assert!(configure_vue_module_resolution(&mut cfg, tmp.path()));
let plugins = cfg
.initialization_options
.as_ref()
.map(|v| serde_json::to_value(v).unwrap())
.unwrap()
.pointer("/vtsls/tsserver/globalPlugins")
.unwrap()
.as_array()
.unwrap()
.clone();
assert_eq!(plugins.len(), 2);
assert_eq!(plugins[0]["name"], "@vue/typescript-plugin");
assert_eq!(plugins[1]["name"], "openidea-vue-module-resolution");
let index = tmp.path().join("tsplugins/node_modules/openidea-vue-module-resolution/index.js");
assert_eq!(std::fs::read_to_string(&index).unwrap(), include_str!("vue-module-resolution.js"));
// Running again replaces its own entry instead of stacking copies.
assert!(configure_vue_module_resolution(&mut cfg, tmp.path()));
let plugins = cfg
.initialization_options
.as_ref()
.map(|v| serde_json::to_value(v).unwrap())
.unwrap()
.pointer("/vtsls/tsserver/globalPlugins")
.unwrap()
.as_array()
.unwrap()
.clone();
assert_eq!(plugins.len(), 2);
}
#[test]
fn without_the_vue_plugin_the_module_resolution_plugin_stays_out() {
let tmp = tempfile::tempdir().unwrap();
let mut cfg = server("vtsls");
assert!(!configure_vue_module_resolution(&mut cfg, tmp.path()));
assert!(cfg.initialization_options.is_none());
}
+142
Переглянути файл
@@ -0,0 +1,142 @@
"use strict";
// Companion tsserver plugin for `@vue/typescript-plugin`: when TypeScript cannot resolve an
// extension-less relative import, retry it with the `.vue` extension. The Vue plugin only
// resolves specifiers that already name the `.vue` file (through a faked `.d.vue.ts`
// declaration), so a directory `index.js` re-exporting a sibling `.vue`
// (`import X from './X'`) leaves the component `any`, and with it every `@event="method"`
// handler type in the project's templates. This is the host-side equivalent of VS Code's
// `patch-tsserver.js`, which adds `.vue` to the extensions tsserver tries.
module.exports = ({ typescript }) => ({
create(info) {
const ts = typescript;
const host = info.languageServiceHost;
if (!host) {
return info.languageService;
}
const VUE = ".vue";
const DECLARATION = ".d.vue.ts";
// Specifiers TypeScript never resolves on its own that could still name an SFC:
// relative and without a known extension (`./ChildButton`, `./ChildButton/`).
const withVueExtension = (moduleName) => {
const base = moduleName.replace(/\/+$/, "");
if (
!ts.isExternalModuleNameRelative(base) ||
base.endsWith(VUE) ||
/\.[cm]?[jt]sx?$/.test(base) ||
/\.json$/.test(base)
) {
return undefined;
}
return base + VUE;
};
const fileExists = (fileName) =>
typeof host.fileExists === "function" ? host.fileExists(fileName) : ts.sys.fileExists(fileName);
const readFile = (fileName) => {
try {
return typeof host.readFile === "function" ? host.readFile(fileName) : ts.sys.readFile(fileName);
} catch {
return undefined;
}
};
// TypeScript probes `<specifier>.d.vue.ts` for a `.vue` import under
// `allowArbitraryExtensions`; answer `true` when the `.vue` itself is on disk.
const moduleResolutionHost = {
fileExists: (fileName) =>
fileName.endsWith(DECLARATION)
? fileExists(fileName.slice(0, -DECLARATION.length) + VUE)
: fileExists(fileName),
readFile,
directoryExists: host.directoryExists?.bind(host),
realpath: host.realpath?.bind(host),
getCurrentDirectory: host.getCurrentDirectory?.bind(host),
getDirectories: host.getDirectories?.bind(host),
useCaseSensitiveFileNames:
typeof host.useCaseSensitiveFileNames === "function"
? host.useCaseSensitiveFileNames.bind(host)
: host.useCaseSensitiveFileNames,
};
// The SFC's service script is TypeScript when it says `<script lang="ts">`, else JavaScript.
const scriptExtension = (vueFileName) => {
const head = readFile(vueFileName)?.slice(0, 4096) ?? "";
return /<script\b[^>]*\blang\s*=\s*["']tsx?["']/i.test(head) ? ".ts" : ".js";
};
const resolveVue = (moduleName, containingFile, options, redirectedReference, resolutionMode) => {
const specifier = withVueExtension(moduleName);
if (!specifier) {
return undefined;
}
const result = ts.resolveModuleName(
specifier,
containingFile,
{ ...options, allowArbitraryExtensions: true },
moduleResolutionHost,
undefined,
redirectedReference,
resolutionMode,
);
const resolved = result.resolvedModule;
if (!resolved || !resolved.resolvedFileName.endsWith(DECLARATION)) {
return undefined;
}
const vueFileName = resolved.resolvedFileName.slice(0, -DECLARATION.length) + VUE;
resolved.resolvedFileName = vueFileName;
resolved.extension = scriptExtension(vueFileName);
return resolved;
};
// Loaded after `@vue/typescript-plugin`, so its decorated resolvers run first; the
// retry only fills what both it and tsserver left unresolved.
if (typeof host.resolveModuleNameLiterals === "function") {
const resolveModuleNameLiterals = host.resolveModuleNameLiterals.bind(host);
host.resolveModuleNameLiterals = (
moduleLiterals,
containingFile,
redirectedReference,
options,
containingSourceFile,
...rest
) => {
const results = resolveModuleNameLiterals(
moduleLiterals,
containingFile,
redirectedReference,
options,
containingSourceFile,
...rest,
);
return moduleLiterals.map((literal, i) => {
if (results[i]?.resolvedModule) {
return results[i];
}
const mode = ts.getModeForUsageLocation?.(containingSourceFile, literal, options);
const resolved = resolveVue(literal.text, containingFile, options, redirectedReference, mode);
return resolved ? { resolvedModule: resolved } : results[i];
});
};
}
if (typeof host.resolveModuleNames === "function") {
const resolveModuleNames = host.resolveModuleNames.bind(host);
host.resolveModuleNames = (
moduleNames,
containingFile,
reusedNames,
redirectedReference,
options,
containingSourceFile,
) => {
const results = resolveModuleNames(
moduleNames,
containingFile,
reusedNames,
redirectedReference,
options,
containingSourceFile,
);
const mode = containingSourceFile?.impliedNodeFormat;
return moduleNames.map(
(moduleName, i) => results[i] ?? resolveVue(moduleName, containingFile, options, redirectedReference, mode),
);
};
}
return info.languageService;
},
});
+61 -1
Переглянути файл
@@ -11,7 +11,11 @@ use std::time::Duration;
pub(crate) const SERVER: &str = "vue-language-server";
const PACKAGE: &str = "@vue/language-server";
const PLUGIN: &str = "@vue/typescript-plugin";
pub(crate) const PLUGIN: &str = "@vue/typescript-plugin";
/// The companion plugin's package name under the IDE's data dir.
pub(crate) const MODULE_RESOLUTION_PLUGIN: &str = "openidea-vue-module-resolution";
/// The TS plugin shipped as an asset: retries extension-less relative imports with `.vue`.
const MODULE_RESOLUTION_JS: &str = include_str!("vue-module-resolution.js");
/// The file extension the plugin adds to tsserver.
pub(crate) const EXTENSION: &str = "vue";
const CLI_SERVICE: &str = "@vue/cli-service";
@@ -49,6 +53,25 @@ pub(crate) fn tsserver_plugin(package: &Path) -> serde_json::Value {
})
}
/// The companion module-resolution plugin (`vue-module-resolution.js`) written under
/// `<data_dir>/tsplugins`, as one more tsserver global plugin. `location` is the directory
/// holding its `node_modules`, the layout a plugin probe path resolves. Idempotent: the file
/// is only rewritten when its content changed. `None` when the data dir cannot be written.
pub(crate) fn module_resolution_plugin(data_dir: &Path) -> Option<serde_json::Value> {
let root = data_dir.join("tsplugins");
let dir = root.join("node_modules").join(MODULE_RESOLUTION_PLUGIN);
if std::fs::read(dir.join("index.js")).ok().as_deref() != Some(MODULE_RESOLUTION_JS.as_bytes()) {
std::fs::create_dir_all(&dir).ok()?;
std::fs::write(dir.join("index.js"), MODULE_RESOLUTION_JS).ok()?;
}
Some(serde_json::json!({
"name": MODULE_RESOLUTION_PLUGIN,
"location": root.to_string_lossy(),
"languages": ["vue"],
"enableForWorkspaceTypeScriptVersions": true,
}))
}
/// `compilerOptions.paths` for the webpack aliases of a Vue project at `root` (`@/*` →
/// `<root>/src/*`), for its tsserver project when it has no `jsconfig.json`: tsserver can't
/// read webpack configurations, so `@/` imports resolve to nothing, and a mixin imported
@@ -280,4 +303,41 @@ module.exports = { resolve: { alias: {
touch(&tmp.path().join("node_modules/typescript/lib/typescript.js"));
assert_eq!(own_typescript(&pkg), Some(tmp.path().join("node_modules/typescript/lib")));
}
#[test]
fn the_module_resolution_plugin_is_written_where_a_probe_path_finds_it() {
let tmp = tempfile::tempdir().unwrap();
let t = tmp.path();
let plugin = module_resolution_plugin(t).unwrap();
assert_eq!(plugin["name"], MODULE_RESOLUTION_PLUGIN);
assert_eq!(plugin["location"], t.join("tsplugins").to_string_lossy().as_ref());
assert_eq!(plugin["enableForWorkspaceTypeScriptVersions"], true);
let index = t.join("tsplugins/node_modules").join(MODULE_RESOLUTION_PLUGIN).join("index.js");
assert_eq!(std::fs::read_to_string(&index).unwrap(), MODULE_RESOLUTION_JS);
// A stale file from an older release is replaced.
std::fs::write(&index, "outdated").unwrap();
module_resolution_plugin(t).unwrap();
assert_eq!(std::fs::read_to_string(&index).unwrap(), MODULE_RESOLUTION_JS);
}
#[test]
fn the_module_resolution_plugin_loads_as_a_tsserver_plugin() {
let Some(node) = crate::exec::which("node") else { return };
let tmp = tempfile::tempdir().unwrap();
module_resolution_plugin(tmp.path()).unwrap();
let index = tmp.path().join("tsplugins/node_modules").join(MODULE_RESOLUTION_PLUGIN).join("index.js");
// tsserver requires the package and calls the factory with `{ typescript }`.
let out = crate::exec::query_in(
&node,
&[
"-e",
"const p = require(process.argv[1]); if (typeof p !== 'function') process.exit(1); process.stdout.write('factory');",
&index.to_string_lossy(),
],
None,
&[],
std::time::Duration::from_secs(30),
);
assert_eq!(out.as_deref(), Some("factory"));
}
}
+5 -4
Переглянути файл
@@ -536,15 +536,16 @@ mod tests {
let dest = tmp.path().join("install with spaces");
extract(&archive, ArchiveKind::Zip, &dest, "unity-debug", &CancellationToken::new()).unwrap();
let target = locate(&dest, &["UnityDebug.exe".into()]).unwrap();
let wrapper =
link_executable_with_runtime(&dest.join("bin"), "unity-debug", &target, cfg!(unix).then_some("mono"))
.unwrap();
let bin = dest.join("bin");
let wrapper = link_executable_with_runtime(&bin, "unity-debug", &target, cfg!(unix).then_some("mono")).unwrap();
let script = fs::read_to_string(wrapper).unwrap();
#[cfg(unix)]
assert!(script.contains(&*target.to_string_lossy()));
#[cfg(unix)]
assert!(script.contains("exec mono '") && script.contains("\"$@\""));
// The shim names the adapter relative to itself (see `cmd_path`).
#[cfg(windows)]
assert!(script.contains("\" %*") && !script.contains("mono "));
assert!(script.contains(&format!("\"{}\" %*", cmd_path(&bin, &target))) && !script.contains("mono "));
assert_eq!(fs::read(target.with_extension("exe.config")).unwrap(), b"runtime config");
assert_eq!(fs::read(target.parent().unwrap().join("Mono.Debugger.Soft.dll")).unwrap(), b"dependency");
}
+20 -1
Переглянути файл
@@ -19,6 +19,7 @@ pub mod archive;
mod bundled;
pub mod formatter;
pub mod jdk;
mod moved_venv;
pub mod platform;
#[cfg(any(windows, test))]
pub mod portable_update;
@@ -47,6 +48,8 @@ use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::mpsc;
use std::time::Duration;
pub use moved_venv::drop_moved_venvs;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum ToolStatus {
@@ -92,6 +95,10 @@ pub struct ToolInfo {
/// The interchangeable servers this one belongs to, in preference order: a
/// server and the `fallback` ones after it. Empty when it has none.
pub alternatives: Vec<String>,
/// A language server used for part of what its languages need (`features` in its
/// definition: pylsp-rope's refactorings next to basedpyright). Not offered for install
/// when missing; the Language Servers page lists it.
pub companion: bool,
}
/// Streamed install progress.
@@ -331,6 +338,7 @@ struct Usage {
args: Vec<String>,
initialization_options: Option<String>,
alternatives: Vec<String>,
companion: bool,
}
fn usages(langs: &[LanguageConfig]) -> BTreeMap<String, Usage> {
@@ -364,6 +372,11 @@ fn usages(langs: &[LanguageConfig]) -> BTreeMap<String, Usage> {
add(name, &d.command, ToolKind::Debugger, d.install_hint.as_ref(), &l.name);
}
}
for s in langs.iter().flat_map(|l| &l.language_servers).filter(|s| !s.features.is_empty()) {
if let Some(u) = map.get_mut(&s.name) {
u.companion = true;
}
}
for (plugin, host) in registry::PLUGIN_HOSTS {
let languages = map.get(*host).map(|u| u.languages.clone()).unwrap_or_default();
map.entry(plugin.to_string()).or_default().languages = languages;
@@ -749,6 +762,7 @@ impl Tools {
default_args: u.args.clone(),
default_initialization_options: u.initialization_options.clone(),
alternatives: u.alternatives.clone(),
companion: u.companion,
})
.map(|info| self.apply_custom(info, None));
};
@@ -775,6 +789,7 @@ impl Tools {
default_args: usage.map(|u| u.args.clone()).unwrap_or_default(),
default_initialization_options: usage.and_then(|u| u.initialization_options.clone()),
alternatives: usage.map(|u| u.alternatives.clone()).unwrap_or_default(),
companion: usage.is_some_and(|u| u.companion),
})
.map(|info| self.apply_custom(info, Some(spec)))
}
@@ -1444,7 +1459,9 @@ impl Tools {
let pkg = staging.join("pkg");
let kind = archive::ArchiveKind::from_name(&dl.name);
let main = spec.commands[0];
let exe_name = self.platform.exe(main);
// A PHP archive keeps its name and runs through `php` (Windows can't launch it itself).
let phar = dl.name.ends_with(".phar");
let exe_name = if phar { format!("{main}.phar") } else { self.platform.exe(main) };
match kind {
archive::ArchiveKind::Gz | archive::ArchiveKind::Raw => {
archive::extract(&archive, kind, &pkg.join("bin"), &exe_name, cancel)?
@@ -1488,6 +1505,8 @@ impl Tools {
if self.exe_in(&bin, main).as_deref() != Some(target.as_path()) {
if spec.name == "unity-debug" && cfg!(unix) {
archive::link_executable_with_runtime(&bin, main, &target, Some("mono"))?;
} else if phar {
archive::link_executable_with_runtime(&bin, main, &target, Some("php"))?;
} else {
archive::link_executable(&bin, main, &target)?;
}
+124
Переглянути файл
@@ -0,0 +1,124 @@
//! Managed virtual environments only work where they were created: their launchers
//! (uv's `.exe` trampolines, script shebangs) name the interpreter by absolute path.
//! One moved from outside the IDE (a copied data directory, a relocated AppData) fails
//! to start, so it is removed and installed afresh when next needed.
use crate::registry::{Method, TOOLS};
use std::path::{Path, PathBuf};
/// Removes the managed virtual-environment tools under `tools_root` that no longer sit
/// where they were created. Call at start-up, before language servers start.
pub fn drop_moved_venvs(tools_root: &Path) {
for spec in TOOLS.iter().filter(|spec| matches!(spec.method, Method::PipVenv { .. })) {
let dir = tools_root.join(spec.name);
if !venv_moved(&dir.join("venv")) {
continue;
}
tracing::info!(?dir, "virtual environment was moved from where it was created; removing it to reinstall");
if let Err(error) = std::fs::remove_dir_all(&dir) {
tracing::warn!(?dir, %error, "cannot remove the moved virtual environment");
}
}
}
fn venv_moved(venv: &Path) -> bool {
let Some(created) = venv_origin(venv) else { return false };
match (std::fs::canonicalize(&created), std::fs::canonicalize(venv)) {
(Ok(created), Ok(venv)) => created != venv,
// The interpreter path its launchers hold is gone.
(Err(_), Ok(_)) => true,
_ => false,
}
}
/// Where a virtual environment was created: the `VIRTUAL_ENV` its activation script sets.
fn venv_origin(venv: &Path) -> Option<PathBuf> {
let script =
if cfg!(windows) { venv.join("Scripts").join("activate.bat") } else { venv.join("bin").join("activate") };
let text = std::fs::read_to_string(script).ok()?;
text.lines().find_map(virtual_env).map(PathBuf::from)
}
/// The path a line of an activation script assigns to `VIRTUAL_ENV`, as uv and CPython write them:
/// `VIRTUAL_ENV='/v'`, `VIRTUAL_ENV="/v"`, `export VIRTUAL_ENV=$(cygpath "/v")`,
/// `set "VIRTUAL_ENV=C:\v"`, and uv's `@for %%i in ("C:\v") do @set "VIRTUAL_ENV=%%~fi"`.
fn virtual_env(line: &str) -> Option<&str> {
let at = line.find("VIRTUAL_ENV=")?;
if let Some(start) = line[..at].find("in (\"") {
let rest = &line[start + 5..];
return rest.find('"').map(|end| &rest[..end]).filter(|value| !value.is_empty());
}
let rest = line[at + "VIRTUAL_ENV=".len()..].trim_start_matches("$(cygpath ");
let value = match rest.chars().next()? {
quote @ ('"' | '\'') => rest[1..].split(quote).next()?,
_ if line[..at].ends_with('"') => rest.split('"').next()?,
_ => rest.split_whitespace().next()?.trim_end_matches(')'),
};
(!value.is_empty() && !value.starts_with(['$', '%'])).then_some(value)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reads_virtual_env_as_uv_and_cpython_write_it() {
assert_eq!(virtual_env("VIRTUAL_ENV='/data/tools/ty/venv'"), Some("/data/tools/ty/venv"));
assert_eq!(virtual_env("VIRTUAL_ENV=\"/a b/venv\""), Some("/a b/venv"));
assert_eq!(virtual_env(" export VIRTUAL_ENV=$(cygpath \"/a/venv\")"), Some("/a/venv"));
assert_eq!(virtual_env(" export VIRTUAL_ENV=$(cygpath /a/venv)"), Some("/a/venv"));
assert_eq!(virtual_env(r#"set "VIRTUAL_ENV=E:\App Data\tools\ty\venv""#), Some(r"E:\App Data\tools\ty\venv"));
assert_eq!(
virtual_env(r#"@for %%i in ("E:\data\tools\ty\venv") do @set "VIRTUAL_ENV=%%~fi""#),
Some(r"E:\data\tools\ty\venv")
);
assert_eq!(virtual_env(" export VIRTUAL_ENV"), None);
assert_eq!(virtual_env("unset VIRTUAL_ENV_PROMPT"), None);
assert_eq!(virtual_env("set VIRTUAL_ENV=%~dp0.."), None);
}
fn venv_created_at(tools: &Path, name: &str, origin: &Path) {
let venv = tools.join(name).join("venv");
let script =
if cfg!(windows) { venv.join("Scripts").join("activate.bat") } else { venv.join("bin").join("activate") };
std::fs::create_dir_all(script.parent().unwrap()).unwrap();
let line = if cfg!(windows) {
format!("@for %%i in (\"{}\") do @set \"VIRTUAL_ENV=%%~fi\"\r\n", origin.display())
} else {
format!("VIRTUAL_ENV='{}'\nexport VIRTUAL_ENV\n", origin.display())
};
std::fs::write(script, line).unwrap();
}
#[test]
fn removes_only_virtual_environments_moved_from_where_they_were_created() {
let tmp = tempfile::tempdir().unwrap();
let tools = tmp.path().join("tools");
// Created here.
venv_created_at(&tools, "ty", &tools.join("ty").join("venv"));
// Copied from another data directory that is gone.
venv_created_at(&tools, "basedpyright", &tmp.path().join("old/tools/basedpyright/venv"));
// Copied, the original still in place.
let old_ruff = tmp.path().join("old-kept/tools/ruff/venv");
std::fs::create_dir_all(&old_ruff).unwrap();
venv_created_at(&tools, "ruff", &old_ruff);
// No activation script to tell.
std::fs::create_dir_all(tools.join("pyrefly").join("venv")).unwrap();
// Not a virtual-environment tool.
std::fs::create_dir_all(tools.join("gopls").join("bin")).unwrap();
drop_moved_venvs(&tools);
assert!(tools.join("ty").exists());
assert!(!tools.join("basedpyright").exists());
assert!(!tools.join("ruff").exists());
assert!(tools.join("pyrefly").exists());
assert!(tools.join("gopls").exists());
}
#[test]
fn a_missing_tools_directory_is_left_alone() {
let tmp = tempfile::tempdir().unwrap();
drop_moved_venvs(&tmp.path().join("missing"));
}
}
+42
Переглянути файл
@@ -289,6 +289,17 @@ pub static TOOLS: &[ToolSpec] = &[
homepage: "https://docs.astral.sh/ty/",
needs: &[],
},
ToolSpec {
name: "pylsp",
display: "pylsp-rope (Python refactorings)",
kind: LanguageServer,
commands: &["pylsp"],
method: Method::PipVenv { package: "pylsp-rope" },
fallback: None,
version: ver("pylsp"),
homepage: "https://github.com/python-rope/pylsp-rope",
needs: &[],
},
ToolSpec {
name: "pyrefly",
display: "Pyrefly (Python)",
@@ -311,6 +322,17 @@ pub static TOOLS: &[ToolSpec] = &[
homepage: "https://docs.astral.sh/ruff/",
needs: &[],
},
ToolSpec {
name: "djlsp",
display: "Django Template LSP",
kind: LanguageServer,
commands: &["djlsp"],
method: Method::PipVenv { package: "django-template-lsp" },
fallback: None,
version: ver("djlsp"),
homepage: "https://github.com/fourdigits/django-template-lsp",
needs: &[],
},
ToolSpec {
name: "bash-language-server",
display: "Bash Language Server",
@@ -455,6 +477,26 @@ pub static TOOLS: &[ToolSpec] = &[
homepage: "https://intelephense.com",
needs: &[],
},
ToolSpec {
name: "phpactor",
display: "Phpactor (PHP)",
kind: LanguageServer,
commands: &["phpactor"],
// One PHP archive for every platform, run through the project's PHP.
method: Method::Release {
source: ReleaseSource::GitHub { repo: "phpactor/phpactor" },
assets: &[
any_arch(Mac, "phpactor.phar"),
any_arch(Linux, "phpactor.phar"),
any_arch(Windows, "phpactor.phar"),
],
locate: &["phpactor.phar"],
},
fallback: None,
version: ver("phpactor"),
homepage: "https://phpactor.readthedocs.io",
needs: &[("php", "Phpactor runs on PHP")],
},
ToolSpec {
name: "laravel-lsp",
display: "Laravel LSP",
+53 -6
Переглянути файл
@@ -315,9 +315,10 @@ fn concurrent_installs_of_one_tool_are_rejected() {
/// A second caller mid-install joins the run (the other Settings window's
/// duplicate install) and shares the result instead of `AlreadyExists`.
// Slot names no real install in other tests uses: tests share the process-wide slots.
#[test]
fn second_install_joins_the_running_one() {
let slot = match install_slot("sqls", &CancellationToken::new()) {
let slot = match install_slot("join-test-slot", &CancellationToken::new()) {
Ok(slot) => slot,
Err(_) => panic!("no install is running"),
};
@@ -328,7 +329,7 @@ fn second_install_joins_the_running_one() {
slot.broadcast(InstallEvent::Line { text: format!("line {i}") });
std::thread::sleep(Duration::from_millis(20));
}
release_install_slot("sqls", &slot);
release_install_slot("join-test-slot", &slot);
slot.finish(Err(IdeError::new(ErrorKind::Io, "compile failed")));
})
};
@@ -348,8 +349,8 @@ fn second_install_joins_the_running_one() {
assert!(texts.contains(&"Joined the install already in progress…".to_string()), "{texts:?}");
assert!(texts.iter().any(|l| l == "line 2"), "{texts:?}");
// The slot is released: a fresh install can start.
match install_slot("sqls", &CancellationToken::new()) {
Ok(fresh) => release_install_slot("sqls", &fresh),
match install_slot("join-test-slot", &CancellationToken::new()) {
Ok(fresh) => release_install_slot("join-test-slot", &fresh),
Err(_) => panic!("the finished install still holds its slot"),
}
}
@@ -357,7 +358,7 @@ fn second_install_joins_the_running_one() {
/// A late caller gets the finished result without waiting.
#[test]
fn install_joined_after_it_finished_returns_the_result() {
let slot = match install_slot("marksman", &CancellationToken::new()) {
let slot = match install_slot("finished-test-slot", &CancellationToken::new()) {
Ok(slot) => slot,
Err(_) => panic!("no install is running"),
};
@@ -380,8 +381,9 @@ fn install_joined_after_it_finished_returns_the_result() {
default_args: vec![],
default_initialization_options: None,
alternatives: vec![],
companion: false,
};
release_install_slot("marksman", &slot);
release_install_slot("finished-test-slot", &slot);
slot.finish(Ok(ok));
let info = join_install(&slot, &CancellationToken::new(), &|_| {}).unwrap();
assert_eq!(info.version.as_deref(), Some("1.0"));
@@ -459,6 +461,51 @@ esac"#,
assert!(exe.exists());
}
/// A PHP archive release (phpactor) keeps its `.phar` name and is launched through `php`.
#[cfg(unix)]
#[test]
fn phar_release_installs_with_a_php_launcher() {
let env = Env::new();
let fixtures = env.root.parent().unwrap().join("fixtures");
fs::create_dir_all(&fixtures).unwrap();
let phar = fixtures.join("phpactor.phar");
fs::write(&phar, b"<?php __HALT_COMPILER();").unwrap();
let digest = sources::sha256_file(&phar).unwrap();
let json = fixtures.join("release.json");
fs::write(
&json,
format!(
r#"{{"tag_name":"2026.10.07.0","assets":[{{"name":"phpactor.phar","browser_download_url":"https://example.invalid/phpactor.phar","size":{},"digest":"sha256:{digest}"}}]}}"#,
fs::metadata(&phar).unwrap().len()
),
)
.unwrap();
env.script(
&env.sys,
"curl",
&format!(
r#"out=""; url=""
while [ $# -gt 0 ]; do case "$1" in -o) out="$2"; shift 2;; -A|-H|--retry|--connect-timeout) shift 2;; -*) shift;; *) url="$1"; shift;; esac; done
case "$url" in
https://api.github.com/*) /bin/cat '{json}';;
*) /bin/cp '{phar}' "$out";;
esac"#,
json = json.display(),
phar = phar.display()
),
);
env.script(&env.sys, "php", r#"echo "php $*""#);
let info = env.tools().install("phpactor", &langs(), &CancellationToken::new(), &|_| {}).unwrap();
assert_eq!(info.status, ToolStatus::Installed);
let launcher = env.root.join("phpactor/bin/phpactor");
assert_eq!(info.path.as_deref(), Some(launcher.as_path()));
let archive = env.root.join("phpactor/bin/phpactor.phar");
assert_eq!(fs::read(&archive).unwrap(), b"<?php __HALT_COMPILER();");
let out = Command::new(&launcher).arg("language-server").env("PATH", &env.sys).output().unwrap();
assert_eq!(String::from_utf8_lossy(&out.stdout).trim(), format!("php {} language-server", archive.display()));
}
/// npm installs go to `<tools>/node_modules` with `--prefix`.
#[cfg(unix)]
#[test]
+59 -4
Переглянути файл
@@ -12,7 +12,9 @@ use std::path::Path;
use std::sync::{Arc, Mutex, OnceLock, Weak};
use std::time::SystemTime;
pub(crate) const COMMITS: TableDefinition<&str, &[u8]> = TableDefinition::new("summaries-v2");
// v3: summaries follow git's subject (the first paragraph on one line), not the first line.
pub(crate) const COMMITS: TableDefinition<&str, &[u8]> = TableDefinition::new("summaries-v3");
const STALE_COMMITS: TableDefinition<&str, &[u8]> = TableDefinition::new("summaries-v2");
const MESSAGES: TableDefinition<&str, &str> = TableDefinition::new("messages-v1");
const MAX_MEMORY_COMMITS: usize = 4096;
const MAX_MEMORY_MESSAGES: usize = 1024;
@@ -268,6 +270,7 @@ impl LogIndex {
let mut databases = DATABASES.get_or_init(Mutex::default).lock().unwrap_or_else(|p| p.into_inner());
self.db = databases.get(&path).and_then(Weak::upgrade).or_else(|| {
let db = Arc::new(std::fs::create_dir_all(dir).ok().and_then(|_| Database::create(&path).ok())?);
drop_stale_tables(&db);
databases.insert(path, Arc::downgrade(&db));
Some(db)
});
@@ -309,8 +312,8 @@ impl LogIndex {
let author = commit.author().map_err(gx)?;
let committer = commit.committer().map_err(gx)?;
let raw = commit.message_raw_sloppy();
let summary = raw.split(|b| *b == b'\n').find(|l| !l.trim().is_empty()).unwrap_or_default().trim();
let summary_text = to_string(summary.as_bstr());
let summary_text = subject(raw.as_bstr());
let message_truncated = raw.trim() != summary_text.as_bytes();
let record = Arc::new(Commit {
id: key.clone(),
short_id: key[..key.len().min(8)].to_string(),
@@ -327,7 +330,7 @@ impl LogIndex {
commit_time_ms: committer.time().map(|t| t.seconds as f64 * 1000.0).unwrap_or(0.0),
summary: summary_text.clone(),
message: summary_text,
message_truncated: raw.trim() != summary,
message_truncated,
history_path: None,
log_position: None,
log_total: None,
@@ -425,6 +428,23 @@ pub(crate) fn matches_user(query: &str, name: &str, email: &str) -> bool {
.any(|alias| target.contains(&normalize_user(alias)))
}
/// git's subject (`%s`, `git log --oneline`): the message's first paragraph on one line.
/// A whitespace-only line ends the paragraph, as in git; `\r\n` endings count as newlines.
fn subject(message: &gix::bstr::BStr) -> String {
let lines = message.lines().map(|l| l.trim_end()).skip_while(|l| l.is_empty());
let paragraph: Vec<String> = lines.take_while(|l| !l.is_empty()).map(|l| to_string(l.as_bstr())).collect();
// git skips leading whitespace (blank lines and the first line's indent) before the subject.
paragraph.join(" ").trim_start().to_owned()
}
/// Drops tables an older version wrote, so outdated summaries don't stay on disk.
fn drop_stale_tables(db: &Database) {
let Ok(txn) = db.begin_write() else { return };
if txn.delete_table(STALE_COMMITS).unwrap_or(false) {
let _ = txn.commit();
}
}
#[cfg(test)]
mod tests {
use super::*;
@@ -487,4 +507,39 @@ mod tests {
assert_eq!(branches[1], vec!["feature".to_string(), "main".to_string()]);
assert_eq!(branches[2], vec!["main".to_string()]);
}
#[test]
fn summary_is_git_subject_first_paragraph_on_one_line() {
let tmp = tempfile::tempdir().unwrap();
let dir = tmp.path();
git(dir, &["init", "-q"]);
let messages = [
// The reporter's template: one paragraph of field lines (#3680).
"[所属项目]:能力平台-订单\n[发布版本]:v1.2\n[需求单号]:REQ-1\n[需求描述]:导出\n[修改内容]:修复",
"Subject only",
"Subject\n\nBody that stays in the details",
"Wrapped subject\ncontinues here\n\nBody",
"CRLF subject\r\nsecond line\r\n\r\nBody",
"Ends at a blank line\n \t\nBody",
"\n\n Leading blank lines \nand indent kept\n",
"Trailing spaces \n",
];
let mut ids = Vec::new();
for (i, message) in messages.iter().enumerate() {
std::fs::write(dir.join("a.txt"), i.to_string()).unwrap();
std::fs::write(dir.join(".git/msg.txt"), message).unwrap();
git(dir, &["add", "-A"]);
git(dir, &["commit", "-q", "--cleanup=verbatim", "-F", ".git/msg.txt"]);
ids.push(ObjectId::from_hex(git(dir, &["rev-parse", "HEAD"]).as_bytes()).unwrap());
}
let repo = gix::open(dir).unwrap();
let mut index = LogIndex::default();
for (id, message) in ids.iter().zip(messages) {
let expected = git(dir, &["log", "-1", "--format=%s", &id.to_string()]);
let commit = index.get(&repo, *id).unwrap();
assert_eq!(commit.summary, expected, "{message:?}");
assert_eq!(commit.message_truncated, message.trim() != expected, "{message:?}");
}
assert_eq!(index.get(&repo, ids[0]).unwrap().summary, messages[0].replace('\n', " "));
}
}
+1 -1
Переглянути файл
@@ -43,7 +43,7 @@ User-visible text is written in English at the call site and goes through the te
## WebKit compatibility
On macOS and Linux the app runs in WebKit, and the supported floor is Safari 15.4, the engine of macOS 12 (the app's minimum). `pnpm build` runs `scripts/check-webkit.ts` on the bundle, and `src/platform/webkitCompatibility.test.ts` checks application regexes. Avoid:
On macOS and Linux the app runs in WebKit, and the supported floor is Safari 15.4, the engine of macOS 12 (the app's minimum). On macOS 11 and on macOS 12 before 12.3, `src-tauri/src/macos_webview.rs` loads the newer WebKit staged by a Safari update, provided that update is installed. `pnpm build` runs `scripts/check-webkit.ts` on the bundle, and `src/platform/webkitCompatibility.test.ts` checks application regexes. Avoid:
- regex lookbehind (`(?<=…)`, `(?<!…)`), which needs Safari 16.4, and the regex `v` flag;
- import attributes;
+2
Переглянути файл
@@ -44,6 +44,8 @@ You don't need a JDK to build: the Java extension bundles in `java/` are checked
`pnpm dev:app` is the same as `pnpm tauri dev`, plus the global Tauri API (`window.__TAURI__`, from `src-tauri/tauri.dev.conf.json`), which is useful when you drive the app from scripts.
On macOS, `.cargo/config.toml` defaults `MACOSX_DEPLOYMENT_TARGET` to 11.0 (export your own value to override), so debug builds launch on older systems too. When the system WebKit predates Safari 15.4, `src-tauri/src/macos_webview.rs` re-execs once into the newer WebKit staged by a Safari update; set `OPENIDEA_DISABLE_STAGED_WEBKIT=1` to keep the system engine while debugging.
Other everyday commands:
| Command | What it does |
+11
Переглянути файл
@@ -32,6 +32,8 @@ These agents are built in. Install the agent's own CLI and sign in once in a ter
Agents are unavailable in a project you have not marked as trusted.
Codex keeps its own project trust decision. If it disables the current project's `.codex` configuration, the task asks whether to **Trust Project in Codex** or **Keep Untrusted**. Trusting saves only that project's trust entry through Codex's configuration API before the session loads its configuration, including MCP servers, hooks and exec policies. This confirmation is required even in Full Access mode; declining keeps the configuration disabled and shows the reason without stopping the conversation. Codex configuration and runtime warnings also appear in the task.
## Start a task
| Action | macOS | Windows / Linux |
@@ -121,6 +123,15 @@ Tasks are saved per project and survive restarts. When the agent supports resumi
**Settings › Tools › Agents › Chat** chooses what the task header shows: **Context window usage**, **Time spent on the task**, **Usage limits** (when the agent reports them, such as Claude Code) and **Session cost**.
### External MCP servers
**Settings › Agents › External MCP Servers** configures MCP servers across three persistent levels, while the composer's **MCP** picker (or `/mcp`) controls them per session:
- **Global (`User`)**: saved in `settings.toml` with environment variable and HTTP header values stored in the OS credential store, shared across projects and agents (or scoped to selected agents).
- **Project (`Workspace`)**: saved in `.openidea/settings.toml`; entries with the same name override Global servers, and servers added outside OpenIDEA stay off until approved.
- **Agent Configs**: discovers servers already configured in `~/.copilot/mcp-config.json`, `~/.claude.json`, `~/.codex/config.toml`, `~/.cursor/mcp.json`, `~/.gemini/settings.json`, `~/.jetbrains/mcp/mcp.json`, `.mcp.json`, and `.vscode/mcp.json` so you can import them into Global or Project settings with one click. You can also add or edit servers via structured fields or raw `mcpServers` JSON (**Add from JSON**), and run **Test Connection** to inspect the tools a server advertises.
- **Per-session (`MCP` / `/mcp`)**: in both **New Agent Task** and active task conversations, open **MCP** in the composer toolbar (or run `/mcp`) to enable or disable individual servers—including the built-in `openidea` server—for that task only, or click **Reset** to return to the inherited defaults.
While the agent works, the line under the conversation says what it is doing: thinking, reading, editing, running a command, writing its reply. **Settings › Agents › Working Status** can show playful words for what it does there instead; they are off by default. Once turned on, they take turns from the moment the work changes, or only after the agent reports nothing new for a number of seconds (0 to 600, 0 by default); screen readers still hear what the agent is doing. Each word stays eight seconds while the agent keeps at the same work, and at least three when it moves on, so the line doesn't flicker. The same page replaces the words: pick what the status says (**Reading…**, **Running a command…**…) and add or remove its words. **Restore Built-in Words** brings back OpenIDEA's; an activity left without words keeps its plain status.
## Add a custom agent
+3
Переглянути файл
@@ -52,6 +52,7 @@ Language servers that support LSP inline completion show a grey suggestion at th
| **Go to Type Declaration** | `⇧⌘B` | `Ctrl+Shift+B` |
| **Super Method** | `⌘U` | `Ctrl+U` |
| **Navigate › Test** | `⇧⌘T` | `Ctrl+Shift+T` |
| **Navigate › Related Symbol…** | `⌃⌘↑` | `Ctrl+Alt+Home` |
| **Back** / **Forward** | `⌘[` / `⌘]` | `Ctrl+Alt+Left` / `Ctrl+Alt+Right` |
| **Next Method** / **Previous Method** | `⌃⇧↓` / `⌃⇧↑` | `Alt+Down` / `Alt+Up` |
@@ -59,6 +60,8 @@ Language servers that support LSP inline completion show a grey suggestion at th
- Hold `⌘` / `Ctrl` and hover over a name to see it underlined as a link, with brief information about it.
- Gutter icons mark types and methods that are implemented or overridden (↓) and methods that implement or override another (↑). Click one to go there.
- **Navigate › Test** jumps between a class and its tests by naming convention and offers **Create New Test…** when there is none.
- **Navigate › Related Symbol…** goes to the files tied to the current one by convention: a C, C++ or Objective-C header and its source file, and in Rails a controller action and its views, a view and its action, a controller and its helper and model, a model and its controller and migrations. With several targets it shows a chooser.
- In Rails, **Go to Declaration** also follows method symbols in callbacks (`before_action :load_user`, `if: :admin?`) to their `def`, and controller actions in `config/routes.rb` (`to: "users#index"`, `resources :users`) to the controller.
Going to files, classes and symbols by name is covered in [Search and navigation](/en/guide/search).
Loaded 100 of 450 files, more files were not shown because too many files have changed in this diff. Show more