mirror of
https://github.com/l0ng-ai/openidea.git
synced 2026-11-17 05:21:15 -10:00
Compare commits
17
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
115a436d80 | ||
|
|
74e66a5dae | ||
|
|
6c301a7b6b | ||
|
|
d171a946fe | ||
|
|
6ae167efc9 | ||
|
|
8432bf9997 | ||
|
|
59fba1a65d | ||
|
|
3bfd3134c0 | ||
|
|
573adbf9ab | ||
|
|
d2381096fb | ||
|
|
2c70c12bf2 | ||
|
|
3ef7fee3e2 | ||
|
|
deec6d05a0 | ||
|
|
4a98ce544b | ||
|
|
396a8d4b26 | ||
|
|
2889b301b8 | ||
|
|
e26e1d1d7d |
No files matched your search
+238
-31
@@ -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 = ¶ms["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"))
|
||||
}
|
||||
|
||||
@@ -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)]
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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";
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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)?;
|
||||
|
||||
@@ -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| {
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)))
|
||||
);
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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())], &[]);
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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 },
|
||||
|
||||
@@ -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
@@ -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
@@ -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
|
||||
Binary file not shown.
+1
-1
@@ -1 +1 @@
|
||||
c37f6a7ea9018ca636d0fd486a9d91cd397158615410de9b837ca9b8f9f593b7
|
||||
491e8e713e51045ebef81c4f07ed5475ed41688e88ac47ee26d13f2bc5c53b49
|
||||
Binary file not shown.
@@ -1 +1 @@
|
||||
1b298dfa5c1f2163d609ef0ccc3d42fafe78e69326002effe53abc4b82974749
|
||||
63b2f6007782c9d3498c86505a6c107b70f09d90678c79cf16c859ecbf349e70
|
||||
+3
-3
@@ -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
|
||||
@@ -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))
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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) |
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -76,6 +76,10 @@ OpenIDEA 本身不带模型或账号:它启动你已安装并登录的 agent
|
||||
|
||||
此快捷键不适用于已归档任务、子 agent 对话或“新建任务”页面,也不会从打开的弹出窗口或对话框中抢走焦点。在任务对话之外,按键保留原有的编辑器或终端行为。要修改或移除绑定,请打开 **设置 › 按键映射 › 智能体 › 聚焦 Agent 输入框**。
|
||||
|
||||
所有内置按键映射中,**循环切换 Agent 思考强度** 的默认快捷键都是 macOS 上的 `Option+T`、Windows / Linux 上的 `Alt+T`。焦点位于“新建任务”或你自己的可输入任务对话中时,无论显示在编辑器标签页还是工具窗口中,它都会按提供商声明的顺序切换当前模型支持的思考强度,从最后一级循环回第一级。它会保留消息、选区、光标和焦点,不发送任何内容。与思考强度控件一样,它修改的是提供商配置,不保证改变已经运行中的轮次。
|
||||
|
||||
不支持思考强度或仅支持一级时,以及已归档任务、子 agent 对话或打开弹出窗口、对话框时,此快捷键不可用。它不会从代码编辑器或终端抢走焦点。要修改或移除绑定,请打开 **设置 › 按键映射 › 智能体 › 循环切换 Agent 思考强度**。
|
||||
|
||||
右键点击链接并选择 **复制链接地址** 可复制它的 URL;**复制** 复制选中的文字。
|
||||
|
||||
### 权限
|
||||
|
||||
@@ -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) |
|
||||
|
||||
|
||||
@@ -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` 导出。
|
||||
|
||||
@@ -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")));
|
||||
});
|
||||
}
|
||||
@@ -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.");
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
@@ -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
@@ -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
|
||||
|
||||
BIN
Binary file not shown.
+1
-1
@@ -1 +1 @@
|
||||
93f5619378f0edaf2e78a95b38e92e6e14ffc4377aab425d575dbbcb30c7c3e4
|
||||
92aa9dc2ab94e8bfa234980aeadc0eb7c437d0917af5526c193f286c97e70214
|
||||
Binary file not shown.
@@ -1 +1 @@
|
||||
007134d609d842c6f57386e35a6725948ad17fdd6458a2e209398ee38d034a23
|
||||
d284a0921686a9a8a05a22db31fe150c0a6bf3743106eee037f1078a96d180a1
|
||||
BIN
Binary file not shown.
+1
-1
@@ -1 +1 @@
|
||||
01d5abc7a65811684cac58e39d733218d5cde46681b7e57231897f6a07318133
|
||||
aacf2df2ee10a0cd361152c7459a1c0dfae2741ab1c2fefd2860a32f885a6f40
|
||||
Binary file not shown.
@@ -1 +1 @@
|
||||
9b29d2a047e223ecd432fb90914c684f708eb8becba6cc72cd55462064d15956
|
||||
ba4d1e0b3c0c05b075e9d2c855d17fdb47a45c489a9df74fc9b202c260370bdb
|
||||
BIN
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
Reference in new issue
Block a user