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

...
Автор SHA1 Повідомлення Дата
l0ng-ai cf95edf296 docs: suggest XWayland first for a Linux window that stops responding 2026-11-18 22:43:26 +08:00
l0ng-ai f3e80ba020 feat(http-client): navigate from a request URL to its endpoint handler (#4341)
⌘-click / Go to Declaration on a request URL in a .http file opens the handler of the endpoint it reaches, matched by method and path ({var}/*/** in the mapping, {{var}} in the request, an optional context path).
2026-11-18 22:42:02 +08:00
l0ng-ai f767bd2e7c fix(http-client): resolve Spring mapping constants declared in other classes (#4340)
Mapping paths were evaluated with the controller file's own constants only, so paths built from another class's constants dropped out of Endpoints search and showed partial URLs in the gutter. A shared constant pool finds the referenced classes by name in the index (imported package first), reads them and resolves their constants, following static imports and superclasses up to three hops.
2026-11-18 22:39:20 +08:00
l0ng-ai 51174842cc fix(database): keep Save password ticked in the connect prompt (#4338)
The connect-time password prompt stored the password but left the data source's savePassword off, and saved passwords are only read when it is on, so every connection asked again. The prompt's checkbox now updates the data source setting; the SSH secret prompt does the same for a source's own SSH settings.
2026-11-18 22:32:53 +08:00
l0ng-ai e4ece2bd8d fix(search): list scratch files in Recent Files (#4337)
Recent Files only recorded paths inside the project, so scratch files never appeared in ⌘E. Files outside the project are now recorded and persisted by absolute path; the popup and Switcher show files under the Scratches root as Scratches/<path>.
2026-11-18 22:30:54 +08:00
l0ng-ai a5093c0cd1 fix(workbench): space project tabs from the island below by the island gap (#4336)
The tab bar's bottom padding was --space-0-5 (2px), so the selected project tab island sat 2px above the islands below while islands are --island-gap (6px) apart.
2026-11-18 22:23:47 +08:00
l0ng-ai 9a0256c7d4 fix(ui): show a resize cursor on splitters under WebKit on macOS 26.2 (#4334)
WebKit on macOS 26.2 renders ew-resize/ns-resize as the default arrow, so dividers gave no hover feedback. Dividers (tool window gaps and splits, editor splits, side tabs, diff gutter, column resizers, review handles) and the drag-time cursor lock now use col-resize/row-resize. Window and popup edge handles are unchanged.
2026-11-18 22:21:24 +08:00
l0ng-ai 78b478ee38 fix(plugins): say which project a document-changed path is relative to (#4332)
document-changed gave plugins the path relative to the file's own project but not which project, so with two open projects holding the same relative path a plugin couldn't tell which document changed. The event now carries project (the root the path is relative to); the SDK's DocumentChanged exposes it as Option<String>. The payload is JSON through other, so WIT is unchanged; plugin components are rebuilt for the SDK change.
2026-11-18 22:13:03 +08:00
Akbar Husain 926a5424d1 perf(build): bound retained compile output, keep head and tail (#4025)
A compile step kept every line of its child's output in memory for the error summary, though each line is already streamed to the Build tool window. Compile steps now run through process::run_bounded, which keeps the head and tail of the output (and splits over-long lines) and marks the text as truncated; the error summary says when lines may be missing. Callers that parse a successful run's output (Gradle model and tasks, Gradle dependencies, Maven dependency trees and sources) keep using process::run with full retention.

Co-authored-by: akbar1214 <[email protected]>
2026-11-18 21:53:57 +08:00
MyRRR f1aa47e762 feat(editor): structured Julia syntax highlighting (#4161)
Julia used CodeMirror's legacy StreamLanguage mode, which has no tags for function calls, type names or macros. It now uses Pluto's MIT-licensed Lezer grammar (@plutojl/lang-julia), with call targets tagged as function names, and Julia joins the language-scoped Color Scheme settings with a preview sample.

Co-authored-by: Royshare <[email protected]>
2026-11-18 21:50:17 +08:00
l0ng-ai 305dbdc316 fix(gradle): show resolvable configurations for the selected project (#4281)
Dependency Analyzer offered a fixed list of configurations, so a custom resolvable configuration couldn't be selected. It now lists the configurations Gradle reports as resolvable for the selected project, custom ones included, and syncs projects whose configuration data is missing or stale when it opens. Configurations used only to declare dependencies are excluded.
2026-11-18 21:46:45 +08:00
Mamaev Igor 0a4f2fc1df fix(vim): move between notebook cells with j and k (#4317)
In a notebook with Vim enabled, Normal-mode j on a cell's last line and k on its first line now continue into the next or previous cell that shows an editor (code, or Markdown being edited), at the same column; Markdown previews and raw cells are skipped. Counts, operators and registers (3j, dj) stay inside the cell. Notebooks provide the neighbouring editor through a new adjacentEditor facet.

Co-authored-by: pxc1984 <[email protected]>
2026-11-18 21:45:04 +08:00
Mr0Bread 93210c8c04 fix(agents): refresh models in existing chats (#4062)
An existing chat only offered the models its session reported. Its composer now uses the same searchable model picker and Refresh models control as New Agent Task. A model that only the fresh catalog lists is tried on the live session first; if the agent rejects it and the session is idle and resumable, the choice is kept as pending, the live process is recycled, and the next message reloads the same session and applies it through the existing wanted-settings path. If the reload can't apply it, the previous model is restored and the error reported without sending.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-18 21:43:50 +08:00
Vladislav Kuzmin c52067f815 fix(database): support ClickHouse HTTP endpoints without session affinity (#4316)
Behind an endpoint that alternates replicas, the named HTTP session opened by Test Connection was missing on the next node (code 372), so the data source could not connect. Setting use_http_session=false in a data source's Advanced properties sends each request without a session, carrying its own database, settings and limits; startup scripts are rejected in that mode. Named sessions stay the default and now run USE for the configured database, since the HTTP database parameter applies only to the request carrying it. A lost session reports how to fix it and never replays the user's SQL.

Co-authored-by: principalwater <[email protected]>
2026-11-18 21:39:34 +08:00
Moler1995 fce37c5627 fix(vim): sync registers with the system clipboard and route paste/copy per mode (#4136)
The "+ and "* registers read and write the system clipboard (CRLF normalised, linewise when the text ends with a line break), Insert-mode Ctrl+V / Shift+Insert paste and Visual-mode Ctrl+C copy. A new clipboard option (default ideaput,autoselect) controls the unnamed register: set clipboard+=unnamed or clipboard=unnamedplus in .ideavimrc mirrors yanks, deletes and changes to the system clipboard; by default they stay in Vim's registers. "+ is read through the native clipboard where the backend provides it.

Co-authored-by: Moler1995 <[email protected]>
2026-11-18 21:38:01 +08:00
liziing 90df4ba48e fix(vcs): show declaration icons in the Compare tool window (#4300)
The Compare tool window chose every icon from the file name alone. When a revision is compared with the working tree, files that still exist now take their icon from the shared file presentation cache, as the Project tree does: Java and Kotlin classes, interfaces and tests, and Spring config files. Deleted files and comparisons between two revisions keep their file-type icons.

Co-authored-by: liziing <[email protected]>
2026-11-18 21:33:45 +08:00
l0ng-ai c3034b25e8 Stage TODO and Vim preferences until Settings applies them (#4283) 2026-11-18 21:32:25 +08:00
l0ng-ai b5c2a84d5d Keep file type association edits on the visible selection (#4282) 2026-11-18 21:32:17 +08:00
lleviathe 723666891d feat(settings): indent dependent options under their checkbox and disable them while unchecked (#4308)
A checkbox option on a declarative settings page can have children, rendered indented under it and disabled while it is unchecked, like the editor pages already do. IDE MCP Server's Port is the first one, under Use a fixed port; both search indexes still list it.

Co-authored-by: lleviathe <[email protected]>
2026-11-18 21:30:35 +08:00
lleviathe 268f12349f fix(settings): space hints from their control and start checkbox hints at the checkbox text (#4306)
Hints now sit 4px below their control, and checkbox hints start at the checkbox text (box plus label gap) on both declarative and editor settings pages.

Co-authored-by: lleviathe <[email protected]>
2026-11-18 21:30:31 +08:00
lleviathe 4dfdbd35fd fix(settings): keep wrapped hints from overlapping the next row in WebKit (#4305)
WebKit sizes an auto grid row from its item's height at an earlier width, so after the Settings window narrowed, a hint that wrapped to one more line lay over the row below. The form group and row grids now use grid-auto-rows: min-content.

Co-authored-by: lleviathe <[email protected]>
2026-11-18 21:30:26 +08:00
l0ng-ai 281b093774 fix(todo): include live matches from all files in Open Files scope (#4279) 2026-11-18 21:29:54 +08:00
l0ng-ai a55394782a Apply Vim mappings when reloading from Settings (#4278) 2026-11-18 21:29:47 +08:00
l0ng-ai ede72f0941 fix(startup): don't time out while the Trust Project prompt waits for an answer (#4321)
A window opened for an untrusted project asks Trust Project over the splash. The 60-second startup watchdog in boot.js kept counting while the prompt was up, so answering after a minute replaced it with the startup failure page. askOverSplash now signals when a question starts and ends, and the watchdog pauses for that time, as it already does while the window is hidden.
2026-11-18 21:25:58 +08:00
215 змінених файлів з 4232 додано та 396 видалено

No files matched your search

+30
Переглянути файл
@@ -194,6 +194,36 @@ declarations, key and animation binding names (`(keydown.enter)`, `[@fade]`,
`(@fade.done)`), runs of text that entities split (`a && b`) parsed as one, and one
token for `{` and `}`.
## Julia CodeMirror language support
[`@plutojl/lang-julia`](https://github.com/JuliaPluto/lang-julia) 1.2.0 and its
[`@plutojl/lezer-julia`](https://github.com/JuliaPluto/lezer-julia) parser dependency
provide the Julia CodeMirror 6 language mode. Both packages are MIT licensed;
the full license text is below. The mode wraps a Lezer grammar and exposes its
syntax tags through `julia()`.
### MIT License (@plutojl/lang-julia and @plutojl/lezer-julia)
Copyright (c) 2021 Andrey Popp
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
## nvim-treesitter queries
`crates/ide-syntax/queries/<grammar>/locals.scm` are derived from the `locals.scm`
+25
Переглянути файл
@@ -213,6 +213,31 @@ impl AgentCatalogs {
.unwrap_or_else(|| Self::fallback(shared, provider))
}
/// Availability for an explicit session switch must come from a recent discovery for this
/// launch, not from the display fallback or a different project's session report.
pub(super) fn fresh_model(
&self,
shared: &Shared,
spec: &provider::ProviderSpec,
model: &str,
) -> Option<crate::AgentConfigValue> {
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
let select = |catalog: &CatalogData| {
let age = self.epoch_ms() - catalog.refreshed_at_ms?;
if !(0.0..FRESH_FOR.as_millis() as f64).contains(&age) {
return None;
}
catalog.model_option()?.values.iter().find(|value| value.value == model).cloned()
};
let state = self.state.lock();
if let Some(entry) = state.entries.get(&Self::key(shared, &spec.id)) {
return select(entry.catalog.as_ref().filter(|_| entry.context == context)?);
}
let cache = shared.known.lock();
let saved = cache.get(&spec.id)?.catalogs.get(&shared.root_key())?;
(saved.fingerprint == context.fingerprint()).then(|| select(&saved.catalog)).flatten()
}
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
let state = self.state.lock();
if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref())
+227 -2
Переглянути файл
@@ -11,6 +11,7 @@ const PROVIDER: &str = "catalog-test";
#[derive(Debug)]
struct Pending {
launch: usize,
method: String,
params: Value,
reply: oneshot::Sender<Result<Value, String>>,
@@ -44,7 +45,7 @@ impl Harness {
let launches = launches.clone();
let live = live.clone();
move |_, _, client, _| {
launches.fetch_add(1, Ordering::SeqCst);
let launch = launches.fetch_add(1, Ordering::SeqCst);
live.fetch_add(1, Ordering::SeqCst);
let guard = Live(live.clone());
let pending = pending_tx.clone();
@@ -75,10 +76,17 @@ impl Harness {
}
let response = match request["method"].as_str().unwrap() {
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }),
"session/new" | "session/set_config_option" | "session/set_model" => {
"session/new"
| "session/set_config_option"
| "session/set_model"
| "session/load"
| "session/resume"
| "session/prompt"
| "session/set_mode" => {
let (reply, mut result) = oneshot::channel();
pending
.send(Pending {
launch,
method: request["method"].as_str().unwrap().to_owned(),
params: request["params"].clone(),
reply,
@@ -290,6 +298,223 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
assert_eq!(efforts(&fresh, "second"), ["off", "auto"]);
}
#[tokio::test]
async fn discovered_model_is_confirmed_by_the_live_session() {
switch_chat_model(ChatSwitch::Live).await;
}
#[tokio::test]
async fn discovered_model_reloads_the_same_session_on_the_next_message() {
switch_chat_model(ChatSwitch::Resume).await;
}
#[tokio::test]
async fn discovered_model_leaves_the_original_session_intact_after_resume_failure() {
switch_chat_model(ChatSwitch::ResumeFails).await;
}
#[tokio::test]
async fn discovered_model_is_reverted_when_the_reloaded_session_does_not_offer_it() {
switch_chat_model(ChatSwitch::Unavailable).await;
}
#[tokio::test]
async fn discovered_model_can_be_selected_while_the_session_is_not_running() {
switch_chat_model(ChatSwitch::Idle).await;
}
#[derive(Clone, Copy)]
enum ChatSwitch {
Live,
Resume,
ResumeFails,
Unavailable,
Idle,
}
async fn switch_chat_model(scenario: ChatSwitch) {
use crate::{AgentPrompt, AgentStatus, Isolation, NewAgentTask};
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::with_initialize(json!({
"protocolVersion": 1, "agentCapabilities": { "loadSession": true }
}));
let mut manager = make_manager(tmp.path(), Arc::default(), &harness);
let task = manager
.create(NewAgentTask {
prompt: AgentPrompt { text: "first".into(), ..Default::default() },
provider: PROVIDER.into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
let next = harness.next().await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/new"));
let mut initial = response(&["old"], &["low", "high"]);
initial["sessionId"] = json!("saved-chat");
initial["modes"] = json!({
"currentModeId": "code", "availableModes": [{"id": "ask", "name": "Ask"}, {"id": "code", "name": "Code"}]
});
next.reply.send(Ok(initial.clone())).unwrap();
let next = harness.next().await;
assert_eq!(
(next.launch, next.method.as_str(), &next.params["sessionId"]),
(0, "session/prompt", &json!("saved-chat"))
);
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
{
let mode = manager.set_config(&task.id, "mode", "ask".into());
tokio::pin!(mode);
let set = next_chat_request(&mut harness, mode.as_mut()).await;
assert_eq!((set.launch, set.method.as_str()), (0, "session/set_mode"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
set.reply.send(Ok(json!({}))).unwrap();
mode.await.unwrap();
}
let before_entries = serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap();
let before_config = manager.task(&task.id).unwrap().state.lock().task.config.clone();
if matches!(scenario, ChatSwitch::Idle) {
manager.shutdown();
manager = make_manager(tmp.path(), Arc::default(), &harness);
}
let mut events = events(&manager);
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
let next = harness.next().await;
assert_eq!((next.launch, next.method.as_str()), (1, "session/new"));
next.reply.send(Ok(response(&["new", "old"], &["catalog-only"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["new", "old"]);
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
let live = matches!(scenario, ChatSwitch::Live);
let offline = matches!(scenario, ChatSwitch::Idle);
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
let switching = manager.set_config(&task.id, "model", "new".into());
tokio::pin!(switching);
if !offline {
let next = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
if live {
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
} else {
next.reply.send(Err("not in this process's model list".into())).unwrap();
}
}
// A fallback selection settles without waiting for a new process.
tokio::select! {
result = &mut switching => result.unwrap(),
request = harness.next() => panic!("selection must not open another session: {request:?}"),
}
assert_eq!(serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap(), before_entries);
let snapshot = |manager: &AgentManager| manager.subscribe(Arc::new(|_| {})).remove(0);
let current = snapshot(&manager);
assert_eq!(current.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("new"));
assert_eq!(current.model.as_deref(), Some(if live { "new" } else { "old" }));
manager.prompt(&task.id, AgentPrompt { text: "next".into(), ..Default::default() }, false).await.unwrap();
if !live {
let load = harness.next().await;
assert_eq!((load.launch, load.method.as_str()), (2, "session/load"));
assert_eq!(load.params["sessionId"], "saved-chat");
load.notifications
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
"sessionId": "saved-chat",
"update": {"sessionUpdate": "agent_message_chunk", "content": {"type": "text", "text": "replay"}}
}}))
.unwrap();
if load_fails {
load.notifications
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
"sessionId": "saved-chat",
"update": {"sessionUpdate": "config_option_update",
"configOptions": response(&["other", "old"], &["low"])["configOptions"]}
}}))
.unwrap();
load.reply.send(Err("cannot resume saved-chat".into())).unwrap();
} else {
let models: &[&str] = if unavailable { &["old"] } else { &["old", "new"] };
let mut resumed = response(models, &["low", "high"]);
resumed["modes"] = initial["modes"].clone();
load.reply.send(Ok(resumed)).unwrap();
}
if load_fails || unavailable {
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
let task = snapshot(&manager);
assert_eq!(task.model.as_deref(), Some("old"));
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
let expected = if load_fails { "cannot resume saved-chat" } else { "does not offer model new" };
assert!(task.error.as_deref().unwrap().contains(expected), "{:?}", task.error);
assert!(harness.pending.try_recv().is_err(), "must not send on the previous model or create a session");
if load_fails {
manager
.prompt(&task.id, AgentPrompt { text: "retry".into(), ..Default::default() }, false)
.await
.unwrap();
let retry = harness.next().await;
assert_eq!((retry.launch, retry.method.as_str()), (3, "session/load"));
assert_eq!(retry.params["sessionId"], "saved-chat");
retry.reply.send(Ok(initial.clone())).unwrap();
let set = harness.next().await;
assert_eq!(set.method, "session/set_mode");
set.reply.send(Ok(json!({}))).unwrap();
let prompt = harness.next().await;
assert_eq!(prompt.method, "session/prompt");
assert_eq!(prompt.params["sessionId"], "saved-chat");
prompt.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
}
manager.shutdown();
return;
}
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_config_option"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
set.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_mode"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
set.reply.send(Ok(json!({}))).unwrap();
}
let next = harness.next().await;
assert_eq!(
(next.launch, next.method.as_str(), &next.params["sessionId"]),
(if live { 0 } else { 2 }, "session/prompt", &json!("saved-chat"))
);
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
let current = snapshot(&manager);
assert_eq!(current.model.as_deref(), Some("new"));
assert_eq!(current.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("session-only"));
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
manager.shutdown();
}
async fn wait_for_chat(manager: &AgentManager, id: &str, status: crate::AgentStatus) {
let task = manager.task(id).unwrap();
tokio::time::timeout(Duration::from_secs(5), async {
while task.state.lock().task.status != status || task.state.lock().busy {
tokio::task::yield_now().await;
}
})
.await
.unwrap();
}
async fn next_chat_request(
harness: &mut Harness,
switching: std::pin::Pin<&mut impl Future<Output = crate::IdeResult<()>>>,
) -> Pending {
tokio::select! {
result = switching => panic!("model switching ended before contacting the session: {result:?}"),
request = harness.next() => request,
}
}
#[tokio::test]
async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
let tmp = tempfile::tempdir().unwrap();
+17
Переглянути файл
@@ -219,6 +219,23 @@ pub(crate) fn set_request(option: &AgentConfigOption, value: &str) -> (&'static
}
}
/// Legacy setters and agents that report the change in a notification may return no model.
pub(super) fn accepts_model(reply: &Value, id: &str, value: &str) -> bool {
reply
.get("configOptions")
.and_then(Value::as_array)
.and_then(|options| {
options.iter().find(|option| {
option.get("category").and_then(Value::as_str) == Some("model")
|| option.get("id").or_else(|| option.get("configId")).and_then(Value::as_str) == Some(id)
})
})
.and_then(|option| option.get("currentValue"))
.or_else(|| reply.pointer("/models/currentModelId"))
.and_then(Value::as_str)
.is_none_or(|current| current == value)
}
/// `available_commands_update`.
pub(crate) fn commands_of(update: &Value, provider: &str) -> Vec<AgentCommand> {
update
+224 -27
Переглянути файл
@@ -348,6 +348,9 @@ struct TaskFile {
/// Settings the user chose, re-applied to every new or reloaded session.
#[serde(default)]
wanted: Vec<AgentConfigChoice>,
/// Option id of a discovered model in `wanted` that still needs a same-session reload.
#[serde(default, skip_serializing_if = "Option::is_none")]
pending_model: Option<String>,
/// In the project's own checkout: files already changed when the task started.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
before: BTreeMap<String, worktree::Stamp>,
@@ -380,6 +383,7 @@ struct TaskState {
session_id: Option<String>,
conversation: Conversation,
wanted: Vec<AgentConfigChoice>,
pending_model: Option<String>,
model_choice: u64,
before: Arc<BTreeMap<String, worktree::Stamp>>,
saved: Option<String>,
@@ -398,6 +402,24 @@ struct TaskState {
background_tasks: Vec<Value>,
}
impl TaskState {
fn pending_model(&self) -> Option<&AgentConfigChoice> {
let id = self.pending_model.as_deref()?;
self.wanted.iter().find(|c| c.id == id)
}
fn snapshot(&self) -> AgentTask {
let mut task = self.task.clone();
if let Some(choice) = self.pending_model()
&& let Some(model) = task.config.iter_mut().find(|o| o.id == choice.id)
{
model.current = Some(choice.value.clone());
task.config.retain(|o| !config::is_per_model_option(o));
}
task
}
}
/// A running agent and its session.
#[derive(Clone)]
struct Live {
@@ -524,7 +546,7 @@ impl AgentManager {
/// Routes events to `sink` (replacing the previous subscriber); returns every task.
pub fn subscribe(&self, sink: AgentSink) -> Vec<AgentTask> {
*self.shared.sink.write() = Some(sink);
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().task.clone()).collect();
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().snapshot()).collect();
tasks.sort_by(|a, b| b.updated_ms.total_cmp(&a.updated_ms));
tasks
}
@@ -755,6 +777,7 @@ impl AgentManager {
session_id: Some(session_id.to_owned()),
entries: Vec::new(),
wanted: Vec::new(),
pending_model: None,
before: BTreeMap::new(),
saved: None,
touched: Some(BTreeSet::new()),
@@ -869,6 +892,7 @@ impl AgentManager {
session_id: None,
entries: Vec::new(),
wanted: req.config,
pending_model: None,
before,
saved,
touched: (req.isolation == Isolation::Local).then(BTreeSet::new),
@@ -1001,7 +1025,7 @@ impl AgentManager {
/// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts.
pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> {
let task = self.task(id)?;
let (target, model_choice, previous_levels) = {
let (target, change) = {
let mut s = task.state.lock();
let target = s
.task
@@ -1011,22 +1035,28 @@ impl AgentManager {
.ok_or_else(|| IdeError::not_found("no such setting"))?
.clone();
if !target.values.iter().any(|v| v.value == value) {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
if target.category.as_deref() != Some("model") {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
}
(target, None)
} else {
let switching_model = target.category.as_deref() == Some("model");
if switching_model {
s.model_choice += 1;
s.pending_model = None;
}
let previous_levels = (switching_model && target.current.as_deref() != Some(value.as_str()))
.then(|| s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>());
s.wanted.retain(|c| c.id != option);
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current =
Some(value.clone());
s.task.model = model_of(&s.task.config).or(s.task.model.take());
(target, Some((s.model_choice, previous_levels)))
}
if target.category.as_deref() == Some("model") {
s.model_choice += 1;
}
let previous_levels =
if target.category.as_deref() == Some("model") && target.current.as_deref() != Some(value.as_str()) {
Some(s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>())
} else {
None
};
s.wanted.retain(|c| c.id != option);
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current = Some(value.clone());
s.task.model = model_of(&s.task.config).or(s.task.model.take());
(target, s.model_choice, previous_levels)
};
let Some((model_choice, previous_levels)) = change else {
return task.switch_discovered_model(target, value).await;
};
let previous = target.current.clone();
// Cursor's `session/set_config_option` (Fast, effort) can take seconds. Show the
@@ -1193,6 +1223,7 @@ impl AgentManager {
session_id: Some(session),
entries,
wanted: s.wanted.clone(),
pending_model: None,
before: (*s.before).clone(),
saved: s.saved.clone(),
touched: s.touched.as_deref().cloned(),
@@ -1237,6 +1268,7 @@ impl AgentManager {
_ => None,
};
s.session_id = None;
s.pending_model = None;
s.conversation = Conversation::default();
// The fresh session reports its own usage; nothing carries over.
s.task.usage = None;
@@ -1785,7 +1817,7 @@ impl AgentManager {
s.task.mcp_overrides = cleaned;
s.task.updated_ms = now_ms();
}
(changed, s.busy, !s.background_tasks.is_empty(), s.task.clone())
(changed, s.busy, !s.background_tasks.is_empty(), s.snapshot())
};
if changed {
task.persist();
@@ -1843,6 +1875,7 @@ impl Task {
session_id: file.session_id,
conversation,
wanted: file.wanted,
pending_model: file.pending_model,
model_choice: 0,
before: Arc::new(file.before),
saved: file.saved,
@@ -1939,7 +1972,7 @@ impl Task {
}
fn emit_task(&self) {
let task = self.state.lock().task.clone();
let task = self.state.lock().snapshot();
self.shared.emit(AgentEvent::Task { task: Box::new(task) });
}
@@ -2036,6 +2069,7 @@ impl Task {
session_id: s.session_id.clone(),
entries: s.conversation.main.entries.clone(),
wanted: s.wanted.clone(),
pending_model: s.pending_model.clone(),
before: (*s.before).clone(),
saved: s.saved.clone(),
touched: s.touched.as_deref().cloned(),
@@ -2141,7 +2175,7 @@ impl Task {
}
}
/// Drops an idle resumable live session so the next turn reloads it with fresh MCP servers.
/// Drops an idle resumable live session so the next turn reloads it.
fn recycle_resumable_session(&self) {
self.mcp_reload_pending.store(false, Ordering::Release);
let live = {
@@ -2149,12 +2183,110 @@ impl Task {
if live.as_ref().is_some_and(|l| l.resumable && !l.peer.is_closed()) { live.take() } else { None }
};
if let Some(live) = live {
tracing::debug!("agent task {}: restarting idle resumable session for MCP override update", self.id);
tracing::debug!("agent task {}: recycling idle resumable session", self.id);
live.peer.kill();
self.clear_shown_background();
}
}
async fn switch_discovered_model(&self, target: AgentConfigOption, value: String) -> IdeResult<()> {
let provider = self.state.lock().task.provider.clone();
let spec = self.shared.spec(&provider).ok_or_else(|| IdeError::not_found("no such agent"))?;
let candidate = self.shared.paths.catalogs.fresh_model(&self.shared, &spec, &value).ok_or_else(|| {
IdeError::invalid(format!("{} has no value {value} in the current model catalog", target.name))
})?;
let model_choice = {
let mut s = self.state.lock();
s.model_choice += 1;
s.model_choice
};
// A prompt starting during the switch must not grab the peer we're about to recycle.
let _connecting = self.connecting.lock().await;
{
let s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
}
let live = self.live.lock().clone();
let result = if let Some(live) = live.as_ref().filter(|l| !l.peer.is_closed()) {
let (method, mut params) = config::set_request(&target, &value);
params["sessionId"] = json!(live.session);
match live.peer.request::<_, Value>(method, params, None).await {
Ok(reply) if config::accepts_model(&reply, &target.id, &value) => Ok(Some(reply)),
Ok(_) => Err(format!("The agent did not switch to model {value}.")),
Err(e) => Err(self.describe(e)),
}
} else {
Ok(None)
};
let accepted = {
let mut s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
let pending = match result {
Ok(Some(reply)) => {
if let Some(options) = reply.get("configOptions") {
config::merge_update(&mut s.task.config, options);
} else if s.task.model.as_deref() != Some(value.as_str()) {
s.task.config.retain(|o| !config::is_per_model_option(o));
}
let model =
if let Some(i) = s.task.config.iter().position(|o| o.category.as_deref() == Some("model")) {
&mut s.task.config[i]
} else {
s.task.config.push(target.clone());
s.task.config.last_mut().unwrap()
};
if !model.values.iter().any(|v| v.value == value) {
model.values.push(candidate);
}
model.current = Some(value.clone());
s.task.model = Some(value.clone());
sync_usage_context_size(&mut s.task);
false
}
refused => {
if s.session_id.is_none()
|| live.as_ref().is_some_and(|l| !l.resumable)
|| self.start_fresh.load(Ordering::Acquire)
{
return Err(IdeError::unavailable(
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
));
}
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
return Err(IdeError::invalid("wait until the agent is done"));
}
true
}
};
s.wanted.retain(|c| c.id != target.id);
s.pending_model = pending.then(|| target.id.clone());
s.wanted.push(AgentConfigChoice { id: target.id, value });
(!pending).then(|| {
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
(s.task.config.clone(), model)
})
};
if let Some((config, model)) = accepted {
self.shared.remember(&provider, Some(&config), None, model.as_deref());
} else {
self.recycle_resumable_session();
}
self.persist();
self.emit_task();
Ok(())
}
/// Stops the agent's process once the task has stayed idle for [`IDLE_RELEASE`], so
/// finished tasks don't keep an agent (and what it started) running. Only an agent that
/// reloads its session: the next message starts it again with the conversation intact.
@@ -2402,10 +2534,12 @@ impl Task {
{
return Ok(live);
}
let (provider_id, cwd, saved) = {
let (provider_id, cwd, saved, pending) = {
let s = self.state.lock();
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone())
let pending = s.pending_model().map(|choice| (choice.clone(), s.task.model.clone()));
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), pending)
};
let pending_model = pending.as_ref().map(|(choice, _)| choice);
let raw_spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
let can_fallback =
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
@@ -2414,8 +2548,8 @@ impl Task {
} else {
raw_spec.clone()
};
let live = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone()).await {
Ok(live) => live,
let opened = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone(), pending_model).await {
Ok(live) => Ok(live),
Err(err) if can_fallback && err.allow_acp_fallback => {
tracing::warn!(
"agent task {}: Copilot headless session setup failed ({}); falling back to `copilot --acp`",
@@ -2424,9 +2558,32 @@ impl Task {
);
self.shared.mark_copilot_acp_fallback(&raw_spec);
let acp_spec = native::copilot::acp_fallback_spec(&raw_spec);
self.open_session(&provider_id, acp_spec, &cwd, saved).await.map_err(|e| e.message)?
self.open_session(&provider_id, acp_spec, &cwd, saved, pending_model).await
}
Err(err) => Err(err),
};
let live = match opened {
Ok(live) => live,
Err(err) => {
if let Some((choice, previous)) = pending {
let mut s = self.state.lock();
if s.pending_model() == Some(&choice) {
s.pending_model = None;
s.wanted.retain(|c| c.id != choice.id);
if let Some(model) = s.task.config.iter_mut().find(|o| o.id == choice.id) {
model.current.clone_from(&previous);
}
s.task.model.clone_from(&previous);
if let Some(value) = previous {
s.wanted.push(AgentConfigChoice { id: choice.id, value });
}
drop(s);
self.persist();
self.emit_task();
}
}
return Err(err.message);
}
Err(err) => return Err(err.message),
};
*self.live.lock() = Some(live.clone());
Ok(live)
@@ -2438,6 +2595,7 @@ impl Task {
spec: provider::ProviderSpec,
cwd: &Path,
saved: Option<String>,
pending_model: Option<&AgentConfigChoice>,
) -> Result<Live, SessionOpenError> {
let launch_cwd = cwd.to_path_buf();
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
@@ -2487,6 +2645,12 @@ impl Task {
let mut tried_auth = false;
let mut session = None;
let start_fresh = self.start_fresh.load(Ordering::Acquire);
if pending_model.is_some() && (saved.is_none() || !can_load || start_fresh) {
return Err(SessionOpenError {
message: "The agent does not support resuming this session.".into(),
allow_acp_fallback: false,
});
}
if let (Some(id), true, false) = (saved, can_load, start_fresh) {
self.replaying.store(true, Ordering::Release);
let mut params = session_params(&cwd_s, &mcp_servers);
@@ -2502,6 +2666,16 @@ impl Task {
if let Some(message) = self.sign_in_error(&e, Some(&sign_in_message)) {
return Err(SessionOpenError { message, allow_acp_fallback: false });
}
if pending_model.is_some() {
return Err(SessionOpenError {
message: format!(
"Couldn't reopen this conversation's {} session: {}",
spec.name,
self.describe(e)
),
allow_acp_fallback: false,
});
}
self.start_fresh.store(true, Ordering::Release);
return Err(SessionOpenError {
message: format!(
@@ -2573,6 +2747,19 @@ impl Task {
});
let mut model_options = known;
for choice in &wanted {
let pending = pending_model == Some(choice);
if pending
&& !options.iter().any(|o| {
o.id == choice.id
&& (o.values.iter().any(|v| v.value == choice.value)
|| (known && o.current.as_deref() == Some(choice.value.as_str())))
})
{
return Err(SessionOpenError {
message: format!("The reloaded session does not offer model {}.", choice.value),
allow_acp_fallback: false,
});
}
// An option the session doesn't offer yet is set once it does (`apply_late_choices`).
let Some(o) = options.iter().find(|o| o.id == choice.id).cloned() else { continue };
if o.id == config::CURSOR_APPROVAL {
@@ -2593,6 +2780,12 @@ impl Task {
params["sessionId"] = json!(session_id);
match peer.request::<_, Value>(method, params, None).await {
Ok(reply) => {
if pending && !config::accepts_model(&reply, &o.id, &choice.value) {
return Err(SessionOpenError {
message: format!("The reloaded session did not switch to model {}.", choice.value),
allow_acp_fallback: false,
});
}
if let Some(fresh) = reply.get("configOptions") {
config::merge_update(&mut options, fresh);
model_options = true;
@@ -2606,6 +2799,9 @@ impl Task {
o.current = Some(choice.value.clone());
}
}
Err(e) if pending => {
return Err(SessionOpenError { message: self.describe(e), allow_acp_fallback: false });
}
Err(e) => tracing::warn!("agent task {}: setting {} to {} failed: {e}", self.id, o.id, choice.value),
}
}
@@ -2615,6 +2811,7 @@ impl Task {
let mut s = self.state.lock();
s.task.model = model_of(&options).or(s.task.model.take());
s.task.config = options;
s.pending_model = None;
s.task.capabilities = capabilities;
s.session_id = Some(session_id.clone());
self.start_fresh.store(false, Ordering::Release);
+2 -2
Переглянути файл
@@ -715,7 +715,7 @@ pub fn run(
}
}
};
let out = process::run(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
let out = process::run_bounded(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
let parsed = parser.feed(line);
match parsed.console {
Some(text) if text.is_empty() => {}
@@ -757,7 +757,7 @@ pub fn run(
if !out.success {
success = false;
if !messages.iter().any(|m| m.severity == Severity::Error) {
let summary = crate::sync::error_summary(&out.text);
let summary = crate::sync::error_summary(&out);
let text = if summary.is_empty() { last_error_line.clone() } else { summary };
let m = BuildMessage { severity: Severity::Error, text, path: None, range: None, code: None };
on_event(BuildEvent::Message { message: m.clone() });
+1
Переглянути файл
@@ -30,6 +30,7 @@ def processedResources = { Project p, s ->
def describe = { Project p ->
def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
if (p.gradle.parent != null) m.build = identity(p.rootProject)
m.resolvableConfigurations = p.configurations.findAll { it.canBeResolved }.collect { it.name }.sort()
// Gradle 4.x has it as a convention property, not an extension.
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
if (sets != null) {
+19
Переглянути файл
@@ -41,6 +41,10 @@ pub struct GradleProject {
/// Project-relative build script, if any.
pub build_file: Option<String>,
pub tasks: Vec<GradleTask>,
/// Configurations Gradle can resolve, or null before Gradle reports the project.
#[serde(default)]
#[specta(optional)]
pub resolvable_configurations: Option<Vec<String>>,
/// Identity path of the nested build holding the project (`:lib` for `includeBuild`,
/// `:buildSrc`); null for the opened build.
#[serde(default)]
@@ -301,6 +305,7 @@ fn project_at(root: &Path, path: String, name: String, pdir: &Path) -> GradlePro
path,
name,
tasks,
resolvable_configurations: None,
build: None,
}
}
@@ -317,6 +322,8 @@ pub struct ReportedProject {
pub build_dir: Option<String>,
#[serde(default)]
pub source_sets: Vec<ReportedSourceSet>,
#[serde(default)]
pub resolvable_configurations: Option<Vec<String>>,
/// Toolchain language version, else target compatibility.
#[serde(default)]
pub java: Option<u32>,
@@ -412,6 +419,7 @@ pub fn merge_reported_projects(root: &Path, model: &mut GradleModel, reported: &
if p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc")) {
project.tasks.clear();
}
project.resolvable_configurations = p.resolvable_configurations.clone();
project.build = p.build.clone();
project
})
@@ -1630,6 +1638,11 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
path: path.into(),
dir: ws.join(d).to_string_lossy().into_owned(),
build: build.map(Into::into),
resolvable_configurations: match path {
":" => Some(vec!["reviewTools".into(), "runtimeClasspath".into()]),
":lib:core" => Some(Vec::new()),
_ => None,
},
..ReportedProject::default()
};
format!("{MODEL_LINE}{}\n", serde_json::to_string(&project).unwrap())
@@ -1658,6 +1671,12 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
);
let build_src = &model.projects[2];
assert!(build_src.tasks.is_empty(), "buildSrc tasks cannot run from the root build");
assert_eq!(
model.projects[0].resolvable_configurations,
Some(vec!["reviewTools".into(), "runtimeClasspath".into()])
);
assert_eq!(model.projects[1].resolvable_configurations, None);
assert_eq!(model.projects[4].resolvable_configurations, Some(Vec::new()));
assert!(!model.projects[4].tasks.is_empty());
assert!(build_files(&root, &model).contains(&ws.join("lib/settings.gradle")));
}
+8 -5
Переглянути файл
@@ -135,7 +135,7 @@ pub fn gradle_dependencies(
configuration: &str,
cancel: &CancellationToken,
) -> IdeResult<Vec<GradleDependency>> {
if !configuration.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-') || configuration.is_empty() {
if configuration.is_empty() || !configuration.chars().all(|c| c.is_alphanumeric() || matches!(c, '_' | '-' | '.')) {
return Err(IdeError::invalid(format!("not a configuration name: {configuration}")));
}
if !project.starts_with(':') || project.chars().any(char::is_whitespace) {
@@ -143,7 +143,7 @@ pub fn gradle_dependencies(
}
let task = if project == ":" { ":dependencies".to_owned() } else { format!("{project}:dependencies") };
let mut args: Vec<String> =
vec!["--console=plain".into(), "-q".into(), task, "--configuration".into(), configuration.into()];
vec!["--console=plain".into(), "-q".into(), task, format!("--configuration={configuration}")];
if options.offline {
args.push("--offline".into());
}
@@ -156,7 +156,10 @@ pub fn gradle_dependencies(
|_, _| {},
)?;
if !out.success {
return Err(IdeError::unavailable(error_summary(&out.text)));
return Err(IdeError::unavailable(error_summary(&out)));
}
if let Some(note) = sync::truncation_note(&out) {
return Err(IdeError::unavailable(note));
}
Ok(parse_report(&out.text))
}
@@ -337,14 +340,14 @@ runtimeClasspath - Runtime classpath of source set 'main'.
&gradle::load(root).unwrap(),
&options,
":app",
"testRuntimeClasspath",
"review.tools",
&CancellationToken::new(),
)
.unwrap();
assert_eq!(tree, vec![dep("org.a", "b", Some("1.0"))]);
assert_eq!(
std::fs::read_to_string(root.join("args")).unwrap().trim(),
"--console=plain -q :app:dependencies --configuration testRuntimeClasspath --offline"
"--console=plain -q :app:dependencies --configuration=review.tools --offline"
);
}
}
+2
Переглянути файл
@@ -13,6 +13,8 @@ pub mod kotlin_bridge;
pub mod maven;
pub mod pom_edit;
mod process;
#[cfg(test)]
mod process_numbers;
pub mod sbt;
mod sync;
pub mod web;
+337 -19
Переглянути файл
@@ -17,10 +17,72 @@ pub(crate) enum Stream {
Stderr,
}
/// A single line longer than this without a newline is delivered as several lines: the pump
/// buffer stays bounded whatever the child prints (progress bars, minified bundles, binary
/// output), and every byte still arrives.
pub(crate) const MAX_LINE_BYTES: usize = 1024 * 1024;
/// `Output::text` stops growing past this while the pipes keep draining: a chatty build can
/// print far more than is ever parsed back out of the retained copy.
pub(crate) const MAX_TEXT_BYTES: usize = 32 * 1024 * 1024;
pub(crate) struct Output {
pub success: bool,
/// Every line, stdout and stderr interleaved as received.
/// Every line, stdout and stderr interleaved as received, up to [`MAX_TEXT_BYTES`].
pub text: String,
/// More output followed the retained `text`; the lines were still fed to `on_line`.
pub truncated: bool,
}
/// Bounded pump for callers that stream every line and only summarize errors: reads fixed
/// 64 KiB chunks, splits newline-free runs at a UTF-8 char boundary at the line cap, and
/// never grows one line buffer without bound.
fn pump_bounded(stream: Box<dyn Read + Send>, kind: Stream, tx: &mpsc::Sender<(Stream, String)>) {
let mut reader = BufReader::new(stream);
// `terminated`: the buffer ends in the stream's newline. A segment cut from a
// newline-free run at the line cap must keep a trailing `\r` — it is data.
let send = |buf: &mut Vec<u8>, terminated: bool, tx: &mpsc::Sender<(Stream, String)>| {
let line = ide_core::output_encoding::decode_tool_output(buf);
let line = if terminated { line.trim_end_matches(['\n', '\r']).to_owned() } else { line };
buf.clear();
tx.send((kind, line)).is_ok()
};
let mut chunk = vec![0u8; 64 * 1024];
let mut line: Vec<u8> = Vec::with_capacity(256);
'read: loop {
let n = match reader.read(&mut chunk) {
Ok(0) | Err(_) => break,
Ok(n) => n,
};
let mut start = 0;
for (i, &b) in chunk[..n].iter().enumerate() {
if b == b'\n' {
line.extend_from_slice(&chunk[start..=i]);
if !send(&mut line, true, tx) {
break 'read;
}
start = i + 1;
}
}
line.extend_from_slice(&chunk[start..n]);
while line.len() > MAX_LINE_BYTES {
let mut at = MAX_LINE_BYTES;
while at > 0 && line[at] & 0xC0 == 0x80 {
at -= 1;
}
// Malformed input with no boundary at all: split raw and let decoding say so.
if at == 0 {
at = MAX_LINE_BYTES;
}
let rest = line.split_off(at);
if !send(&mut line, false, tx) {
break 'read;
}
line = rest;
}
}
if !line.is_empty() {
send(&mut line, true, tx);
}
}
/// `program` as spawnable: a bare name (`mvn`, `mvn.cmd`) resolves on the IDE's
@@ -41,7 +103,8 @@ pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>, cwd: &
}
/// Runs `program args` in `cwd`, feeding each output line to `on_line`; kills
/// the process group and returns `cancelled` when `cancel` fires.
/// the process group and returns `cancelled` when `cancel` fires. `Output.text`
/// keeps every line: callers that parse a complete model from it use this.
pub(crate) fn run(
program: &str,
args: &[String],
@@ -53,6 +116,20 @@ pub(crate) fn run(
run_with_env(program, args, cwd, env, false, cancel, on_line)
}
/// Like [`run`], but bounds both the per-line buffer and the retained copy. For callers
/// that stream every line to `on_line` and use `Output.text` only for error summaries:
/// sync/model listings must be kept whole and use [`run`] instead.
pub(crate) fn run_bounded(
program: &str,
args: &[String],
cwd: &Path,
env: &BTreeMap<String, String>,
cancel: &CancellationToken,
on_line: impl FnMut(Stream, &str),
) -> IdeResult<Output> {
run_with_env_capture(program, args, cwd, env, RunOptions { bounded: true, ..Default::default() }, cancel, on_line)
}
pub(crate) fn run_with_env(
program: &str,
args: &[String],
@@ -60,8 +137,27 @@ pub(crate) fn run_with_env(
env: &BTreeMap<String, String>,
clear_env: bool,
cancel: &CancellationToken,
on_line: impl FnMut(Stream, &str),
) -> IdeResult<Output> {
run_with_env_capture(program, args, cwd, env, RunOptions { clear_env, ..Default::default() }, cancel, on_line)
}
#[derive(Clone, Copy, Default)]
struct RunOptions {
clear_env: bool,
bounded: bool,
}
fn run_with_env_capture(
program: &str,
args: &[String],
cwd: &Path,
env: &BTreeMap<String, String>,
options: RunOptions,
cancel: &CancellationToken,
mut on_line: impl FnMut(Stream, &str),
) -> IdeResult<Output> {
let RunOptions { clear_env, bounded } = options;
tracing::info!("build: {program} {} (in {})", args.join(" "), cwd.display());
// Output is read as UTF-8: JVMs on Windows are told to write it (see `ide_core::output_encoding`).
let encoding =
@@ -80,17 +176,22 @@ pub(crate) fn run_with_env(
let (tx, rx) = mpsc::channel::<(Stream, String)>();
let pump = |stream: Box<dyn Read + Send>, kind: Stream, tx: mpsc::Sender<(Stream, String)>| {
std::thread::spawn(move || {
let mut reader = BufReader::new(stream);
let mut buf = Vec::new();
loop {
buf.clear();
match reader.read_until(b'\n', &mut buf) {
Ok(0) | Err(_) => break,
Ok(_) => {
let line = ide_core::output_encoding::decode_tool_output(&buf);
let line = line.trim_end_matches(['\n', '\r']).to_owned();
if tx.send((kind, line)).is_err() {
break;
if bounded {
pump_bounded(stream, kind, &tx);
} else {
// Model listings are parsed from Output.text: keep every line whole, however long.
let mut reader = BufReader::new(stream);
let mut buf = Vec::new();
loop {
buf.clear();
match reader.read_until(b'\n', &mut buf) {
Ok(0) | Err(_) => break,
Ok(_) => {
let line = ide_core::output_encoding::decode_tool_output(&buf);
let line = line.trim_end_matches(['\n', '\r']).to_owned();
if tx.send((kind, line)).is_err() {
break;
}
}
}
}
@@ -102,7 +203,17 @@ pub(crate) fn run_with_env(
child.stderr.take().map(|s| pump(Box::new(s), Stream::Stderr, tx.clone())),
];
drop(tx);
let mut text = String::new();
// Retained copy of the output: the first half of the cap, then — once output overflows —
// a rolling tail instead of the middle. Error summaries read the end of the output, while
// listings parsed out of a successful run read from the start. The pipes keep draining
// either way: `on_line` still sees every line, so the child never blocks on a full pipe.
let cap = MAX_TEXT_BYTES / 2;
let mut head = String::new();
let mut tail: std::collections::VecDeque<Vec<u8>> = Default::default();
let mut chunk: Vec<u8> = Vec::new();
let mut tail_bytes = 0usize;
let mut total = 0usize;
let mut truncated = false;
loop {
if cancel.is_cancelled() {
kill_tree(&mut child);
@@ -112,8 +223,34 @@ pub(crate) fn run_with_env(
Ok((_, line)) if encoding.notice.as_ref() == Some(&line) => {}
Ok((stream, line)) => {
on_line(stream, &line);
text.push_str(&line);
text.push('\n');
if !bounded {
// The caller parses a complete model from `text`, so keep every line.
head.push_str(&line);
head.push('\n');
continue;
}
total += line.len() + 1;
if !truncated {
if head.len() + line.len() < cap {
head.push_str(&line);
head.push('\n');
continue;
}
truncated = true;
}
// Fixed-size chunks, not per-line buffers: a chatty build pushes millions of
// lines past the cap, and the tail must add no allocation per line.
chunk.extend_from_slice(line.as_bytes());
chunk.push(b'\n');
if chunk.len() >= 64 * 1024 {
tail_bytes += chunk.len();
tail.push_back(std::mem::take(&mut chunk));
chunk.reserve_exact(64 * 1024);
while tail_bytes > cap {
let Some(front) = tail.pop_front() else { break };
tail_bytes -= front.len();
}
}
}
Err(mpsc::RecvTimeoutError::Timeout) => {}
Err(mpsc::RecvTimeoutError::Disconnected) => break,
@@ -123,13 +260,85 @@ pub(crate) fn run_with_env(
let _ = r.join();
}
let status = child.wait()?;
Ok(Output { success: status.success(), text })
let mut text = head;
if truncated {
if !chunk.is_empty() {
tail_bytes += chunk.len();
tail.push_back(std::mem::take(&mut chunk));
}
// The last partial chunk may sit past the cap; drop whole front chunks back under it.
while tail_bytes > cap {
let Some(front) = tail.pop_front() else { break };
tail_bytes -= front.len();
}
// Tail chunks are flushed only right after a completed line, so the tail always begins
// at a line boundary — no leading fragment to drop.
let tail = ide_core::output_encoding::decode_tool_output(&tail.into_iter().flatten().collect::<Vec<u8>>());
let omitted = total.saturating_sub(text.len() + tail.len());
if omitted == 0 {
// Everything that overflowed the head still fits in the tail: nothing was lost.
truncated = false;
} else {
text.push_str(&format!("[{omitted} bytes of build output between these lines were not retained]\n"));
}
text.push_str(&tail);
}
Ok(Output { success: status.success(), text, truncated })
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_model_line_over_one_mebibyte_is_kept_whole_for_the_parsers() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// A Gradle MODEL_LINE JSON line longer than the bounded pump's 1 MiB line cap,
// surrounded by ordinary output.
let script = "echo start; head -c 1048576 /dev/zero | tr '\\0' a; printf '\\n{\"id\":\"big\"}\\n'; echo end";
let mut lines = Vec::new();
let out = run(
"sh",
&["-c".into(), script.into()],
tmp.path(),
&BTreeMap::new(),
&CancellationToken::new(),
|_, line| lines.push(line.to_owned()),
)
.unwrap();
assert!(out.success);
assert!(!out.truncated);
// The long line is one line, not segments that a JSON-line parser would skip.
assert_eq!(lines.len(), 4);
assert_eq!(lines[1].len(), 1_048_576);
assert!(out.text.contains("{\"id\":\"big\"}"));
let models: Vec<serde_json::Value> = out.text.lines().filter_map(|l| serde_json::from_str(l).ok()).collect();
assert_eq!(models.len(), 1, "the model line must survive full retention");
}
#[test]
fn a_successful_report_over_the_text_cap_is_retained_in_full() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
let args = ["-c".into(), r"awk 'BEGIN{for(i=1;i<=6000000;i++)print i}'".into()];
let mut fed = 0usize;
let out = run("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
fed += line.len() + 1;
})
.unwrap();
assert!(out.success);
assert!(!out.truncated);
// Every line of a large successful dependency/model report is still there.
assert_eq!(out.text.len(), fed);
assert!(out.text.starts_with("1\n"));
assert!(out.text.ends_with("6000000\n"));
}
#[test]
fn runs_and_cancels_processes() {
if cfg!(windows) {
@@ -148,10 +357,11 @@ mod tests {
)
.unwrap();
assert!(!out.success);
assert!(!out.truncated);
lines.sort_by(|a, b| a.1.cmp(&b.1));
assert_eq!(lines, [(Stream::Stdout, "one".to_owned()), (Stream::Stderr, "two".to_owned())]);
cancel.cancel();
let err = run("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
let err = run_bounded("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
.err()
.unwrap();
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
@@ -171,9 +381,117 @@ mod tests {
std::thread::sleep(Duration::from_millis(200));
c.cancel();
});
let err = run("sh", &["-c".into(), script], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {}).err().unwrap();
let err =
run_bounded("sh", &["-c".into(), script], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {}).err().unwrap();
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
std::thread::sleep(Duration::from_millis(1300));
assert!(!marker.exists(), "the background child must be killed with the group");
}
#[test]
fn output_past_the_text_cap_keeps_head_and_tail_and_drains() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// Numbered lines 1..=6,000,000 ≈ 45 MB: past the 32 MiB retained cap.
let args = ["-c".into(), r"awk 'BEGIN{for(i=1;i<=6000000;i++)print i}'".into()];
let mut fed = 0usize;
let mut last_seen = String::new();
let out = run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
fed += line.len() + 1;
last_seen = line.to_owned();
})
.unwrap();
assert!(out.success);
assert!(out.truncated);
// The pipes drained to the end: the callback saw the last line.
assert_eq!(last_seen, "6000000");
assert_eq!(fed, out_success_bytes());
// The retained copy is bounded, keeps the head and the tail, and says what was dropped.
assert!(out.text.len() <= MAX_TEXT_BYTES + 128, "{}", out.text.len());
assert!(out.text.starts_with("1\n"));
assert!(out.text.ends_with("6000000\n"));
assert!(out.text.contains("were not retained]"));
assert!(!out.text.contains("\n3000000\n"), "a middle line must be the dropped part");
}
/// Lines `1..=6_000_000` emit exactly this many bytes (digit count + newline each).
fn out_success_bytes() -> usize {
(1..=6_000_000u64).map(|n| n.checked_ilog10().unwrap() as usize + 2).sum()
}
#[test]
fn a_newline_free_run_longer_than_the_line_cap_arrives_as_split_lines() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// 2.5 MiB of `x` without a single newline.
let args = ["-c".into(), "head -c 2621440 /dev/zero | tr '\\0' x".into()];
let mut lines = Vec::new();
let out = run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
lines.push(line.to_owned())
})
.unwrap();
assert!(out.success);
assert!(!out.truncated);
// Split at the cap, not dropped: the segments carry every byte and none is unbounded.
assert!(lines.len() >= 3, "{}", lines.len());
assert_eq!(lines.iter().map(String::len).sum::<usize>(), 2_621_440);
assert!(lines.iter().all(|l| l.len() <= MAX_LINE_BYTES));
}
#[test]
fn a_line_split_never_cuts_a_multibyte_character() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// `x` up to one byte before the 1 MiB cap, then `é` (two bytes) straddling it, then more `x`.
let script =
"head -c 1048575 /dev/zero | tr '\\0' x; printf '\\303\\251'; head -c 1048575 /dev/zero | tr '\\0' x";
let mut lines = Vec::new();
let out = run_bounded(
"sh",
&["-c".into(), script.into()],
tmp.path(),
&BTreeMap::new(),
&CancellationToken::new(),
|_, line| lines.push(line.to_owned()),
)
.unwrap();
assert!(out.success);
// The é straddles the 1 MiB split point: segments shift to keep it whole.
assert!(lines.len() >= 2, "{}", lines.len());
// The character survived the split: present whole, never as U+FFFD halves.
assert!(lines.iter().any(|l| l.contains('é')));
assert!(lines.iter().all(|l| !l.contains('\u{FFFD}')));
assert_eq!(lines.iter().map(String::len).sum::<usize>(), 1_048_575 + 2 + 1_048_575);
}
#[test]
fn output_just_past_the_head_cap_loses_nothing() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// 4-byte `pad` lines up to just past the 16 MiB head cap, then the real last line:
// the overflow fits the tail whole, so nothing is dropped and nothing is marked.
let script = "yes pad | head -c 16777213; echo 'FATAL: the real error'";
let out = run_bounded(
"sh",
&["-c".into(), script.into()],
tmp.path(),
&BTreeMap::new(),
&CancellationToken::new(),
|_, _| {},
)
.unwrap();
assert!(out.success);
assert!(!out.truncated);
assert!(!out.text.contains("were not retained]"));
assert!(out.text.starts_with("pad\n"));
assert!(out.text.ends_with("FATAL: the real error\n"));
}
}
+36
Переглянути файл
@@ -0,0 +1,36 @@
//! Timed evidence for the bounded build-output capture (issue #3936). Not an assertion:
//! run it on both revisions of `process.rs` and compare the printed numbers.
//!
//! ```text
//! cargo test -p ide-build --release --lib -- --ignored --nocapture numbers
//! ```
use crate::process;
use ide_core::CancellationToken;
use std::collections::BTreeMap;
use std::time::Instant;
/// 256 MiB of 17-byte lines from `yes`, drained by `process::run` with a counting callback.
#[test]
#[ignore = "prints elapsed time and retained bytes; see the module docs"]
fn high_output_process_numbers() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
let args = ["-c".into(), "yes 0123456789abcdef | head -c 268435456".into()];
let start = Instant::now();
let mut lines = 0u64;
let mut fed = 0usize;
let out = process::run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
lines += 1;
fed += line.len() + 1;
})
.unwrap();
println!(
"elapsed {:?} | success {} | retained {} bytes | fed {lines} lines / {fed} bytes",
start.elapsed(),
out.success,
out.text.len()
);
}
+40 -8
Переглянути файл
@@ -268,8 +268,20 @@ fn run(
process::run(program, args, cwd, env, cancel, |_, line| on_line(line))
}
/// What a sync records when a *successful* child run's output was truncated: parsing a
/// truncated listing would silently produce an incomplete model, so it is surfaced, not hidden.
pub(crate) fn truncation_note(out: &Output) -> Option<String> {
out.truncated.then(|| {
format!(
"the build printed more than the retained {} MiB of output; the model may be incomplete",
crate::process::MAX_TEXT_BYTES / (1024 * 1024)
)
})
}
/// The first error lines of a failed build, for the tool window.
pub(crate) fn error_summary(text: &str) -> String {
pub(crate) fn error_summary(output: &Output) -> String {
let text = &output.text;
// The JVM's "could not find or load main class" (localized) when `gradlew` has no jar.
if text.contains("org.gradle.wrapper.GradleWrapperMain") {
return "gradle/wrapper/gradle-wrapper.jar is missing (often excluded by a `*.jar` rule in .gitignore). \
@@ -289,11 +301,15 @@ pub(crate) fn error_summary(text: &str) -> String {
.filter(|l| !l.is_empty() && !l.starts_with("Re-run Maven") && !l.starts_with("To see the full stack trace"))
.take(4)
.collect();
if lines.is_empty() {
let mut summary = if lines.is_empty() {
text.lines().rev().find(|l| !l.trim().is_empty()).unwrap_or("the build failed").trim().to_owned()
} else {
lines.join("\n")
};
if output.truncated {
summary.push_str("\n[the build printed more than the retained output; this summary may miss lines]");
}
summary
}
/// `[INFO] Building core 1.0-SNAPSHOT [2/3]` → ("core 1.0-SNAPSHOT", 2, 3).
@@ -397,7 +413,9 @@ pub fn sync_maven(
}
}
if !out.success {
errors.push(error_summary(&out.text));
errors.push(error_summary(&out));
} else if let Some(note) = truncation_note(&out) {
errors.push(note);
}
}
cache.at_ms = now_ms();
@@ -437,6 +455,8 @@ pub fn sync_gradle_model(
let mut args: Vec<String> = vec![
"--console=plain".into(),
"-q".into(),
// The init script reports the evaluated projects, even when a build enables the configuration cache.
"-Dorg.gradle.configuration-cache=false".into(),
"--init-script".into(),
init_script.to_string_lossy().into_owned(),
"tasks".into(),
@@ -457,7 +477,7 @@ pub fn sync_gradle_model(
Ok(out) => out,
Err(_) if cancel.is_cancelled() => return Err(IdeError::cancelled()),
Err(error) if error.kind == ide_core::error::ErrorKind::Unavailable => {
Output { success: false, text: error.message }
Output { success: false, text: error.message, truncated: false }
}
Err(error) => return Err(error),
};
@@ -470,7 +490,7 @@ pub fn sync_gradle_model(
let cache = GradleCache {
hash: hash_gradle_files(&gradle::build_files(root, &model)),
at_ms: now_ms(),
error: (!out.success).then(|| error_summary(&out.text)),
error: if !out.success { Some(error_summary(&out)) } else { truncation_note(&out) },
tasks: if out.success { gradle::parse_tasks(&out.text) } else { Vec::new() },
projects,
resources: true,
@@ -914,10 +934,22 @@ mod tests {
);
assert_eq!(maven_building("[INFO] Building jar: x.jar"), None);
let text = "[INFO] x\n[ERROR] Failed to execute goal\n[ERROR] \n[ERROR] Re-run Maven using -X\n";
assert_eq!(error_summary(text), "Failed to execute goal");
assert_eq!(error_summary("one\nlast line\n\n"), "last line");
let out = |text: &str, truncated| crate::process::Output { success: false, text: text.to_owned(), truncated };
assert_eq!(error_summary(&out(text, false)), "Failed to execute goal");
assert_eq!(error_summary(&out("one\nlast line\n\n", false)), "last line");
let missing_jar = "错误: 找不到或无法加载主类 org.gradle.wrapper.GradleWrapperMain\n";
assert!(error_summary(missing_jar).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
assert!(error_summary(&out(missing_jar, false)).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
// A truncated capture says so instead of hiding that lines are missing.
assert!(error_summary(&out(text, true)).ends_with("this summary may miss lines]"));
}
#[test]
fn a_truncated_successful_run_is_surfaced_not_silent() {
let out = |truncated| crate::process::Output { success: true, text: String::new(), truncated };
assert!(truncation_note(&out(false)).is_none());
let note = truncation_note(&out(true)).unwrap();
assert!(note.starts_with("the build printed more than the retained 32 MiB"), "{note}");
assert!(note.ends_with("the model may be incomplete"));
}
#[test]
+223 -24
Переглянути файл
@@ -18,13 +18,13 @@ struct State {
database: String,
settings: Vec<(String, String)>,
read_only: bool,
session_id: String,
session: Mutex<Session>,
closed: CancellationToken,
}
#[derive(Default)]
struct Session {
id: Option<String>,
initialized: bool,
strict_read_only: bool,
}
@@ -32,6 +32,7 @@ struct Session {
/// The response format: a names line, a types line, then one JSON array per row, so rows past
/// the grid's limit are skipped without being parsed.
const FORMAT: &str = "JSONCompactEachRowWithNamesAndTypes";
const SESSION_LOST: &str = "ClickHouse HTTP session not found on this node (code 372). Use one node or session affinity, or set use_http_session=false in Advanced for independent queries.";
pub(crate) fn transaction_error() -> IdeError {
IdeError::invalid("ClickHouse HTTP does not support SQL transactions; use auto-commit and run writes directly")
@@ -42,11 +43,32 @@ impl ClickhousePool {
if source.options.transaction == DbTxMode::Manual {
return Err(transaction_error());
}
for (name, _) in &setup.params {
if reserved_setting(name) {
let mut use_http_session = None;
let mut settings = Vec::with_capacity(setup.params.len());
for (name, value) in setup.params {
if name.eq_ignore_ascii_case("use_http_session") {
if use_http_session.is_some() {
return Err(IdeError::invalid("ClickHouse use_http_session must be specified only once"));
}
use_http_session = Some(if value.eq_ignore_ascii_case("true") {
true
} else if value.eq_ignore_ascii_case("false") {
false
} else {
return Err(IdeError::invalid("ClickHouse use_http_session must be true or false"));
});
} else if reserved_setting(&name) {
return Err(IdeError::invalid(format!("ClickHouse HTTP manages the {name} setting")));
} else {
settings.push((name, value));
}
}
let use_http_session = use_http_session.unwrap_or(true);
if !use_http_session && (!setup.statements.is_empty() || !source.options.startup_script.trim().is_empty()) {
return Err(IdeError::invalid(
"ClickHouse use_http_session=false does not support startup scripts; configure database and settings on the data source for each request",
));
}
let secure = matches!(source.ssl, DbSslMode::Require | DbSslMode::VerifyCa | DbSslMode::VerifyFull);
let tls_files = [&source.ssl_ca_file, &source.ssl_cert_file, &source.ssl_key_file];
if !secure && tls_files.iter().any(|p| !p.trim().is_empty()) {
@@ -112,10 +134,12 @@ impl ClickhousePool {
user: if source.user.is_empty() { "default".into() } else { source.user.clone() },
password: password.unwrap_or_default().to_owned(),
database: if database.is_empty() { "default".into() } else { database.into() },
settings: setup.params,
settings,
read_only: source.read_only,
session_id: uuid::Uuid::new_v4().to_string(),
session: Mutex::new(Session::default()),
session: Mutex::new(Session {
id: use_http_session.then(|| uuid::Uuid::new_v4().to_string()),
..Session::default()
}),
closed: CancellationToken::new(),
}));
let cancel = CancellationToken::new();
@@ -124,14 +148,35 @@ impl ClickhousePool {
if !rejects_driver_setting(&error) {
return Err(error);
}
if !use_http_session {
return Err(IdeError::new(
error.kind,
format!(
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
error.message
),
));
}
// Retry only the connection probe. Keep relying on the server for write protection
// only after verifying strict read-only mode in this same session.
pool.0.session.lock().await.strict_read_only = true;
{
let mut session = pool.0.session.lock().await;
// Start the proof in a fresh session: the rejected probe may have left
// its id on another replica without applying the configured database.
session.id = Some(uuid::Uuid::new_v4().to_string());
session.strict_read_only = true;
}
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
return Err(error);
}
}
// The HTTP database parameter applies to one request. A named session needs
// USE once so later queries inherit the selection (and may change it).
if use_http_session && !database.is_empty() {
let name = crate::sql::quote_ident(crate::DbDriver::Clickhouse, database);
pool.execute(&format!("USE {name}"), 0, &cancel).await?;
}
for sql in setup.statements {
pool.execute(&sql, 0, &cancel).await?;
}
@@ -174,12 +219,7 @@ impl ClickhousePool {
.basic_auth(&self.0.user, Some(&self.0.password))
.header(reqwest::header::CONTENT_TYPE, "text/plain; charset=utf-8")
.query(&self.0.settings)
.query(&[
("session_id", self.0.session_id.clone()),
("session_timeout", "3600".into()),
("query_id", query_id.to_owned()),
("default_format", FORMAT.into()),
]);
.query(&[("query_id", query_id), ("default_format", FORMAT)]);
if !session.strict_read_only {
request = request.query(&[
("output_format_json_quote_denormals", "1".into()),
@@ -187,9 +227,13 @@ impl ClickhousePool {
("result_overflow_mode", "break".into()),
]);
}
if session.initialized {
request = request.query(&[("session_check", "1")]);
} else {
if let Some(session_id) = &session.id {
request = request.query(&[("session_id", session_id.as_str()), ("session_timeout", "3600")]);
if session.initialized {
request = request.query(&[("session_check", "1")]);
}
}
if session.id.is_none() || !session.initialized {
request = request.query(&[("database", &self.0.database)]);
}
if self.0.read_only && !session.strict_read_only {
@@ -328,11 +372,7 @@ impl ClickhousePool {
let auth = matches!(status, StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN)
|| matches!(code, Some("193" | "194" | "195" | "516" | "497"));
let detail = if message.is_empty() { status.canonical_reason().unwrap_or("request failed") } else { &message };
let detail = if detail.contains("SESSION_NOT_FOUND") || detail.contains("Session not found") {
"ClickHouse HTTP session expired; reconnect to restore session settings"
} else {
detail
};
let detail = if code == Some("372") || session_not_found(detail) { SESSION_LOST } else { detail };
self.redact_error(IdeError::new(
if auth { ErrorKind::PermissionDenied } else { ErrorKind::InvalidInput },
format!("ClickHouse HTTP {}: {detail}", status.as_u16()),
@@ -454,7 +494,11 @@ impl RowReader {
let rest = std::mem::take(&mut self.pending);
self.line(&rest)?;
if let Some(exception) = self.exception {
return Err(IdeError::invalid(format!("ClickHouse: {}", exception_text(&exception))));
let detail = exception_text(&exception);
return Err(IdeError::invalid(format!(
"ClickHouse: {}",
if session_not_found(detail) { SESSION_LOST } else { detail }
)));
}
let Some(names) = self.names else { return Ok((Vec::new(), Vec::new(), false)) };
let types = self.types.unwrap_or_default();
@@ -466,6 +510,13 @@ impl RowReader {
}
}
/// Whether a server message reports a named HTTP session this node doesn't have.
fn session_not_found(detail: &str) -> bool {
detail.starts_with("Code: 372.")
|| detail.starts_with("Session not found")
|| detail.starts_with("SESSION_NOT_FOUND")
}
/// The server's message in a failed response: rows already streamed and the
/// `__exception__` block markers ClickHouse wraps a mid-stream error in are dropped.
fn exception_text(body: &str) -> &str {
@@ -610,6 +661,19 @@ mod tests {
DataSource { driver: DbDriver::Clickhouse, host: "127.0.0.1".into(), port: Some(port), ..Default::default() }
}
fn property(name: &str, value: &str) -> DbProperty {
DbProperty { name: name.into(), value: value.into() }
}
fn request_url(request: &str) -> Url {
let target = request.lines().next().unwrap().split_whitespace().nth(1).unwrap();
Url::parse(&format!("http://localhost{target}")).unwrap()
}
fn query_value(url: &Url, key: &str) -> Option<String> {
url.query_pairs().find(|(name, _)| name == key).map(|(_, value)| value.into_owned())
}
fn decode(body: &[u8], max_rows: usize, chunk: usize) -> IdeResult<DecodedResult> {
decode_from(body, 0, max_rows, chunk)
}
@@ -688,6 +752,7 @@ mod tests {
let (port, requests) = server(vec![
("200 OK", "X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n", ONE),
("200 OK", "", ""),
("200 OK", "", ""),
(
"200 OK",
"X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n",
@@ -699,7 +764,7 @@ mod tests {
user: "reader".into(),
read_only: true,
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
properties: vec![property("max_threads", "2"), property("use_http_session", "true")],
..source(port)
};
let pool = Pool::connect(&source, Some("mock-password"), None).await.unwrap();
@@ -722,7 +787,7 @@ mod tests {
assert_eq!(value(&urls[1], "session_check").as_deref(), Some("1"));
assert_eq!(value(&urls[0], "session_id"), value(&urls[2], "session_id"));
assert_ne!(value(&urls[0], "query_id"), value(&urls[2], "query_id"));
assert_eq!(value(&urls[2], "max_result_rows").as_deref(), Some("2"));
assert_eq!(value(&urls[3], "max_result_rows").as_deref(), Some("2"));
for (request, url) in requests.iter().zip(&urls) {
assert!(request.starts_with("POST /?"));
assert!(request.contains("Basic cmVhZGVyOm1vY2stcGFzc3dvcmQ="));
@@ -730,8 +795,10 @@ mod tests {
assert_eq!(value(url, "readonly").as_deref(), Some("1"));
assert_eq!(value(url, "session_timezone").as_deref(), Some("UTC"));
assert_eq!(value(url, "max_threads").as_deref(), Some("2"));
assert_eq!(value(url, "use_http_session"), None);
}
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[1].ends_with("USE `analytics`"));
assert!(pool.transaction(&[]).await.is_err());
let cancel = CancellationToken::new();
cancel.cancel();
@@ -741,6 +808,71 @@ mod tests {
assert!(pool.execute("SELECT 1", 1, &CancellationToken::new()).await.is_err());
}
#[tokio::test]
async fn stateless_requests_keep_database_settings_readonly_and_limits() {
let (port, requests) = server(vec![("200 OK", "", ONE); 3]).await;
let source = DataSource {
database: "configured_database".into(),
read_only: true,
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
..source(port)
};
let pool = Pool::connect(&source, None, None).await.unwrap();
pool.execute("SELECT 2", 2, &CancellationToken::new()).await.unwrap();
pool.execute("SELECT 3", 3, &CancellationToken::new()).await.unwrap();
let requests = requests.await.unwrap();
let mut query_ids = std::collections::HashSet::new();
for (index, request) in requests.iter().enumerate() {
let url = request_url(request);
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
assert_eq!(query_value(&url, name), None, "{name} must not be sent in stateless mode");
}
assert_eq!(query_value(&url, "database").as_deref(), Some("analytics"));
assert_eq!(query_value(&url, "session_timezone").as_deref(), Some("UTC"));
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
assert_eq!(query_value(&url, "max_result_rows"), Some((index + 2).to_string()));
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), Some("break"));
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), Some("1"));
assert_eq!(query_value(&url, "default_format").as_deref(), Some(FORMAT));
assert!(query_ids.insert(query_value(&url, "query_id").unwrap()));
assert!(request.ends_with(&format!("SELECT {}", index + 1)));
}
}
#[tokio::test]
async fn default_session_expiry_never_recreates_the_session_or_replays_sql() {
for failure in [
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 372\r\n", "session unavailable"),
("500 Internal Server Error", "", "Code: 372. DB::Exception: Session not found. (SESSION_NOT_FOUND)"),
("200 OK", "", "Code: 372. DB::Exception: Session not found. (SESSION_NOT_FOUND)"),
] {
let (port, requests) = server(vec![("200 OK", "", ONE), failure, ("200 OK", "", ONE)]).await;
let pool = Pool::connect(&source(port), None, None).await.unwrap();
let sql = "INSERT INTO events VALUES (1)";
let error = pool.execute(sql, 0, &CancellationToken::new()).await.unwrap_err();
assert!(error.message.contains("372"));
assert!(error.message.contains("one node or session affinity"));
assert!(error.message.contains("use_http_session=false"));
pool.execute("SELECT 1", 1, &CancellationToken::new()).await.unwrap();
let requests = requests.await.unwrap();
assert_eq!(requests.len(), 3);
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[1].ends_with(sql));
assert!(requests[2].ends_with("SELECT 1"));
let session_id = query_value(&request_url(&requests[0]), "session_id").unwrap();
for request in &requests[1..] {
let url = request_url(request);
assert_eq!(query_value(&url, "session_id").as_deref(), Some(session_id.as_str()));
assert_eq!(query_value(&url, "session_check").as_deref(), Some("1"));
assert_eq!(query_value(&url, "database"), None);
}
}
}
#[tokio::test]
async fn sequential_queries_reuse_the_http_connection() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
@@ -770,10 +902,12 @@ mod tests {
"Code: 164. DB::Exception: Cannot modify 'output_format_json_quote_denormals' setting in readonly mode. (READONLY)",
),
("200 OK", "", ONE),
("200 OK", "", ""),
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[1]\n[2]\n"),
])
.await;
let source = DataSource {
database: "system".into(),
read_only: true,
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
..source(port)
@@ -787,8 +921,13 @@ mod tests {
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[0].contains("output_format_json_quote_denormals=1"));
assert!(requests[1].ends_with("SELECT getSetting('readonly')"));
assert!(!requests[1].contains("session_check="));
assert_eq!(query_value(&request_url(&requests[1]), "database").as_deref(), Some("system"));
assert!(requests[2].contains("session_check=1"));
let session_id = query_value(&request_url(&requests[1]), "session_id").unwrap();
assert_ne!(query_value(&request_url(&requests[0]), "session_id").as_deref(), Some(session_id.as_str()));
for request in &requests[1..] {
assert_eq!(query_value(&request_url(request), "session_id").as_deref(), Some(session_id.as_str()));
assert!(request.contains("default_format=JSONCompactEachRowWithNamesAndTypes"));
assert!(request.contains("max_threads=2"));
for setting in
@@ -799,6 +938,66 @@ mod tests {
}
}
#[tokio::test]
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
for read_only in [false, true] {
let (port, requests) = server(vec![(
"500 Internal Server Error",
"X-ClickHouse-Exception-Code: 164\r\n",
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
)])
.await;
let source =
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
assert!(error.message.contains("use_http_session=false requires per-request"));
let requests = requests.await.unwrap();
assert_eq!(requests.len(), 1);
assert!(requests[0].ends_with("SELECT 1"));
let url = request_url(&requests[0]);
assert_eq!(query_value(&url, "max_result_rows").as_deref(), Some("2"));
assert_eq!(query_value(&url, "readonly").as_deref(), read_only.then_some("1"));
assert_eq!(query_value(&url, "session_id"), None);
}
}
#[tokio::test]
async fn incompatible_stateless_options_are_rejected_before_connecting() {
for (properties, startup_script, expected) in [
(vec![property("use_http_session", "false")], "SET max_threads = 2", "does not support startup scripts"),
(vec![property("use_http_session", "invalid")], "", "must be true or false"),
(
vec![property("use_http_session", "false"), property("USE_HTTP_SESSION", "true")],
"",
"must be specified only once",
),
(
vec![property("use_http_session", "false"), property("session_id", "custom")],
"",
"manages the session_id",
),
(
vec![property("use_http_session", "false"), property("session_check", "0")],
"",
"manages the session_check",
),
(
vec![property("use_http_session", "false"), property("session_timeout", "60")],
"",
"manages the session_timeout",
),
] {
let source = DataSource {
properties,
options: DbOptions { startup_script: startup_script.into(), ..Default::default() },
..source(1)
};
let error = Pool::connect(&source, None, None).await.err().expect("incompatible options must fail");
assert!(error.message.contains(expected), "{}", error.message);
}
}
#[tokio::test]
async fn readonly_probe_does_not_disable_settings_on_a_writable_session() {
let (port, requests) = server(vec![
+3 -1
Переглянути файл
@@ -162,7 +162,8 @@ impl PluginHost {
.collect()
}
/// What a plugin receives for `document-changed`: the path relative to the file's own project.
/// What a plugin receives for `document-changed`: the path relative to the file's own
/// project, and that project's root, since two open projects can hold the same relative path.
pub(super) fn relativize_documents(
shared: &super::api::Shared,
client: Option<&str>,
@@ -181,6 +182,7 @@ impl PluginHost {
.to_string_lossy()
.replace('\\', "/");
change.path = relative;
change.project = Some(ide_core::ipc_path::to_ipc(&root));
Some(WorkbenchEvent::DocumentChanged(change))
})
.collect()
+3
Переглянути файл
@@ -5298,6 +5298,7 @@ fn document_changes_reach_plugins_relative_to_the_project() {
let deliver = |path: &str| {
let change = ide_plugin::DocumentChanged {
path: to_ipc(&f.project.join(path)),
project: None,
base_version: 1,
version: 2,
changes: Vec::new(),
@@ -5311,6 +5312,8 @@ fn document_changes_reach_plugins_relative_to_the_project() {
// Queued with the absolute path, filtered again at delivery, handed over project-relative.
deliver("config/app.yaml");
assert_eq!(f.run("test.path-events", "document", None).unwrap().as_deref(), Some("config/app.yaml"));
// With the project it is relative to: another open project may hold the same path.
assert_eq!(f.run("test.path-events", "document-project", None).unwrap(), Some(to_ipc(&f.project)));
}
#[test]
+9
Переглянути файл
@@ -241,6 +241,15 @@ impl PathFilter {
(!rel.is_empty()).then_some(rel)
}
/// Recent Files' stored form: the store key for a project file, the absolute
/// path for one outside it (a scratch file). Loading joins it to the root,
/// which leaves an absolute path as it is.
pub(crate) fn recent_key(&self, path: &Path) -> Option<String> {
self.store_key(path).or_else(|| {
(path.is_absolute() && !path.starts_with(&self.root)).then(|| path.to_str().map(str::to_owned))?
})
}
fn excluded_rel(&self, rel: &str) -> bool {
self.excludes.is_match(rel)
}
+18 -15
Переглянути файл
@@ -400,15 +400,10 @@ impl ProjectIndex {
/// Boost for "recent files" ranking.
/// Records a recently opened file; a virtual document's URI (library
/// class) is kept verbatim, like IDEA lists library classes in Recent Files.
/// class) is kept verbatim, and a file outside the project (a scratch file)
/// by its absolute path.
pub fn mark_recent(&self, path: &Path) {
let path = match path.to_str() {
Some(s) if ide_core::text::is_virtual_uri(s) => path.to_owned(),
_ => match self.normalize(path) {
Some(p) => p,
None => return,
},
};
let Some(path) = self.recent_key(path) else { return };
{
let mut r = self.shared.recent.lock();
r.retain(|p| p != &path);
@@ -420,13 +415,7 @@ impl ProjectIndex {
/// Drops a file from Recent Files (Delete in the ⌘E popup).
pub fn remove_recent(&self, path: &Path) {
let path = match path.to_str() {
Some(s) if ide_core::text::is_virtual_uri(s) => path.to_owned(),
_ => match self.normalize(path) {
Some(p) => p,
None => return,
},
};
let Some(path) = self.recent_key(path) else { return };
{
let mut r = self.shared.recent.lock();
let before = r.len();
@@ -473,6 +462,20 @@ impl ProjectIndex {
&self.root
}
/// How Recent Files stores `path`: a virtual URI verbatim, a project file normalized,
/// and an existing file outside the root canonicalized. Excluded files under the root
/// are left out.
fn recent_key(&self, path: &Path) -> Option<PathBuf> {
if path.to_str().is_some_and(ide_core::text::is_virtual_uri) {
return Some(path.to_owned());
}
if let Some(p) = self.normalize(path) {
return Some(p);
}
let p = dunce::canonicalize(path).ok().filter(|p| p.is_file())?;
(!p.starts_with(&self.root)).then_some(p)
}
/// Absolute path inside the root (or a content root), or `None` for paths outside the project.
fn normalize(&self, path: &Path) -> Option<PathBuf> {
let filter = self.shared.filter();
+20
Переглянути файл
@@ -251,6 +251,26 @@ fn recent_files_skip_deleted_files_but_keep_virtual_documents() {
assert_eq!(idx.recent_files(), vec![virt]);
}
#[test]
fn recent_files_keep_files_outside_the_project() {
let fx = sample();
let scratches = tempfile::tempdir().unwrap();
let scratch = dunce::canonicalize(scratches.path()).unwrap().join("generated-requests.http");
std::fs::write(&scratch, "GET http://localhost\n").unwrap();
let app = fx.root.join("web/app.py");
{
let idx = fx.open();
idx.mark_recent(&app);
idx.mark_recent(&scratch);
assert_eq!(idx.recent_files(), vec![scratch.clone(), app.clone()]);
assert!(idx.wait_idle(WAIT));
}
let idx = fx.open();
assert_eq!(idx.recent_files(), vec![scratch.clone(), app.clone()], "persisted by absolute path");
idx.remove_recent(&scratch);
assert_eq!(idx.recent_files(), vec![app]);
}
#[test]
fn persistence_skips_unchanged_files_on_reopen() {
let fx = sample();
+2 -2
Переглянути файл
@@ -591,7 +591,7 @@ impl Shared {
let update_elapsed = update_started.elapsed();
let snapshot_started = Instant::now();
if let Some(store) = &self.store {
let recent: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.store_key(p)).collect();
let recent: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.recent_key(p)).collect();
let d = self.data.read();
let snapshot_started = Instant::now();
if let Err(e) = store.save_snapshot(&d, &filter, guard) {
@@ -976,7 +976,7 @@ impl Shared {
}
}
if save_recent && let Some(store) = &self.store {
let rels: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.store_key(p)).collect();
let rels: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.recent_key(p)).collect();
if let Err(e) = store.save_recent(&rels) {
tracing::warn!("index cache: saving recent files failed: {e}");
}
+3
Переглянути файл
@@ -250,6 +250,9 @@ pub struct DocumentTextChange {
#[serde(rename_all = "camelCase")]
pub struct DocumentChanged {
pub path: String,
/// The open project `path` is relative to, set when the event is handed to a plugin
/// (the editor posts the absolute path and `null`).
pub project: Option<String>,
pub base_version: u64,
pub version: u64,
pub changes: Vec<DocumentTextChange>,
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
c10d6f373bd3a701e201350d0272a211da72b23cef010144760db5bae44e2c11
ada68dfdf2875668eff1765ec22678315f18ac6f1364c5f7eda742cb58dc3c60
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
cd7a14b6d4464a559c197ba7fcba30fb045a8927c074fd0c310bec6039af0e0f
2279ae4f79c565c4cd59d9191f394c4d7d5b23ef955f1bd30c2e5396d608e46c
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
017cb719d8c3a226cb6178d75da7ae0396b2d78799658ef560f729e8e06f36e3
77be736c11c39de3a1b021a5e66e905c76e2d32352d889d6bcc9315607c54271
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
93a9660a0941f2f57d11ea7ae331bd6d209ddcb134729ee88ec2fd96e978e631
304690bf13cba5d262d54d709d6f18c627880954f0140919118aea0439fbaaf3
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
6a0008339af0935c7c0128d23bf3e885a642c335ad57097cffb3f000766aba33
b24767627e7445ec093cc79cd6c18844e4dcdf123c6b04c24bc37f109c5cdb0f
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
09369df431bb6922463a242484eb82325ce8af287654af97a99eefb3884115a5
0fa52a91772ceb3d45307db4f2561c132df4b966d15f7f9ce177b7a373f7163d
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
897898835f2f42763da34dad29b8f926b230b33f506830e4118e6c5914720bd4
34ea07edc731ab28748b99c398f7e1ee4d41aa22c0760d57027adad40759292f
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
b56b918d1ff51c902dc956a7da944163194fcc93ba5bcf8baafa44fc2b6b039b
470a54d825e84e8ec0418a244c1fc46426c02f299f4a456ff4cc83fa604d08a0
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
ec2f6463d1ce5d70ad7331ae51bca3c8205b55f1f9e5abfe2218d53be2b61437
20a4f662437478b20e5a80aa30afe20b155001f94c2934843ab11b69192833d4
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
8a25727e09b96b35bc90f906215e13d29697b3792ed81f7f80024299e8b23d44
c118a6562e0398e7f0deb64abc9913dd14acec74869d5c04c452923a81455463
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
33d331d6ab59aa44f9884504ecc77a474e99c7223253735983c327bee6e75984
194fa719b8c96ca23f2da73d2d7225c4805b5c48af67b1efff8e76852f0a6a1c
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
b804f22b06f924aebce86f8bc2c24b5306913f2d2a4a0167af10ce86c8f606db
3db661dd4d45a242b79caf642510d71841ba9f09b3b5eaa1854eabe9fcf6292e
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
27e24e96578471e51dace84968daa6ee189aae0d63d27f3054bf4f3a0841fe0c
196769808ae37ede0a7564f42cae087a18f756b3cd31acb7d99470f1bfd70ea6
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
283320b057d39decafce4f86e09ace4df46ef2f31524b6cac0af22bd62795b0c
dcd05de6c207f4594d347ad3dc44089204353dc898e53873f437e3db1928d629
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
dff4f3571bf72eedfbe2e0e2d6b8908e703e890639fb1b854eb4f35226ddbc98
ece50a864d5a85263cb30eb39dceae90fe174336904e9208ae5c9d5da5cbb036
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
f5d7f62056547beffaadf68a04e8393ee29d73d57501d9f8bb39e902e9d9bf61
a2854d3c357d976b5ee1bf7b31fa541a55581102d37ec85ea719d4fdedd962cb
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
8ea7d2a041efe6bcabe8f9bb58b216fe583a7ad39207f0f10b4bf423facc56e7
dbebe5cfa79092169689d43945e4d71e1a61303ce88f6b4f02216ab69083b955
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
3b5b541b94b674762d6c0494bb5e26bbc871460767015a669ecd2771dc063b8a
993b0f11e8cae470b0529fcfcbe9a520c855069ef63f242da3b26a3da2574d5d
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
64411ddd70ae2906710d03c90add26727aa319db38c5bd23971eb442943154c5
d803928d82cbb2991b3f0c53b73dbe2da625b7b2ce25050706b6da09687f2873
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
ff7468eabf0b09be01afda83ede9d8b540d17cbccb414e1972899bb851c19d84
1c779c4913a2b83fa51980ee0017e3f2625041f1b4de921cedcdcb3bd4120d67
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
b24fb8d5161006104698fb07a43432601b4f16fdc4a34cc70058cbef7e973066
bd09f3b47470087095ae50c3b0f134c471dd9ba1e5f812cd0285cef904065725
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
8ded9b882110bc6b1235b14797128d5999f20079178a6134f172f64f77922985
ada14d3aa0e462478de7dff28be356b2105f4d3ec8d4dff8a7a4a858d15c4613
+4
Переглянути файл
@@ -33,6 +33,10 @@ title = "off"
id = "document"
title = "document"
[[contributes.commands]]
id = "document-project"
title = "document-project"
[[contributes.commands]]
id = "count"
title = "count"
+2
Переглянути файл
@@ -33,6 +33,7 @@ impl Plugin for Fixture {
}
"count" => Ok(host::storage::get("count")?),
"document" => Ok(host::storage::get("document")?),
"document-project" => Ok(host::storage::get("document-project")?),
_ => Err(Error::NotFound(id.into())),
}
}
@@ -42,6 +43,7 @@ impl Plugin for Fixture {
for event in events {
if let Event::DocumentChanged(change) = event {
host::storage::set("document", &change.path).unwrap();
host::storage::set("document-project", change.project.as_deref().unwrap_or_default()).unwrap();
}
}
}
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
c38f6ca9e44f0a0674b9186ef105e73e0c66a914de92a1aec97b5985f31fc29a
3d628f747d13d3d2fae9a75adeb951c8af09b1db5fb15523fc71289857d97d99
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
a74d851ebf2cad085b9d0fb56ad26c7b18d737c8cc0ef32a592a8f1b05b9be06
43e7552ae0f8b42383cade84924adc81952c78253186a71c2693b11d98f01acd
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
ce5fc1e202210942f287b593fbb88f2f1d51b573702c476e9f2d96f684d546c6
373188558b7925b4f9c9f975b0b6aa7b13acdf8da0c622a4ab12f39b69c1f071
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
a9821d31a040a5b2244e205632bc4edf8ebeae5c34aa5911438b69254f767183
9c91a083fd31e57658f28c34329e061dc17cc08871fe09b3b96fa557bc085c8d
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
792cd02805a24a37655629a24da97d82c2cc4f385dea21720167792302a75236
1a2182ca4e272d3473084451932a1d8df861ac2e67ad1814c0e01e089584ab3f
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
e6235b32744d6e5b3042ff2231e1a30eb4966324e790d01176f88fc9955db638
d5e8c538e410f480d79454c616bf9b0e7eaa7e502ed0268bf20f75214ca93d17
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
c277285eab80d917597ca26bcee94c5bde17cb7d0d38f3bd2866ce75b048f226
756f2a459f2aa17d6eb1d9dbe089a3d6dc5079012ed68ee47e55d5256c589359
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
84e2be128daa6dbe04df383fee1250cd2b6d65d90a3de2afdaed98be147599cb
28327a76a68737fda8ae0b22a439f5bbe86dd53347a7ee2806bb66ae90714238
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
3a492f0664ed153d631ec3c1089e7bdf5dcf31f969cb75654516290ac35cf984
ac3a564273429fcaad2c443e3463f06694953889ad894c9f68b824e87e291ae0
+2
Переглянути файл
@@ -78,6 +78,8 @@ The task tab shows the conversation: your messages, the agent's replies, its rea
On your own messages you can **Edit** (the messages after it are replaced; files already changed stay as they are) or **Retract Message**. On replies you can **Copy Markdown**, **Quote Reply**, **Regenerate Response** and **Branch Conversation from Here**, which starts a new task from that point.
In an existing chat, open **Model › Refresh models** to discover newly available models without sending a message or changing the selection. If the agent can't switch in place, the choice stays pending until your next message reopens the same session. If the session can't be reopened or doesn't accept the model, OpenIDEA restores the previous selection and reports the error without sending the message.
**Focus Agent Input** defaults to `⌘L` on macOS and `Ctrl+L` on Windows / Linux in every built-in keymap. When focus is inside your writable task conversation, in either an editor tab or the tool window, it returns focus to the message input without changing your draft, caret position or selection—even when pressed repeatedly. It does not send a message or jump through message history.
With focus anywhere else, the same shortcut jumps to the message input of the task shown in an editor tab or the tool window (the one you used last, if several are shown), unless a panel claims the shortcut there: in a code editor `⌘L` / `Ctrl+L` keeps its editor meaning (for example Go to Line), and in a terminal on Windows / Linux `Ctrl+L` still reaches the shell. It does not apply to archived tasks, subagent conversations or the New Task page, and does not take focus from open popups or dialogs. To change or remove the binding, open **Settings › Keymap › Agents › Focus Agent Input**.
+10
Переглянути файл
@@ -158,6 +158,16 @@ The export button offers **Export Data…** and quick copies: **Copy as CSV**, *
**Import Data from File…** loads CSV, TSV or TXT into a table: the separator is detected, the first row can be a header matched to columns by name, and empty values can become `NULL`. The import runs in one transaction. It is not available for ClickHouse.
## ClickHouse
The built-in HTTP driver uses a named session by default (`use_http_session=true`). Route requests to one node or enable session affinity. If the session expires or another node reports code 372, OpenIDEA shows a reconnect error and never replays the statement.
For endpoints that route each request to a different node, add **Advanced** property `use_http_session` with value `false`. Each request omits `session_id`, `session_check` and `session_timeout`, and sends the configured database (or **Default schema**), time zone and Advanced settings again. **Read-only** sends `readonly=1` on every request; result-limit settings remain enabled.
Stateless statements must be independent: `USE`, standalone `SET`, temporary tables and other session state cannot carry over to later requests. Configure the database and settings on the data source. Startup scripts and explicit session properties (`session_id`, `session_check`, `session_timeout`) are rejected. SQL transactions and statement caching are unsupported in either mode.
Strict read-only servers that refuse per-request driver settings cannot use stateless mode: the connection fails without dropping read-only protection or limits. The strict read-only fallback requires proof in the same named HTTP session, including on subsequent requests; use one node or session affinity.
## Oracle
Oracle connections use a built-in pure-Rust thin driver, so no Oracle client library or `ORACLE_HOME` is needed. It
+8 -2
Переглянути файл
@@ -47,13 +47,19 @@ The Windows packages aren't code-signed yet, so Microsoft Defender SmartScreen m
## The window stays blank or stops responding on Linux
WebKitGTK's DMA-BUF renderer fails on some Wayland setups. With the NVIDIA driver on Wayland, OpenIDEA turns the driver's explicit sync off for itself (`__NV_DISABLE_EXPLICIT_SYNC=1`), which avoids the failure and keeps the renderer. If the window stays blank, draws incorrectly, or stops reacting to the keyboard and mouse a few seconds after launch in another setup, quit OpenIDEA and start it from a terminal with the DMA-BUF renderer turned off, for example:
WebKitGTK's DMA-BUF renderer fails on some Wayland setups. With the NVIDIA driver on Wayland, OpenIDEA turns the driver's explicit sync off for itself (`__NV_DISABLE_EXPLICIT_SYNC=1`), which avoids the failure and keeps the renderer. If the window stays blank, draws incorrectly, or stops reacting to the keyboard and mouse a few seconds after launch in another setup, quit OpenIDEA and start it from a terminal through XWayland first:
```sh
GDK_BACKEND=x11 ./OpenIDEA_<version>_amd64.AppImage
```
The page is still drawn on the GPU this way; at a fractional display scale the window may look less sharp. If that does not help, turn the DMA-BUF renderer off instead:
```sh
WEBKIT_DISABLE_DMABUF_RENDERER=1 ./OpenIDEA_<version>_amd64.AppImage
```
The page is then drawn without the GPU, so dragging large panels can be slower. To keep the setting for launches from the application menu with the deb or rpm package, copy `/usr/share/applications/OpenIDEA.desktop` to `~/.local/share/applications/` and change its `Exec=` line to `Exec=env WEBKIT_DISABLE_DMABUF_RENDERER=1 openidea`.
The page is then drawn without the GPU, so dragging large panels can be slower. To keep either setting for launches from the application menu with the deb or rpm package, copy `/usr/share/applications/OpenIDEA.desktop` to `~/.local/share/applications/` and change its `Exec=` line, for example to `Exec=env GDK_BACKEND=x11 openidea`.
## OpenIDEA exits at startup with a data directory error
+2
Переглянути файл
@@ -78,6 +78,8 @@ Codex 有自己的项目信任设置。如果它禁用了当前项目的 `.codex
在你自己的消息上可以 **编辑**(其后的消息会被替换,已经改动的文件保持不变)或 **撤回消息**。在回复上可以 **复制 Markdown**、**引用回复**、**重新生成回复**,以及 **从此处创建分支对话**,从这一点开始一个新任务。
在已有对话中,打开**模型 › 刷新模型**即可查找新上线的模型,不会发送消息或更改当前选择。如果 agent 无法直接切换,所选模型会在下一条消息重新打开原会话时才应用。如果无法恢复会话,或原会话不接受所选模型,OpenIDEA 会还原之前的选择并提示错误,不会发送该消息。
所有内置按键映射中,**聚焦 Agent 输入框** 的默认快捷键都是 macOS 上的 `⌘L`、Windows / Linux 上的 `Ctrl+L`。焦点位于你自己的可输入任务对话中时,无论对话显示在编辑器标签页还是工具窗口中,它都会将焦点移回消息输入框,保留草稿、光标位置和选区;重复按下也不会改变这些内容。它不会发送消息,也不会跳转消息历史。
焦点位于其他位置时,同一快捷键会跳转到编辑器标签页或工具窗口中显示的任务的消息输入框(显示多个时,选择你最近使用的那个),除非该位置有面板占用此快捷键:在代码编辑器中,`⌘L` / `Ctrl+L` 保留编辑器含义(例如“转到行”);在 Windows / Linux 的终端中,`Ctrl+L` 仍会发送给 shell。此快捷键不适用于已归档任务、子 agent 对话或“新建任务”页面,也不会从打开的弹出窗口或对话框中抢走焦点。要修改或移除绑定,请打开 **设置 › 按键映射 › 智能体 › 聚焦 Agent 输入框**。
+10
Переглянути файл
@@ -157,6 +157,16 @@ SQL 补全基于已连接的架构:`FROM`/`JOIN` 后补全表(并根据外
**从文件导入数据…** 把 CSV、TSV 或 TXT 导入到表中:自动识别分隔符,第一行可作为标题并按名称匹配列,空值可以视为 `NULL`。导入在一个事务中完成。ClickHouse 不支持导入。
## ClickHouse
内置 HTTP 驱动默认使用命名会话(`use_http_session=true`)。请求应路由到同一节点,或启用会话亲和性。如果会话过期或其他节点返回代码 372,OpenIDEA 会提示重新连接,且不会重放语句。
如果端点把每个请求路由到不同节点,可在 **高级** 中添加属性 `use_http_session`,值设为 `false`。每个请求都省略 `session_id`、`session_check` 和 `session_timeout`,并重新发送配置的数据库(或 **默认架构**)、时区及高级设置。启用 **只读** 时,每个请求都发送 `readonly=1`;结果行数限制设置也会保留。
无会话模式下,每条语句必须独立:`USE`、独立的 `SET`、临时表及其他会话状态无法延续到后续请求。请在数据源中配置数据库和设置。驱动会拒绝启动脚本以及显式会话属性(`session_id`、`session_check`、`session_timeout`)。两种模式均不支持 SQL 事务和语句缓存。
拒绝逐请求驱动设置的严格只读服务器无法使用无会话模式:连接会失败,不会移除只读保护或限制。严格只读回退必须在同一个命名 HTTP 会话中验证,后续请求也必须使用该会话;请使用单一节点或会话亲和性。
## Oracle
Oracle 连接使用内置的纯 Rust thin 驱动,不需要 Oracle 客户端库或 `ORACLE_HOME`。支持 Oracle Database 19 及以上版本。
+8 -2
Переглянути файл
@@ -47,13 +47,19 @@ Windows 安装包目前还没有代码签名,Microsoft Defender SmartScreen
## Linux 上窗口空白或无响应
在部分 Wayland 环境中,WebKitGTK 的 DMA-BUF 渲染器会出错。在使用 NVIDIA 驱动的 Wayland 会话中,OpenIDEA 会为自身关闭驱动的显式同步(`__NV_DISABLE_EXPLICIT_SYNC=1`),这样既能避开问题,又能保留该渲染器。如果在其他环境下窗口一片空白、显示异常,或启动几秒后键盘和鼠标都没有反应,先退出 OpenIDEA,再在终端中关闭 DMA-BUF 渲染器启动,例如:
在部分 Wayland 环境中,WebKitGTK 的 DMA-BUF 渲染器会出错。在使用 NVIDIA 驱动的 Wayland 会话中,OpenIDEA 会为自身关闭驱动的显式同步(`__NV_DISABLE_EXPLICIT_SYNC=1`),这样既能避开问题,又能保留该渲染器。如果在其他环境下窗口一片空白、显示异常,或启动几秒后键盘和鼠标都没有反应,先退出 OpenIDEA,再在终端中通过 XWayland 启动:
```sh
GDK_BACKEND=x11 ./OpenIDEA_<version>_amd64.AppImage
```
这样页面仍由 GPU 绘制;在非整数缩放比例下,窗口可能不够清晰。如果仍有问题,改为关闭 DMA-BUF 渲染器启动:
```sh
WEBKIT_DISABLE_DMABUF_RENDERER=1 ./OpenIDEA_<version>_amd64.AppImage
```
这样页面不再用 GPU 绘制,拖动较大的面板可能变慢。使用 deb 或 rpm 包时,如果希望从应用菜单启动也带上这个设置,把 `/usr/share/applications/OpenIDEA.desktop` 复制到 `~/.local/share/applications/`,并把其中的 `Exec=` 一行改成 `Exec=env WEBKIT_DISABLE_DMABUF_RENDERER=1 openidea`。
这样页面不再用 GPU 绘制,拖动较大的面板可能变慢。使用 deb 或 rpm 包时,如果希望从应用菜单启动也带上其中一个设置,把 `/usr/share/applications/OpenIDEA.desktop` 复制到 `~/.local/share/applications/`,并修改其中的 `Exec=` 一行,例如改成 `Exec=env GDK_BACKEND=x11 openidea`。
## 启动时提示数据目录错误并退出
+228
Переглянути файл
@@ -0,0 +1,228 @@
import type { Page } from "@playwright/test";
import { expect, stubDesktop, test } from "./fixtures";
const FILE = "/dev/acme-api/probe.txt";
async function openEditor(page: Page) {
const editor = page.locator(".cm-editor").first();
await expect(editor).toHaveAttribute("data-openidea-vim", "true");
await editor.locator(".cm-content").click();
return editor;
}
async function reset(page: Page, doc: string) {
await page.keyboard.press("Escape");
await page.keyboard.press("Escape");
await page.evaluate(async (text) => {
// Load the app module in the browser's Vite realm; the variable keeps knip from resolving the URL.
const apiPath = "/src/editor/api.ts";
const { activeEditor } = await import(apiPath);
const view = activeEditor()!.view;
view.dispatch({
changes: { from: 0, to: view.state.doc.length, insert: text },
selection: { anchor: 0 },
});
view.focus();
}, doc);
}
async function keys(page: Page, ...strokes: string[]) {
for (const stroke of strokes) await page.keyboard.press(stroke);
}
/** The app talks to the desktop backend for the clipboard; route those two commands to the browser's. */
async function bridgeClipboard(page: Page) {
await page.evaluate(() => {
window.__ipc.handlers["clipboard_write_text"] = async ({ text }) => {
await navigator.clipboard.writeText(text as string);
return null;
};
window.__ipc.handlers["clipboard_text"] = () => navigator.clipboard.readText();
});
}
/** Windows stores text with CRLF; compare the text Vim would see. */
const readClipboard = (page: Page) =>
page.evaluate(() => navigator.clipboard.readText().then((text) => text.replace(/\r\n/g, "\n")));
async function expectClipboard(page: Page, text: string) {
await expect.poll(() => readClipboard(page)).toBe(text);
}
const documentText = (page: Page) =>
page.evaluate(async () => {
// Load the app module in the browser's Vite realm; the variable keeps knip from resolving the URL.
const apiPath = "/src/editor/api.ts";
const { activeEditor } = await import(apiPath);
return activeEditor()!.view.state.doc.toString();
});
test.beforeEach(async ({ page, context }) => {
test.setTimeout(180_000);
await context.grantPermissions(["clipboard-read", "clipboard-write"]);
await page.addInitScript(() =>
localStorage.setItem("openidea.vim.v1", JSON.stringify({ enabled: true, handlers: {} })),
);
await page.goto("/");
await expect(page.getByRole("tree", { name: "Project" })).toBeVisible();
await stubDesktop(page);
await bridgeClipboard(page);
await page.evaluate(async (path) => {
const backendPath = "/src/editor/core/backend.ts";
const contributionsPath = "/src/workbench/contributions.ts";
const { docBackend } = await import(backendPath);
const { editorService } = await import(contributionsPath);
docBackend().files.set(path, "alpha\nbravo\ncharlie\n");
await editorService().openFile(path);
}, FILE);
await openEditor(page);
});
/** Applies rc file lines through the same parser and engine the app uses. */
async function applyRc(page: Page, rc: string) {
await page.evaluate(async (text) => {
// Load the app modules in the browser's Vite realm; the variables keep knip from resolving the URLs.
const enginePath = "/src/features/vim/engine.ts";
const rcPath = "/src/features/vim/rc.ts";
const { applyRcCommands } = await import(enginePath);
const { parseVimrc } = await import(rcPath);
applyRcCommands(parseVimrc(text).commands);
}, rc);
}
test("unnamed register writes stay out of the clipboard by default", async ({ page }) => {
await page.evaluate(() => navigator.clipboard.writeText("SENTINEL"));
await reset(page, "alpha\nbravo\n");
await keys(page, "y", "y");
await page.waitForTimeout(150);
expect(await readClipboard(page)).toBe("SENTINEL");
await keys(page, "d", "d");
await page.waitForTimeout(150);
expect(await readClipboard(page)).toBe("SENTINEL");
});
test("clipboard+=unnamed mirrors unnamed yanks and deletes", async ({ page }) => {
await applyRc(page, "set clipboard+=unnamed");
await page.evaluate(() => navigator.clipboard.writeText("SENTINEL"));
await reset(page, "alpha\nbravo\ncharlie\n");
await keys(page, "y", "y");
await expectClipboard(page, "alpha\n");
await page.evaluate(() => navigator.clipboard.writeText("SENTINEL"));
await reset(page, "alpha\nbravo\ncharlie\n");
await keys(page, "d", "d");
await expectClipboard(page, "alpha\n");
await page.evaluate(() => navigator.clipboard.writeText("SENTINEL"));
await reset(page, "alpha bravo\n");
await keys(page, "v", "e", "y");
await expectClipboard(page, "alpha");
});
test("explicit registers keep the clipboard out of the sync", async ({ page }) => {
await applyRc(page, "set clipboard+=unnamed");
for (const strokes of [
['"', "a", "y", "y"],
['"', "_", "d", "d"],
]) {
await page.evaluate(() => navigator.clipboard.writeText("SENTINEL"));
await reset(page, "alpha\nbravo\n");
await keys(page, ...strokes);
await page.waitForTimeout(150);
expect(await readClipboard(page)).toBe("SENTINEL");
}
await page.evaluate(() => navigator.clipboard.writeText("SENTINEL"));
await reset(page, "alpha\nbravo\n");
await keys(page, '"', "+", "y", "y");
await expectClipboard(page, "alpha\n");
});
test("the editor mirrors the current Vim mode", async ({ page }) => {
const editor = page.locator(".cm-editor").first();
await expect(editor).toHaveAttribute("data-vim-mode", "normal");
await keys(page, "i");
await expect(editor).toHaveAttribute("data-vim-mode", "insert");
await page.keyboard.press("Escape");
await keys(page, "v");
await expect(editor).toHaveAttribute("data-vim-mode", "visual");
await page.keyboard.press("Escape");
await expect(editor).toHaveAttribute("data-vim-mode", "normal");
});
test("Insert mode pastes with Ctrl+V and Shift+Insert, staying in Insert mode", async ({ page }) => {
const editor = page.locator(".cm-editor").first();
for (const stroke of ["Control+V", "Shift+Insert"]) {
await page.evaluate(() => navigator.clipboard.writeText("PASTED"));
await reset(page, "one\ntwo\n");
await keys(page, "i");
await page.keyboard.press(stroke);
await expect.poll(() => documentText(page)).toBe("PASTEDone\ntwo\n");
await expect(editor).toHaveAttribute("data-vim-mode", "insert");
await page.keyboard.press("Escape");
}
});
test("Visual mode Ctrl+C copies the selection and returns to Normal mode", async ({ page }) => {
await page.evaluate(() => navigator.clipboard.writeText("SENTINEL"));
await reset(page, "alpha bravo\n");
await keys(page, "v", "e");
await page.keyboard.press("Control+C");
await expectClipboard(page, "alpha");
await expect(page.locator(".cm-editor").first()).toHaveAttribute("data-vim-mode", "normal");
expect(await documentText(page)).toBe("alpha bravo\n");
});
test("the settings page documents what Ctrl+V and Ctrl+C do in each mode", async ({ page }) => {
await page.keyboard.press("Meta+,");
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
await settings.getByRole("textbox", { name: "Search settings", exact: true }).fill("Vim");
await settings.getByRole("treeitem", { name: "Vim", exact: true }).click();
const conflicts = settings.getByRole("region", { name: "Shortcut conflicts", exact: true });
await expect(
conflicts.getByText(
"Ctrl+V pastes in Insert mode and starts a Visual block in Normal and Visual modes. Ctrl+C copies the selection in Visual mode and otherwise leaves the current mode.",
{ exact: true },
),
).toBeVisible();
await expect(
settings.getByText(
"Unnamed yanks and deletes stay in Vim's registers. Add set clipboard+=unnamed (or set clipboard=unnamedplus) to the rc file to mirror them to the system clipboard.",
{ exact: true },
),
).toBeVisible();
const rowFor = (description: string, stroke: string) =>
conflicts
.getByRole("row", { name: new RegExp(description) })
.getByRole("button", { name: `Handler for ${stroke}` });
await expect(rowFor("Visual block; paste in Insert mode", "Ctrl+V")).toBeVisible();
await expect(rowFor("Exit to Normal mode; copy a Visual selection", "Ctrl+C")).toBeVisible();
});
test("Visual mode Ctrl+C still leaves Visual mode when the clipboard cannot be written", async ({ page }) => {
await reset(page, "alpha bravo\n");
await keys(page, "v", "e");
await page.evaluate(() => {
document.execCommand = () => false;
});
await page.keyboard.press("Control+C");
await expect(page.locator(".cm-editor").first()).toHaveAttribute("data-vim-mode", "normal");
expect(await documentText(page)).toBe("alpha bravo\n");
});
test("clipboard text pasted with +p keeps its line shape", async ({ page }) => {
await page.evaluate(() => navigator.clipboard.writeText("hello\r\n"));
await reset(page, "one\ntwo\n");
await keys(page, '"', "+", "p");
await expect.poll(() => documentText(page)).toBe("one\nhello\ntwo\n");
await reset(page, "one\ntwo\n");
await keys(page, '"', "+", "y", "y");
await reset(page, "one\ntwo\n");
await keys(page, '"', "+", "p");
await expect.poll(() => documentText(page)).toBe("one\none\ntwo\n");
});
+1
Переглянути файл
@@ -67,6 +67,7 @@
"@lezer/common": "^1.5.3",
"@lezer/highlight": "^1.2.5",
"@lezer/lr": "^1.4.11",
"@plutojl/lang-julia": "^1.2.0",
"@replit/codemirror-vim": "6.4.0",
"@tanstack/react-virtual": "^3.14.21",
"@tauri-apps/api": "^2",
+4 -1
Переглянути файл
@@ -1196,7 +1196,10 @@ The SDK's event enums are `#[non_exhaustive]`; match them with a `_` arm.
API 1.3 adds `host::subscribe_paths("file-opened", &["config/*.yaml"])`
(`events.subscribe-paths`). The host matches project-relative globs before
queueing an event or waking an idle plugin. `file-saved`, `document-changed`
and `files-changed` work the same way. For `files-changed`, each category is filtered and an empty batch
and `files-changed` work the same way. A `document-changed` path is relative to
its own project, which the event names in `project` (the root's absolute path):
two open projects can hold the same relative path, so key per-document state by
both. IDEs before this field omit it. For `files-changed`, each category is filtered and an empty batch
is omitted; replacing or pausing a filter also affects batches already queued.
Patterns use `/`, `*` stays within a directory, and `**` crosses
directories. Up to 64 patterns of 1024 bytes each are accepted; absolute paths,
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
3527a73b71c5cab6c694ccf27a60d621fd8cd5e5f238a4f36cb0fa2dd107209d
1f41ef42ab398d26e480532e226f7ac904dad06be140d0e4265bd9dd55effda8
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
61445c4d44cb6ea511bcc350259a8dd131a911ba2edd9a660870d420130df634
919dd2ca7fd59ce0e9faed6cebaf744cbf4a30d684cff2ed12a7e898bbaeae78
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
61f7cd994ea48fbc0e6df883ef8f380bec88dc7e650fda09c000a6d30b8a18c4
4b5517eee830ed31e891c8610e47d0e5008bb64d50a6cf2dbb5ba8cd46b7dac0
Loaded 100 of 215 files, more files were not shown because too many files have changed in this diff. Show more