Compare commits

...
Author SHA1 Message Date
l0ng-ai 115a436d80 fix(debugger): replace a finished Debug tab when a prepared start begins
A start that builds first (Maven/Gradle compile, classpath resolution) added its
tab right away but dropped finished sessions only once the adapter started, so
the previous run's terminated tab stayed next to the new one during the build.
2026-11-15 11:15:01 +08:00
l0ng-ai 74e66a5dae feat(plugins): environment and debugger for plugin run configurations (API 1.9) (#3476)
Plugin run configurations could not set environment variables, and Debug
only worked when a source file in the arguments let the IDE infer a
debugger, so a plugin could run `func start` for an Azure Functions app but
not debug the worker it starts.

API 1.9 adds the optional `launch-configurations` export, preferred over
`run-configurations` when a component has both. Each configuration can add
environment variables (only names the IDE's environment doesn't already
have, like `process` commands) and name a debugger: launch the program
under a language's debugger, or run it and attach to the first process of
an Attach to Process kind that the run starts. Only the run's own
descendants are candidates; the IDE waits up to a minute while the run
lasts and otherwise leaves it running without the debugger. Remote projects
resolve the process on the server.

The SDK gets `LaunchConfigurations` / `launch_configurations`, the README
and docs describe the export, and the bundled components and fixtures are
rebuilt for 1.9.
2026-11-15 11:01:12 +08:00
l0ng-ai 6c301a7b6b feat(run): fold the chooser's other configurations under All Configurations (#3473)
Once some configurations are pinned or recent (and there are five or more), the run configuration chooser folds the rest under a collapsed "All Configurations N" row, kept per project; a search still finds them. Each row gets a ⋮ button (→ on the keyboard) with Run, Debug, Edit…, Pin / Unpin and Delete. Current File now follows the configurations.

Closes #3074
2026-11-15 10:34:53 +08:00
l0ng-ai d171a946fe fix(editor): Spring, endpoint, npm, Docker and plugin gutter icons join the shared icon area (#3472)
Following #3452, the remaining line-marker kinds kept a gutter column each (a Spring controller showed its mapping icons in a second column beside the run icon). Scripts and Docker/Compose targets join the run icons in the shared icon area (hidden with them), Spring mappings and endpoints follow, then plugin line markers, gutter actions and indexed mappings (now 14px like the others). Presses go to the pressed icon's source.
2026-11-15 10:31:42 +08:00
l0ng-ai 6ae167efc9 test(lsp): wait for merged injection diagnostics instead of reading them at once (#3470)
The SQL server's launch fails with the test launcher and reports its status from a runtime thread; while that thread drains the server's event queue it delivers the diagnostics the test emits, so reading the sink straight after emitting could find no host event (24/200 failures alone). The test now waits for the expected host diagnostics at each step (0/300).
2026-11-15 09:53:29 +08:00
Deng Liuanddengliu 8432bf9997 feat(agents): add "Fit conversation to the window width" chat setting (#3455)
Settings › Agents › Chat › Conversation gets an opt-in toggle (agents.fitWindowWidth, off by default). When on, the conversation stream, composer, question card, user message bubbles and the New Task page drop their max-width caps and follow the pane width; when off, the readable 900 px column stays.

Co-authored-by: dengliu <[email protected]>
2026-11-15 09:50:13 +08:00
Deng Liuanddengliu 59fba1a65d refactor(agents): hide redundant Terminal actions for local project-root tasks (#3460)
A task running in the local checkout at the project root opens the same folder as the IDE's own terminal, so its status-bar Terminal button and task-menu Terminal entry are hidden there. Worktree tasks and imported sessions in another folder keep both.

Co-authored-by: dengliu <[email protected]>
2026-11-15 09:45:47 +08:00
Mr0Bread 3bfd3134c0 feat(agents): add a shortcut to cycle reasoning effort (#3454)
Cycle Agent Effort (Option+T / Alt+T in every built-in keymap) cycles the current model's advertised effort levels while focus is in New Task or a writable task conversation, through the existing config setter; the message, caret and focus are kept and Send stays available.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-15 08:59:01 +08:00
l0ng-ai 573adbf9ab fix(lsp): open dependency classes without sources decompiled by jdtls (#3469)
Go to declaration from Kotlin into a dependency class with no cached sources jar opened the Kotlin LSP's signature-only decompile output. When jdtls is running, the jar: location is resolved to the same class in jdtls' Java model (matching archive and package), decompiled with method bodies and navigable; the Kotlin output stays the fallback.

Refs #3447
2026-11-15 08:53:33 +08:00
Muuandmuutot d2381096fb fix(editor): re-render inheritance markers when files change (#3468)
A Python file added or removed invalidated the cached inheritance graph and markers, but nothing redrew the open documents, so a tooltip kept naming a deleted class. The file-change handler now refreshes the live marker plugins, as a settling server already did.

Co-authored-by: muutot <[email protected]>
2026-11-15 08:46:50 +08:00
Muuandmuutot 2c70c12bf2 fix(analysis): refresh Python inspections when their profile changes (#3466)
The inheritance inspections read the profile when they run, but only an edit, a file change or a settling server ran them, so turning one on or off in Settings looked inert until the file was touched. They now subscribe to profile changes, like the server diagnostics already do.

Co-authored-by: muutot <[email protected]>
2026-11-15 08:46:45 +08:00
l0ng-ai 3ef7fee3e2 fix(menu): keep New first in the File menu, with Untitled File inside it (#3467)
#3427 put New Untitled File above the New submenu, which broke the menu test
that the File menu starts with New (as in IntelliJ IDEA). It now sits in New
next to Scratch File, labelled Untitled File.
2026-11-15 08:45:04 +08:00
Sergei Melnikov deec6d05a0 fix(vcs): show the Push dialog's repositories, unpushed commits, files and diff as IntelliJ IDEA does (#3461)
Push… from one repository's branch menu lists only that repository, and a branch without upstream lists the commits no remote branch has instead of its last 50. Push all lists every repository (up-to-date ones greyed) and checks those with commits. Commits and changed files sit side by side at a fixed height, so selecting a row no longer resizes the dialog and swallows the first checkbox click; the commit details and file tree are split by a draggable divider, and a selected file's diff opens full-width below both panes with a close button and a draggable height.

Co-authored-by: pdasilem <[email protected]>
2026-11-15 08:42:50 +08:00
Muuandmuutot 4a98ce544b fix(editor): resolve an imported Python name to its declaration, not the import (#3462)
basedpyright and pyrefly analyse one root, so for a name declared in an attached dependency project they answer the file's own import statement. When the declaration request's only answer is an import line of this Python file, the name's from-import binding (aliases included) names the module; nav_resolve_module finds it, attached projects included, and the project index's declaration there becomes the target (or the module file when the index has none). A caret on the import itself keeps its existing answer.

Co-authored-by: muutot <[email protected]>
2026-11-15 08:30:14 +08:00
SunZhiQiang 396a8d4b26 feat(agents): temporary side conversations from a selection (#3411)
Selecting text in an agent conversation shows a toolbar with Reply (quotes it into the composer) and Start Side Conversation, which opens a temporary, read-only conversation beside the task. It carries the source conversation (newest first within a 100k-character budget, long tool outputs trimmed) as the context of its first message, stays out of the Agents list and the store, and is discarded with its context when its view closes. Its session is pushed to a mode that asks before changing things, and edit / delete / move / execute requests are denied; an agent without such a mode is refused.

Co-authored-by: panda-student <[email protected]>
2026-11-15 08:27:35 +08:00
l0ng-aiandpanda-student 2889b301b8 fix(ide-workspace): declare GetProcessTimes consistently (#3465)
process.rs and memory.rs declared the same kernel32 GetProcessTimes with different out-pointer types, which Windows clippy rejects (clashing_extern_declarations). Both now read the FILETIMEs as u64.

Co-authored-by: panda-student <[email protected]>
2026-11-15 08:24:15 +08:00
l0ng-ai e26e1d1d7d fix(themes): add the shell command token to the theme template and docs (#3464)
#3458 added --syn-shell-command without setting it in the Harbor Night
scheme (the template new themes start from) or regenerating plugins/themes.md,
so scripts/theme/theme.test.ts failed. Imported IntelliJ schemes map
BASH.EXTERNAL_COMMAND to it.
2026-11-15 08:23:20 +08:00
259 changed files with 4504 additions and 739 deletions

No files matched your search

+238 -31
View File
@@ -305,6 +305,11 @@ struct TaskState {
title_renamed: bool,
/// A turn is running or about to (prompts arriving now are queued).
busy: bool,
/// A temporary side conversation: lives in memory only, never persisted.
ephemeral: bool,
/// The conversation a temporary side conversation starts with, sent to the agent with
/// its first real message; the task's own entries hold only the questions.
ephemeral_context: Option<String>,
/// Background tasks the agent reported as running (`run_in_background` commands and
/// the like), as it sent them: unlike a turn they outlive it, so an idle release
/// waits for the last one. A (re)started process runs nothing yet.
@@ -424,8 +429,14 @@ impl AgentManager {
}
/// Routes events to `sink` (replacing the previous subscriber); returns every task.
/// Ephemeral tasks belonged to the previous page session: a fresh one starts without them.
pub fn subscribe(&self, sink: AgentSink) -> Vec<AgentTask> {
*self.shared.sink.write() = Some(sink);
let stale: Vec<Arc<Task>> = self.tasks.read().values().filter(|t| t.state.lock().ephemeral).cloned().collect();
for task in &stale {
self.drop_in_memory(task);
self.shared.emit(AgentEvent::Removed { id: task.id.clone() });
}
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().task.clone()).collect();
tasks.sort_by(|a, b| b.updated_ms.total_cmp(&a.updated_ms));
tasks
@@ -655,7 +666,7 @@ impl AgentManager {
retry: None,
background: Box::default(),
};
let file = TaskFile {
let handle = self.register(TaskFile {
task: task.clone(),
session_id: Some(session_id.to_owned()),
entries: Vec::new(),
@@ -665,9 +676,7 @@ impl AgentManager {
subagents: Vec::new(),
pending_rollback: 0,
title_renamed: true,
};
let handle = Task::restore(file, self.shared.clone());
self.tasks.write().insert(task.id.clone(), handle.clone());
});
handle.emit_task();
handle.persist();
Ok(task)
@@ -705,27 +714,8 @@ impl AgentManager {
(root, None, base, commit, before)
}
};
// Until the session reports its own, show what the agent offered last time with the choices applied.
let catalog = self.shared.paths.catalogs.cached(&self.shared, &spec.id);
let mut levels = catalog.thought_levels;
let mut config = self.shared.config_for_new_task(catalog.config, &spec.id);
for choice in &req.config {
if let Some(o) = config.iter_mut().find(|o| o.id == choice.id) {
o.current = Some(choice.value.clone());
}
}
if let Some(model) = model_of(&config)
&& let Some(levels) = levels.remove(&model)
{
config.extend(levels.into_iter().map(|mut o| {
if let Some(choice) =
req.config.iter().find(|c| c.id == o.id && o.values.iter().any(|v| v.value == c.value))
{
o.current = Some(choice.value.clone());
}
o
}));
}
// The session's settings: what the agent offered last time, with the choices applied.
let config = self.merged_config(&spec.id, &req.config);
let now = now_ms();
let id = uuid::Uuid::new_v4().simple().to_string();
// Copies of the files the user had changed already, for rolling back the task's changes to them.
@@ -766,7 +756,7 @@ impl AgentManager {
retry: None,
background: Box::default(),
};
let file = TaskFile {
let handle = self.register(TaskFile {
task: task.clone(),
session_id: None,
entries: Vec::new(),
@@ -776,16 +766,116 @@ impl AgentManager {
subagents: Vec::new(),
pending_rollback: 0,
title_renamed: false,
};
let handle = Task::restore(file, self.shared.clone());
});
handle.state.lock().busy = true;
self.tasks.write().insert(task.id.clone(), handle.clone());
handle.emit_task();
handle.persist();
self.shared.runtime.spawn(async move { handle.run(prompt).await });
Ok(task)
}
/// Builds the in-memory handle of a fresh task, registers it and announces it. The
/// caller decides what else its life starts with (a persisted file, a session, a run).
fn register(&self, file: TaskFile) -> Arc<Task> {
let handle = Task::restore(file, self.shared.clone());
self.tasks.write().insert(handle.id.clone(), handle.clone());
handle.emit_task();
handle
}
/// The session's settings: what the agent offered last time, with the request's
/// choices — and the chosen model's thought levels — applied.
fn merged_config(&self, provider: &str, req: &[AgentConfigChoice]) -> Vec<AgentConfigOption> {
let catalog = self.shared.paths.catalogs.cached(&self.shared, provider);
let mut levels = catalog.thought_levels;
let mut config = self.shared.config_for_new_task(catalog.config, provider);
for choice in req {
if let Some(o) = config.iter_mut().find(|o| o.id == choice.id) {
o.current = Some(choice.value.clone());
}
}
if let Some(model) = model_of(&config)
&& let Some(levels) = levels.remove(&model)
{
config.extend(levels.into_iter().map(|mut o| {
if let Some(choice) = req.iter().find(|c| c.id == o.id && o.values.iter().any(|v| v.value == c.value)) {
o.current = Some(choice.value.clone());
}
o
}));
}
config
}
/// Creates a temporary side conversation of `source`: an in-memory task that is never
/// persisted, whose session starts with its first real message (`prompt` only names
/// the title). `source`'s conversation rides along as the context of that message.
/// The task is read-only: its settings are pushed to a mode that asks before anything,
/// and requests that would change the project are denied regardless. Fails for an
/// agent that offers no way to ask.
pub async fn create_ephemeral(&self, req: NewAgentTask, source: &str) -> IdeResult<AgentTask> {
let spec = self
.shared
.spec(&req.provider)
.ok_or_else(|| IdeError::invalid(format!("unknown agent {}", req.provider)))?;
let prompt = clean(req.prompt).ok_or_else(|| IdeError::invalid("describe the topic first"))?;
let title = title_of(&prompt);
let mut config = self.merged_config(&spec.id, &req.config);
config::ask_for_approvals(&mut config);
if config::bypass_approvals(&config) {
return Err(IdeError::invalid(
"this agent has no mode that asks before changing things, so it can't run a side conversation",
));
}
let read_only = !config::bypass_approvals(&config);
let context = context_transcript(&self.task(source)?.state.lock().conversation.main.entries);
let root = self.shared.paths.project_root.clone();
let before = blocking(move || Ok(worktree::snapshot(&root).unwrap_or_default())).await?;
let now = now_ms();
let mut capabilities = self.shared.probes.lock().get(&spec.id).map(|p| p.capabilities).unwrap_or_default();
capabilities.read_only = read_only;
let task = AgentTask {
project_root: Some(IpcPath(self.shared.paths.project_root.clone())),
id: uuid::Uuid::new_v4().simple().to_string(),
title,
provider: spec.id.clone(),
model: model_of(&config),
status: AgentStatus::Ready,
isolation: Isolation::Local,
cwd: IpcPath(self.shared.paths.project_root.clone()),
branch: None,
base: None,
base_commit: None,
error: None,
created_ms: now,
updated_ms: now,
commands: self.shared.known_commands(&spec.id),
usage: None,
queue: Vec::new(),
capabilities,
resets_ms: None,
retry: None,
background: Box::default(),
config,
};
let handle = self.register(TaskFile {
task: task.clone(),
session_id: None,
entries: Vec::new(),
wanted: req.config,
before,
saved: None,
subagents: Vec::new(),
pending_rollback: 0,
title_renamed: false,
});
{
let mut s = handle.state.lock();
s.ephemeral = true;
s.ephemeral_context = Some(context);
}
Ok(task)
}
/// Sends a message. While the agent works it is queued, or with `now` the current turn
/// is cancelled and the message goes next.
pub async fn prompt(&self, id: &str, prompt: AgentPrompt, now: bool) -> IdeResult<()> {
@@ -1205,6 +1295,15 @@ impl AgentManager {
Ok(())
}
/// Removes a task from the manager's table and stops its agent. The disk (its file,
/// its worktree) is the caller's business.
fn drop_in_memory(&self, task: &Arc<Task>) {
task.kill();
self.tasks.write().remove(&task.id);
*task.deleted.lock() = true;
let _ = std::fs::remove_file(self.shared.paths.store_dir.join(format!("{}.json", task.id)));
}
/// Returns an archived task to the active list without starting the agent.
pub fn unarchive(&self, id: &str) -> IdeResult<()> {
let task = self.task(id)?;
@@ -1426,6 +1525,8 @@ impl Task {
pending_rollback: file.pending_rollback,
title_renamed: file.title_renamed,
busy: false,
ephemeral: false,
ephemeral_context: None,
background_tasks: Vec::new(),
}),
live: Mutex::new(None),
@@ -1527,6 +1628,9 @@ impl Task {
if *deleted {
return;
}
if self.state.lock().ephemeral {
return;
}
let bytes = {
let s = self.state.lock();
serde_json::to_vec(&TaskFile {
@@ -1757,7 +1861,20 @@ impl Task {
if !prompt.images.is_empty() && !live.capabilities.images {
return Err(Failure::from("This agent can't read images.".to_owned()));
}
let content = self.content(&live, prompt).await;
// A temporary side conversation's context rides with its first real message; the
// conversation itself records only the question (and whatever comes after).
let prompt = {
let context = self.state.lock().ephemeral_context.take();
match context {
Some(context) => {
let mut owned = prompt.clone();
owned.text = format!("{context}\n\n---\n\n{}", owned.text);
owned
}
None => prompt.clone(),
}
};
let content = self.content(&live, &prompt).await;
let result: Result<Value, RpcError> =
live.peer.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None).await;
match result {
@@ -2211,6 +2328,29 @@ impl Task {
.collect()
})
.unwrap_or_default();
// A side conversation is read-only: deny anything that would change the project
// (its task is deleted when its pane closes, leaving nothing to review or revert).
if self.state.lock().ephemeral
&& params
.pointer("/toolCall/kind")
.or_else(|| params.pointer("/subject/toolCall/kind"))
.and_then(Value::as_str)
.is_some_and(|kind| matches!(kind, "edit" | "delete" | "move" | "execute"))
{
let reject = options.iter().find(|o| o.kind.starts_with("reject")).cloned();
let _ = self.push_entry(AgentEntry::Permission {
id,
title,
command: None,
options,
questions: Vec::new(),
chosen: Some("Denied: side conversations are read-only".to_owned()),
});
return match reject {
Some(option) => json!({ "outcome": { "outcome": "selected", "optionId": option.id } }),
None => json!({ "outcome": { "outcome": "cancelled" } }),
};
}
let asked: Vec<String> = questions
.iter()
.map(|question| question.answer_key.clone().unwrap_or_else(|| question.question.clone()))
@@ -2408,6 +2548,72 @@ fn clean(mut prompt: AgentPrompt) -> Option<AgentPrompt> {
(!prompt.text.is_empty() || !prompt.images.is_empty() || !prompt.files.is_empty()).then_some(prompt)
}
/// The character budget of a side conversation's context: the newest entries win, the
/// oldest are dropped first. Leaves room for the question and the agent's answer.
const CONTEXT_BUDGET: usize = 100_000;
/// A long tool output trimmed to its first and last few lines, with the elided middle noted.
fn trimmed_output(output: &str) -> String {
const KEPT: usize = 4;
let lines: Vec<&str> = output.lines().collect();
if lines.len() <= KEPT * 2 + 1 {
return output.to_owned();
}
let omitted = lines.len() - KEPT * 2;
let mut out = lines[..KEPT].join("\n");
out.push_str(&format!("\n… {omitted} lines omitted …\n"));
out.push_str(&lines[lines.len() - KEPT..].join("\n"));
out
}
fn context_entry(e: &AgentEntry) -> Option<String> {
match e {
AgentEntry::User { text, .. } => Some(format!("User: {text}")),
AgentEntry::Agent { text, .. } if !text.trim().is_empty() => Some(format!("Agent: {text}")),
AgentEntry::Thought { text, .. } if !text.trim().is_empty() => Some(format!("Thought: {text}")),
AgentEntry::Tool { title, output, .. } => match output.as_deref() {
Some(output) if !output.trim().is_empty() => Some(format!("Tool: {title}\n{}", trimmed_output(output))),
_ => Some(format!("Tool: {title}")),
},
AgentEntry::Error { message, .. } => Some(format!("Error: {message}")),
_ => None,
}
}
/// The conversation as the context a temporary side conversation starts with: what was
/// said, what was done (tool calls with trimmed output), errors and the agent's reasoning,
/// oldest first, within [`CONTEXT_BUDGET`].
fn context_transcript(entries: &[AgentEntry]) -> String {
// Newest wins: walk back until the budget is spent, dropping the oldest entries first.
let mut lines: Vec<String> = Vec::new();
let mut used = 0usize;
for e in entries.iter().rev() {
let Some(line) = context_entry(e) else { continue };
if used + line.len() > CONTEXT_BUDGET {
if lines.is_empty() {
// Even the newest entry alone exceeds the budget: keep its head.
lines.push(line.chars().take(CONTEXT_BUDGET).collect());
}
break;
}
used += line.len();
lines.push(line);
}
lines.reverse();
let dropped = entries.iter().rev().filter_map(context_entry).count() - lines.len();
let mut context = String::from(
"You are answering a side question in a temporary conversation. The conversation so far is below, \
for context only; answer the new question after the marker, and do not continue the main task \
unless asked.\n\n<conversation>\n",
);
if dropped > 0 {
context.push_str(&format!("(The {dropped} oldest entries are omitted.)\n\n"));
}
context.push_str(&lines.join("\n\n"));
context.push_str("\n</conversation>");
context
}
fn permission_title(params: &Value) -> String {
let call = &params["toolCall"];
let title = call.get("title").and_then(Value::as_str).filter(|t| !t.is_empty());
@@ -2608,6 +2814,7 @@ fn capabilities_of(init: &acp::Negotiated) -> (AgentCapabilities, bool) {
rollback: meta("/openidea/rollback"),
steer: meta("/openidea/steer"),
background_tasks: meta("/openidea/backgroundTasks"),
read_only: false,
};
(capabilities, init.prompt("embeddedContext"))
}
+3
View File
@@ -36,6 +36,9 @@ pub struct AgentCapabilities {
pub steer: bool,
/// It reports its background tasks and stops them one by one.
pub background_tasks: bool,
/// The task runs read-only: it asks before anything, and requests that would change
/// the project are denied (a temporary side conversation).
pub read_only: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
+189
View File
@@ -3227,3 +3227,192 @@ async fn security_policy_never_auto_approves_a_request_that_only_reads_like_a_co
"{entries:?}"
);
}
/// A temporary side conversation is created ready, without starting its session and
/// without writing anything to the store; a fresh subscriber (a reloaded page) sweeps
/// it, and deleting it just drops it from memory.
#[tokio::test(flavor = "multi_thread")]
async fn ephemeral_tasks_stay_in_memory_only() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent.clone());
let source = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("hello"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &source.id, AgentStatus::NeedsInput).await;
let calls_before = agent.calls.lock().len();
let task = mgr
.create_ephemeral(
NewAgentTask {
project_root: None,
prompt: text("What changed in this file?"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
},
&source.id,
)
.await
.unwrap();
// Registering it starts nothing: the session waits for its first real message.
assert_eq!(agent.calls.lock().len(), calls_before);
assert_eq!(mgr.task(&task.id).unwrap().state.lock().task.status, AgentStatus::Ready);
assert!(!tmp.path().join("store").join(format!("{}.json", task.id)).exists());
// Its first message starts the session like any task's, and still saves nothing: the
// conversation records the question, not the context that rode along to the agent.
// The fake agent's turn asks to change something, which a side conversation denies by
// itself, so the turn ends without waiting for the user.
mgr.prompt(&task.id, text("Why?"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let entries = mgr.entries(&task.id, None).unwrap();
let question = entries.iter().find_map(|e| match e {
AgentEntry::User { text, .. } => Some(text.clone()),
_ => None,
});
assert_eq!(question.as_deref(), Some("Why?"));
assert!(
entries.iter().any(|e| matches!(e, AgentEntry::Permission { chosen: Some(c), .. } if c.contains("read-only"))),
"its `cargo test` request was denied: {entries:?}"
);
assert!(!tmp.path().join("store").join(format!("{}.json", task.id)).exists());
// A fresh subscriber (a reloaded page) sweeps it: it never reaches the task list.
let events: Arc<Mutex<Vec<AgentEvent>>> = Arc::new(Mutex::new(Vec::new()));
let sink_events = events.clone();
let tasks = mgr.subscribe(Arc::new(move |e| sink_events.lock().push(e)));
assert!(!tasks.iter().any(|t| t.id == task.id));
assert!(mgr.task(&task.id).is_err());
assert!(events.lock().iter().any(|e| matches!(e, AgentEvent::Removed { id } if *id == task.id)));
mgr.shutdown();
}
/// A side conversation's context stays within its budget: long tool outputs are cut to
/// their head and tail, and entries that no longer fit are dropped oldest first.
#[test]
fn side_conversation_context_is_bounded() {
let long_output = (0..400).map(|i| format!("line {i}")).collect::<Vec<_>>().join(
"
",
);
// Each reply alone is well inside the budget; together they are past it.
let reply = |n: usize| AgentEntry::Agent { text: format!("reply {n} {}", "x".repeat(30_000)) };
let entries = vec![
AgentEntry::User {
text: "oldest question".into(),
attachments: vec![],
images: vec![],
sent_ms: None,
done_ms: None,
steered: false,
},
reply(1),
reply(2),
reply(3),
reply(4),
AgentEntry::Tool {
id: "t1".into(),
title: "grep".into(),
kind: "search".into(),
status: AgentToolStatus::Completed,
locations: vec![],
output: Some(long_output),
diffs: vec![],
},
AgentEntry::User {
text: "newest question".into(),
attachments: vec![],
images: vec![],
sent_ms: None,
done_ms: None,
steered: false,
},
];
let transcript = context_transcript(&entries);
assert!(transcript.contains("newest question"), "the newest entry is always kept");
assert!(transcript.contains("lines omitted"), "a long tool output is trimmed");
assert!(transcript.contains("line 0") && transcript.contains("line 399"), "its head and tail stay");
assert!(!transcript.contains("oldest question"), "entries past the budget are dropped oldest first");
assert!(transcript.contains("oldest entries are omitted"));
}
/// An ephemeral task denies a permission request that would change the project.
#[tokio::test(flavor = "multi_thread")]
async fn ephemeral_tasks_deny_write_permissions() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent.clone());
let source = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("Something with a conversation to reuse"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &source.id, AgentStatus::NeedsInput).await;
let pending = mgr
.entries(&source.id, None)
.unwrap()
.iter()
.find_map(|e| match e {
AgentEntry::Permission { id, chosen: None, .. } => Some(*id),
_ => None,
})
.unwrap_or_else(|| panic!("no pending permission request"));
mgr.respond(&source.id, pending, Some("no".into())).unwrap();
wait_for(&mgr, &source.id, AgentStatus::Ready).await;
let task = mgr
.create_ephemeral(
NewAgentTask {
project_root: None,
prompt: text("What changed in this file?"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
},
&source.id,
)
.await
.unwrap();
assert!(mgr.task(&task.id).unwrap().state.lock().task.capabilities.read_only);
let answer = mgr
.task(&task.id)
.unwrap()
.ask_permission(&json!({
"sessionId": "c1",
"toolCall": {"toolCallId": "c1-t2", "title": "Edit main.rs", "kind": "edit"},
"options": [
{"optionId": "yes", "name": "Allow", "kind": "allow_once"},
{"optionId": "no", "name": "Reject", "kind": "reject_once"}
]
}))
.pointer("/outcome/optionId")
.and_then(Value::as_str)
.unwrap_or("none")
.to_owned();
assert_eq!(answer, "no", "the write request is denied");
let entries = mgr.entries(&task.id, None).unwrap();
assert!(
entries
.iter()
.any(|e| matches!(e, AgentEntry::Permission { chosen: Some(chosen), .. } if chosen.contains("read-only"))),
"{entries:?}"
);
mgr.shutdown();
}
+24
View File
@@ -141,6 +141,30 @@ pub fn process_tree(pid: i32) -> Vec<i32> {
tree
}
/// Every process `pid` started, directly or not, parents before their children.
pub fn descendants(pid: u32) -> Vec<u32> {
#[cfg(unix)]
{
let Ok(root) = i32::try_from(pid) else { return Vec::new() };
process_tree(root).into_iter().skip(1).filter_map(|p| u32::try_from(p).ok()).collect()
}
#[cfg(windows)]
{
use std::os::windows::io::AsRawHandle;
windows_tree::descendants(pid)
.iter()
// SAFETY: a live process handle opened with query access.
.map(|h| unsafe { windows_sys::Win32::System::Threading::GetProcessId(h.as_raw_handle()) })
.filter(|&p| p != 0)
.collect()
}
#[cfg(not(any(unix, windows)))]
{
let _ = pid;
Vec::new()
}
}
/// [`kill_tree`] that first asks the group to exit: `SIGTERM`, then `grace`, then `SIGKILL`.
/// Git removes its `index.lock` on `SIGTERM`, where `SIGKILL` leaves it behind and the next
/// git command fails. Windows has no such signal to send from outside the child's console,
+7
View File
@@ -86,6 +86,8 @@ pub struct AgentSettings {
pub fold_turns: bool,
/// Streaming text is revealed at a steady pace rather than chunk by chunk.
pub smooth_text: bool,
/// Conversations and the composer expand to the full width of the pane instead of staying in a centred column.
pub fit_window_width: bool,
#[serde(deserialize_with = "or_default")]
#[specta(type = ThinkingDisplay)]
pub thinking: ThinkingDisplay,
@@ -127,6 +129,7 @@ impl Default for AgentSettings {
show_cost: false,
fold_turns: true,
smooth_text: true,
fit_window_width: false,
thinking: ThinkingDisplay::Auto,
tool_calls: ToolCallDisplay::Grouped,
expand_tool_output: false,
@@ -1715,11 +1718,15 @@ mod tests {
let old: Settings = serde_json::from_str(r#"{"agents":{"showCost":true}}"#).unwrap();
assert!(old.agents.show_cost);
assert!(old.agents.show_context_usage && old.agents.show_work_time && old.agents.show_usage_limits);
assert!(!old.agents.fit_window_width);
assert!(!Settings::default().agents.show_cost);
assert!(!Settings::default().agents.fit_window_width);
let mut settings = Settings::default();
settings.agents.show_usage_limits = false;
settings.agents.fit_window_width = true;
let json = serde_json::to_value(&settings).unwrap();
assert_eq!(json["agents"]["showUsageLimits"], false);
assert_eq!(json["agents"]["fitWindowWidth"], true);
let restored: Settings = serde_json::from_value(json).unwrap();
assert_eq!(restored.agents, settings.agents);
}
+40
View File
@@ -405,6 +405,24 @@ pub fn attachable_processes() -> IdeResult<Vec<AttachableProcess>> {
Ok(out)
}
/// The Attach to Process candidates among the processes `root` started, parents first.
/// Blocking, like [`attachable_processes`].
pub fn attachable_descendants(root: u32) -> IdeResult<Vec<AttachableProcess>> {
let order = ide_core::process::descendants(root);
if order.is_empty() {
return Ok(Vec::new());
}
let cwd = std::env::temp_dir();
let native = if adapter::resolve_binary("codelldb", &cwd).is_some() { "codelldb" } else { "lldb-dap" };
let mut out: Vec<AttachableProcess> = list_processes()?
.iter()
.filter(|p| order.contains(&p.pid))
.filter_map(|p| classify(p, is_dotnet, is_go_binary, native))
.collect();
out.sort_by_key(|p| order.iter().position(|&pid| pid == p.pid));
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
@@ -418,6 +436,28 @@ mod tests {
.map(|p| (p.kind, p.port))
}
#[cfg(unix)]
#[test]
fn a_runs_candidates_are_the_processes_it_started() {
let mut child = std::process::Command::new("sh").args(["-c", "sleep 30; true"]).spawn().unwrap();
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
let found = loop {
let found = attachable_descendants(child.id()).unwrap();
if !found.is_empty() || std::time::Instant::now() > deadline {
break found;
}
std::thread::sleep(std::time::Duration::from_millis(50));
};
for p in &found {
let _ = std::process::Command::new("kill").arg(p.pid.to_string()).status();
}
child.kill().unwrap();
child.wait().unwrap();
assert!(found.iter().all(|p| p.pid != child.id()), "{found:?}");
assert!(found.iter().any(|p| p.name == "sleep" && p.kind == AttachKind::Native), "{found:?}");
assert!(attachable_descendants(u32::MAX - 1).unwrap().is_empty());
}
#[test]
fn parses_jdwp_agents() {
let a = "java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005 -jar app.jar";
+1 -1
View File
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
pub const MANIFEST_FILE: &str = "plugin.toml";
/// The plugin API (engine) version this host implements.
pub const ENGINE_VERSION: &str = "1.8.0";
pub const ENGINE_VERSION: &str = "1.9.0";
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
pub const LEGACY_API: &str = "0.1";
/// Marketplace categories, in the order they are shown.
+12
View File
@@ -261,6 +261,18 @@ pub async fn fork(host: &Host, window: &str, task: String, turns: Option<u32>) -
host.project(window)?.agents.fork(&task, turns).await
}
/// Creates a temporary side conversation of `source`: lives in memory only, never
/// persisted, not listed.
pub async fn create_ephemeral(
host: &Host,
window: &str,
request: NewAgentTask,
source: String,
) -> IdeResult<AgentTask> {
host.require_trust(window)?;
host.project(window)?.agents.create_ephemeral(request, &source).await
}
/// Drops the task's turns after its first `turns`; returns the message of the first dropped one.
pub async fn rollback(host: &Host, window: &str, task: String, turns: u32) -> IdeResult<Option<AgentPrompt>> {
host.require_trust(window)?;
+10 -1
View File
@@ -3047,7 +3047,16 @@ impl PluginWorkspace for HostWorkspace {
&project.root,
&project.settings.effective(),
);
if config.debug_adapter.is_none() {
if config.debug_adapter.is_none()
&& let Some(language) = config.extras.params.get(super::run_detectors::DEBUG_LANGUAGE)
{
config.debug_adapter = project
.languages
.get(&ide_core::LanguageId::new(language.as_str()))
.and_then(|l| l.debugger)
.map(|d| d.adapter);
}
if config.debug_adapter.is_none() && !config.extras.params.contains_key(super::run_detectors::DEBUG_ATTACH) {
let cwd = config.cwd.as_ref().map(|p| p.as_ref()).unwrap_or(&project.root);
config.debug_adapter =
config.args.iter().map(|arg| cwd.join(arg)).filter(|path| path.is_file()).find_map(|path| {
+155
View File
@@ -415,6 +415,67 @@ fn validate_configurations(
if let Some(cwd) = &c.cwd {
ide_plugin::resolve_new_in_root(root, cwd).map_err(HostError::Invalid)?;
}
validate_env(&c.env)?;
validate_debugger(c.debugger.as_ref())?;
}
Ok(())
}
/// Like `process` commands, a configuration only adds variables: one the IDE's own
/// environment has (`PATH`, …) would change what the approved program runs.
fn validate_env(env: &[(String, String)]) -> Result<(), HostError> {
if env.len() > 64 {
return Err(HostError::Invalid("at most 64 environment variables".into()));
}
let mut names = std::collections::BTreeSet::new();
for (name, value) in env {
if name.is_empty() || name.len() > 256 || name.contains(['=', '\0']) {
return Err(HostError::Invalid(format!("{name:?} is not an environment variable name")));
}
if value.len() > 4096 || value.contains('\0') {
return Err(HostError::Invalid(format!("the value of {name:?} is too long or holds a NUL")));
}
let key = if cfg!(windows) { name.to_ascii_uppercase() } else { name.clone() };
if !names.insert(key) || inherited_env(name) {
return Err(HostError::Invalid(format!(
"environment variable {name:?} is repeated or already set; only new variables may be added"
)));
}
}
Ok(())
}
fn inherited_env(name: &str) -> bool {
std::env::vars_os().any(|(inherited, _)| {
if cfg!(windows) { inherited.to_string_lossy().eq_ignore_ascii_case(name) } else { inherited == name }
})
}
/// Attach to Process kinds a configuration may attach to.
pub(super) const ATTACH_KINDS: [&str; 5] = ["dotnet", "node", "python", "go", "native"];
fn validate_debugger(debugger: Option<&ide_plugin::PluginDebugger>) -> Result<(), HostError> {
match debugger {
Some(ide_plugin::PluginDebugger::Launch { language }) => {
if language.is_empty()
|| language.len() > 64
|| !language.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '.'))
{
return Err(HostError::Invalid(format!("{language:?} is not a language id")));
}
}
Some(ide_plugin::PluginDebugger::AttachChild { kind, command_contains }) => {
if !ATTACH_KINDS.contains(&kind.as_str()) {
return Err(HostError::Invalid(format!(
"attach-child kind {kind:?} is not one of {}",
ATTACH_KINDS.join(", ")
)));
}
if command_contains.as_ref().is_some_and(|t| t.is_empty() || t.len() > 256 || t.contains('\0')) {
return Err(HostError::Invalid("attach-child command-contains must be 1-256 bytes".into()));
}
}
None => {}
}
Ok(())
}
@@ -531,6 +592,52 @@ impl PluginHost {
}
}
impl PluginHost {
/// The process an `attach-child` configuration's debugger attaches to: the first Attach to
/// Process candidate of its kind that `run` (a run of this configuration) started, waited
/// for while the run lasts, up to a minute. Only the run's own descendants are candidates.
pub fn debug_attach_target(
&self,
host: &crate::Host,
client: &str,
config: &str,
run: ide_core::RunId,
) -> IdeResult<ide_dap::attach::AttachableProcess> {
use super::run_detectors::{DEBUG_ATTACH, DEBUG_ATTACH_CONTAINS};
let Some((plugin, id)) = config.strip_prefix(ide_run::EXTERNAL_PREFIX).and_then(|s| s.split_once(':')) else {
return Err(IdeError::invalid("not a plugin configuration"));
};
let workspace = self.shared.workspace().ok_or_else(IdeError::cancelled)?;
let owned = workspace.run_configuration(client, plugin, id).map_err(|e| IdeError::invalid(e.to_string()))?;
let kind = owned
.extras
.params
.get(DEBUG_ATTACH)
.filter(|k| ATTACH_KINDS.contains(&k.as_str()))
.ok_or_else(|| IdeError::invalid("this configuration does not attach to a process"))?
.clone();
let contains = owned.extras.params.get(DEBUG_ATTACH_CONTAINS).cloned();
let deadline = Instant::now() + Duration::from_secs(60);
loop {
let info = crate::ops::run::list(host).into_iter().find(|r| r.id == run && r.config_id == owned.id);
let Some(pid) = info.as_ref().filter(|r| r.running).and_then(|r| r.pid) else {
return Err(IdeError::not_found("the run ended before a process to debug started"));
};
let found = ide_dap::attach::attachable_descendants(pid)?.into_iter().find(|p| {
serde_json::to_value(p.kind).ok().and_then(|v| v.as_str().map(|k| k == kind)) == Some(true)
&& contains.as_ref().is_none_or(|t| p.command_line.contains(t.as_str()))
});
if let Some(process) = found {
return Ok(process);
}
if Instant::now() >= deadline {
return Err(IdeError::not_found(format!("no {kind} process started by the run within a minute")));
}
std::thread::sleep(Duration::from_millis(500));
}
}
}
/// Internal launch metadata; it is ignored after the original operation finishes.
pub(super) const RUN_OPERATION: &str = "plugin.operation";
impl PluginHost {
@@ -605,4 +712,52 @@ mod tests {
matches!(validate_diff(&diff("a\0".into(), String::new())), Err(HostError::Invalid(m)) if m.contains("NUL"))
);
}
fn launch(
env: Vec<(&str, &str)>,
debugger: Option<ide_plugin::PluginDebugger>,
) -> ide_plugin::PluginRunConfiguration {
ide_plugin::PluginRunConfiguration {
id: "app".into(),
name: "App".into(),
program: "tool".into(),
env: env.into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
debugger,
..Default::default()
}
}
#[test]
fn configurations_only_add_environment_variables() {
let root = std::env::temp_dir();
let ok = |c| validate_configurations(&root, &[c]).is_ok();
assert!(ok(launch(vec![("OPENIDEA_TEST_NEW_VARIABLE", "1")], None)));
let (inherited, _) = std::env::vars().next().expect("the test runs with an environment");
assert!(!ok(launch(vec![(inherited.as_str(), "x")], None)));
assert!(!ok(launch(vec![("A_B", "1"), ("A_B", "2")], None)));
for name in ["", "A=B", "A\0"] {
assert!(!ok(launch(vec![(name, "1")], None)), "{name:?}");
}
assert!(!ok(launch(vec![("OPENIDEA_TEST_NUL", "a\0")], None)));
let many: Vec<_> = (0..65).map(|i| (format!("OPENIDEA_TEST_{i}"), String::new())).collect();
let mut config = launch(vec![], None);
config.env = many;
assert!(!ok(config));
}
#[test]
fn configurations_name_a_language_or_an_attach_to_process_kind() {
use ide_plugin::PluginDebugger::{AttachChild, Launch};
let root = std::env::temp_dir();
let ok = |d| validate_configurations(&root, &[launch(vec![], Some(d))]).is_ok();
assert!(ok(Launch { language: "csharp".into() }));
assert!(!ok(Launch { language: String::new() }));
assert!(!ok(Launch { language: "c sharp".into() }));
for kind in ATTACH_KINDS {
assert!(ok(AttachChild { kind: kind.into(), command_contains: None }), "{kind}");
}
assert!(!ok(AttachChild { kind: "java".into(), command_contains: None }));
assert!(ok(AttachChild { kind: "dotnet".into(), command_contains: Some("Worker.dll".into()) }));
assert!(!ok(AttachChild { kind: "dotnet".into(), command_contains: Some(String::new()) }));
}
}
@@ -57,6 +57,7 @@ pub const COMMANDS: &[&str] = &[
"plugin_terminal_session_close",
"plugin_terminal_session_spawn",
"plugin_prepare_debug_run",
"plugin_debug_attach_target",
"plugin_finish_operation",
"plugin_content_tab_action",
"plugin_post_events",
@@ -572,6 +573,15 @@ impl RemotePlugins {
}
});
let h = host.clone();
d.add("plugin_debug_attach_target", move |c| {
let h = h.clone();
async move {
let plugins = alive(&h)?;
let (config, run) = (c.arg::<String>("config")?, c.arg("run")?);
blocking(move || plugins.debug_attach_target(&c.host, &c.window, &config, run)).await
}
});
let h = host.clone();
d.add("plugin_finish_operation", move |c| {
let h = h.clone();
async move {
@@ -130,6 +130,11 @@ pub struct PluginRunDetection {
pub(crate) project_pins: super::api::ProjectPins,
}
/// `RunConfig.extras.params` keys carrying an API 1.9 configuration's debugger.
pub const DEBUG_LANGUAGE: &str = "debugLanguage";
pub const DEBUG_ATTACH: &str = "debugAttach";
pub const DEBUG_ATTACH_CONTAINS: &str = "debugAttachContains";
pub(super) fn config_id(plugin: &str, detector: &str) -> String {
format!("{EXTERNAL_PREFIX}{plugin}:{detector}")
}
@@ -195,6 +200,19 @@ impl ExternalDetection for PluginRunDetection {
if let Some(framework) = &c.framework {
config.extras.params.insert("framework".into(), framework.clone());
}
config.env = c.env.iter().cloned().collect();
match &c.debugger {
Some(ide_plugin::PluginDebugger::Launch { language }) => {
config.extras.params.insert(DEBUG_LANGUAGE.into(), language.clone());
}
Some(ide_plugin::PluginDebugger::AttachChild { kind, command_contains }) => {
config.extras.params.insert(DEBUG_ATTACH.into(), kind.clone());
if let Some(text) = command_contains {
config.extras.params.insert(DEBUG_ATTACH_CONTAINS.into(), text.clone());
}
}
None => {}
}
configs.push(config);
}
}
+7 -1
View File
@@ -6450,7 +6450,13 @@ fn api14_stage3_configurations_test_results_and_content_actions_use_real_exports
let configs = f.host.run_detection().detect(&f.project);
assert!(configs.iter().any(|c| c.id == "plugin:execution:dynamic"
&& c.is_test
&& c.extras.params.get("framework").map(String::as_str) == Some("plugin")));
&& c.extras.params.get("framework").map(String::as_str) == Some("plugin")
&& c.env.get("OPENIDEA_EXECUTION_FIXTURE").map(String::as_str) == Some("1")
&& c.extras.params.get("debugLanguage").map(String::as_str) == Some("python")));
let worker = configs.iter().find(|c| c.id == "plugin:execution:worker").unwrap();
assert_eq!(worker.extras.params.get("debugAttach").map(String::as_str), Some("dotnet"));
assert_eq!(worker.extras.params.get("debugAttachContains").map(String::as_str), Some("Worker.dll"));
assert!(worker.env.is_empty() && !worker.is_test);
assert_eq!(
f.host.parse_test_results("main", "plugin:execution:dynamic", "batch".into()).unwrap().unwrap().len(),
3
+18 -16
View File
@@ -715,33 +715,35 @@ mod tests {
server.set_diagnostics(a.path.clone(), vec![diag(2, 5, "a"), diag(0, 1, "outside"), diag(4, 6, "crosses")]);
let items = server.set_diagnostics(b.path.clone(), vec![diag(7, 10, "b")]);
mgr.emit_diagnostics(&server, b.path, items, Encoding::Utf16);
let latest = || {
events
.lock()
.iter()
.rev()
.find_map(|e| match e {
// The SQL server's failed launch reports its status from a runtime thread; while that
// thread drains the server's event queue, events emitted here reach the sink from it.
let latest = |want: &dyn Fn(&[ide_core::Diagnostic]) -> bool| {
let deadline = std::time::Instant::now() + Duration::from_secs(5);
loop {
let items = events.lock().iter().rev().find_map(|e| match e {
ide_core::IdeEvent::Diagnostics { path: p, source, items }
if p.0 == path && source == &server.name =>
{
Some(items.clone())
}
_ => None,
})
.unwrap()
});
match items {
Some(items) if want(&items) => return items,
_ if std::time::Instant::now() > deadline => panic!("latest host diagnostics: {items:?}"),
_ => std::thread::sleep(Duration::from_millis(5)),
}
}
};
assert_eq!(latest().iter().map(|d| d.message.as_str()).collect::<Vec<_>>().len(), 3);
let messages = |items: &[ide_core::Diagnostic]| items.iter().map(|d| d.message.clone()).collect::<Vec<_>>();
let merged = latest(&|items| items.len() == 3);
assert!(
latest()
.iter()
.filter(|d| d.message != "native")
.all(|d| d.source.as_deref() == Some(server.name.as_str()))
merged.iter().filter(|d| d.message != "native").all(|d| d.source.as_deref() == Some(server.name.as_str()))
);
mgr.set_injections(host, 1, vec![injection(7, 10)]);
assert_eq!(latest().iter().map(|d| d.message.clone()).collect::<Vec<_>>(), ["native", "b"]);
latest(&|items| messages(items) == ["native", "b"]);
mgr.set_injections(host, 1, vec![]);
assert_eq!(latest()[0].message, "native");
assert_eq!(latest().len(), 1);
latest(&|items| messages(items) == ["native"]);
assert!(
events.lock().iter().all(|e| !matches!(e, ide_core::IdeEvent::Diagnostics { path, .. } if reserved(path)))
);
+33
View File
@@ -1767,6 +1767,38 @@ impl LspManager {
}
}
/// Library classes in `jar:` targets that have no cached sources jar: the official Kotlin
/// LSP decompiles them to signatures only (`/* compiled code */`). When jdtls is running,
/// the same class from its Java model instead, decompiled with method bodies and navigable.
/// Its documents belong to jdtls ([`Self::virtual_document`] records it).
async fn jdt_library_classes(&self, snap: &DocSnap, pos: Pos, locs: Vec<Location>) -> Vec<Location> {
let jar_class = |l: &Location| l.uri.as_deref().is_some_and(|u| u.starts_with("jar:") && u.ends_with(".class"));
if !locs.iter().any(jar_class)
|| !self.servers.lock().iter().any(|s| s.name == jdtls::SERVER && s.running().is_some())
{
return locs;
}
let name = library_source::identifier_at(snap.text.line(pos.line as usize), pos.col).map(str::to_owned);
let mut out = Vec::with_capacity(locs.len());
for loc in locs {
let entry = loc.uri.as_deref().filter(|_| jar_class(&loc)).and_then(library_source::parse);
let Some(entry) = entry else {
out.push(loc);
continue;
};
let Ok(uri) = self.java_class_file(Path::new(""), Some((entry.jar, entry.entry))).await else {
out.push(loc);
continue;
};
let range = match (&name, self.virtual_document(&uri).await) {
(Some(name), Ok(doc)) => library_source::declaration_range(&doc.text, name),
_ => Range::default(),
};
out.push(Location { path: uri.clone().into(), range, uri: Some(uri) });
}
out
}
async fn goto_in(
&self,
snap: &DocSnap,
@@ -1808,6 +1840,7 @@ impl LspManager {
let locs = library_sources(snap, &self.project_root, pos, locs).await;
self.note_virtual(&t.server, locs.iter().map(|l| l.uri.as_deref()));
self.note_arduino_sources(&t.server, &locs);
let locs = self.jdt_library_classes(snap, pos, locs).await;
let locs = merge_locations(first, locs);
if !locs.is_empty() {
return Ok(locs);
+96 -28
View File
@@ -296,37 +296,48 @@ fn harness_configured(
servers: &[(&str, Value)],
adjust: impl Fn(&mut LanguageServerConfig),
) -> Harness {
harness_languages(&[(lang_id, ext, servers)], adjust)
}
/// A language as `(id, extension, servers)`.
type MockLanguage<'a> = (&'a str, &'a str, &'a [(&'a str, Value)]);
/// Several languages; documents open as the first.
fn harness_languages(languages: &[MockLanguage<'_>], adjust: impl Fn(&mut LanguageServerConfig)) -> Harness {
let dir = tempfile::tempdir().unwrap();
// Edits and references report canonical paths.
let root = dunce::canonicalize(dir.path()).unwrap();
let lang = LanguageConfig {
id: LanguageId::new(lang_id),
name: "Mock".into(),
extensions: vec![ext.into()],
filenames: vec![],
first_line: None,
line_comment: None,
block_comment: None,
indent: None,
ui_mode: None,
framework_ui_modes: Vec::new(),
framework_files: Vec::new(),
formatter: None,
scratch_template: None,
tree_sitter: None,
language_servers: servers
.iter()
.map(|(n, _)| {
let mut cfg = server_cfg(n);
adjust(&mut cfg);
cfg
})
.collect(),
debugger: None,
};
let registry = Arc::new(LanguageRegistry::from_configs(vec![lang]));
let configs = languages
.iter()
.map(|(lang_id, ext, servers)| LanguageConfig {
id: LanguageId::new(*lang_id),
name: "Mock".into(),
extensions: vec![ext.to_string()],
filenames: vec![],
first_line: None,
line_comment: None,
block_comment: None,
indent: None,
ui_mode: None,
framework_ui_modes: Vec::new(),
framework_files: Vec::new(),
formatter: None,
scratch_template: None,
tree_sitter: None,
language_servers: servers
.iter()
.map(|(n, _)| {
let mut cfg = server_cfg(n);
adjust(&mut cfg);
cfg
})
.collect(),
debugger: None,
})
.collect();
let registry = Arc::new(LanguageRegistry::from_configs(configs));
let launcher = Arc::new(MockLauncher::default());
for (name, caps) in servers {
for (name, caps) in languages.iter().flat_map(|(_, _, servers)| servers.iter()) {
*launcher.state(name).caps.lock() = caps.clone();
}
let events = Arc::new(Mutex::new(Vec::new()));
@@ -335,7 +346,7 @@ fn harness_configured(
Arc::new(move |e: IdeEvent| events.lock().push(e))
};
let mgr = LspManager::with_launcher(root.clone(), registry, sink, launcher.clone());
Harness { _dir: dir, root, mgr, launcher, events, lang: LanguageId::new(lang_id) }
Harness { _dir: dir, root, mgr, launcher, events, lang: LanguageId::new(languages[0].0) }
}
impl Harness {
@@ -2946,6 +2957,63 @@ async fn library_classes_in_jars_open_as_their_source_or_decompiled() {
assert_eq!(asked[0], json!({ "command": "decompile", "arguments": [thing] }));
}
#[tokio::test(flavor = "multi_thread")]
async fn library_classes_without_sources_open_decompiled_by_a_running_jdtls() {
use std::io::Write;
let repo = tempfile::tempdir().unwrap();
let jar = dunce::canonicalize(repo.path()).unwrap().join("acme/lib/1.0/lib-1.0.jar");
std::fs::create_dir_all(jar.parent().unwrap()).unwrap();
let mut zip = zip::ZipWriter::new(std::fs::File::create(&jar).unwrap());
zip.start_file("acme/Thing.class", zip::write::SimpleFileOptions::default()).unwrap();
zip.write_all(b"\0").unwrap();
zip.finish().unwrap();
let class = format!("jar://{}!/acme/Thing.class", uri_of(&jar).trim_start_matches("file://"));
let escaped = jar.to_string_lossy().replace('/', "%5C/");
let jdt = format!("jdt://contents/lib-1.0.jar/acme/Thing.class?=app/{escaped}%3Cacme%28Thing.class");
let decompiled =
"package acme;\n\npublic class Thing {\n public void run() {\n System.out.println();\n }\n}\n";
let mut kotlin = incremental_caps();
kotlin["executeCommandProvider"] = json!({ "commands": ["decompile"] });
let mut java = incremental_caps();
java["workspaceSymbolProvider"] = json!(true);
let h =
harness_languages(&[("kotlin", "kt", &[("kotlin-lsp", kotlin)]), ("java", "java", &[("jdtls", java)])], |_| {});
let (doc, _) = h.open("Main.kt", "val thing = Thing()\n");
h.wait_status("kotlin-lsp", ServerStatus::Ready).await;
let k = h.launcher.state("kotlin-lsp");
k.respond(
"textDocument/definition",
json!({ "uri": class, "range": {"start":{"line":0,"character":6},"end":{"line":0,"character":11}} }),
);
let r = json!({"start":{"line":2,"character":13},"end":{"line":2,"character":18}});
// jdtls not running: the Kotlin server's own target and decompiler.
let defs = h.mgr.goto(doc, Pos::new(0, 14), GotoKind::Definition).await.unwrap();
assert_eq!(defs[0].uri.as_deref(), Some(class.as_str()));
let path = h.root.join("Sample.java");
std::fs::write(&path, "class Sample {}").unwrap();
h.mgr.did_open(DocId::next(), &path, &LanguageId::new("java"), 1, "class Sample {}");
h.wait_status("jdtls", ServerStatus::Ready).await;
let j = h.launcher.state("jdtls");
j.respond(
"workspace/symbol",
json!([{ "name": "Thing", "kind": 5, "containerName": "acme", "location": { "uri": jdt, "range": r } }]),
);
j.respond("java/classFileContents", json!(decompiled));
let defs = h.mgr.goto(doc, Pos::new(0, 14), GotoKind::Definition).await.unwrap();
assert_eq!(
defs,
vec![ide_core::Location { path: jdt.clone().into(), range: rng(2, 13, 2, 18), uri: Some(jdt.clone()) }]
);
assert_eq!(j.requested("workspace/symbol")[0]["query"], "acme.Thing");
let vd = h.mgr.virtual_document(&jdt).await.unwrap();
assert_eq!(vd.text, decompiled);
assert!(k.requested("workspace/executeCommand").is_empty(), "the Kotlin stub is not asked for");
}
#[tokio::test(flavor = "multi_thread")]
async fn alternative_java_server_uses_lsp_without_jdt_commands() {
let h = harness_for("java", "java", &[("kmp-lsp", incremental_caps())], &[]);
+18
View File
@@ -61,6 +61,24 @@ pub struct PluginRunConfiguration {
pub cwd: Option<String>,
pub test: bool,
pub framework: Option<String>,
/// API 1.9: variables added to the run's environment.
#[serde(default)]
pub env: Vec<(String, String)>,
/// API 1.9: how Debug starts the configuration.
#[serde(default)]
pub debugger: Option<PluginDebugger>,
}
/// How Debug starts a plugin configuration (API 1.9 `launch-configurations.debugger`).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", tag = "type")]
pub enum PluginDebugger {
/// `program` under the debugger of this language id.
#[serde(rename_all = "camelCase")]
Launch { language: String },
/// Run, then attach to the first matching process the run starts.
#[serde(rename_all = "camelCase")]
AttachChild { kind: String, command_contains: Option<String> },
}
/// RunExited data exchanged with the IDE.
+62 -23
View File
@@ -36,6 +36,7 @@ use wasmtime::{Config, Engine, Store, StoreLimits, StoreLimitsBuilder, UpdateDea
use wasmtime_wasi::p2::pipe::MemoryOutputPipe;
use wasmtime_wasi::{WasiCtx, WasiCtxView, WasiView};
use crate::wit_host::launch_configurations_bindings::exports::openidea::plugin::launch_configurations as wit_launch;
use crate::wit_host::run_configurations_bindings::exports::openidea::plugin::run_configurations as wit_configs;
use crate::wit_host::test_results_bindings::exports::openidea::plugin::test_results as wit_tests;
use bindings::openidea::plugin::events as wit_events;
@@ -55,7 +56,7 @@ use views_bindings::exports::openidea::plugin::view_provider as wit_view;
use views_bindings::openidea::plugin::view_types as wit_vt;
/// The API version of the world above, `major.minor` of [`host_api`].
pub const API_VERSION: &str = "1.8";
pub const API_VERSION: &str = "1.9";
const EPOCH_TICK: Duration = Duration::from_millis(10);
pub(crate) const MAX_TEXT: usize = 1 << 20;
pub(crate) const MAX_TITLE: usize = 256;
@@ -1008,6 +1009,7 @@ struct Exports {
inlay: Option<wit_inlay::Guest>,
endpoints: Option<wit_endpoints::Guest>,
run_configurations: Option<wit_configs::Guest>,
launch_configurations: Option<wit_launch::Guest>,
test_results: Option<wit_tests::Guest>,
mcp: Option<crate::wit_host::mcp_bindings::exports::openidea::plugin::mcp_provider::Guest>,
}
@@ -1147,6 +1149,7 @@ impl Runtime {
let inlay_indices = wit_inlay::GuestIndices::new(&pre).ok();
let endpoint_indices = wit_endpoints::GuestIndices::new(&pre).ok();
let configs_indices = wit_configs::GuestIndices::new(&pre).ok();
let launch_indices = wit_launch::GuestIndices::new(&pre).ok();
let tests_indices = wit_tests::GuestIndices::new(&pre).ok();
let validation_indices = wit_rtv::GuestIndices::new(&pre).ok();
let lf_indices = wit_lf::GuestIndices::new(&pre).ok();
@@ -1157,6 +1160,8 @@ impl Runtime {
let mcp = mcp_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
let run_configurations =
configs_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
let launch_configurations =
launch_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
let test_results = tests_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
let language_features = lf_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
let injections = inj_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
@@ -1230,6 +1235,7 @@ impl Runtime {
inlay,
endpoints,
run_configurations,
launch_configurations,
test_results,
mcp,
file_actions,
@@ -1269,34 +1275,67 @@ impl Runtime {
.map(|r| r.map_err(|message| clip(message, 4096)))
}
/// Complete configurations from the optional API 1.4 export.
/// Complete configurations from the optional API 1.9 export, else the API 1.4 one.
pub fn run_configurations(
&mut self,
root: String,
timeout: Duration,
) -> Result<Vec<crate::PluginRunConfiguration>, CallError> {
if self.exports.run_configurations.is_none() {
return Err(CallError::missing_export("run-configurations"));
}
let invocation = Invocation { workspace_root: Some(root.clone().into()), ..Default::default() };
let items = self.call(invocation, timeout, |e, store| {
e.run_configurations.as_ref().unwrap().call_configurations(store, &root)
})?;
if items.len() > 1000 {
return Err(CallError::Guest(GuestError::Invalid("too many run configurations".into())));
}
Ok(items
.into_iter()
.map(|c| crate::PluginRunConfiguration {
id: c.id,
name: c.name,
program: c.program,
args: c.args,
cwd: c.cwd,
test: c.test,
framework: c.framework,
})
.collect())
let items: Vec<crate::PluginRunConfiguration> = if self.exports.launch_configurations.is_some() {
let items = self.call(invocation, timeout, |e, store| {
e.launch_configurations.as_ref().unwrap().call_configurations(store, &root)
})?;
if items.len() > 1000 {
return Err(CallError::Guest(GuestError::Invalid("too many run configurations".into())));
}
items
.into_iter()
.map(|c| crate::PluginRunConfiguration {
id: c.id,
name: c.name,
program: c.program,
args: c.args,
cwd: c.cwd,
test: c.test,
framework: c.framework,
env: c.env,
debugger: match c.debugger {
Some(wit_launch::Debugger::Launch(language)) => {
Some(crate::PluginDebugger::Launch { language })
}
Some(wit_launch::Debugger::AttachChild(a)) => Some(crate::PluginDebugger::AttachChild {
kind: a.kind,
command_contains: a.command_contains,
}),
Some(wit_launch::Debugger::Other(_)) | None => None,
},
})
.collect()
} else if self.exports.run_configurations.is_some() {
let items = self.call(invocation, timeout, |e, store| {
e.run_configurations.as_ref().unwrap().call_configurations(store, &root)
})?;
if items.len() > 1000 {
return Err(CallError::Guest(GuestError::Invalid("too many run configurations".into())));
}
items
.into_iter()
.map(|c| crate::PluginRunConfiguration {
id: c.id,
name: c.name,
program: c.program,
args: c.args,
cwd: c.cwd,
test: c.test,
framework: c.framework,
..Default::default()
})
.collect()
} else {
return Err(CallError::missing_export("run-configurations"));
};
Ok(items)
}
/// Selects tests under the same budget as the test parser.
pub fn select_tests(
+5
View File
@@ -2254,6 +2254,11 @@ impl bindings::openidea::plugin::run::Host for StoreData {
pub(crate) mod run_configurations_bindings {
wasmtime::component::bindgen!({ world: "configurations-provider", path: "../../wit" });
}
pub(crate) mod launch_configurations_bindings {
wasmtime::component::bindgen!({ world: "launch-configurations-provider", path: "../../wit",
with: { "openidea:plugin/types": super::bindings::openidea::plugin::types },
});
}
pub(crate) mod test_results_bindings {
wasmtime::component::bindgen!({ world: "test-results-provider", path: "../../wit",
with: { "openidea:plugin/types": super::bindings::openidea::plugin::types },
+5 -5
View File
@@ -91,15 +91,15 @@ fn the_sdk_carries_the_hosts_wit() {
#[test]
fn the_version_check_runs_compatible_components_and_explains_the_rest() {
let host = v("1.8.0");
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.0.0-rc.1"] {
let host = v("1.9.0");
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.9.0", "1.0.0-rc.1"] {
assert_eq!(check_api(&v(ok), &host), Ok(()), "{ok}");
}
let newer = check_api(&v("1.9.0"), &host).unwrap_err();
assert!(newer.contains("1.9") && newer.contains("update OpenIDEA"), "{newer}");
let newer = check_api(&v("1.10.0"), &host).unwrap_err();
assert!(newer.contains("1.10") && newer.contains("update OpenIDEA"), "{newer}");
assert!(check_api(&v("2.0.0"), &host).unwrap_err().contains("update OpenIDEA"));
let older = check_api(&v("0.2.0"), &host).unwrap_err();
assert!(older.contains("rebuild it with the 1.8 SDK"), "{older}");
assert!(older.contains("rebuild it with the 1.9 SDK"), "{older}");
// 0.x: every minor is its own API.
assert_eq!(check_api(&v("0.2.0"), &v("0.2.5")), Ok(()));
assert!(check_api(&v("0.1.0"), &v("0.2.0")).is_err());
Binary file not shown.
@@ -1 +1 @@
0b77e7a414ec3b0dd1f41e5658b981f059dd842743dbe2f06e5d428f5b9570f9
a3d2511f30277245a8cb9673c4d8a948a8a025b8b9149d5015bed5137a98ccdd
Binary file not shown.
@@ -1 +1 @@
6f7d6527837c8e5c86c377479cceef5116decd61666b28f36dd11332e36e9934
dad3edad99ad85234aa612bbc1f3a66e50361189e54038b91674703815f049cc
Binary file not shown.
@@ -1 +1 @@
c1ac86a5b4d45b55013e6e00dcb83deda33b759ecc366c3fdf57739bdd22cbff
918af7d4d8bc302621b9b68070a56930813b1fc2ba235d89de4e56c53eaba5bd
Binary file not shown.
@@ -1 +1 @@
e4d8d8f5f5849b912b2c0ebee6b91d60796c3070929d7698323e8ce4f200a38a
7a140c2255a3d251a5ab9079bec953cccc4408727b067b49da47cf8fb27d8cb8
Binary file not shown.
@@ -1 +1 @@
e2e2fc44ad9cae9cf26a5bf706768d3786502f23db6994dc29695deb249ed73f
ef41934bd0b67f76a17ef321b44c172496314c9fea6b46b4cd2f1d0f4b96907d
Binary file not shown.
@@ -1 +1 @@
61e1f0c43bbfddc35dcf40685169eb273777ddca13da534626e1699b47e8eac3
c6dc1ae00d9f3d936f4bf5ff110915050cb503ac06982bdc48e967deac84a913
Binary file not shown.
@@ -1 +1 @@
2ea1c1693db8638db996c9c47597f0c1635ef0a9c7dfb33685c515b7af95e6a6
25a782556dd6bbf8ed1ad7b50b9b55685f074d80220af08f3bd9cb12cf07f74e
+1 -1
View File
@@ -1,7 +1,7 @@
id = "execution"
name = "Plugin execution tests"
version = "0.1.0"
engines.openidea = "^1.5"
engines.openidea = "^1.9"
wasm = "dist/plugin.wasm"
activation = ["on-command:*"]
[capabilities]
+32 -12
View File
@@ -114,17 +114,37 @@ impl Plugin for Execution {
host::storage::set("events", &serde_json::to_string(&received).unwrap()).unwrap();
}
}
impl RunConfigurations for Execution {
fn configurations(&mut self, _: &str) -> Vec<PluginRunConfiguration> {
vec![PluginRunConfiguration {
id: "dynamic".into(),
name: "Dynamic tests".into(),
program: "execution-tool".into(),
args: vec!["test".into()],
test: true,
framework: Some("plugin".into()),
..Default::default()
}]
impl LaunchConfigurations for Execution {
fn launch_configurations(&mut self, _: &str) -> Vec<PluginLaunchConfiguration> {
vec![
PluginLaunchConfiguration {
config: PluginRunConfiguration {
id: "dynamic".into(),
name: "Dynamic tests".into(),
program: "execution-tool".into(),
args: vec!["test".into()],
test: true,
framework: Some("plugin".into()),
..Default::default()
},
env: vec![("OPENIDEA_EXECUTION_FIXTURE".into(), "1".into())],
debugger: Some(Debugger::Launch { language: "python".into() }),
},
PluginLaunchConfiguration {
config: PluginRunConfiguration {
id: "worker".into(),
name: "Worker".into(),
program: "execution-tool".into(),
args: vec!["start".into()],
..Default::default()
},
env: Vec::new(),
debugger: Some(Debugger::AttachChild {
kind: "dotnet".into(),
command_contains: Some("Worker.dll".into()),
}),
},
]
}
}
impl TestResults for Execution {
@@ -181,4 +201,4 @@ impl RunTargetValidation for Execution {
}
}
}
register_plugin!(Execution, run_configurations, test_results, run_target_validation);
register_plugin!(Execution, launch_configurations, test_results, run_target_validation);
Binary file not shown.
@@ -1 +1 @@
3c788f6092b229484a5d94fd0e6f4651afc88dd0ab1b22b067d84614a6a0c85e
f58b5f68d56611c3d15f69ff8e73e6e65d84e55d14c9bae00ed50b346460adfa
Binary file not shown.
@@ -1 +1 @@
18273599cc459833d6a30185a5f0ba127cdb4e22bc054a973571e530eb3a85ca
749bff2d051984edf65590494ef803225dfccd03d032de140974d8e984683ac1
Binary file not shown.
@@ -1 +1 @@
c9fafba362fa0745d7ee1685efe5582d432510003c04c98100eddd557bd1e2cf
50c609ebf387b400a01ea28e6ccf0f3de2ff7a5eedbb47c0a4bc40d05e3aaade
Binary file not shown.
@@ -1 +1 @@
4121009913709edeca8c5cb52d88dfcc2b16867bc06859768f73c17cf9c456a2
c2350d0277636285b182d1484d01d706c3116ef5e28917ddeb24ca78bac251ba
Binary file not shown.
@@ -1 +1 @@
b55bd202a06f5643c4f70abb6fb473fbe53af657f4e21a6d13581a23a726e085
3aaa2a7655189a1e4da55a86fb30fdfde29a5b6ad65de53a78b18df30eeb97f3
Binary file not shown.
@@ -1 +1 @@
11a12228df67f9b94bd52375b5dddb2d955f7e5f88d7f9ea0a430b1db128f6ca
975ead22afb4c5bc5c79799b76c1d3a683b572b906e3bade94944319920f7f84
Binary file not shown.
@@ -1 +1 @@
553ce6c57052f8ff2ea2526e88762d5a0aee2489cda192fc7ab708766078ccf7
b849aeca8e5d6b6ede216e372cfc019bac08774006e11ed81d272f67770adc17
Binary file not shown.
@@ -1 +1 @@
7b43f8a2a06d7b2952f8d46727a4cce524fb2bdecee1035dad9c767261d276d0
79505f2677e5f19374a3ed46cccdc1ed8d3092a3c43e3154e8cfd73063533251
Binary file not shown.
@@ -1 +1 @@
e994c69fda5eef94ae85d6dac5aec3d04fb6811c35c446c9d33236a449bd1c6c
f7f43d46ebd545cc4c52d859c4307d08bb95b3187a4b947704e37c27cf0f4fa0
@@ -1 +1 @@
c37f6a7ea9018ca636d0fd486a9d91cd397158615410de9b837ca9b8f9f593b7
491e8e713e51045ebef81c4f07ed5475ed41688e88ac47ee26d13f2bc5c53b49
Binary file not shown.
@@ -1 +1 @@
1b298dfa5c1f2163d609ef0ccc3d42fafe78e69326002effe53abc4b82974749
63b2f6007782c9d3498c86505a6c107b70f09d90678c79cf16c859ecbf349e70
+3 -3
View File
@@ -5,9 +5,9 @@ wit_bindgen::generate!({
inline: "
package fixture:misbehave;
world misbehave {
include openidea:plugin/plugin-syntax@1.8.0;
export openidea:plugin/providers@1.8.0;
export openidea:plugin/file-actions@1.8.0;
include openidea:plugin/plugin-syntax@1.9.0;
export openidea:plugin/providers@1.9.0;
export openidea:plugin/file-actions@1.9.0;
}
",
path: "../../../../../wit",
Binary file not shown.
@@ -1 +1 @@
1e11a95e0909d18308d21a9a8448f8b2e427d240d5d8cd13d8ddbe6ba5009237
3d1f2451dee8bba3cc874f497bcea909fa9bd58ae605dc1d74b4298b4b11ed94
Binary file not shown.
@@ -1 +1 @@
d5cd77130cc97cffdbc742f04e3e1196f14160107b636806c6ef3c9b40724e84
26a2b15b9354fa0ba2bf5934114bfdd20f7906c4a67497d013146cc6b3fc9643
Binary file not shown.
@@ -1 +1 @@
a0f74430b0a7d9ff48524d7aae4f8a0bd0fc60511e2a951dde9991b9bf7d15a9
c9ef2cf7b6e8f3204f8ee382d7a381a5190b1e812e11d51bd1262c3d429a315f
Binary file not shown.
@@ -1 +1 @@
65508f6e25bd0efc85820ae7d0f9037b58c778fa61e8498c5b9a5055cc38f6fc
b07cc854c1302fd5bfd29fb3037732c7439efde606fc57295b2c0f94602a1077
Binary file not shown.
@@ -1 +1 @@
c86ed41d68c132f72eb8b5794f31b975492e5ad42e41b7823d1bf28ba118a262
12c4004f118070d0f37125ac32639ab9f332d59cc4585e74a8af61e3e6c5c1e8
Binary file not shown.
@@ -1 +1 @@
3da1a09906d803234016b3f9c30a88b9b40bf3187fc73840ff60a2e05f504b48
7517da988ab8cacaa3abf7645274a84e364de582ea9edf60a63926b1442d1581
Binary file not shown.
@@ -1 +1 @@
39e7a805120ce6433750c32b1d670b3caba990f7b15aea866a29c23b01cba708
6e045ee3fcaa655bae773774e48e3eeb9d97ae9d8db1f52bf76c38459dcecb3f
Binary file not shown.
@@ -1 +1 @@
5ec9be607955ce2aa4d921884df17c49af3ce98945f8fa641cec9a7f1b4d8384
69bb92e6e24e54458978a316c465d17b93d9ce9613cd26d7d6de9a1cef9b9447
Binary file not shown.
@@ -1 +1 @@
f05df5c2faf1718ba9702be4d979c367ea8445a854794bb21e8e36b211f18122
fc64a30e9d3b46275a6480641454b367b5082aea82da23a11b57106aa02387e1
Binary file not shown.
@@ -1 +1 @@
548cb8321b63b0685049fcf796dbc8390fcb22f3c1ffcfa09452e5a63382d27d
e6f3b5a4d81e62240fa1de4d1624b3706f145d47c014a1a2ed2b899cab24e0e4
+7 -13
View File
@@ -246,30 +246,24 @@ mod imp {
}
pub fn process_start() -> Option<std::time::SystemTime> {
#[repr(C)]
#[derive(Default)]
struct FileTime {
low: u32,
high: u32,
}
#[link(name = "kernel32")]
unsafe extern "system" {
// The same signature `memory.rs` declares: FILETIMEs read as packed u64s.
fn GetProcessTimes(
process: *mut std::ffi::c_void,
creation: *mut FileTime,
exit: *mut FileTime,
kernel: *mut FileTime,
user: *mut FileTime,
creation: *mut u64,
exit: *mut u64,
kernel: *mut u64,
user: *mut u64,
) -> i32;
}
let (mut c, mut e, mut k, mut u) = Default::default();
// SAFETY: all out-pointers are valid FILETIME structs.
// SAFETY: all out-pointers are valid 64-bit FILETIME slots.
let ok = unsafe { GetProcessTimes(GetCurrentProcess(), &mut c, &mut e, &mut k, &mut u) };
if ok == 0 {
return None;
}
let c: FileTime = c;
let ticks = ((c.high as u64) << 32) | c.low as u64; // 100 ns since 1601-01-01
let ticks = c; // 100 ns since 1601-01-01
let unix_100ns = ticks.checked_sub(116_444_736_000_000_000)?;
Some(std::time::UNIX_EPOCH + std::time::Duration::from_nanos(unix_100ns * 100))
}
+4
View File
@@ -76,6 +76,10 @@ On your own messages you can **Edit** (the messages after it are replaced; files
The shortcut does not apply to archived tasks, subagent conversations or the New Task page, and does not take focus from open popups or dialogs. Outside the task conversation, the keys keep their usual editor or terminal behavior. To change or remove the binding, open **Settings › Keymap › Agents › Focus Agent Input**.
**Cycle Agent Effort** defaults to `Option+T` on macOS and `Alt+T` on Windows / Linux in every built-in keymap. With focus inside New Task or your own writable task conversation, in an editor tab or the tool window, it cycles the current model's provider-advertised effort levels in order, wrapping from the last to the first. It preserves your message, selection, caret and focus, and sends nothing. Like the effort control, it changes the provider configuration; it does not promise to change a turn already running.
The shortcut is unavailable when effort is unsupported or has only one level, for archived tasks or subagent conversations, and while a popup or dialog is open. It does not take focus from the code editor or terminal. Change or remove it under **Settings › Keymap › Agents › Cycle Agent Effort**.
Right-click a link and choose **Copy Link Address** to copy its URL; **Copy** copies the selected text.
### Permissions
+1
View File
@@ -77,6 +77,7 @@ The IDE calls these. The first three are in every code plugin; the rest are opti
| `detail-provider` | [details.wit](https://github.com/l0ng-ai/openidea/blob/main/wit/details.wit) | The detail pane of the plugin's nodes in the Services tool window |
| `commit-checker` | [commit.wit](https://github.com/l0ng-ai/openidea/blob/main/wit/commit.wit) | Before-commit checks |
| `run-configurations` | [run.wit](https://github.com/l0ng-ai/openidea/blob/main/wit/run.wit) | Dynamic run configurations for a project (API 1.4) |
| `launch-configurations` | [run.wit](https://github.com/l0ng-ai/openidea/blob/main/wit/run.wit) | Run configurations with an environment and a debugger (API 1.9) |
| `test-results` | [run.wit](https://github.com/l0ng-ai/openidea/blob/main/wit/run.wit) | Parsing test output and selecting tests to rerun (API 1.4) |
| `mcp-provider` | [mcp.wit](https://github.com/l0ng-ai/openidea/blob/main/wit/mcp.wit) | Tools the plugin contributes to the built-in MCP server (API 1.4) |
+40
View File
@@ -11,6 +11,7 @@ every start. On top of that, a plugin can:
| ---------------------------------------------------------------------- | ----------------------------------------------------------------- | --------- |
| Offer a fixed command when the project has a marker file | `[[contributes.runDetectors]]` (no code) | 1.0 |
| Compute the project's configurations in code | `[[contributes.runConfigurations]]` + `run-configurations` export | 1.4 |
| Give configurations an environment and a debugger | `launch-configurations` export | 1.9 |
| Turn test output into the IDE's test tree | `test-results` export, `framework = "plugin"` | 1.4 |
| Start one of its configurations from a command | `host::start_run` (WIT `run.start`) | 1.4 |
| Make every run of the project go through a wrapper (DDEV, a container) | `host::register_run_target` (WIT `run-targets`) | 1.4 |
@@ -78,6 +79,45 @@ the project root; it is refreshed when configurations are listed. The host keeps
1000 entries / 4 MiB, keeps the last valid list when the export fails, and doesn't offer
entries whose program isn't approved. The export runs without a window and can't prompt.
## Environment and debugger
From API 1.9, export `launch-configurations` instead (`LaunchConfigurations`, registered as
`launch_configurations`) to give each configuration an environment and a debugger. The IDE
uses it when a component exports both.
```rust
use openidea_plugin::{Debugger, LaunchConfigurations, PluginLaunchConfiguration, PluginRunConfiguration};
impl LaunchConfigurations for Functions {
fn launch_configurations(&mut self, _root: &str) -> Vec<PluginLaunchConfiguration> {
vec![PluginLaunchConfiguration {
config: PluginRunConfiguration {
id: "func".into(),
name: "Functions host".into(),
program: "func".into(),
args: vec!["start".into(), "--dotnet-isolated-debug".into()],
..Default::default()
},
env: vec![("FUNCTIONS_WORKER_RUNTIME".into(), "dotnet-isolated".into())],
debugger: Some(Debugger::AttachChild { kind: "dotnet".into(), command_contains: None }),
}]
}
}
register_plugin!(Functions, launch_configurations);
```
- `env` adds at most 64 variables to the run's environment. Like `process` commands, it can
only add: a name the IDE's own environment already has (`PATH`, …) makes the list invalid.
- `debugger: None` keeps the default: Debug infers the debugger from a source file in `args`.
- `Debugger::Launch { language }` starts `program` under that language's debugger (its
`[debugger]`), for programs whose arguments name no source file.
- `Debugger::AttachChild { kind, command_contains }` makes Debug run the configuration as Run
does, then attach to the first process of that kind (`dotnet`, `node`, `python`, `go` or
`native`, as in Attach to Process) the run starts, optionally only one whose command line
contains `command_contains`. Only the run's own processes are candidates. The IDE waits while
the run lasts, up to a minute; without a match the run goes on without the debugger.
## Test results
With `framework = "plugin"` (on a detector or a returned configuration), the IDE feeds the
+4
View File
@@ -76,6 +76,10 @@ OpenIDEA 本身不带模型或账号:它启动你已安装并登录的 agent
此快捷键不适用于已归档任务、子 agent 对话或“新建任务”页面,也不会从打开的弹出窗口或对话框中抢走焦点。在任务对话之外,按键保留原有的编辑器或终端行为。要修改或移除绑定,请打开 **设置 › 按键映射 › 智能体 › 聚焦 Agent 输入框**。
所有内置按键映射中,**循环切换 Agent 思考强度** 的默认快捷键都是 macOS 上的 `Option+T`、Windows / Linux 上的 `Alt+T`。焦点位于“新建任务”或你自己的可输入任务对话中时,无论显示在编辑器标签页还是工具窗口中,它都会按提供商声明的顺序切换当前模型支持的思考强度,从最后一级循环回第一级。它会保留消息、选区、光标和焦点,不发送任何内容。与思考强度控件一样,它修改的是提供商配置,不保证改变已经运行中的轮次。
不支持思考强度或仅支持一级时,以及已归档任务、子 agent 对话或打开弹出窗口、对话框时,此快捷键不可用。它不会从代码编辑器或终端抢走焦点。要修改或移除绑定,请打开 **设置 › 按键映射 › 智能体 › 循环切换 Agent 思考强度**。
右键点击链接并选择 **复制链接地址** 可复制它的 URL;**复制** 复制选中的文字。
### 权限
+1
View File
@@ -77,6 +77,7 @@ description: "openidea:plugin WIT 包中的每个 interface:一句话说明及
| `detail-provider` | [details.wit](https://github.com/l0ng-ai/openidea/blob/main/wit/details.wit) | Services 工具窗口中插件节点的详情面板 |
| `commit-checker` | [commit.wit](https://github.com/l0ng-ai/openidea/blob/main/wit/commit.wit) | 提交前检查 |
| `run-configurations` | [run.wit](https://github.com/l0ng-ai/openidea/blob/main/wit/run.wit) | 项目的动态运行配置(API 1.4) |
| `launch-configurations` | [run.wit](https://github.com/l0ng-ai/openidea/blob/main/wit/run.wit) | 带环境变量和调试器的运行配置(API 1.9) |
| `test-results` | [run.wit](https://github.com/l0ng-ai/openidea/blob/main/wit/run.wit) | 解析测试输出、选择要重新运行的测试(API 1.4) |
| `mcp-provider` | [mcp.wit](https://github.com/l0ng-ai/openidea/blob/main/wit/mcp.wit) | 插件为内置 MCP 服务器提供的工具(API 1.4) |
+35
View File
@@ -10,6 +10,7 @@ description: "贡献运行配置,把测试输出解析进测试树,从代码
| ---------------------------------------------- | --------------------------------------------------------------- | --------- |
| 项目包含某个标记文件时提供固定命令 | `[[contributes.runDetectors]]`(无需代码) | 1.0 |
| 在代码中计算项目的运行配置 | `[[contributes.runConfigurations]]` + `run-configurations` 导出 | 1.4 |
| 给配置加上环境变量和调试器 | `launch-configurations` 导出 | 1.9 |
| 把测试输出转成 IDE 的测试树 | `test-results` 导出,`framework = "plugin"` | 1.4 |
| 从命令中启动自己的某个配置 | `host::start_run`(WIT `run.start`) | 1.4 |
| 让项目的所有运行都经过包装程序(DDEV、容器等) | `host::register_run_target`(WIT `run-targets`) | 1.4 |
@@ -71,6 +72,40 @@ register_plugin!(TestRunner, run_configurations);
请返回该项目根目录的完整列表;列出配置时会刷新。宿主最多保留 1000 项 / 4 MiB,导出失败时保留上一次有效的列表,
程序未获批准的条目不会提供。该导出在没有窗口的情况下运行,不能弹出对话框。
## 环境变量和调试器
从 API 1.9 起,可以改为导出 `launch-configurations`(实现 `LaunchConfigurations`,注册为 `launch_configurations`),
给每个配置加上环境变量和调试器。组件同时导出两者时,IDE 使用这一个。
```rust
use openidea_plugin::{Debugger, LaunchConfigurations, PluginLaunchConfiguration, PluginRunConfiguration};
impl LaunchConfigurations for Functions {
fn launch_configurations(&mut self, _root: &str) -> Vec<PluginLaunchConfiguration> {
vec![PluginLaunchConfiguration {
config: PluginRunConfiguration {
id: "func".into(),
name: "Functions host".into(),
program: "func".into(),
args: vec!["start".into(), "--dotnet-isolated-debug".into()],
..Default::default()
},
env: vec![("FUNCTIONS_WORKER_RUNTIME".into(), "dotnet-isolated".into())],
debugger: Some(Debugger::AttachChild { kind: "dotnet".into(), command_contains: None }),
}]
}
}
register_plugin!(Functions, launch_configurations);
```
- `env` 最多给运行的环境添加 64 个变量。和 `process` 命令一样只能新增:IDE 自身环境里已有的变量名(`PATH` 等)会让整个列表无效。
- `debugger: None` 保持默认行为:Debug 根据 `args` 中的源文件推断调试器。
- `Debugger::Launch { language }` 在该语言的调试器(其 `[debugger]`)下启动 `program`,适用于参数里没有源文件的程序。
- `Debugger::AttachChild { kind, command_contains }` 让 Debug 先像 Run 一样运行配置,再附加到这次运行启动的第一个该类型进程
(`dotnet`、`node`、`python`、`go` 或 `native`,与 Attach to Process 相同),可选地只匹配命令行包含 `command_contains` 的进程。
只有这次运行自己的进程才是候选。IDE 在运行期间最多等待一分钟;没有匹配时运行继续,但不附加调试器。
## 测试结果
设置 `framework = "plugin"`(在检测器或返回的配置上)后,IDE 会把运行输出交给 `test-results` 导出。
+533
View File
@@ -0,0 +1,533 @@
import type { Locator, Page } from "@playwright/test";
import type { AgentConfigOption, AgentEntry, AgentProvider, AgentTask } from "../src/bindings";
import { expect, ipcCalls, openFromTree, stubDesktop, test } from "./fixtures";
type Placement = "editor" | "toolWindow";
const effortId = "deliberation-budget";
const modelId = "cortex";
const draft = "draft keep this unsent";
const rebound = "Control+Meta+Shift+J";
const option = (id: string, category: string, values: [string, string][], current: string): AgentConfigOption => ({
id,
category,
name: category === "model" ? "Model" : "Reasoning",
description: null,
current,
via: "option",
values: values.map(([value, name]) => ({ value, name, description: null })),
});
const models = option(
modelId,
"model",
[
["atlas", "Atlas"],
["swift", "Swift"],
["plain", "Plain"],
["solo", "Solo"],
],
"atlas",
);
const atlas = option(
effortId,
"thought_level",
[
["budget-7", "Gentle"],
["budget-23", "Balanced"],
["budget-91", "Deep"],
],
"budget-7",
);
const swift = option(
effortId,
"thought_level",
[
["quick", "Quick"],
["thorough", "Thorough"],
],
"quick",
);
const solo = option(effortId, "thought_level", [["only", "Only"]], "only");
const provider: AgentProvider = {
id: "acceptance-provider",
name: "Acceptance Provider",
command: "acceptance",
program: "acceptance",
args: [],
defaultProgram: null,
defaultArgs: [],
loginHint: null,
commandOverridden: false,
commandEditable: true,
commandReadOnlyReason: null,
installed: true,
env: {},
commands: [],
source: { kind: "custom" },
config: [models],
thoughtLevels: { atlas: [atlas], swift: [swift], plain: [], solo: [solo] },
};
const firstTask: AgentTask = {
id: "effort-first",
title: "First effort task",
provider: provider.id,
status: "ready",
isolation: "local",
model: "atlas",
cwd: "/dev/acme-api",
branch: null,
base: null,
baseCommit: null,
error: null,
createdMs: 0,
updatedMs: 0,
config: [models, atlas],
commands: [],
usage: null,
queue: [],
};
const secondTask: AgentTask = { ...firstTask, id: "effort-second", title: "Second effort task" };
const subagent: AgentEntry = {
type: "subagent",
id: "effort-child",
title: "Inspect the project",
description: null,
status: "done",
error: null,
prompt: null,
reply: null,
tools: 0,
activity: null,
startedMs: null,
endedMs: null,
cancellable: false,
};
async function seed(
page: Page,
placement: Placement,
surface: "new" | "task" = "task",
model = "atlas",
status: AgentTask["status"] = "ready",
) {
await stubDesktop(page);
await page.evaluate(
async ({ placement, surface, provider, firstTask, secondTask, subagent, model, status, modelId }) => {
// In-memory sample tasks belong to Vite's browser realm. Static Node imports create a different store and cannot seed the workbench.
const storePath = "/src/features/agents/store.ts";
const store = await import(storePath);
const configFor = (model: string) => [
{ ...provider.config[0]!, current: model },
...(provider.thoughtLevels?.[model] ?? []),
];
const tasks = new Map(
[firstTask, secondTask].map((task) => [task.id, { ...task, status, model, config: configFor(model) }]),
);
const entries: AgentEntry[] = Array.from({ length: 24 }, (_, turn): AgentEntry[] => [
{ type: "user", text: `Request ${turn}`, attachments: [] },
{ type: "agent", text: `Reply ${turn}` },
]).flat();
let channel: unknown;
const handlers = window.__ipc.handlers;
// Settings writes must update the browser's project store, just as the desktop response does.
const projectPath = "/src/platform/project.ts";
const { useProject } = await import(projectPath);
handlers.settings_set = ({ key, value }) => {
const next: Record<string, unknown> = structuredClone(useProject.getState().settings ?? {});
const path = String(key).split(".");
let node = next;
for (const segment of path.slice(0, -1)) {
node[segment] ??= {};
node = node[segment] as Record<string, unknown>;
}
const last = path.at(-1)!;
const parsed: unknown = JSON.parse(String(value));
if (parsed === null) delete node[last];
else node[last] = parsed;
useProject.setState({ settings: next });
return next;
};
handlers.agent_subscribe = ({ onEvent }) => {
channel = onEvent;
return [...tasks.values()];
};
handlers.agent_providers = () => [provider];
handlers.agent_refresh_models = () => ({
provider: provider.id,
config: provider.config,
thoughtLevels: provider.thoughtLevels,
refreshing: false,
refreshedAtMs: Date.now(),
retryAtMs: null,
error: null,
});
handlers.agent_probe = () => null;
handlers.agent_commands = () => [];
handlers.agent_entries = ({ subagent: child }) =>
child ? [{ type: "agent", text: "Subagent findings" }] : [...entries, subagent];
handlers.agent_changes = () => [];
handlers.agent_grouped_changes = () => ({ uncommitted: [], commits: [] });
handlers.vcs_branch_info = () => ({ head: "main" });
handlers.vcs_branches = () => [];
handlers.agent_set_config = async ({ task: id, option, value }) => {
const previous = tasks.get(String(id))!;
const updated =
option === modelId
? { ...previous, model: String(value), config: configFor(String(value)) }
: {
...previous,
config: previous.config.map((entry) =>
entry.id === option ? { ...entry, current: String(value) } : entry,
),
};
// Mirror the backend's optimistic task event; production's subscription reducer owns the UI update.
tasks.set(updated.id, updated);
window.__ipc.send(channel, { type: "task", task: updated });
if (document.documentElement.dataset.holdConfig === "true") {
delete document.documentElement.dataset.holdConfig;
const { promise, resolve } = Promise.withResolvers<void>();
document.addEventListener("release-config", () => resolve(), { once: true });
await promise;
}
return null;
};
handlers.agent_prompt = () => null;
handlers.agent_interrupt = () => null;
await store.connect();
store.useAgents.setState({
composers: new Map(),
unread: new Set(),
docked: null,
homeOpen: false,
sessionLocation: placement,
draft: store.savedDraft({ provider: provider.id, config: { [modelId]: model } }),
});
if (surface === "new") store.openHome();
else store.openTask(firstTask.id);
},
{ placement, surface, provider, firstTask, secondTask, subagent, model, status, modelId },
);
await expect(box(page)).toBeVisible();
await page.evaluate(() => document.fonts.ready);
}
function box(page: Page) {
return page.getByRole("textbox", { name: "Message", exact: true }).filter({ visible: true });
}
function history(page: Page) {
return page.locator("[class*='_stream_']:visible");
}
function modelButton(page: Page) {
return page.getByRole("button", { name: "Model", exact: true }).filter({ visible: true });
}
async function expectEffort(page: Page, name: string) {
await expect(modelButton(page)).toHaveAttribute("title", new RegExp(`Reasoning: ${name}(?: ·|$)`));
}
async function selected(box: Locator) {
return box.evaluate((element) => {
const selection = window.getSelection();
if (
!selection?.anchorNode ||
!selection.focusNode ||
!element.contains(selection.anchorNode) ||
!element.contains(selection.focusNode)
)
return null;
const offset = (node: Node, at: number) => {
const range = document.createRange();
range.selectNodeContents(element);
range.setEnd(node, at);
return range.toString().length;
};
return {
anchor: offset(selection.anchorNode, selection.anchorOffset),
head: offset(selection.focusNode, selection.focusOffset),
text: selection.toString(),
};
});
}
async function selectDraft(page: Page) {
const input = box(page);
await input.fill(draft);
await input.press("Home");
for (let i = 0; i < 6; i++) await input.press("ArrowRight");
for (let i = 0; i < 4; i++) await input.press("Shift+ArrowRight");
await expect.poll(() => selected(input)).toEqual({ anchor: 6, head: 10, text: "keep" });
}
async function chooseModel(page: Page, name: string) {
await modelButton(page).click();
await page.getByRole("option", { name, exact: true }).click();
await page.keyboard.press("Escape");
await box(page).focus();
}
async function expectNoSubmission(page: Page) {
expect(await ipcCalls(page, "agent_prompt")).toEqual([]);
expect(await ipcCalls(page, "agent_interrupt")).toEqual([]);
expect(await ipcCalls(page, "agent_create")).toEqual([]);
}
for (const placement of ["editor", "toolWindow"] as const) {
test(`${placement}: existing task cycles advertised values and wraps without editing, moving focus or scrolling`, async ({
workbench: page,
}) => {
await seed(page, placement);
const stream = history(page);
await stream.click({ position: { x: 12, y: 20 } });
await stream.press("Home");
await expect.poll(() => stream.evaluate((element) => element.scrollTop)).toBe(0);
await selectDraft(page);
for (const [value, name] of [
["budget-23", "Balanced"],
["budget-91", "Deep"],
["budget-7", "Gentle"],
]) {
await page.keyboard.press("Alt+t");
await expectEffort(page, name!);
await expect(box(page)).toBeFocused();
await expect(box(page)).toHaveText(draft);
await expect.poll(() => selected(box(page))).toEqual({ anchor: 6, head: 10, text: "keep" });
await expect.poll(() => stream.evaluate((element) => element.scrollTop)).toBe(0);
expect((await ipcCalls(page, "agent_set_config")).at(-1)).toEqual({
task: firstTask.id,
option: effortId,
value,
});
await expect(page.getByRole("dialog", { name: "Model & effort settings", exact: true })).toHaveCount(0);
}
await expectNoSubmission(page);
await stream.click({ position: { x: 12, y: 20 } });
await page.keyboard.press("Alt+t");
await expectEffort(page, "Balanced");
await expect(stream).toBeFocused();
await expect.poll(() => stream.evaluate((element) => element.scrollTop)).toBe(0);
});
test(`${placement}: New Task cycles effort without changing or submitting the draft`, async ({ workbench: page }) => {
await seed(page, placement, "new");
await selectDraft(page);
// macOS Option+T may report † as key; the dispatcher's physical code must still resolve Alt+T.
await box(page).dispatchEvent("keydown", { key: "†", code: "KeyT", altKey: true, bubbles: true, cancelable: true });
await expectEffort(page, "Balanced");
await expect(box(page)).toBeFocused();
await expect(box(page)).toHaveText(draft);
await expect.poll(() => selected(box(page))).toEqual({ anchor: 6, head: 10, text: "keep" });
await expectNoSubmission(page);
});
}
for (const [surface, model, status] of [
["new", "plain", "ready"],
["new", "solo", "ready"],
["task", "plain", "ready"],
["task", "solo", "ready"],
["task", "atlas", "archived"],
] as const) {
test(`${surface} ${model} ${status}: unavailable effort leaves configuration untouched`, async ({
workbench: page,
}) => {
await seed(page, "editor", surface, model, status);
if (status === "archived") await history(page).click({ position: { x: 12, y: 20 } });
else await box(page).focus();
const before = await modelButton(page).textContent();
await page.keyboard.press("Alt+t");
await expect(modelButton(page)).toHaveText(before!);
expect(await ipcCalls(page, "agent_set_config")).toEqual([]);
await expectNoSubmission(page);
});
}
test("subagent conversation never changes its hidden parent's effort", async ({ workbench: page }) => {
await seed(page, "editor");
await page.getByTitle("Open the subagent's conversation", { exact: true }).click();
await expect(page.getByRole("navigation", { name: "Subagent", exact: true })).toBeVisible();
await history(page).click({ position: { x: 12, y: 20 } });
await page.keyboard.press("Alt+t");
expect(await ipcCalls(page, "agent_set_config")).toEqual([]);
await page
.getByRole("navigation", { name: "Subagent", exact: true })
.getByRole("button", { name: firstTask.title, exact: true })
.click();
await expectEffort(page, "Gentle");
});
test("Settings and model popup exclude the agent shortcut", async ({ workbench: page }) => {
await seed(page, "editor");
await box(page).fill(draft);
await page.keyboard.press("Meta+,");
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
const search = settings.getByRole("textbox", { name: "Search settings", exact: true });
await search.fill("keymap");
await page.keyboard.press("Alt+t");
await expect(search).toBeFocused();
await expect(search).toHaveValue("keymap");
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
await modelButton(page).click();
const popup = page.getByRole("dialog", { name: "Model & effort settings", exact: true });
await expect(popup).toBeVisible();
await popup.getByRole("slider", { name: "Reasoning" }).focus();
await page.keyboard.press("Alt+t");
await expect(popup.getByRole("slider", { name: "Reasoning" })).toHaveAttribute("aria-valuetext", "Gentle");
expect(await ipcCalls(page, "agent_set_config")).toEqual([]);
await page.keyboard.press("Escape");
await expectEffort(page, "Gentle");
await expect(box(page)).toHaveText(draft);
});
test("code editor and terminal do not mutate the previously focused docked agent", async ({ workbench: page }) => {
const editor = await openFromTree(page, "README.md");
await seed(page, "toolWindow");
await box(page).fill(draft);
await editor.locator(".cm-content").click();
await page.keyboard.press("Alt+t");
await expect(editor.locator(".cm-content")).toBeFocused();
await page.keyboard.press("Alt+F12");
const terminal = page.getByRole("region", { name: "Terminal", exact: true });
const input = terminal.getByRole("textbox", { name: "Terminal input" });
await expect(input).toBeFocused();
await page.keyboard.press("Alt+t");
await expect(input).toBeFocused();
expect(await ipcCalls(page, "agent_set_config")).toEqual([]);
await expectNoSubmission(page);
});
test("hidden kept-alive editor tasks stay isolated", async ({ workbench: page }) => {
await seed(page, "editor");
await box(page).fill("first draft");
await page.evaluate(async (id) => {
// Open the existing browser store; a static Node import cannot reach the mounted workbench.
const storePath = "/src/features/agents/store.ts";
(await import(storePath)).openTask(id);
}, secondTask.id);
await box(page).fill("second draft");
await page.keyboard.press("Alt+t");
await expectEffort(page, "Balanced");
await page.getByRole("tab", { name: firstTask.title, exact: true }).click();
await expectEffort(page, "Gentle");
await expect(box(page)).toHaveText("first draft");
await box(page).focus();
await page.keyboard.press("Alt+t");
await expectEffort(page, "Balanced");
expect(await ipcCalls(page, "agent_set_config")).toEqual([
{ task: secondTask.id, option: effortId, value: "budget-23" },
{ task: firstTask.id, option: effortId, value: "budget-23" },
]);
});
test("Settings → Keymap rebinds Cycle Agent Effort and removes Alt+T", async ({ workbench: page }) => {
await seed(page, "editor");
await selectDraft(page);
await page.keyboard.press("Meta+,");
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
await settings.getByRole("treeitem", { name: "Keymap", exact: true }).click();
await settings.getByRole("textbox", { name: "Search actions", exact: true }).fill("Cycle Agent Effort");
const row = settings.getByRole("tree", { name: "Actions" }).getByRole("treeitem", { name: /Cycle Agent Effort/ });
await row.dblclick();
await page.getByRole("menuitem", { name: "Add Keyboard Shortcut", exact: true }).click();
const recorder = page.getByRole("dialog", { name: "Keyboard Shortcut: Cycle Agent Effort", exact: true });
await recorder.getByRole("textbox", { name: "First stroke" }).press(rebound);
await recorder.getByRole("button", { name: "OK", exact: true }).click();
await expect(recorder).toBeHidden();
await row.click({ button: "right" });
await page.getByRole("menuitem", { name: "Remove ⌥T", exact: true }).click();
await settings.getByRole("button", { name: "OK", exact: true }).click();
await expect(settings).toBeHidden();
await box(page).focus();
await page.keyboard.press("Alt+t");
await expectEffort(page, "Gentle");
expect(await ipcCalls(page, "agent_set_config")).toEqual([]);
await page.keyboard.press(rebound);
await expectEffort(page, "Balanced");
expect(await ipcCalls(page, "agent_set_config")).toEqual([
{ task: firstTask.id, option: effortId, value: "budget-23" },
]);
await expect(box(page)).toHaveText(draft);
});
test("Find Action executes Cycle Agent Effort after closing its popup", async ({ workbench: page }) => {
await seed(page, "editor");
await selectDraft(page);
await page.keyboard.press("Meta+Shift+A");
const search = page.getByRole("dialog", { name: "Search Everywhere", exact: true });
await search.getByRole("combobox").fill("Cycle Agent Effort");
await expect(search.getByRole("option", { name: /Cycle Agent Effort/ })).toBeVisible();
await search.getByRole("combobox").press("Enter");
await expect(search).toBeHidden();
await expectEffort(page, "Balanced");
await expect(box(page)).toHaveText(draft);
expect(await ipcCalls(page, "agent_set_config")).toEqual([
{ task: firstTask.id, option: effortId, value: "budget-23" },
]);
});
test("compact docked composer shows the cycled effort visibly", async ({ workbench: page }) => {
await page.setViewportSize({ width: 600, height: 800 });
await seed(page, "toolWindow");
await box(page).focus();
await page.keyboard.press("Alt+t");
await expect(page.getByText("Effort: Balanced", { exact: true }).filter({ visible: true })).toBeVisible();
expect(await ipcCalls(page, "agent_set_config")).toEqual([
{ task: firstTask.id, option: effortId, value: "budget-23" },
]);
});
for (const preset of [
"intellij-macos",
"intellij-windows",
"vscode-macos",
"vscode-windows",
"eclipse-macos",
"eclipse-windows",
]) {
test(`${preset}: Alt+T cycles effort using the preset's default binding`, async ({ workbench: page }) => {
await seed(page, "editor");
await page.evaluate(async (preset) => {
// The dispatcher lives in Vite's browser realm; a Node import cannot update its active keymap.
const keymapPath = "/src/platform/keymap.ts";
(await import(keymapPath)).applyKeymapSettings(preset, {});
}, preset);
await box(page).focus();
await page.keyboard.press("Alt+t");
await expectEffort(page, "Balanced");
expect(await ipcCalls(page, "agent_set_config")).toEqual([
{ task: firstTask.id, option: effortId, value: "budget-23" },
]);
});
}
for (const setting of ["effort", "model"] as const) {
test(`pending ${setting} changes do not block Send or serialize shortcut presses`, async ({ workbench: page }) => {
await seed(page, "editor");
await box(page).fill(draft);
await page.evaluate(() => {
document.documentElement.dataset.holdConfig = "true";
});
if (setting === "effort") {
await page.keyboard.press("Alt+t");
await expectEffort(page, "Balanced");
await page.keyboard.press("Alt+t");
await expectEffort(page, "Deep");
} else {
await chooseModel(page, "Swift");
await expectEffort(page, "Quick");
}
expect(await ipcCalls(page, "agent_set_config")).toEqual(
setting === "effort"
? [
{ task: firstTask.id, option: effortId, value: "budget-23" },
{ task: firstTask.id, option: effortId, value: "budget-91" },
]
: [{ task: firstTask.id, option: modelId, value: "swift" }],
);
await expect(page.getByRole("button", { name: "Send", exact: true })).toBeEnabled();
await box(page).fill("send while configuration is pending");
await box(page).press("Enter");
await expect
.poll(() => ipcCalls(page, "agent_prompt"))
.toEqual([
expect.objectContaining({
task: firstTask.id,
prompt: expect.objectContaining({ text: "send while configuration is pending" }),
}),
]);
await page.evaluate(() => document.dispatchEvent(new Event("release-config")));
});
}
+91
View File
@@ -372,6 +372,97 @@ test("keeps chat history readable and selections free of timestamps and status l
expect(narrow.reply).toBeLessThanOrEqual((narrow.width - narrow.padding) * 0.96);
});
test("fits conversation stream, composer, question card and user bubbles to window width when enabled", async ({
page,
}) => {
await page.setViewportSize({ width: 1800, height: 1000 });
await openReply(page, "Initial reply");
await page.evaluate(async (task) => {
const storePath = "/src/features/agents/store.ts";
const store = await import(storePath);
store.useAgents.setState({
tasks: new Map([[task.id, { ...task, status: "needsInput" as const }]]),
entries: new Map([
[
task.id,
[
{
type: "user",
text: "Long prompt ".repeat(40),
attachments: [],
sentMs: 1,
doneMs: 2,
steered: false,
},
{ type: "agent", text: "Wide reply body." },
{
type: "permission",
id: 1,
title: "Choose layout",
options: [],
chosen: null,
questions: [
{
header: "Width",
question: "Use full window width?",
multiSelect: false,
options: [{ label: "Yes", description: "Fill the pane", preview: null }],
},
],
},
],
],
]),
});
store.openTaskInEditorLocation(task.id);
}, TASK);
const stream = page.locator("[class*='_stream_']:visible");
await expect(page.getByRole("form", { name: "Choose layout" })).toBeVisible();
const measure = () =>
stream.evaluate((root) => {
const conversation = root.closest<HTMLElement>("[class*='_conversation_']")!;
const column = root.querySelector<HTMLElement>("[class*='_agentMessage_']")!.getBoundingClientRect();
const bubble = root.querySelector<HTMLElement>("[class*='_user_']")!.getBoundingClientRect();
const composer = conversation.querySelector<HTMLElement>("[class*='_composerArea_']")!.getBoundingClientRect();
const question = conversation.querySelector<HTMLElement>("[class*='_questionCard_']")!.getBoundingClientRect();
const padding =
Number.parseFloat(getComputedStyle(root).paddingLeft) + Number.parseFloat(getComputedStyle(root).paddingRight);
return {
conversationWidth: conversation.clientWidth,
streamInnerWidth: root.clientWidth - padding,
columnWidth: column.width,
bubbleWidth: bubble.width,
composerWidth: composer.width,
questionWidth: question.width,
};
});
const capped = await measure();
expect(capped.conversationWidth).toBeGreaterThan(1000);
expect(Math.abs(capped.columnWidth - 900)).toBeLessThan(1);
expect(Math.abs(capped.bubbleWidth - 720)).toBeLessThan(1);
expect(Math.abs(capped.composerWidth - 924)).toBeLessThan(1);
expect(Math.abs(capped.questionWidth - 900)).toBeLessThan(1);
await page.evaluate(async () => {
const projectPath = "/src/platform/project.ts";
const { useProject } = await import(projectPath);
const settings = useProject.getState().settings;
useProject.setState({
settings: { ...settings, agents: { ...settings?.agents, fitWindowWidth: true } } as never,
});
});
const fitted = await measure();
expect(Math.abs(fitted.columnWidth - fitted.streamInnerWidth)).toBeLessThan(1);
expect(fitted.bubbleWidth).toBeGreaterThan(720);
expect(Math.abs(fitted.bubbleWidth - fitted.streamInnerWidth * 0.8)).toBeLessThan(1);
expect(Math.abs(fitted.composerWidth - fitted.conversationWidth)).toBeLessThan(1);
expect(Math.abs(fitted.questionWidth - fitted.streamInnerWidth)).toBeLessThan(1);
});
test("keeps hover actions reachable when the pointer leaves the message body", async ({ page, context }) => {
await context.grantPermissions(["clipboard-read", "clipboard-write"]);
const reply = await openReply(page, "A short answer.");
+2 -2
View File
@@ -33,7 +33,7 @@ test("plugin routes feed search, HTTP completion and the declaration gutter and
});
await editorService().openFile("/dev/acme-api/routes.txt");
});
await expect(page.locator('.cm-openidea-gutter-endpoints button[title="Open in HTTP Client"]')).toBeVisible();
await expect(page.locator('.cm-openidea-iconArea button[title="Open in HTTP Client"]')).toBeVisible();
await doubleShift(page);
const search = page.getByRole("dialog", { name: "Search Everywhere" });
await search.getByRole("combobox").fill("/people");
@@ -59,5 +59,5 @@ test("plugin routes feed search, HTTP completion and the declaration gutter and
const path = "/src/workbench/contributions.ts";
await (await import(path)).editorService().openFile("/dev/acme-api/routes.txt");
});
await expect(page.locator('.cm-openidea-gutter-endpoints button[title="Open in HTTP Client"]')).toBeHidden();
await expect(page.locator('.cm-openidea-iconArea button[title="Open in HTTP Client"]')).toBeHidden();
});
+3 -3
View File
@@ -67,13 +67,13 @@ test("plugin markers render names and package SVG variants and keep the indexed
);
await editorService().openFile(source);
});
const markers = page.locator(".cm-openidea-gutter-pluginMarkers");
const markers = page.locator(".cm-openidea-iconArea");
await expect(markers.locator('[title="Run marker"] svg')).toHaveAttribute("data-icon", "gutter-run");
await expect(markers.locator('[title="Database marker"] svg')).toHaveAttribute("data-icon", "database");
const custom = markers.locator('[title="Package marker"] svg');
await expect(custom).toHaveAttribute("data-icon", /^ext:pluginIcon\/hello\//);
// CodeMirror clips every gutter column to its width (`overflow: hidden`), so an icon wider than
// the column loses its edges: each line-marker icon stays inside the 14px column.
// the column loses its edges: each line-marker icon stays inside the shared icon area.
const outside = await markers.evaluate((column) => {
const bounds = column.getBoundingClientRect();
return [...column.querySelectorAll("svg")].filter((svg) => {
@@ -96,7 +96,7 @@ test("plugin markers render names and package SVG variants and keep the indexed
await expect(custom.locator("rect")).toBeVisible();
await expect(custom.locator("circle")).toBeHidden();
await page.screenshot({ path: test.info().outputPath("markers-light.png"), animations: "disabled" });
await page.locator(".cm-plugin-mapping-gutter button").click();
await markers.locator('button[aria-label^="Go to mapping:"]').click();
const chooser = page.getByRole("dialog", { name: "Choose Mapping Target" });
await expect(chooser.getByRole("option")).toHaveCount(2);
await page.screenshot({ path: test.info().outputPath("markers-chooser.png"), animations: "disabled" });
+59 -2
View File
@@ -418,9 +418,22 @@ are always available. Calling a gated function without its capability returns
## 3. Writing code (Rust SDK)
### API 1.9
API 1.9.0 is in development on `main`. Use `engines.openidea = "^1.9"` and the
matching SDK. Released 1.8 plugins keep working. New in 1.9:
- The `launch-configurations` export (`LaunchConfigurations`, registration
`launch_configurations`, world `plugin-launch-configurations`): run
configurations with an `env` added to the run's environment and a `debugger`,
either `Debugger::Launch { language }` (the program starts under that
language's debugger) or `Debugger::AttachChild { kind, command_contains }`
(Debug runs the configuration and attaches to a process the run starts). See
_Environment and debugger_ under _Runs, terminal sessions and test results_.
### API 1.8
API 1.8.0 is in development on `main`. Use `engines.openidea = "^1.8"` and the
API 1.8.0 shipped with OpenIDEA 0.1.45. Use `engines.openidea = "^1.8"` and the
matching SDK. Released 1.7 plugins keep working. New in 1.8:
- `problems-changed` (activation `on-event:problems-changed`, event
@@ -671,6 +684,7 @@ then run `openidea-plugin check`.
| `host::reply_content_tab(request_id, reply)` | `views.reply-content-tab` | API 1.4: reply to an owned action in the originating window. No capability; commands/events only. |
| `host::open_diff(diff, file_name)` | `views.open-diff` | API 1.7: two texts in the invoking window's diff viewer; `file_name` (at most 256 characters) picks the highlighting. Commands/events only; each side at most 8 MiB (earlier hosts: 1 MiB), a larger side fails with `Invalid("diff too large: …")`. |
| `RunConfigurations::configurations(root)` | export `run-configurations.configurations` | API 1.4: optional `plugin-run-configurations` world; SDK registration `run_configurations`. Full project list, refreshed on configuration listing. |
| `LaunchConfigurations::launch_configurations(root)` | export `launch-configurations` | API 1.9: optional `plugin-launch-configurations` world; SDK registration `launch_configurations`. The same list with `env` and `debugger`; preferred over `run-configurations`. |
| `TestResults::parse(config, chunk)` | export `test-results.parse` | API 1.4: optional `plugin-test-results` world; SDK registration `test_results`. Bounded output batches for `framework = "plugin"`; failures use built-in parsers. |
| `TestResults::select_tests(config, tests)` | export `test-results.select-tests` | API 1.4: full replacement argv for test-tree name paths, or `None` when unsupported (the SDK default). Enables rerunning failed tests and running tree selections. |
| `host::open_location(path, line, column)` | `views.open-location` | Opens a file inside the project in an editor of the invoking window, the caret at `line`/`column` (0-based, UTF-16): a view's links to code. Needs `project.read`. |
@@ -1836,6 +1850,49 @@ Implement `RunConfigurations` and register `run_configurations`. Each returned
valid list after an export failure. Entries without an approved program are not
offered. Configuration exports run without a window or prompt context.
#### Environment and debugger (API 1.9)
Implement `LaunchConfigurations` and register `launch_configurations` instead
to give configurations an environment and a debugger. Each
`PluginLaunchConfiguration` wraps a `PluginRunConfiguration` (`config`) with:
- `env`: variables added to the run's environment, at most 64. As with
`process` commands, a configuration only adds variables: a name the IDE's
own environment already has (`PATH`, …) makes the whole list invalid.
- `debugger`: `None` keeps the default (Debug infers the debugger from a source
file in `args`). `Debugger::Launch { language }` starts `program` under the
debugger of that language id (its `[debugger]`), for programs whose arguments
name no source file. `Debugger::AttachChild { kind, command_contains }` makes
Debug run the configuration as Run does, then attach to the first process of
that Attach to Process kind (`dotnet`, `node`, `python`, `go` or `native`) the
run starts, optionally only one whose command line contains
`command_contains`. Only the run's own descendants are candidates; the IDE
waits for one while the run lasts, up to a minute, and otherwise leaves the
run going without the debugger. A host that predates a later variant treats
the configuration as having no debugger.
```rust
impl LaunchConfigurations for Functions {
fn launch_configurations(&mut self, _root: &str) -> Vec<PluginLaunchConfiguration> {
vec![PluginLaunchConfiguration {
config: PluginRunConfiguration {
id: "func".into(),
name: "Functions host".into(),
program: "func".into(),
args: vec!["start".into(), "--dotnet-isolated-debug".into()],
..Default::default()
},
env: vec![("FUNCTIONS_WORKER_RUNTIME".into(), "dotnet-isolated".into())],
debugger: Some(Debugger::AttachChild { kind: "dotnet".into(), command_contains: None }),
}]
}
}
register_plugin!(Functions, launch_configurations);
```
A component exporting both uses `launch-configurations`. Plugins that call
`run.start(config, args, true)` on such a configuration get the same Debug.
For a static detector, `framework = "plugin"` is an API 1.4 manifest field. For
either kind of configuration, it enables the optional `TestResults` export
(registration `test_results`). `parse(config, chunk)` receives the short config
@@ -2458,7 +2515,7 @@ the API itself follows _Evolving the plugin API_ below.
Released versions are frozen: 1.0.0 shipped with OpenIDEA 0.1.36, 1.1.0
with 0.1.37, 1.2.0 with 0.1.38, 1.3.0 with 0.1.39 and 1.4.0 with 0.1.40.
API 1.5.0 shipped with 0.1.41 and 1.6.0 with 0.1.43; API 1.7.0 is in development on `main`. wasmtime decides what stays compatible: it resolves interface names
API 1.5.0 shipped with 0.1.41, 1.6.0 with 0.1.43, 1.7.0 with 0.1.44 and 1.8.0 with 0.1.45; API 1.9.0 is in development on `main`. wasmtime decides what stays compatible: it resolves interface names
by semver (a component importing `openidea:plugin/[email protected]` links against a
host defining `@1.1.0`, and the host finds its exports the same way), but
function types must match exactly — a record with another field count, or a
Binary file not shown.
+1 -1
View File
@@ -1 +1 @@
93f5619378f0edaf2e78a95b38e92e6e14ffc4377aab425d575dbbcb30c7c3e4
92aa9dc2ab94e8bfa234980aeadc0eb7c437d0917af5526c193f286c97e70214
Binary file not shown.
@@ -1 +1 @@
007134d609d842c6f57386e35a6725948ad17fdd6458a2e209398ee38d034a23
d284a0921686a9a8a05a22db31fe150c0a6bf3743106eee037f1078a96d180a1
Binary file not shown.
+1 -1
View File
@@ -1 +1 @@
01d5abc7a65811684cac58e39d733218d5cde46681b7e57231897f6a07318133
aacf2df2ee10a0cd361152c7459a1c0dfae2741ab1c2fefd2860a32f885a6f40
Binary file not shown.
+1 -1
View File
@@ -1 +1 @@
9b29d2a047e223ecd432fb90914c684f708eb8becba6cc72cd55462064d15956
ba4d1e0b3c0c05b075e9d2c855d17fdb47a45c489a9df74fc9b202c260370bdb
Binary file not shown.
Loaded 100 of 259 files, more files were not shown because too many files have changed in this diff. Show more