дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-16 14:45:40 +02:00
Порівняти коміти
67
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
cd574a3e28 | ||
|
|
8aed4156f4 | ||
|
|
0221034936 | ||
|
|
0d432bf1a6 | ||
|
|
cbac930a6f | ||
|
|
33f082e32f | ||
|
|
0bbf5568cd | ||
|
|
2277c1cdfd | ||
|
|
a537223233 | ||
|
|
19c7947fc4 | ||
|
|
98f9fc0063 | ||
|
|
0d5ef48a94 | ||
|
|
444b620985 | ||
|
|
0c45a96d84 | ||
|
|
fd8f8d6dd0 | ||
|
|
c1bec5182c | ||
|
|
dcb4835a87 | ||
|
|
f74bc7abac | ||
|
|
c871c164c1 | ||
|
|
db65b12afe | ||
|
|
0cc873565a | ||
|
|
7cc100367d | ||
|
|
39c0f6676e | ||
|
|
f19d5dc3f9 | ||
|
|
0a8df16941 | ||
|
|
6dcece3081 | ||
|
|
5c59566897 | ||
|
|
6b3edb6cf5 | ||
|
|
e598936529 | ||
|
|
8b7318e59a | ||
|
|
faa9a91953 | ||
|
|
c805173467 | ||
|
|
94b72c271a | ||
|
|
610d68ee41 | ||
|
|
c6bd809d08 | ||
|
|
401d66d850 | ||
|
|
4561ae05b2 | ||
|
|
34c81a61e4 | ||
|
|
3cc4c1c9b1 | ||
|
|
9c07e3e136 | ||
|
|
844611c7d5 | ||
|
|
c9c75fa3b7 | ||
|
|
32abc77a74 | ||
|
|
de107e145c | ||
|
|
9adf35b097 | ||
|
|
0e473c6dac | ||
|
|
b01f70390e | ||
|
|
efc1e607b8 | ||
|
|
f4469a2f53 | ||
|
|
708cca8e4f | ||
|
|
f5b4e5ad8c | ||
|
|
77984361b6 | ||
|
|
86ba75cbf4 | ||
|
|
d50348bc94 | ||
|
|
e8c6ff8f2f | ||
|
|
5150e8e81b | ||
|
|
88a2508bee | ||
|
|
61da1bc685 | ||
|
|
4f2fc3ecb1 | ||
|
|
5b0006fa42 | ||
|
|
d986b7408b | ||
|
|
6b2bb0bb6a | ||
|
|
2b353dfe53 | ||
|
|
ead2594d72 | ||
|
|
2cb573d5ad | ||
|
|
0360690c6a | ||
|
|
f179c970ba |
No files matched your search
@@ -0,0 +1,7 @@
|
||||
# Link debug builds for the oldest system we support, so Launch Services
|
||||
# accepts the bundle on macOS 11. Without this a newer SDK leaves
|
||||
# LC_BUILD_VERSION.minos at 12.0 and the app is refused (-10825) before main
|
||||
# can load a newer WebKit. An explicitly exported MACOSX_DEPLOYMENT_TARGET
|
||||
# still wins: this is only the default for local builds and CI.
|
||||
[env]
|
||||
MACOSX_DEPLOYMENT_TARGET = "11.0"
|
||||
@@ -155,6 +155,7 @@ async fn a_task_runs_on_a_v2_agent_and_resumes_its_session() {
|
||||
config: vec![AgentConfigChoice { id: "model".into(), value: "haiku".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
@@ -17,6 +17,8 @@
|
||||
pub(crate) mod discover;
|
||||
mod normalize;
|
||||
|
||||
pub(crate) use normalize::base64 as normalize_base64;
|
||||
|
||||
use ide_jsonrpc::{Handler, Peer, RpcError, codes};
|
||||
use normalize::Normalizer;
|
||||
use parking_lot::Mutex;
|
||||
|
||||
@@ -109,6 +109,7 @@ impl LaunchContext {
|
||||
provider::Driver::Acp => b"acp",
|
||||
provider::Driver::Codex => b"codex",
|
||||
provider::Driver::Claude => b"claude",
|
||||
provider::Driver::Copilot => b"copilot",
|
||||
},
|
||||
);
|
||||
field(&mut hash, self.spec.command.as_bytes());
|
||||
@@ -203,6 +204,14 @@ impl AgentCatalogs {
|
||||
.unwrap_or_else(|| Self::fallback(shared, provider))
|
||||
}
|
||||
|
||||
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
|
||||
let key = Self::key(shared, provider);
|
||||
let mut state = self.state.lock();
|
||||
if state.entries.get(&key).is_some_and(|e| e.flight.is_none()) {
|
||||
state.entries.remove(&key);
|
||||
}
|
||||
}
|
||||
|
||||
fn snapshot(&self, shared: &Shared, provider: &str, entry: &Entry) -> AgentModelCatalog {
|
||||
let catalog = entry.catalog.clone().unwrap_or_else(|| Self::fallback(shared, provider));
|
||||
AgentModelCatalog {
|
||||
@@ -472,6 +481,43 @@ async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<
|
||||
.collect(),
|
||||
})
|
||||
}
|
||||
provider::Driver::Copilot => {
|
||||
if shared.uses_copilot_acp_fallback(&spec) {
|
||||
let acp_spec = native::copilot::acp_fallback_spec(&spec);
|
||||
return acp::discover::run(shared, &acp_spec).await;
|
||||
}
|
||||
match native::copilot::discover(spec.clone(), shared.paths.project_root.clone()).await {
|
||||
Ok(found) => Ok(Discovered {
|
||||
commands: Some(config::commands_of(
|
||||
&serde_json::json!({ "availableCommands": found.commands }),
|
||||
&spec.id,
|
||||
)),
|
||||
config: config::options_of(&serde_json::json!({ "configOptions": found.options })),
|
||||
levels: found
|
||||
.per_model
|
||||
.into_iter()
|
||||
.map(|(model, opts)| {
|
||||
let parsed = if opts.is_empty() {
|
||||
Vec::new()
|
||||
} else {
|
||||
config::options_of(&serde_json::json!({ "configOptions": opts }))
|
||||
};
|
||||
(model, parsed)
|
||||
})
|
||||
.collect(),
|
||||
}),
|
||||
Err(err) if err.allow_acp_fallback => {
|
||||
tracing::warn!(
|
||||
"Copilot headless catalog discovery failed ({}); falling back to `copilot --acp`",
|
||||
err.message
|
||||
);
|
||||
shared.mark_copilot_acp_fallback(&spec);
|
||||
let acp_spec = native::copilot::acp_fallback_spec(&spec);
|
||||
acp::discover::run(shared, &acp_spec).await
|
||||
}
|
||||
Err(err) => Err(err.message),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -2,8 +2,8 @@
|
||||
//! the agent reports them over ACP.
|
||||
|
||||
use crate::model::{
|
||||
AgentCommand, AgentCommandSource, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit,
|
||||
AgentUsage,
|
||||
AgentCommand, AgentCommandSource, AgentConfigChoice, AgentConfigOption, AgentConfigValue, AgentConfigVia,
|
||||
AgentCost, AgentLimit, AgentModelPricing, AgentUsage,
|
||||
};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
@@ -29,6 +29,7 @@ pub(crate) fn add_client_options(provider: &str, config: &mut Vec<AgentConfigOpt
|
||||
description: Some("Show permission requests from Cursor".into()),
|
||||
cost_category: None,
|
||||
usage_multiplier: None,
|
||||
pricing: None,
|
||||
},
|
||||
AgentConfigValue {
|
||||
value: "bypass".into(),
|
||||
@@ -36,6 +37,7 @@ pub(crate) fn add_client_options(provider: &str, config: &mut Vec<AgentConfigOpt
|
||||
description: Some("Automatically approve tool requests in this conversation".into()),
|
||||
cost_category: None,
|
||||
usage_multiplier: None,
|
||||
pricing: None,
|
||||
},
|
||||
],
|
||||
});
|
||||
@@ -52,6 +54,45 @@ pub(crate) fn bypass_approvals(config: &[AgentConfigOption]) -> bool {
|
||||
.any(|category| selected(category).zip(bypass_value(category)).is_some_and(|(value, bypass)| bypass(value)))
|
||||
}
|
||||
|
||||
/// Mode values that ask before anything changes the project, most careful first: Codex's
|
||||
/// Read Only (its Ask still edits the workspace), Claude Code's default (its Accept Edits
|
||||
/// doesn't ask), then plan modes.
|
||||
const ASKING_MODES: [&str; 4] = ["read-only", "default", "plan", "ask"];
|
||||
|
||||
/// Moves `config` to settings that ask before anything changes the project (a side
|
||||
/// conversation): approvals that approve everything ask, and the mode is the most careful one.
|
||||
pub(crate) fn keep_asking(config: &mut [AgentConfigOption]) {
|
||||
ask_for_approvals(config);
|
||||
for option in config.iter_mut().filter(|o| o.category.as_deref() == Some("mode")) {
|
||||
if let Some(mode) = ASKING_MODES.iter().find(|m| option.values.iter().any(|v| v.value == **m)) {
|
||||
option.current = Some((*mode).to_owned());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The choices that keep a session asking before it changes anything: `wanted` without its
|
||||
/// mode and approval choices, and the [`keep_asking`] value of each such option of `options`.
|
||||
pub(crate) fn asking_choices(options: &[AgentConfigOption], wanted: &[AgentConfigChoice]) -> Vec<AgentConfigChoice> {
|
||||
let guarded = |o: &AgentConfigOption| o.category.as_deref().and_then(bypass_value).is_some();
|
||||
let mut out: Vec<AgentConfigChoice> =
|
||||
wanted.iter().filter(|c| !options.iter().any(|o| o.id == c.id && guarded(o))).cloned().collect();
|
||||
let mut asking = options.to_vec();
|
||||
keep_asking(&mut asking);
|
||||
for option in asking.iter().filter(|o| guarded(o)) {
|
||||
if let Some(value) = &option.current {
|
||||
out.push(AgentConfigChoice { id: option.id.clone(), value: value.clone() });
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Whether `config` is what [`keep_asking`] makes of it.
|
||||
pub(crate) fn keeps_asking(config: &[AgentConfigOption]) -> bool {
|
||||
let mut asking = config.to_vec();
|
||||
keep_asking(&mut asking);
|
||||
asking.iter().zip(config).all(|(a, b)| a.current == b.current)
|
||||
}
|
||||
|
||||
/// For an option of `category` that can approve everything, what tells its approving values.
|
||||
fn bypass_value(category: &str) -> Option<fn(&str) -> bool> {
|
||||
match category {
|
||||
@@ -288,6 +329,7 @@ fn legacy(
|
||||
description: str_of(m, "description"),
|
||||
cost_category: None,
|
||||
usage_multiplier: None,
|
||||
pricing: pricing_of(m),
|
||||
value,
|
||||
})
|
||||
})
|
||||
@@ -324,10 +366,18 @@ fn value_of(v: &Value) -> Option<AgentConfigValue> {
|
||||
description: str_of(v, "description"),
|
||||
cost_category,
|
||||
usage_multiplier,
|
||||
pricing: pricing_of(v),
|
||||
value,
|
||||
})
|
||||
}
|
||||
|
||||
fn pricing_of(v: &Value) -> Option<Box<AgentModelPricing>> {
|
||||
v.pointer("/_meta/pricing")
|
||||
.or_else(|| v.get("pricing"))
|
||||
.and_then(|p| serde_json::from_value(p.clone()).ok())
|
||||
.map(Box::new)
|
||||
}
|
||||
|
||||
fn str_of(v: &Value, key: &str) -> Option<String> {
|
||||
v.get(key).and_then(Value::as_str).map(str::to_owned)
|
||||
}
|
||||
@@ -453,6 +503,26 @@ mod tests {
|
||||
assert_eq!(ids(&c), [("allow_all", Some("off")), ("approval", Some("ask"))]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn asking_choices_keep_a_side_conversation_from_changing_anything() {
|
||||
let codex = options_of(&json!({"modes": {"currentModeId": "full-access",
|
||||
"availableModes": [{"id": "read-only"}, {"id": "ask"}, {"id": "auto"}, {"id": "full-access"}]}}));
|
||||
let mode = codex[0].id.clone();
|
||||
let choice = |id: &str, value: &str| AgentConfigChoice { id: id.into(), value: value.into() };
|
||||
// Codex goes to Read Only (its Ask edits the workspace), whatever the source task chose.
|
||||
let wanted = asking_choices(&codex, &[choice(&mode, "full-access"), choice("model", "gpt")]);
|
||||
assert_eq!(wanted, [choice("model", "gpt"), choice(&mode, "read-only")]);
|
||||
assert_eq!(asking_choices(&codex, &[choice(&mode, "ask")]), [choice(&mode, "read-only")]);
|
||||
// Claude Code's Accept Edits doesn't ask: default does.
|
||||
let claude = options_of(&json!({"modes": {"currentModeId": "acceptEdits",
|
||||
"availableModes": [{"id": "default"}, {"id": "acceptEdits"}, {"id": "plan"}, {"id": "bypassPermissions"}]}}));
|
||||
assert_eq!(asking_choices(&claude, &[]), [choice(&claude[0].id, "default")]);
|
||||
assert!(!keeps_asking(&claude));
|
||||
let mut safe = claude.clone();
|
||||
keep_asking(&mut safe);
|
||||
assert!(keeps_asking(&safe));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn effort_and_fast_categories_are_inferred_from_ids() {
|
||||
let mut c = options_of(&json!({
|
||||
|
||||
@@ -70,6 +70,8 @@ pub(crate) const LIMITS_UPDATE: &str = "openidea_limits";
|
||||
/// A native agent's own update: the background tasks its session runs
|
||||
/// (see [`TaskState::background_tasks`]).
|
||||
pub(crate) const BACKGROUND_TASKS_UPDATE: &str = "openidea_background_tasks";
|
||||
/// A native agent's diagnostic, including warnings emitted before a session exists.
|
||||
pub(crate) const WARNING_NOTIFICATION: &str = "_openidea/warning";
|
||||
/// Referenced files up to this size are embedded in the prompt (when the agent takes it).
|
||||
const MAX_EMBED: u64 = 256 * 1024;
|
||||
/// How long a probe waits for the agent to answer `initialize`.
|
||||
@@ -121,6 +123,13 @@ type Connector = Arc<
|
||||
/// Returns the configured MCP servers (User and Workspace) for this project.
|
||||
pub type McpServersFn = dyn Fn() -> Vec<McpServer> + Send + Sync;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
||||
struct CopilotBinaryKey {
|
||||
command: String,
|
||||
modified: Option<std::time::SystemTime>,
|
||||
len: Option<u64>,
|
||||
}
|
||||
|
||||
struct Shared {
|
||||
paths: AgentPaths,
|
||||
runtime: tokio::runtime::Handle,
|
||||
@@ -132,6 +141,8 @@ struct Shared {
|
||||
providers: RwLock<Vec<provider::ProviderSpec>>,
|
||||
/// Last probe of each provider.
|
||||
probes: Mutex<HashMap<String, AgentProbe>>,
|
||||
/// Copilot CLI installs where `--headless` failed and fell back to `--acp`.
|
||||
copilot_acp_fallback: Mutex<HashSet<CopilotBinaryKey>>,
|
||||
/// [`IDLE_RELEASE`], in milliseconds (shorter in tests).
|
||||
idle_release_ms: AtomicU64,
|
||||
mcp_servers_hook: RwLock<Option<Arc<McpServersFn>>>,
|
||||
@@ -169,6 +180,29 @@ impl Shared {
|
||||
self.paths.env_secrets.as_deref()
|
||||
}
|
||||
|
||||
fn copilot_binary_key(&self, spec: &provider::ProviderSpec) -> CopilotBinaryKey {
|
||||
let resolved = spec.clone().resolve_for_launch(&self.paths.project_root);
|
||||
let executable = dunce::canonicalize(&resolved.command).unwrap_or_else(|_| PathBuf::from(&resolved.command));
|
||||
let metadata = std::fs::metadata(&executable).ok();
|
||||
CopilotBinaryKey {
|
||||
command: executable.to_string_lossy().into_owned(),
|
||||
modified: metadata.as_ref().and_then(|m| m.modified().ok()),
|
||||
len: metadata.as_ref().map(std::fs::Metadata::len),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn uses_copilot_acp_fallback(&self, spec: &provider::ProviderSpec) -> bool {
|
||||
let key = self.copilot_binary_key(spec);
|
||||
self.copilot_acp_fallback.lock().contains(&key)
|
||||
}
|
||||
|
||||
pub(crate) fn mark_copilot_acp_fallback(&self, spec: &provider::ProviderSpec) {
|
||||
let key = self.copilot_binary_key(spec);
|
||||
if self.copilot_acp_fallback.lock().insert(key) {
|
||||
self.paths.catalogs.evict_if_idle(self, &spec.id);
|
||||
}
|
||||
}
|
||||
|
||||
fn emit(&self, event: AgentEvent) {
|
||||
let sink = self.sink.read().clone();
|
||||
if let Some(sink) = sink {
|
||||
@@ -176,11 +210,23 @@ impl Shared {
|
||||
}
|
||||
}
|
||||
|
||||
fn mcp_servers_for_session(&self, provider: &str, init: &acp::Negotiated) -> Vec<Value> {
|
||||
let mut servers = mcp_servers_for(init.mcp_stdio(), &self.paths.project_root);
|
||||
/// The MCP servers passed to a session, and the names of the ones off for it.
|
||||
fn mcp_servers_for_session(
|
||||
&self,
|
||||
provider: &str,
|
||||
init: &acp::Negotiated,
|
||||
overrides: &BTreeMap<String, bool>,
|
||||
) -> McpForSession {
|
||||
let builtin_off = overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false);
|
||||
let mut servers =
|
||||
if builtin_off { Vec::new() } else { mcp_servers_for(init.mcp_stdio(), &self.paths.project_root) };
|
||||
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
|
||||
servers.extend(mcp::acp_mcp_servers(&configured, provider, init));
|
||||
servers
|
||||
servers.extend(mcp::acp_mcp_servers(&configured, provider, init, overrides));
|
||||
let mut off = mcp::servers_off(&configured, overrides);
|
||||
if builtin_off {
|
||||
off.push(BUILTIN_SERVER.to_owned());
|
||||
}
|
||||
McpForSession { servers, off }
|
||||
}
|
||||
|
||||
fn known_config(&self, provider: &str) -> Vec<AgentConfigOption> {
|
||||
@@ -340,6 +386,8 @@ struct TaskState {
|
||||
/// A running agent and its session.
|
||||
#[derive(Clone)]
|
||||
struct Live {
|
||||
provider: String,
|
||||
driver: provider::Driver,
|
||||
sign_in_message: String,
|
||||
peer: acp::Conn,
|
||||
session: String,
|
||||
@@ -375,6 +423,8 @@ struct Task {
|
||||
/// Bumped when the agent's last background task finishes: an idle release scheduled
|
||||
/// before that is void, the usual delay starts over from the report.
|
||||
idle_epoch: AtomicU64,
|
||||
/// Turned on when per-session MCP overrides changed while a turn was busy; dropped once idle.
|
||||
mcp_reload_pending: AtomicBool,
|
||||
/// Settings already sent this session (`(option, value)`), so a refusal is not retried.
|
||||
config_sent: Mutex<HashSet<(String, String)>>,
|
||||
dirty: Mutex<BTreeSet<(Session, usize)>>,
|
||||
@@ -400,6 +450,7 @@ impl AgentManager {
|
||||
}
|
||||
provider::Driver::Codex => native::codex::connect(spec, cwd, client, on_stderr),
|
||||
provider::Driver::Claude => native::claude::connect(spec, cwd, client, on_stderr),
|
||||
provider::Driver::Copilot => native::copilot::connect(spec, cwd, client, on_stderr),
|
||||
});
|
||||
Self::with_connector(paths, runtime, connector)
|
||||
}
|
||||
@@ -417,6 +468,7 @@ impl AgentManager {
|
||||
known,
|
||||
providers,
|
||||
probes: Mutex::new(HashMap::new()),
|
||||
copilot_acp_fallback: Mutex::new(HashSet::new()),
|
||||
idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),
|
||||
mcp_servers_hook: RwLock::new(None),
|
||||
attention_seq: AtomicU64::new(0),
|
||||
@@ -550,6 +602,7 @@ impl AgentManager {
|
||||
let specs = provider::load(self.shared.paths.custom_agents_dir.as_deref(), self.shared.env_secrets());
|
||||
*self.shared.providers.write() = specs;
|
||||
self.shared.probes.lock().clear();
|
||||
self.shared.copilot_acp_fallback.lock().clear();
|
||||
self.shared.emit(AgentEvent::Providers);
|
||||
}
|
||||
|
||||
@@ -589,14 +642,9 @@ impl AgentManager {
|
||||
}
|
||||
offered = self.shared.known_commands(&provider);
|
||||
}
|
||||
for &(name, description) in builtin_commands(&provider) {
|
||||
if !offered.iter().any(|c| c.name == name) {
|
||||
offered.push(AgentCommand {
|
||||
name: name.to_owned(),
|
||||
description: description.to_owned(),
|
||||
hint: None,
|
||||
source: AgentCommandSource::Command,
|
||||
});
|
||||
for command in builtin_commands(&provider) {
|
||||
if !offered.iter().any(|c| c.name == command.name) {
|
||||
offered.push(command);
|
||||
}
|
||||
}
|
||||
if provider != "claude" && provider != "claude-acp" {
|
||||
@@ -687,6 +735,7 @@ impl AgentManager {
|
||||
resets_ms: None,
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
};
|
||||
let handle = self.register(TaskFile {
|
||||
task: task.clone(),
|
||||
@@ -778,6 +827,7 @@ impl AgentManager {
|
||||
resets_ms: None,
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: req.mcp_overrides,
|
||||
};
|
||||
let handle = self.register(TaskFile {
|
||||
task: task.clone(),
|
||||
@@ -844,7 +894,9 @@ impl AgentManager {
|
||||
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);
|
||||
// The source task's choices may change the project without asking; the side conversation asks.
|
||||
let wanted = config::asking_choices(&config, &req.config);
|
||||
config::keep_asking(&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",
|
||||
@@ -879,13 +931,14 @@ impl AgentManager {
|
||||
resets_ms: None,
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: req.mcp_overrides,
|
||||
config,
|
||||
};
|
||||
let handle = self.register(TaskFile {
|
||||
task: task.clone(),
|
||||
session_id: None,
|
||||
entries: Vec::new(),
|
||||
wanted: req.config,
|
||||
wanted,
|
||||
before,
|
||||
saved: None,
|
||||
touched: None,
|
||||
@@ -1002,6 +1055,15 @@ impl AgentManager {
|
||||
if !o.values.iter().any(|v| v.value == value) {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", o.name)));
|
||||
}
|
||||
if s.ephemeral {
|
||||
let mut next = s.task.config.clone();
|
||||
if let Some(n) = next.iter_mut().find(|n| n.id == option) {
|
||||
n.current = Some(value.clone());
|
||||
}
|
||||
if !config::keeps_asking(&next) {
|
||||
return Err(IdeError::invalid("a side conversation asks before changing anything"));
|
||||
}
|
||||
}
|
||||
o.clone()
|
||||
};
|
||||
let previous = target.current.clone();
|
||||
@@ -1053,6 +1115,7 @@ impl AgentManager {
|
||||
o.current = Some(value);
|
||||
}
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
sync_usage_context_size(&mut s.task);
|
||||
let provider = s.task.provider.clone();
|
||||
let config = s.task.config.clone();
|
||||
let model = s.task.model.clone().filter(|_| model_options);
|
||||
@@ -1079,15 +1142,21 @@ impl AgentManager {
|
||||
if !live.capabilities.fork || (keep < total && !live.capabilities.rollback) {
|
||||
return Err(IdeError::invalid("this agent can't copy a conversation from there"));
|
||||
}
|
||||
let cwd = source.state.lock().task.cwd.0.clone();
|
||||
let provider_id = source.state.lock().task.provider.clone();
|
||||
let mcp_servers = source.shared.mcp_servers_for_session(&provider_id, &live.init);
|
||||
let (cwd, provider_id, mcp_overrides) = {
|
||||
let s = source.state.lock();
|
||||
(s.task.cwd.0.clone(), s.task.provider.clone(), s.task.mcp_overrides.clone())
|
||||
};
|
||||
let mcp_servers = source.shared.mcp_servers_for_session(&provider_id, &live.init, &mcp_overrides);
|
||||
let cwd_s = dunce::canonicalize(&cwd).unwrap_or(cwd).to_string_lossy().into_owned();
|
||||
let reply: Value = live
|
||||
.peer
|
||||
.request(
|
||||
"session/fork",
|
||||
json!({ "sessionId": live.session, "cwd": cwd_s, "mcpServers": mcp_servers }),
|
||||
{
|
||||
let mut params = session_params(&cwd_s, &mcp_servers);
|
||||
params["sessionId"] = json!(live.session);
|
||||
params
|
||||
},
|
||||
None,
|
||||
)
|
||||
.await
|
||||
@@ -1215,12 +1284,30 @@ impl AgentManager {
|
||||
if !refresh && let Some(p) = self.shared.probes.lock().get(provider) {
|
||||
return Ok(p.clone());
|
||||
}
|
||||
let spec = self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?;
|
||||
let raw_spec =
|
||||
self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?;
|
||||
let can_fallback =
|
||||
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
|
||||
let mut active_spec = if raw_spec.driver == provider::Driver::Copilot && !can_fallback {
|
||||
native::copilot::acp_fallback_spec(&raw_spec)
|
||||
} else {
|
||||
raw_spec.clone()
|
||||
};
|
||||
let reply = match self.probe_once(&active_spec).await {
|
||||
Ok(reply) => Ok(reply),
|
||||
Err((err, allow_fallback)) if can_fallback && allow_fallback => {
|
||||
tracing::warn!("Copilot headless probe failed ({err}); falling back to `copilot --acp`");
|
||||
self.shared.mark_copilot_acp_fallback(&raw_spec);
|
||||
active_spec = native::copilot::acp_fallback_spec(&raw_spec);
|
||||
self.probe_once(&active_spec).await.map_err(|(e, _)| e)
|
||||
}
|
||||
Err((err, _)) => Err(err),
|
||||
};
|
||||
let mut probe = AgentProbe {
|
||||
provider: spec.id.clone(),
|
||||
provider: active_spec.id.clone(),
|
||||
name: None,
|
||||
version: None,
|
||||
protocol: match spec.driver {
|
||||
protocol: match active_spec.driver {
|
||||
provider::Driver::Acp => "ACP".into(),
|
||||
_ => "native".into(),
|
||||
},
|
||||
@@ -1228,31 +1315,6 @@ impl AgentManager {
|
||||
auth_methods: Vec::new(),
|
||||
error: None,
|
||||
};
|
||||
let stderr: Arc<Mutex<Vec<String>>> = Arc::default();
|
||||
let lines = stderr.clone();
|
||||
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(move |l| lines.lock().push(l));
|
||||
let started = (self.shared.connector)(
|
||||
&spec,
|
||||
&self.shared.paths.project_root,
|
||||
Arc::new(ide_jsonrpc::NoopHandler),
|
||||
on_stderr,
|
||||
);
|
||||
let reply = match started {
|
||||
Err(e) => Err(format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command)),
|
||||
Ok(peer) => {
|
||||
let params = acp::initialize_params(&client_info());
|
||||
let r = tokio::time::timeout(PROBE_TIMEOUT, peer.request::<_, Value>("initialize", params, None)).await;
|
||||
peer.kill();
|
||||
match r {
|
||||
Ok(Ok(v)) => Ok(v),
|
||||
Ok(Err(e)) => Err(match stderr.lock().last() {
|
||||
Some(line) => format!("{e}: {line}"),
|
||||
None => e.to_string(),
|
||||
}),
|
||||
Err(_) => Err("the agent did not answer".into()),
|
||||
}
|
||||
}
|
||||
};
|
||||
match reply {
|
||||
Ok(reply) => {
|
||||
let init = acp::Negotiated::from_initialize(&reply);
|
||||
@@ -1260,7 +1322,7 @@ impl AgentManager {
|
||||
let text = |k: &str| info.get(k).and_then(Value::as_str).map(str::to_owned);
|
||||
probe.name = text("title").or_else(|| text("name"));
|
||||
probe.version = text("version");
|
||||
if spec.driver == provider::Driver::Acp {
|
||||
if active_spec.driver == provider::Driver::Acp {
|
||||
probe.protocol = format!("ACP v{}", init.generation);
|
||||
}
|
||||
probe.capabilities = capabilities_of(&init).0;
|
||||
@@ -1273,11 +1335,47 @@ impl AgentManager {
|
||||
Err(e) => probe.error = Some(e),
|
||||
}
|
||||
if probe.error.is_none() {
|
||||
self.shared.probes.lock().insert(spec.id, probe.clone());
|
||||
self.shared.probes.lock().insert(active_spec.id, probe.clone());
|
||||
}
|
||||
Ok(probe)
|
||||
}
|
||||
|
||||
async fn probe_once(&self, spec: &provider::ProviderSpec) -> Result<Value, (String, bool)> {
|
||||
let stderr: Arc<Mutex<Vec<String>>> = Arc::default();
|
||||
let lines = stderr.clone();
|
||||
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(move |l| lines.lock().push(l));
|
||||
let started = (self.shared.connector)(
|
||||
spec,
|
||||
&self.shared.paths.project_root,
|
||||
Arc::new(ide_jsonrpc::NoopHandler),
|
||||
on_stderr,
|
||||
);
|
||||
match started {
|
||||
Err(e) => Err((
|
||||
format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command),
|
||||
!native::copilot::is_missing_binary_error(&e),
|
||||
)),
|
||||
Ok(peer) => {
|
||||
let params = acp::initialize_params(&client_info());
|
||||
let r = tokio::time::timeout(PROBE_TIMEOUT, peer.request::<_, Value>("initialize", params, None)).await;
|
||||
peer.kill();
|
||||
match r {
|
||||
Ok(Ok(v)) => Ok(v),
|
||||
Ok(Err(e)) => {
|
||||
let is_auth =
|
||||
matches!(&e, RpcError::Server { code, message, .. } if acp::auth_required(*code, message));
|
||||
let msg = match stderr.lock().last() {
|
||||
Some(line) => format!("{e}: {line}"),
|
||||
None => e.to_string(),
|
||||
};
|
||||
Err((msg, !is_auth))
|
||||
}
|
||||
Err(_) => Err(("the agent did not answer".into(), true)),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Stops the current turn (`session/cancel`); pending permission requests are cancelled.
|
||||
/// Queued messages stay queued. With `subagent`, stops only that subagent's work.
|
||||
pub fn cancel(&self, id: &str, subagent: Option<String>) -> IdeResult<()> {
|
||||
@@ -1536,6 +1634,43 @@ impl AgentManager {
|
||||
.await
|
||||
}
|
||||
|
||||
/// Updates per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
|
||||
/// When the task is idle and holds a resumable live session without running background tasks,
|
||||
/// stops the idle process so the next turn reloads the session with the updated MCP servers;
|
||||
/// when busy, schedules the reload for as soon as the turn finishes.
|
||||
pub fn set_mcp_overrides(&self, id: &str, overrides: BTreeMap<String, bool>) -> IdeResult<AgentTask> {
|
||||
let task = self.task(id)?;
|
||||
let cleaned: BTreeMap<String, bool> = overrides
|
||||
.into_iter()
|
||||
.filter_map(|(k, v)| {
|
||||
let k = k.trim();
|
||||
(!k.is_empty()).then(|| (k.to_owned(), v))
|
||||
})
|
||||
.collect();
|
||||
let (changed, busy, has_bg, out) = {
|
||||
let mut s = task.state.lock();
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
let changed = s.task.mcp_overrides != cleaned;
|
||||
if changed {
|
||||
s.task.mcp_overrides = cleaned;
|
||||
s.task.updated_ms = now_ms();
|
||||
}
|
||||
(changed, s.busy, !s.background_tasks.is_empty(), s.task.clone())
|
||||
};
|
||||
if changed {
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
if busy || has_bg || !task.permissions.lock().is_empty() {
|
||||
task.mcp_reload_pending.store(true, Ordering::Release);
|
||||
} else {
|
||||
task.recycle_resumable_session();
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Stops every agent (project closed).
|
||||
pub fn shutdown(&self) {
|
||||
for task in self.tasks.read().values() {
|
||||
@@ -1580,6 +1715,7 @@ impl Task {
|
||||
turn_started: AtomicBool::new(false),
|
||||
turns: AtomicU64::new(0),
|
||||
idle_epoch: AtomicU64::new(0),
|
||||
mcp_reload_pending: AtomicBool::new(false),
|
||||
config_sent: Mutex::new(HashSet::new()),
|
||||
dirty: Mutex::new(BTreeSet::new()),
|
||||
streamed: Mutex::new(HashMap::new()),
|
||||
@@ -1637,7 +1773,7 @@ impl Task {
|
||||
|
||||
fn emit_task(&self) {
|
||||
let task = self.state.lock().task.clone();
|
||||
self.shared.emit(AgentEvent::Task { task });
|
||||
self.shared.emit(AgentEvent::Task { task: Box::new(task) });
|
||||
}
|
||||
|
||||
/// Shows (or clears) the agent's pending retry; emitted only when it changes.
|
||||
@@ -1827,6 +1963,12 @@ impl Task {
|
||||
if stop != "cancelled" {
|
||||
self.emit_attention(AgentAttentionReason::Finished);
|
||||
}
|
||||
if self.mcp_reload_pending.swap(false, Ordering::AcqRel)
|
||||
&& self.state.lock().background_tasks.is_empty()
|
||||
{
|
||||
self.recycle_resumable_session();
|
||||
return;
|
||||
}
|
||||
return self.release_when_idle();
|
||||
}
|
||||
(None, Err(failure)) => return self.fail(failure),
|
||||
@@ -1834,6 +1976,20 @@ impl Task {
|
||||
}
|
||||
}
|
||||
|
||||
/// Drops an idle resumable live session so the next turn reloads it with fresh MCP servers.
|
||||
fn recycle_resumable_session(&self) {
|
||||
self.mcp_reload_pending.store(false, Ordering::Release);
|
||||
let live = {
|
||||
let mut live = self.live.lock();
|
||||
if live.as_ref().is_some_and(|l| l.resumable && !l.peer.is_closed()) { live.take() } else { None }
|
||||
};
|
||||
if let Some(live) = live {
|
||||
tracing::debug!("agent task {}: restarting idle resumable session for MCP override update", self.id);
|
||||
live.peer.kill();
|
||||
self.clear_shown_background();
|
||||
}
|
||||
}
|
||||
|
||||
/// Stops the agent's process once the task has stayed idle for [`IDLE_RELEASE`], so
|
||||
/// finished tasks don't keep an agent (and what it started) running. Only an agent that
|
||||
/// reloads its session: the next message starts it again with the conversation intact.
|
||||
@@ -1969,7 +2125,7 @@ impl Task {
|
||||
// Launching the agent can take a while (`npx` fetches its adapter on first use).
|
||||
let starting = self.live.lock().as_ref().is_none_or(|l| l.peer.is_closed());
|
||||
self.set_status(if starting { AgentStatus::Starting } else { AgentStatus::Running }, None);
|
||||
let live = self.ensure_session().await.map_err(Failure::from)?;
|
||||
let mut live = self.ensure_session().await.map_err(Failure::from)?;
|
||||
// Stopped while the agent started: the prompt is never sent.
|
||||
if self.cancel_pending.load(Ordering::Acquire) {
|
||||
return Ok("cancelled".into());
|
||||
@@ -1991,9 +2147,34 @@ impl Task {
|
||||
None => prompt.clone(),
|
||||
}
|
||||
};
|
||||
let content = self.content(&live, &prompt).await;
|
||||
let result: Result<Value, RpcError> =
|
||||
let mut content = self.content(&live, &prompt).await;
|
||||
let mut result: Result<Value, RpcError> =
|
||||
live.peer.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None).await;
|
||||
if live.driver == provider::Driver::Copilot
|
||||
&& !self.turn_started.load(Ordering::Acquire)
|
||||
&& let Err(RpcError::Server { code, ref message, .. }) = result
|
||||
&& is_headless_protocol_error(code)
|
||||
&& !acp::auth_required(code, message)
|
||||
{
|
||||
tracing::warn!(
|
||||
"agent task {}: Copilot headless prompt failed ({message}); falling back to `copilot --acp`",
|
||||
self.id
|
||||
);
|
||||
if let Some(raw_spec) = self.shared.spec(&live.provider) {
|
||||
self.shared.mark_copilot_acp_fallback(&raw_spec);
|
||||
}
|
||||
live.peer.kill();
|
||||
*self.live.lock() = None;
|
||||
live = self.ensure_session().await.map_err(Failure::from)?;
|
||||
if !prompt.images.is_empty() && !live.capabilities.images {
|
||||
return Err(Failure::from("This agent can't read images.".to_owned()));
|
||||
}
|
||||
content = self.content(&live, &prompt).await;
|
||||
result = live
|
||||
.peer
|
||||
.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None)
|
||||
.await;
|
||||
}
|
||||
match result {
|
||||
Ok(v) => Ok(v.get("stopReason").and_then(Value::as_str).unwrap_or("end_turn").to_owned()),
|
||||
Err(e) => Err(self.failure(e)),
|
||||
@@ -2073,11 +2254,43 @@ impl Task {
|
||||
let s = self.state.lock();
|
||||
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone())
|
||||
};
|
||||
let spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
|
||||
let launch_cwd = cwd.clone();
|
||||
let raw_spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
|
||||
let can_fallback =
|
||||
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
|
||||
let primary_spec = if raw_spec.driver == provider::Driver::Copilot && !can_fallback {
|
||||
native::copilot::acp_fallback_spec(&raw_spec)
|
||||
} else {
|
||||
raw_spec.clone()
|
||||
};
|
||||
let live = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone()).await {
|
||||
Ok(live) => live,
|
||||
Err(err) if can_fallback && err.allow_acp_fallback => {
|
||||
tracing::warn!(
|
||||
"agent task {}: Copilot headless session setup failed ({}); falling back to `copilot --acp`",
|
||||
self.id,
|
||||
err.message
|
||||
);
|
||||
self.shared.mark_copilot_acp_fallback(&raw_spec);
|
||||
let acp_spec = native::copilot::acp_fallback_spec(&raw_spec);
|
||||
self.open_session(&provider_id, acp_spec, &cwd, saved).await.map_err(|e| e.message)?
|
||||
}
|
||||
Err(err) => return Err(err.message),
|
||||
};
|
||||
*self.live.lock() = Some(live.clone());
|
||||
Ok(live)
|
||||
}
|
||||
|
||||
async fn open_session(
|
||||
self: &Arc<Self>,
|
||||
provider_id: &str,
|
||||
spec: provider::ProviderSpec,
|
||||
cwd: &Path,
|
||||
saved: Option<String>,
|
||||
) -> Result<Live, SessionOpenError> {
|
||||
let launch_cwd = cwd.to_path_buf();
|
||||
let spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?;
|
||||
self.stderr.lock().clear();
|
||||
self.config_sent.lock().clear();
|
||||
let weak = Arc::downgrade(self);
|
||||
@@ -2092,23 +2305,32 @@ impl Task {
|
||||
});
|
||||
// Speaks ACP v1 or v2, whichever the agent chooses; the task sees v1 either way.
|
||||
let client = acp::Dialect::wrap(Arc::new(Client { task: Arc::downgrade(self) }));
|
||||
let peer = (self.shared.connector)(&spec, &cwd, client.clone(), on_stderr)
|
||||
.map(|peer| acp::Conn::new(peer, client))
|
||||
.map_err(|e| format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command))?;
|
||||
let raw_peer =
|
||||
(self.shared.connector)(&spec, cwd, client.clone(), on_stderr).map_err(|e| SessionOpenError {
|
||||
message: format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command),
|
||||
allow_acp_fallback: !native::copilot::is_missing_binary_error(&e),
|
||||
})?;
|
||||
let mut stop_on_err = KillOnDrop(Some(raw_peer.clone()));
|
||||
let peer = acp::Conn::new(raw_peer, client);
|
||||
|
||||
let init = peer.initialize(&client_info()).await.map_err(|e| self.describe(e))?;
|
||||
let init = peer.initialize(&client_info()).await.map_err(|e| {
|
||||
let is_auth = matches!(&e, RpcError::Server { code, message, .. } if acp::auth_required(*code, message));
|
||||
SessionOpenError { message: self.describe(e), allow_acp_fallback: !is_auth }
|
||||
})?;
|
||||
let sign_in_message = spec.sign_in_message(&init.auth_methods);
|
||||
let can_load = init.load_session();
|
||||
let (capabilities, embedded) = capabilities_of(&init);
|
||||
let mcp_servers = self.shared.mcp_servers_for_session(&provider_id, &init);
|
||||
let mcp_overrides = self.state.lock().task.mcp_overrides.clone();
|
||||
let mcp_servers = self.shared.mcp_servers_for_session(provider_id, &init, &mcp_overrides);
|
||||
// Agents that compare canonical paths fail in a symlinked directory (macOS `/tmp`).
|
||||
let cwd_s = dunce::canonicalize(&cwd).unwrap_or(cwd).to_string_lossy().into_owned();
|
||||
let cwd_s = dunce::canonicalize(cwd).unwrap_or_else(|_| cwd.to_path_buf()).to_string_lossy().into_owned();
|
||||
|
||||
let mut tried_auth = false;
|
||||
let mut session = None;
|
||||
if let (Some(id), true) = (saved, can_load) {
|
||||
self.replaying.store(true, Ordering::Release);
|
||||
let params = json!({ "sessionId": &id, "cwd": &cwd_s, "mcpServers": &mcp_servers });
|
||||
let mut params = session_params(&cwd_s, &mcp_servers);
|
||||
params["sessionId"] = json!(&id);
|
||||
let loaded = self.request_with_auth(&peer, &init, &mut tried_auth, "session/load", params).await;
|
||||
tokio::time::sleep(REPLAY_GRACE).await;
|
||||
self.replaying.store(false, Ordering::Release);
|
||||
@@ -2121,12 +2343,21 @@ impl Task {
|
||||
let (session_id, result) = match session {
|
||||
Some(s) => s,
|
||||
None => {
|
||||
let params = json!({ "cwd": &cwd_s, "mcpServers": &mcp_servers });
|
||||
let v = self
|
||||
.request_with_auth(&peer, &init, &mut tried_auth, "session/new", params)
|
||||
.await
|
||||
.map_err(|e| self.sign_in_error(&e, Some(&sign_in_message)).unwrap_or_else(|| self.describe(e)))?;
|
||||
let id = v.get("sessionId").and_then(Value::as_str).ok_or("the agent returned no session")?.to_owned();
|
||||
let params = session_params(&cwd_s, &mcp_servers);
|
||||
let v = self.request_with_auth(&peer, &init, &mut tried_auth, "session/new", params).await.map_err(
|
||||
|e| match self.sign_in_error(&e, Some(&sign_in_message)) {
|
||||
Some(msg) => SessionOpenError { message: msg, allow_acp_fallback: false },
|
||||
None => SessionOpenError { message: self.describe(e), allow_acp_fallback: true },
|
||||
},
|
||||
)?;
|
||||
let id = v
|
||||
.get("sessionId")
|
||||
.and_then(Value::as_str)
|
||||
.ok_or_else(|| SessionOpenError {
|
||||
message: "the agent returned no session".into(),
|
||||
allow_acp_fallback: true,
|
||||
})?
|
||||
.to_owned();
|
||||
(id, v)
|
||||
}
|
||||
};
|
||||
@@ -2149,13 +2380,16 @@ impl Task {
|
||||
let reported = config::options_of(&result);
|
||||
let known = !reported.is_empty();
|
||||
if known {
|
||||
self.shared.remember(&provider_id, Some(&reported), None, model_of(&reported).as_deref());
|
||||
self.shared.remember(provider_id, Some(&reported), None, model_of(&reported).as_deref());
|
||||
}
|
||||
let (mut options, mut wanted) = {
|
||||
let s = self.state.lock();
|
||||
(if known { reported } else { s.task.config.clone() }, s.wanted.clone())
|
||||
let options = if known { reported } else { s.task.config.clone() };
|
||||
// A side conversation asks before anything, whatever mode the agent starts in.
|
||||
let wanted = if s.ephemeral { config::asking_choices(&options, &s.wanted) } else { s.wanted.clone() };
|
||||
(options, wanted)
|
||||
};
|
||||
config::add_client_options(&provider_id, &mut options);
|
||||
config::add_client_options(provider_id, &mut options);
|
||||
// Changing model can replace the effort / context-tier choices; validate those only afterwards.
|
||||
wanted.sort_by_key(|c| match options.iter().find(|o| o.id == c.id) {
|
||||
Some(o) if o.category.as_deref() == Some("model") => 0,
|
||||
@@ -2200,8 +2434,16 @@ impl Task {
|
||||
Err(e) => tracing::warn!("agent task {}: setting {} to {} failed: {e}", self.id, o.id, choice.value),
|
||||
}
|
||||
}
|
||||
// A side conversation never runs in a mode that changes things without asking: when the
|
||||
// agent refused the switch, it doesn't start.
|
||||
if self.state.lock().ephemeral && !config::keeps_asking(&options) {
|
||||
return Err(SessionOpenError {
|
||||
message: "The agent didn't switch to a mode that asks before changing anything, so the side conversation can't start".into(),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
let model = model_of(&options).filter(|_| model_options);
|
||||
self.shared.remember(&provider_id, Some(&options), None, model.as_deref());
|
||||
self.shared.remember(provider_id, Some(&options), None, model.as_deref());
|
||||
{
|
||||
let mut s = self.state.lock();
|
||||
s.task.model = model_of(&options).or(s.task.model.take());
|
||||
@@ -2214,10 +2456,18 @@ impl Task {
|
||||
}
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
let live =
|
||||
Live { sign_in_message, peer, session: session_id, capabilities, embedded, resumable: can_load, init };
|
||||
*self.live.lock() = Some(live.clone());
|
||||
Ok(live)
|
||||
stop_on_err.0 = None;
|
||||
Ok(Live {
|
||||
provider: provider_id.to_owned(),
|
||||
driver: spec.driver,
|
||||
sign_in_message,
|
||||
peer,
|
||||
session: session_id,
|
||||
capabilities,
|
||||
embedded,
|
||||
resumable: can_load,
|
||||
init,
|
||||
})
|
||||
}
|
||||
|
||||
/// Sends the user's choices that the session offers only now: an option advertised
|
||||
@@ -2259,6 +2509,7 @@ impl Task {
|
||||
o.current = Some(value);
|
||||
}
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
sync_usage_context_size(&mut s.task);
|
||||
// As in `set_config`: a copy without per-model options can't vouch for them.
|
||||
let model = s.task.model.clone().filter(|_| {
|
||||
reply.get("configOptions").is_some()
|
||||
@@ -2334,11 +2585,20 @@ impl Task {
|
||||
if let Some(title) = title {
|
||||
// Check and write under one lock: a rename landing between them would be lost.
|
||||
let mut s = self.state.lock();
|
||||
if !s.title_renamed && s.task.title != title {
|
||||
let user_named = update.get("userNamed").and_then(Value::as_bool) == Some(true);
|
||||
let flag_changed = user_named && !s.title_renamed;
|
||||
if user_named {
|
||||
s.title_renamed = true;
|
||||
}
|
||||
if (user_named || !s.title_renamed) && s.task.title != title {
|
||||
s.task.title = title.to_owned();
|
||||
drop(s);
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
} else if flag_changed {
|
||||
drop(s);
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
}
|
||||
}
|
||||
return;
|
||||
@@ -2688,6 +2948,15 @@ struct Client {
|
||||
|
||||
impl Handler for Client {
|
||||
fn on_notification(&self, method: &str, params: Value) {
|
||||
if method == WARNING_NOTIFICATION {
|
||||
if let Some(task) = self.task.upgrade()
|
||||
&& let Some(message) = params.get("message").and_then(Value::as_str).filter(|s| !s.trim().is_empty())
|
||||
{
|
||||
task.push_entry(AgentEntry::Error { message: message.to_owned() });
|
||||
task.persist();
|
||||
}
|
||||
return;
|
||||
}
|
||||
if method == "session/update"
|
||||
&& let (Some(task), Some(update)) = (self.task.upgrade(), params.get("update"))
|
||||
{
|
||||
@@ -2898,9 +3167,13 @@ fn embeddable(path: &Path) -> Option<String> {
|
||||
/// A task file from before a field existed, with that field's empty value.
|
||||
fn upgrade(mut file: Value) -> Value {
|
||||
if let Some(task) = file.get_mut("task").and_then(Value::as_object_mut) {
|
||||
for (key, empty) in
|
||||
[("config", json!([])), ("commands", json!([])), ("usage", Value::Null), ("queue", json!([]))]
|
||||
{
|
||||
for (key, empty) in [
|
||||
("config", json!([])),
|
||||
("commands", json!([])),
|
||||
("usage", Value::Null),
|
||||
("queue", json!([])),
|
||||
("mcpOverrides", json!({})),
|
||||
] {
|
||||
task.entry(key).or_insert(empty);
|
||||
}
|
||||
}
|
||||
@@ -3014,6 +3287,23 @@ fn turn_starts(entries: &[AgentEntry]) -> Vec<usize> {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The MCP servers of a session, and the names of the ones off for it.
|
||||
struct McpForSession {
|
||||
servers: Vec<Value>,
|
||||
off: Vec<String>,
|
||||
}
|
||||
|
||||
/// The session parameters `session/new`, `session/load` and `session/fork` share: the MCP
|
||||
/// servers, and the ones off for this session, so an agent that also loads its own
|
||||
/// configuration (Claude Code) can keep a same-named server of it off too.
|
||||
fn session_params(cwd: &str, mcp: &McpForSession) -> Value {
|
||||
let mut params = json!({ "cwd": cwd, "mcpServers": mcp.servers });
|
||||
if !mcp.off.is_empty() {
|
||||
params["_meta"] = json!({ "openidea": { "mcpServersOff": mcp.off } });
|
||||
}
|
||||
params
|
||||
}
|
||||
|
||||
fn is_false(b: &bool) -> bool {
|
||||
!*b
|
||||
}
|
||||
@@ -3047,13 +3337,20 @@ fn model_of(config: &[AgentConfigOption]) -> Option<String> {
|
||||
config.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.clone())
|
||||
}
|
||||
|
||||
/// Commands the agent implements on its own and never lists in `availableCommands` —
|
||||
/// its CLI builtins, passed through as prompt text (e.g. `/compact`). `(name, description)`.
|
||||
fn builtin_commands(provider: &str) -> &'static [(&'static str, &'static str)] {
|
||||
/// Commands the agent implements on its own and never lists in `availableCommands`.
|
||||
fn builtin_commands(provider: &str) -> Vec<AgentCommand> {
|
||||
match provider {
|
||||
// Codex app-server has no command-list API, so the native adapter supplies its
|
||||
// stable builtins and merges the session's dynamic skills separately.
|
||||
"codex" => native::codex::builtin_commands(),
|
||||
// OpenCode ACP handles `/compact` via session.summarize but omits it from its command list.
|
||||
"opencode" => &[("compact", "compact the conversation")],
|
||||
_ => &[],
|
||||
"opencode" => vec![AgentCommand {
|
||||
name: "compact".into(),
|
||||
description: "compact the conversation".into(),
|
||||
hint: None,
|
||||
source: AgentCommandSource::Command,
|
||||
}],
|
||||
_ => Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3115,6 +3412,9 @@ mod replay_tests;
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
/// The name agents know the built-in server by (its tools are `mcp__OpenIDEA__…` in Claude Code).
|
||||
const BUILTIN_SERVER: &str = "OpenIDEA";
|
||||
|
||||
// The desktop advertises its relay only while the built-in server is listening.
|
||||
static MCP_EXECUTABLE: parking_lot::RwLock<Option<std::path::PathBuf>> = parking_lot::RwLock::new(None);
|
||||
|
||||
@@ -3129,7 +3429,7 @@ fn mcp_servers_for(supported: bool, root: &std::path::Path) -> Vec<Value> {
|
||||
fn stdio_mcp_servers(executable: Option<&std::path::Path>, supported: bool, root: &std::path::Path) -> Vec<Value> {
|
||||
let Some(executable) = executable.filter(|_| supported) else { return Vec::new() };
|
||||
let command = ide_mcp::stdio_command(executable, root);
|
||||
vec![json!({ "name": "OpenIDEA", "command": command[0], "args": command[1..], "env": [] })]
|
||||
vec![json!({ "name": BUILTIN_SERVER, "command": command[0], "args": command[1..], "env": [] })]
|
||||
}
|
||||
|
||||
/// What was sent of a streaming message: its first `bytes` (`utf16` UTF-16 units), which
|
||||
@@ -3205,3 +3505,55 @@ fn entry_event(
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct SessionOpenError {
|
||||
message: String,
|
||||
allow_acp_fallback: bool,
|
||||
}
|
||||
|
||||
struct KillOnDrop(Option<Peer>);
|
||||
|
||||
impl Drop for KillOnDrop {
|
||||
fn drop(&mut self) {
|
||||
if let Some(peer) = self.0.take() {
|
||||
peer.kill();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn is_headless_protocol_error(code: i64) -> bool {
|
||||
matches!(
|
||||
code,
|
||||
ide_jsonrpc::codes::PARSE_ERROR
|
||||
| ide_jsonrpc::codes::INVALID_REQUEST
|
||||
| ide_jsonrpc::codes::METHOD_NOT_FOUND
|
||||
| ide_jsonrpc::codes::INVALID_PARAMS
|
||||
)
|
||||
}
|
||||
|
||||
/// Keeps `task.usage.size` aligned with the active model and `context_tier` when pricing
|
||||
/// metadata reports the selected tier's token limit.
|
||||
fn sync_usage_context_size(task: &mut AgentTask) {
|
||||
let Some(usage) = task.usage.as_mut() else { return };
|
||||
let Some(model_opt) = task.config.iter().find(|o| o.category.as_deref() == Some("model")) else { return };
|
||||
let Some(model_id) = model_opt.current.as_deref() else { return };
|
||||
let Some(pricing) = model_opt.values.iter().find(|v| v.value == model_id).and_then(|v| v.pricing.as_deref()) else {
|
||||
return;
|
||||
};
|
||||
let tier = task
|
||||
.config
|
||||
.iter()
|
||||
.find(|o| config::is_context_option(&o.id))
|
||||
.and_then(|o| o.current.as_deref())
|
||||
.unwrap_or("default");
|
||||
if let Some(tokens) = pricing
|
||||
.tiers
|
||||
.get(tier)
|
||||
.or_else(|| pricing.tiers.get("default"))
|
||||
.or_else(|| pricing.tiers.get("long_context"))
|
||||
.and_then(|t| t.context_tokens)
|
||||
.filter(|&n| n > 0)
|
||||
{
|
||||
usage.size = tokens;
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -50,12 +50,13 @@ pub struct AgentCapabilities {
|
||||
pub read_only: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum Isolation {
|
||||
/// A new git worktree on its own branch.
|
||||
Worktree,
|
||||
/// The project's own checkout.
|
||||
#[default]
|
||||
Local,
|
||||
}
|
||||
|
||||
@@ -107,6 +108,9 @@ pub struct AgentTask {
|
||||
// Boxed so that `AgentEvent::Task` stays within clippy's `large_enum_variant` bound on Windows.
|
||||
#[serde(default)]
|
||||
pub background: Box<Vec<AgentBackgroundTask>>,
|
||||
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`), including `"openidea"`.
|
||||
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
||||
pub mcp_overrides: BTreeMap<String, bool>,
|
||||
}
|
||||
|
||||
/// A task the agent runs in the background while the conversation goes on.
|
||||
@@ -132,6 +136,40 @@ pub struct AgentRetry {
|
||||
pub error: Option<String>,
|
||||
}
|
||||
|
||||
/// Token pricing (Credits per 1M tokens) and context window capacity for one tier.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentTokenPricing {
|
||||
pub input: f64,
|
||||
pub output: f64,
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub cache_read: Option<f64>,
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub cache_write: Option<f64>,
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub context_tokens: Option<u32>,
|
||||
}
|
||||
|
||||
/// Pricing and context-tier metadata attached to a model [`AgentConfigValue`].
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentModelPricing {
|
||||
/// `"low"`, `"medium"`, `"high"`, or `"very_high"`.
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub cost_tier: Option<String>,
|
||||
/// Request-based billing multiplier (e.g. `1.0`, `0.33`, `3.0`), when applicable.
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub multiplier: Option<f64>,
|
||||
/// Token pricing keyed by context tier (`"default"`, `"long_context"`).
|
||||
#[serde(default)]
|
||||
pub tiers: BTreeMap<String, AgentTokenPricing>,
|
||||
}
|
||||
|
||||
/// One value of a select-type session setting.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -147,6 +185,10 @@ pub struct AgentConfigValue {
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub usage_multiplier: Option<String>,
|
||||
/// Detailed per-tier token pricing from `_meta.pricing` when available.
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub pricing: Option<Box<AgentModelPricing>>,
|
||||
}
|
||||
|
||||
/// How a setting is changed.
|
||||
@@ -554,7 +596,7 @@ pub struct AgentProbe {
|
||||
pub error: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct NewAgentTask {
|
||||
/// Validated by the host; defaults to the window project root.
|
||||
@@ -567,6 +609,9 @@ pub struct NewAgentTask {
|
||||
pub isolation: Isolation,
|
||||
/// Branch to start the worktree from; the current branch when `None`.
|
||||
pub base: Option<String>,
|
||||
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
|
||||
#[serde(default)]
|
||||
pub mcp_overrides: BTreeMap<String, bool>,
|
||||
}
|
||||
|
||||
/// A file the task changed: against [`AgentTask::base_commit`], or against `HEAD` in the
|
||||
@@ -638,7 +683,7 @@ pub struct AgentModelCatalog {
|
||||
pub enum AgentEvent {
|
||||
/// A task was created or its metadata changed.
|
||||
Task {
|
||||
task: AgentTask,
|
||||
task: Box<AgentTask>,
|
||||
},
|
||||
Removed {
|
||||
id: String,
|
||||
@@ -718,6 +763,9 @@ pub struct McpServer {
|
||||
/// Agent provider ids this server is enabled for; empty means enabled for all agents.
|
||||
#[serde(default)]
|
||||
pub agents: Vec<String>,
|
||||
/// True when this Workspace server was added outside OpenIDEA and has not been approved yet.
|
||||
#[serde(default)]
|
||||
pub unapproved: bool,
|
||||
}
|
||||
|
||||
/// Payload for creating or updating a user or workspace MCP server.
|
||||
@@ -750,6 +798,69 @@ fn default_true() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// An external MCP configuration file discovered on disk (user CLI config or workspace file).
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct McpExternalSource {
|
||||
/// Stable source identifier (e.g. `"copilot-cli"`, `"jetbrains-air"`, `"claude-code"`, `"cursor"`, `"workspace-mcp"`, `"vscode-mcp"`).
|
||||
pub id: String,
|
||||
/// Human-readable source label (e.g. `"GitHub Copilot CLI"`).
|
||||
pub label: String,
|
||||
/// Absolute path of the discovered configuration file.
|
||||
pub path: IpcPath,
|
||||
/// Suggested target scope when importing this source into OpenIDEA settings.
|
||||
pub suggested_scope: McpScope,
|
||||
/// Agent provider ID this external CLI reads natively (`Some("copilot")`, `Some("claude")`, `Some("cursor")`, or `None`).
|
||||
pub native_provider: Option<String>,
|
||||
/// Servers found inside this external configuration file (values omitted for safety; imported directly on the host).
|
||||
pub servers: Vec<McpDiscoveredServer>,
|
||||
}
|
||||
|
||||
/// Summary of one server discovered inside an external MCP configuration file.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct McpDiscoveredServer {
|
||||
pub name: String,
|
||||
pub transport: McpTransport,
|
||||
pub enabled: bool,
|
||||
pub command: Option<String>,
|
||||
pub args: Vec<String>,
|
||||
pub url: Option<String>,
|
||||
/// Environment variable names declared on this server (values stay on the host).
|
||||
pub env_keys: Vec<String>,
|
||||
/// HTTP header names declared on this server (values stay on the host).
|
||||
pub header_keys: Vec<String>,
|
||||
}
|
||||
|
||||
/// Selection of one server from an external MCP configuration source to import.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct McpImportSelection {
|
||||
pub source_id: String,
|
||||
pub name: String,
|
||||
}
|
||||
|
||||
/// One tool advertised by an MCP server during `tools/list`.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct McpToolSummary {
|
||||
pub name: String,
|
||||
pub description: Option<String>,
|
||||
}
|
||||
|
||||
/// Result of testing/probing an MCP server (`initialize` + `tools/list`).
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct McpProbeResult {
|
||||
pub ok: bool,
|
||||
pub server_name: Option<String>,
|
||||
pub server_version: Option<String>,
|
||||
pub protocol_version: Option<String>,
|
||||
pub tools: Vec<McpToolSummary>,
|
||||
pub duration_ms: u32,
|
||||
pub error: Option<String>,
|
||||
}
|
||||
|
||||
/// Payload for creating a custom ACP agent (always the ACP driver); the id
|
||||
/// becomes the `<config>/agents/<id>.toml` file name.
|
||||
#[derive(Clone, Debug, Deserialize, Type)]
|
||||
|
||||
@@ -170,6 +170,8 @@ struct Session {
|
||||
id: String,
|
||||
cwd: PathBuf,
|
||||
mcp_config: Option<tempfile::TempPath>,
|
||||
/// MCP servers switched off for this session (`--disallowedTools`), its own config's too.
|
||||
mcp_off: Vec<String>,
|
||||
shim: Weak<Shim>,
|
||||
st: Mutex<State>,
|
||||
/// Serializes (re)starting the process.
|
||||
@@ -344,9 +346,10 @@ impl Shim {
|
||||
cwd: PathBuf,
|
||||
start: Start,
|
||||
pending: bool,
|
||||
mcp_config: Option<String>,
|
||||
params: &Value,
|
||||
) -> Arc<Session> {
|
||||
let mcp_config = mcp_config.and_then(|json| match write_mcp_config(&json) {
|
||||
let mcp_off = mcp_off(params);
|
||||
let mcp_config = mcp_config(params).and_then(|json| match write_mcp_config(&json) {
|
||||
Ok(path) => Some(path),
|
||||
Err(e) => {
|
||||
tracing::warn!("Claude Code session {id}: cannot write its MCP configuration: {e}");
|
||||
@@ -356,6 +359,7 @@ impl Shim {
|
||||
let session = Arc::new(Session {
|
||||
id: id.to_owned(),
|
||||
mcp_config,
|
||||
mcp_off,
|
||||
shim: Arc::downgrade(self),
|
||||
st: Mutex::new(State {
|
||||
proc: None,
|
||||
@@ -411,13 +415,8 @@ impl Shim {
|
||||
}
|
||||
"session/new" => {
|
||||
let id = new_uuid(false);
|
||||
let session = self.add_session(
|
||||
&id,
|
||||
self.cwd_of(¶ms),
|
||||
Start::New { id: id.clone() },
|
||||
false,
|
||||
mcp_config(¶ms),
|
||||
);
|
||||
let session =
|
||||
self.add_session(&id, self.cwd_of(¶ms), Start::New { id: id.clone() }, false, ¶ms);
|
||||
rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
|
||||
session.announce_commands();
|
||||
Ok(json!({ "sessionId": id, "configOptions": session.st.lock().settings.options() }))
|
||||
@@ -433,7 +432,7 @@ impl Shim {
|
||||
None => return Err(invalid(format!("no Claude Code session {id} in {}", cwd.display()))),
|
||||
};
|
||||
let chain = self.base_chain(&cwd, &start).map_err(internal)?;
|
||||
let session = self.add_session(id, cwd, start, pending, mcp_config(¶ms));
|
||||
let session = self.add_session(id, cwd, start, pending, ¶ms);
|
||||
rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
|
||||
if method == "session/load" {
|
||||
session.replay(&chain);
|
||||
@@ -459,7 +458,7 @@ impl Shim {
|
||||
(start, st.settings.clone())
|
||||
};
|
||||
self.save_pending(&id, Some(&start));
|
||||
let session = self.add_session(&id, source.cwd.clone(), start, true, mcp_config(¶ms));
|
||||
let session = self.add_session(&id, source.cwd.clone(), start, true, ¶ms);
|
||||
session.st.lock().settings = settings;
|
||||
let options = session.st.lock().settings.options();
|
||||
Ok(json!({ "sessionId": id, "configOptions": options }))
|
||||
@@ -666,6 +665,9 @@ impl Session {
|
||||
if let Some(config) = &self.mcp_config {
|
||||
args.extend(["--mcp-config".to_owned(), config.to_string_lossy().into_owned()]);
|
||||
}
|
||||
if !self.mcp_off.is_empty() {
|
||||
args.extend(["--disallowedTools".to_owned(), self.mcp_off.join(",")]);
|
||||
}
|
||||
args.extend(start.args());
|
||||
let launch =
|
||||
Launch { program: shim.config.program.clone(), args, cwd: self.cwd.clone(), env: shim.config.env.clone() };
|
||||
@@ -1497,6 +1499,24 @@ fn write_mcp_config(json: &str) -> std::io::Result<tempfile::TempPath> {
|
||||
Ok(file.into_temp_path())
|
||||
}
|
||||
|
||||
/// The servers switched off for the session (`_meta.openidea.mcpServersOff`) as Claude Code
|
||||
/// permission rules that deny all of a server's tools (`mcp__<server>`), so a server of
|
||||
/// Claude Code's own configuration stays off too.
|
||||
fn mcp_off(params: &Value) -> Vec<String> {
|
||||
params
|
||||
.pointer("/_meta/openidea/mcpServersOff")
|
||||
.and_then(Value::as_array)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(Value::as_str)
|
||||
.map(|name| {
|
||||
let name: String =
|
||||
name.chars().map(|c| if c.is_ascii_alphanumeric() || c == '_' || c == '-' { c } else { '_' }).collect();
|
||||
format!("mcp__{name}")
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// ACP `mcpServers` as Claude Code's `--mcp-config` JSON (`None` when there are none).
|
||||
fn mcp_config(params: &Value) -> Option<String> {
|
||||
let servers = params.get("mcpServers")?.as_array()?;
|
||||
|
||||
@@ -48,10 +48,17 @@ impl Settings {
|
||||
.filter_map(|m| {
|
||||
let s = |k: &str| m.get(k).and_then(Value::as_str).map(str::to_owned);
|
||||
let value = s("value")?;
|
||||
let resolved = s("resolvedModel");
|
||||
// The default entry follows the account's default model, so "Default
|
||||
// (recommended)" hides what actually runs: name the model it resolves to.
|
||||
let name = match (value.as_str(), resolved.as_deref()) {
|
||||
("default", Some(r)) if !r.is_empty() => format!("Default ({r})"),
|
||||
_ => s("displayName").unwrap_or_else(|| value.clone()),
|
||||
};
|
||||
Some(Model {
|
||||
name: s("displayName").unwrap_or_else(|| value.clone()),
|
||||
name,
|
||||
description: s("description"),
|
||||
resolved: s("resolvedModel"),
|
||||
resolved,
|
||||
efforts: if m.get("supportsEffort").and_then(Value::as_bool) == Some(true) {
|
||||
m.get("supportedEffortLevels")
|
||||
.and_then(Value::as_array)
|
||||
@@ -230,6 +237,19 @@ mod tests {
|
||||
assert_eq!(s.model, "claude-x-1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_default_entry_is_named_by_the_model_it_runs() {
|
||||
let s = Settings::from_cli(&init(), &json!({"applied": {"model": "claude-sonnet-5-5"}}));
|
||||
let names: Vec<_> = s.models.iter().map(|m| m.name.as_str()).collect();
|
||||
assert_eq!(names, ["Default (claude-sonnet-5-5)", "Opus", "Haiku 4.5"]);
|
||||
// Without a resolved model, the agent's own name stands.
|
||||
let s = Settings::from_cli(
|
||||
&json!({"models": [{"value": "default", "displayName": "Default (recommended)"}]}),
|
||||
&json!({}),
|
||||
);
|
||||
assert_eq!(s.models[0].name, "Default (recommended)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn options_follow_the_model() {
|
||||
let mut s = Settings::from_cli(&init(), &json!({"applied": {"model": "claude-sonnet-5-5", "effort": "high"}}));
|
||||
|
||||
@@ -1243,6 +1243,13 @@ async fn skipped_questions_have_no_answers() {
|
||||
assert_eq!(cancelled, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn servers_switched_off_become_disallowed_tools() {
|
||||
assert!(mcp_off(&json!({})).is_empty());
|
||||
let off = mcp_off(&json!({ "_meta": { "openidea": { "mcpServersOff": ["github", "my server.v2"] } } }));
|
||||
assert_eq!(off, ["mcp__github", "mcp__my_server_v2"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mcp_servers_become_an_mcp_config() {
|
||||
assert_eq!(mcp_config(&json!({ "mcpServers": [] })), None);
|
||||
|
||||
@@ -0,0 +1,155 @@
|
||||
//! Codex's built-in slash commands. `codex app-server` has no command-list API, so the
|
||||
//! native adapter owns this stable compatibility table; skills stay dynamic via `skills/list`.
|
||||
|
||||
use serde_json::Value;
|
||||
|
||||
/// Menu metadata shared by agent_commands and the prompt dispatcher.
|
||||
pub(crate) struct BuiltinCommandSpec {
|
||||
pub name: &'static str,
|
||||
pub description: &'static str,
|
||||
pub hint: Option<&'static str>,
|
||||
}
|
||||
|
||||
pub(crate) const BUILTIN_COMMANDS: &[BuiltinCommandSpec] = &[
|
||||
BuiltinCommandSpec { name: "plan", description: "Turn plan mode on or off.", hint: None },
|
||||
BuiltinCommandSpec {
|
||||
name: "mcp",
|
||||
description: "Show the status of the MCP servers, or reconnect them.",
|
||||
hint: Some("[reconnect]"),
|
||||
},
|
||||
BuiltinCommandSpec { name: "skills", description: "List available skills.", hint: None },
|
||||
BuiltinCommandSpec { name: "status", description: "Display session configuration and token usage.", hint: None },
|
||||
BuiltinCommandSpec {
|
||||
name: "review",
|
||||
description: "Review uncommitted changes, or review with custom instructions.",
|
||||
hint: Some("optional review instructions"),
|
||||
},
|
||||
BuiltinCommandSpec {
|
||||
name: "review-branch",
|
||||
description: "Review changes relative to a base branch.",
|
||||
hint: Some("branch name"),
|
||||
},
|
||||
BuiltinCommandSpec { name: "review-commit", description: "Review a specific commit.", hint: Some("commit sha") },
|
||||
BuiltinCommandSpec {
|
||||
name: "compact",
|
||||
description: "Summarize conversation to avoid hitting the context limit.",
|
||||
hint: None,
|
||||
},
|
||||
BuiltinCommandSpec {
|
||||
name: "goal",
|
||||
description: "Set a goal to keep pursuing.",
|
||||
hint: Some("[<objective>|clear|pause|resume]"),
|
||||
},
|
||||
BuiltinCommandSpec { name: "rename", description: "Rename the current session.", hint: Some("new name") },
|
||||
BuiltinCommandSpec {
|
||||
name: "logout",
|
||||
description: "Sign out of Codex. This option is available when you are logged in via ChatGPT.",
|
||||
hint: None,
|
||||
},
|
||||
];
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(super) enum BuiltinCommand {
|
||||
Plan,
|
||||
Mcp,
|
||||
Skills,
|
||||
Status,
|
||||
Review,
|
||||
ReviewBranch,
|
||||
ReviewCommit,
|
||||
Compact,
|
||||
Goal,
|
||||
Rename,
|
||||
Logout,
|
||||
}
|
||||
|
||||
impl BuiltinCommand {
|
||||
fn from_name(name: &str) -> Option<Self> {
|
||||
Some(match name {
|
||||
"plan" => Self::Plan,
|
||||
"mcp" => Self::Mcp,
|
||||
"skills" => Self::Skills,
|
||||
"status" => Self::Status,
|
||||
"review" => Self::Review,
|
||||
"review-branch" => Self::ReviewBranch,
|
||||
"review-commit" => Self::ReviewCommit,
|
||||
"compact" => Self::Compact,
|
||||
"goal" => Self::Goal,
|
||||
"rename" => Self::Rename,
|
||||
"logout" => Self::Logout,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub(super) struct ParsedCommand {
|
||||
pub command: BuiltinCommand,
|
||||
/// Everything after the command name, trimmed but otherwise unchanged.
|
||||
pub rest: String,
|
||||
}
|
||||
|
||||
impl ParsedCommand {
|
||||
/// Commands that Codex completes as a turn. Missing review arguments stay local so the
|
||||
/// adapter can print the command's usage without starting an unnecessary model request.
|
||||
pub fn starts_turn(&self) -> bool {
|
||||
matches!(self.command, BuiltinCommand::Compact | BuiltinCommand::Review)
|
||||
|| (matches!(self.command, BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit)
|
||||
&& !self.rest.is_empty())
|
||||
}
|
||||
}
|
||||
|
||||
/// A recognized Codex builtin at the start of the prompt. Unknown slash commands and
|
||||
/// `$skill` invocations return `None`, so they continue through Codex as ordinary prompts.
|
||||
pub(super) fn parse(prompt: &Value) -> Option<ParsedCommand> {
|
||||
let text = prompt.as_array()?.first()?.get("text")?.as_str()?.trim();
|
||||
let command_text = text.strip_prefix('/')?.trim();
|
||||
let (name, rest) = command_text.split_once(char::is_whitespace).unwrap_or((command_text, ""));
|
||||
let command = BuiltinCommand::from_name(&name.to_ascii_lowercase())?;
|
||||
Some(ParsedCommand { command, rest: rest.trim().to_owned() })
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
fn text(value: &str) -> Value {
|
||||
json!([{ "type": "text", "text": value }])
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_builtin_is_registered_and_parsed() {
|
||||
let expected = [
|
||||
"plan",
|
||||
"mcp",
|
||||
"skills",
|
||||
"status",
|
||||
"review",
|
||||
"review-branch",
|
||||
"review-commit",
|
||||
"compact",
|
||||
"goal",
|
||||
"rename",
|
||||
"logout",
|
||||
];
|
||||
assert_eq!(BUILTIN_COMMANDS.iter().map(|c| c.name).collect::<Vec<_>>(), expected);
|
||||
for name in expected {
|
||||
assert!(parse(&text(&format!("/{name}"))).is_some(), "{name}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parsing_keeps_arguments_and_leaves_non_builtins_alone() {
|
||||
let parsed = parse(&text(" /review-branch origin/main ")).unwrap();
|
||||
assert_eq!(parsed.command, BuiltinCommand::ReviewBranch);
|
||||
assert_eq!(parsed.rest, "origin/main");
|
||||
assert!(parsed.starts_turn());
|
||||
assert!(!parse(&text("/review-branch")).unwrap().starts_turn());
|
||||
assert!(parse(&text("/$review check this")).is_none());
|
||||
assert!(parse(&text("review")).is_none());
|
||||
|
||||
let prompt = json!([{ "type": "text", "text": "/compact" }, { "type": "image", "data": "AA==" }]);
|
||||
assert_eq!(parse(&prompt).unwrap().command, BuiltinCommand::Compact);
|
||||
}
|
||||
}
|
||||
@@ -2,7 +2,11 @@
|
||||
//! translated to and from ACP. A codex thread is an ACP session; a subagent's thread is
|
||||
//! a subagent session of the thread that spawned it.
|
||||
|
||||
mod commands;
|
||||
mod translate;
|
||||
mod trust;
|
||||
|
||||
pub(crate) use commands::BUILTIN_COMMANDS;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -10,6 +14,8 @@ mod tests;
|
||||
use super::Shim;
|
||||
use crate::acp::AUTH_REQUIRED;
|
||||
use crate::provider::ProviderSpec;
|
||||
use crate::{AgentCommand, AgentCommandSource};
|
||||
use commands::{BuiltinCommand, ParsedCommand};
|
||||
use ide_jsonrpc::{Framing, Handler, Peer, RpcError, codes};
|
||||
use parking_lot::Mutex;
|
||||
use serde_json::{Value, json};
|
||||
@@ -32,6 +38,19 @@ const EXIT_GRACE: Duration = Duration::from_millis(100);
|
||||
const NAME_PROMPT: &str = "Name this conversation for a list of tasks: a short title of at most six words, in the \
|
||||
language the user writes in. Reply with the title only, without quotes or a closing period.";
|
||||
|
||||
/// Slash-command metadata for provider discovery and sessions without an advertised list.
|
||||
pub(crate) fn builtin_commands() -> Vec<AgentCommand> {
|
||||
BUILTIN_COMMANDS
|
||||
.iter()
|
||||
.map(|command| AgentCommand {
|
||||
name: command.name.to_owned(),
|
||||
description: command.description.to_owned(),
|
||||
hint: command.hint.map(str::to_owned),
|
||||
source: AgentCommandSource::Command,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub(crate) fn connect(
|
||||
spec: &ProviderSpec,
|
||||
cwd: &Path,
|
||||
@@ -183,6 +202,8 @@ struct State {
|
||||
threads: HashMap<String, Thread>,
|
||||
/// The last `account/rateLimits/updated` snapshot.
|
||||
rate_limits: Option<Value>,
|
||||
/// Project trust has been checked (and, when needed, asked about) on this connection.
|
||||
trust_checked: HashSet<String>,
|
||||
/// Codex exited.
|
||||
gone: bool,
|
||||
}
|
||||
@@ -215,6 +236,8 @@ struct Thread {
|
||||
early_cancel: Option<Instant>,
|
||||
/// The latest agent message (a subagent's answer).
|
||||
answer: String,
|
||||
/// The latest `thread/tokenUsage/updated` payload, for the `/status` command.
|
||||
token_usage: Option<Value>,
|
||||
/// The thread has a name.
|
||||
named: bool,
|
||||
/// A name is being asked for.
|
||||
@@ -320,6 +343,12 @@ impl CodexShim {
|
||||
self.codex().request(method, params, None).await.map_err(from_codex)
|
||||
}
|
||||
|
||||
fn warning(&self, message: impl Into<String>) {
|
||||
if let Some(client) = self.client.get() {
|
||||
let _ = client.notify(crate::WARNING_NOTIFICATION, json!({ "message": message.into() }));
|
||||
}
|
||||
}
|
||||
|
||||
async fn handle(&self, method: &str, params: Value) -> Result<Value, ResponseError> {
|
||||
match method {
|
||||
"initialize" => self.initialize().await,
|
||||
@@ -403,6 +432,7 @@ impl CodexShim {
|
||||
|
||||
async fn new_session(&self, params: &Value) -> Result<Value, ResponseError> {
|
||||
let models = self.models().await?;
|
||||
self.prepare_project_trust(params).await;
|
||||
let mut request = json!({ "cwd": params.get("cwd") });
|
||||
if let Some(config) = translate::mcp_config(params) {
|
||||
request["config"] = config;
|
||||
@@ -420,6 +450,7 @@ impl CodexShim {
|
||||
async fn load_session(&self, params: &Value) -> Result<Value, ResponseError> {
|
||||
let id = str_param(params, "sessionId")?;
|
||||
let models = self.models().await?;
|
||||
self.prepare_project_trust(params).await;
|
||||
let mut request = json!({ "threadId": id, "cwd": params.get("cwd") });
|
||||
if let Some(config) = translate::mcp_config(params) {
|
||||
request["config"] = config;
|
||||
@@ -438,6 +469,7 @@ impl CodexShim {
|
||||
async fn fork_session(&self, params: &Value) -> Result<Value, ResponseError> {
|
||||
let source = str_param(params, "sessionId")?;
|
||||
let models = self.models().await?;
|
||||
self.prepare_project_trust(params).await;
|
||||
let settings = self.state.lock().threads.get(source).and_then(|t| t.settings.clone());
|
||||
let mut request = json!({ "threadId": source, "cwd": params.get("cwd") });
|
||||
if let Some(config) = translate::mcp_config(params) {
|
||||
@@ -471,11 +503,18 @@ impl CodexShim {
|
||||
|
||||
async fn prompt(&self, params: &Value) -> Result<Value, ResponseError> {
|
||||
let session = str_param(params, "sessionId")?.to_owned();
|
||||
let input = translate::user_input(params.get("prompt").unwrap_or(&Value::Null));
|
||||
let prompt = params.get("prompt").unwrap_or(&Value::Null);
|
||||
let command = commands::parse(prompt);
|
||||
if let Some(command) = command.as_ref()
|
||||
&& !command.starts_turn()
|
||||
{
|
||||
return self.local_command(&session, command).await;
|
||||
}
|
||||
let input = translate::user_input(prompt);
|
||||
if input.is_empty() {
|
||||
return Err(invalid("empty prompt"));
|
||||
}
|
||||
let models = self.models().await?;
|
||||
let models = if command.is_none() { Some(self.models().await?) } else { None };
|
||||
let (done, ended) = oneshot::channel();
|
||||
let settings = {
|
||||
let mut state = self.state.lock();
|
||||
@@ -491,33 +530,213 @@ impl CodexShim {
|
||||
t.error = None;
|
||||
t.settings.clone()
|
||||
};
|
||||
let mut request = json!({ "threadId": session, "input": input, "summary": "auto" });
|
||||
if let Some(s) = settings {
|
||||
request["model"] = json!(s.model_slug(&models));
|
||||
request["approvalPolicy"] = json!(s.mode.approval_policy());
|
||||
request["sandboxPolicy"] = s.mode.sandbox_policy();
|
||||
if let Some(effort) = &s.effort {
|
||||
request["effort"] = json!(effort);
|
||||
let started = match command.as_ref() {
|
||||
Some(command) => match command.command {
|
||||
BuiltinCommand::Compact => {
|
||||
// Codex reports compaction as its own turn, using the same started/completed
|
||||
// notifications that finish the pending session/prompt above.
|
||||
self.call("thread/compact/start", json!({ "threadId": session })).await
|
||||
}
|
||||
BuiltinCommand::Review | BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit => {
|
||||
self.call("review/start", json!({ "threadId": session, "target": review_target(command) })).await
|
||||
}
|
||||
_ => unreachable!("local commands return before a pending turn is created"),
|
||||
},
|
||||
None => {
|
||||
let models = models.expect("ordinary prompts load the model catalog");
|
||||
let mut request = json!({ "threadId": session, "input": input, "summary": "auto" });
|
||||
if let Some(s) = &settings {
|
||||
request["model"] = json!(s.model_slug(&models));
|
||||
request["approvalPolicy"] = json!(s.mode.approval_policy());
|
||||
request["sandboxPolicy"] = s.mode.sandbox_policy();
|
||||
// Omit the default so older app-server versions keep accepting normal
|
||||
// turns; selecting Plan opts into this newer request field.
|
||||
if s.collaboration_mode == translate::PLAN_COLLABORATION_MODE
|
||||
|| s.collaboration_mode_override.is_some()
|
||||
{
|
||||
request["collaborationMode"] = translate::collaboration_mode(s, &models);
|
||||
}
|
||||
if let Some(effort) = &s.effort {
|
||||
request["effort"] = json!(effort);
|
||||
}
|
||||
}
|
||||
self.call("turn/start", request).await
|
||||
}
|
||||
};
|
||||
if let Ok(started) = &started
|
||||
&& let Some(turn) = started.pointer("/turn/id").and_then(Value::as_str)
|
||||
{
|
||||
self.turn_known(&session, turn, false);
|
||||
}
|
||||
match self.call("turn/start", request).await {
|
||||
Ok(started) => {
|
||||
if let Some(turn) = started.pointer("/turn/id").and_then(Value::as_str) {
|
||||
self.turn_known(&session, turn, false);
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
if let Some(t) = self.state.lock().threads.get_mut(&session) {
|
||||
t.prompt = None;
|
||||
}
|
||||
return Err(e);
|
||||
if started.is_ok()
|
||||
&& command.is_none()
|
||||
&& let Some(thread) = self.state.lock().threads.get_mut(&session)
|
||||
&& let Some(settings) = thread.settings.as_mut()
|
||||
{
|
||||
// A Default override is needed only for the first turn that resets a resumed
|
||||
// Plan thread; omitting it afterwards preserves compatibility with older Codex.
|
||||
settings.collaboration_mode_override = None;
|
||||
}
|
||||
if let Err(e) = started {
|
||||
if let Some(t) = self.state.lock().threads.get_mut(&session) {
|
||||
t.prompt = None;
|
||||
}
|
||||
return Err(e);
|
||||
}
|
||||
let (turn, last_error) = ended.await.map_err(|_| error(codes::INTERNAL_ERROR, "Codex exited"))?;
|
||||
let rate_limits = self.state.lock().rate_limits.clone();
|
||||
stop_reason(&turn, last_error, rate_limits.as_ref())
|
||||
}
|
||||
|
||||
/// Runs commands that codex-acp historically handled locally: configuration, status,
|
||||
/// inventory, naming and account actions. They complete without starting a model turn.
|
||||
async fn local_command(&self, session: &str, command: &ParsedCommand) -> Result<Value, ResponseError> {
|
||||
let (settings, cwd, token_usage, rate_limits) = {
|
||||
let state = self.state.lock();
|
||||
if state.gone {
|
||||
return Err(error(codes::INTERNAL_ERROR, "Codex exited"));
|
||||
}
|
||||
let thread = state.threads.get(session).ok_or_else(|| invalid(format!("no session {session}")))?;
|
||||
if thread.prompt.is_some() || thread.turn.is_some() {
|
||||
return Err(invalid("a turn is already running"));
|
||||
}
|
||||
(thread.settings.clone(), thread.cwd.clone(), thread.token_usage.clone(), state.rate_limits.clone())
|
||||
};
|
||||
|
||||
match command.command {
|
||||
BuiltinCommand::Plan => {
|
||||
if !command.rest.is_empty() {
|
||||
self.say(session, command_usage(BuiltinCommand::Plan));
|
||||
return Ok(json!({ "stopReason": "end_turn" }));
|
||||
}
|
||||
let models = self.models().await?;
|
||||
let options = {
|
||||
let mut state = self.state.lock();
|
||||
let thread =
|
||||
state.threads.get_mut(session).ok_or_else(|| invalid(format!("no session {session}")))?;
|
||||
let settings = thread.settings.as_mut().ok_or_else(|| invalid(format!("no session {session}")))?;
|
||||
settings.collaboration_mode = if settings.collaboration_mode == translate::PLAN_COLLABORATION_MODE {
|
||||
translate::DEFAULT_COLLABORATION_MODE.to_owned()
|
||||
} else {
|
||||
translate::PLAN_COLLABORATION_MODE.to_owned()
|
||||
};
|
||||
settings.collaboration_mode_override = Some(settings.collaboration_mode.clone());
|
||||
translate::config_options(&models, settings)
|
||||
};
|
||||
self.emit(session, json!({ "sessionUpdate": "config_option_update", "configOptions": options }));
|
||||
}
|
||||
BuiltinCommand::Status => {
|
||||
let text =
|
||||
status_text(session, settings.as_ref(), cwd.as_deref(), token_usage.as_ref(), rate_limits.as_ref());
|
||||
self.say(session, text);
|
||||
}
|
||||
BuiltinCommand::Skills => {
|
||||
let cwd = cwd.ok_or_else(|| invalid(format!("no session {session}")))?;
|
||||
let found = self.call("skills/list", json!({ "cwds": [cwd] })).await?;
|
||||
self.say(session, skills_text(&found));
|
||||
}
|
||||
BuiltinCommand::Mcp => match command.rest.as_str() {
|
||||
"" => self.say(session, self.mcp_text(session).await?),
|
||||
rest if rest.eq_ignore_ascii_case("reconnect") => {
|
||||
self.call("config/mcpServer/reload", json!({})).await?;
|
||||
self.say(session, self.mcp_text(session).await?);
|
||||
}
|
||||
_ => self.say(session, command_usage(BuiltinCommand::Mcp)),
|
||||
},
|
||||
BuiltinCommand::Rename => {
|
||||
if command.rest.is_empty() {
|
||||
self.say(session, command_usage(BuiltinCommand::Rename));
|
||||
} else {
|
||||
self.call("thread/name/set", json!({ "threadId": session, "name": command.rest })).await?;
|
||||
// User commands are authoritative over the automatic title, so the manager
|
||||
// must retain this title through later generated-name updates.
|
||||
self.emit(
|
||||
session,
|
||||
json!({ "sessionUpdate": "session_info_update", "title": command.rest, "userNamed": true }),
|
||||
);
|
||||
}
|
||||
}
|
||||
BuiltinCommand::Logout => {
|
||||
self.call("account/logout", Value::Null).await?;
|
||||
self.say(session, "Logged out from Codex account.");
|
||||
}
|
||||
BuiltinCommand::Goal => self.goal_command(session, &command.rest).await?,
|
||||
BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit if command.rest.is_empty() => {
|
||||
self.say(session, command_usage(command.command));
|
||||
}
|
||||
BuiltinCommand::ReviewBranch | BuiltinCommand::ReviewCommit => {
|
||||
return Err(invalid("review command did not start a turn"));
|
||||
}
|
||||
BuiltinCommand::Review | BuiltinCommand::Compact => {
|
||||
return Err(invalid("turn command reached the local command path"));
|
||||
}
|
||||
}
|
||||
Ok(json!({ "stopReason": "end_turn" }))
|
||||
}
|
||||
|
||||
async fn goal_command(&self, session: &str, rest: &str) -> Result<(), ResponseError> {
|
||||
let argument = rest.trim();
|
||||
if argument.is_empty() {
|
||||
self.say(session, command_usage(BuiltinCommand::Goal));
|
||||
return Ok(());
|
||||
}
|
||||
match argument.to_ascii_lowercase().as_str() {
|
||||
"clear" => {
|
||||
self.call("thread/goal/clear", json!({ "threadId": session })).await?;
|
||||
self.say(session, "Goal cleared.");
|
||||
}
|
||||
"pause" => {
|
||||
let response = self
|
||||
.call("thread/goal/set", json!({ "threadId": session, "status": "paused", "origin": "user" }))
|
||||
.await?;
|
||||
self.say(
|
||||
session,
|
||||
format!(
|
||||
"Goal is now {}.",
|
||||
response.pointer("/goal/status").and_then(Value::as_str).unwrap_or("paused")
|
||||
),
|
||||
);
|
||||
}
|
||||
"resume" => {
|
||||
let response = self
|
||||
.call("thread/goal/set", json!({ "threadId": session, "status": "active", "origin": "user" }))
|
||||
.await?;
|
||||
self.say(
|
||||
session,
|
||||
format!(
|
||||
"Goal is now {}.",
|
||||
response.pointer("/goal/status").and_then(Value::as_str).unwrap_or("active")
|
||||
),
|
||||
);
|
||||
}
|
||||
_ if argument.chars().count() > 4000 => {
|
||||
self.say(session, "Command \"/goal\" requires goal text of at most 4000 characters.");
|
||||
}
|
||||
_ => {
|
||||
let response = self
|
||||
.call(
|
||||
"thread/goal/set",
|
||||
json!({ "threadId": session, "objective": argument, "status": "active", "origin": "user" }),
|
||||
)
|
||||
.await?;
|
||||
let status = response.pointer("/goal/status").and_then(Value::as_str).unwrap_or("active");
|
||||
self.say(session, format!("Goal set and {status}."));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn mcp_text(&self, session: &str) -> Result<String, ResponseError> {
|
||||
let response = self
|
||||
.call("mcpServerStatus/list", json!({ "threadId": session, "detail": "toolsAndAuthOnly", "limit": 100 }))
|
||||
.await?;
|
||||
Ok(mcp_text(&response))
|
||||
}
|
||||
|
||||
fn say(&self, session: &str, text: impl AsRef<str>) {
|
||||
self.emit(session, translate::chunk("agent_message_chunk", text.as_ref()));
|
||||
}
|
||||
|
||||
async fn steer(&self, params: &Value) -> Result<Value, ResponseError> {
|
||||
let session = str_param(params, "sessionId")?;
|
||||
let turn = self.state.lock().threads.get(session).and_then(|t| t.turn.clone());
|
||||
@@ -643,6 +862,25 @@ impl CodexShim {
|
||||
fn on_codex_notification(self: &Arc<Self>, method: &str, params: &Value) {
|
||||
let thread = params.get("threadId").and_then(Value::as_str).unwrap_or_default();
|
||||
match method {
|
||||
"configWarning" => {
|
||||
let Some(summary) = params.get("summary").and_then(Value::as_str).filter(|s| !s.trim().is_empty())
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let mut message = summary.trim().to_owned();
|
||||
for key in ["details", "path"] {
|
||||
if let Some(value) = params.get(key).and_then(Value::as_str).filter(|s| !s.trim().is_empty()) {
|
||||
message.push_str("\n\n");
|
||||
message.push_str(value.trim());
|
||||
}
|
||||
}
|
||||
self.warning(message);
|
||||
}
|
||||
"warning" => {
|
||||
if let Some(message) = params.get("message").and_then(Value::as_str).filter(|s| !s.trim().is_empty()) {
|
||||
self.warning(message);
|
||||
}
|
||||
}
|
||||
"skills/changed" => {
|
||||
let shim = self.clone();
|
||||
let sessions: Vec<String> = self
|
||||
@@ -693,7 +931,12 @@ impl CodexShim {
|
||||
t.last_chunk = None;
|
||||
Some(translate::plan(params))
|
||||
}),
|
||||
"thread/tokenUsage/updated" => self.with_thread(thread, |_, _| translate::usage(params)),
|
||||
"thread/tokenUsage/updated" => self.with_thread(thread, |t, _| {
|
||||
if let Some(usage) = params.get("tokenUsage") {
|
||||
t.token_usage = Some(usage.clone());
|
||||
}
|
||||
translate::usage(params)
|
||||
}),
|
||||
"thread/name/updated" => self.with_thread(thread, |t, _| {
|
||||
let title = params.get("threadName").and_then(Value::as_str)?;
|
||||
t.named = true;
|
||||
@@ -1182,3 +1425,114 @@ fn stop_reason(turn: &Value, last_error: Option<Value>, rate_limits: Option<&Val
|
||||
};
|
||||
Ok(json!({ "stopReason": stop }))
|
||||
}
|
||||
|
||||
/// The `review/start` target of a parsed review command.
|
||||
fn review_target(command: &ParsedCommand) -> Value {
|
||||
match command.command {
|
||||
BuiltinCommand::Review if command.rest.is_empty() => json!({ "type": "uncommittedChanges" }),
|
||||
BuiltinCommand::Review => json!({ "type": "custom", "instructions": command.rest }),
|
||||
BuiltinCommand::ReviewBranch => json!({ "type": "baseBranch", "branch": command.rest }),
|
||||
BuiltinCommand::ReviewCommit => json!({ "type": "commit", "sha": command.rest, "title": null }),
|
||||
_ => unreachable!("only review commands have review targets"),
|
||||
}
|
||||
}
|
||||
|
||||
fn command_usage(command: BuiltinCommand) -> String {
|
||||
match command {
|
||||
BuiltinCommand::Plan => "Command \"/plan\" accepts no arguments.".to_owned(),
|
||||
BuiltinCommand::Mcp => "Command \"/mcp\" accepts no arguments, or `reconnect`.".to_owned(),
|
||||
BuiltinCommand::ReviewBranch => "Command \"/review-branch\" requires branch name.".to_owned(),
|
||||
BuiltinCommand::ReviewCommit => "Command \"/review-commit\" requires commit sha.".to_owned(),
|
||||
BuiltinCommand::Goal => "Command \"/goal\" requires [<objective>|clear|pause|resume].".to_owned(),
|
||||
BuiltinCommand::Rename => "Command \"/rename\" requires new name.".to_owned(),
|
||||
_ => "This command does not accept arguments.".to_owned(),
|
||||
}
|
||||
}
|
||||
|
||||
fn status_text(
|
||||
session: &str,
|
||||
settings: Option<&Settings>,
|
||||
cwd: Option<&str>,
|
||||
token_usage: Option<&Value>,
|
||||
rate_limits: Option<&Value>,
|
||||
) -> String {
|
||||
let mut lines = Vec::new();
|
||||
if let Some(settings) = settings {
|
||||
lines.push(format!("**Model:** {}", settings.model));
|
||||
lines.push(format!("**Collaboration:** {}", settings.collaboration_mode));
|
||||
lines.push(format!("**Approval:** {}", settings.mode.approval_policy()));
|
||||
lines.push(format!("**Sandbox:** {}", settings.mode.sandbox_mode()));
|
||||
}
|
||||
if let Some(cwd) = cwd {
|
||||
lines.push(format!("**Directory:** {cwd}"));
|
||||
}
|
||||
lines.push(format!("**Session:** `{session}`"));
|
||||
if let Some(usage) = token_usage {
|
||||
let total = usage.pointer("/total/totalTokens").and_then(Value::as_u64);
|
||||
let used = usage.pointer("/last/totalTokens").and_then(Value::as_u64);
|
||||
let window = usage.get("modelContextWindow").and_then(Value::as_u64).filter(|window| *window > 0);
|
||||
if let (Some(total), Some(used), Some(window)) = (total, used, window) {
|
||||
let percent = (used.saturating_mul(100) + window / 2) / window;
|
||||
lines.push(format!("**Token usage:** {total} total"));
|
||||
lines.push(format!("**Context window:** {used} / {window} ({percent}%)"));
|
||||
}
|
||||
}
|
||||
if let Some(primary) = rate_limits.and_then(|r| r.get("primary"))
|
||||
&& let Some(used) = primary.get("usedPercent").and_then(Value::as_f64)
|
||||
{
|
||||
lines.push(format!("**Rate limit:** {used:.0}% used"));
|
||||
}
|
||||
lines.join(" \n")
|
||||
}
|
||||
|
||||
fn skills_text(response: &Value) -> String {
|
||||
let mut seen = HashSet::new();
|
||||
let names: Vec<String> = response
|
||||
.get("data")
|
||||
.and_then(Value::as_array)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|entry| entry.get("skills").and_then(Value::as_array))
|
||||
.flatten()
|
||||
.filter(|skill| skill.get("enabled") != Some(&Value::Bool(false)))
|
||||
.filter_map(|skill| {
|
||||
let name = skill.get("name").and_then(Value::as_str)?.trim();
|
||||
if name.is_empty() || !seen.insert(name.to_owned()) {
|
||||
return None;
|
||||
}
|
||||
let description = skill
|
||||
.pointer("/interface/shortDescription")
|
||||
.or_else(|| skill.get("shortDescription"))
|
||||
.or_else(|| skill.get("description"))
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or_default();
|
||||
Some(if description.is_empty() { name.to_owned() } else { format!("{name}: {description}") })
|
||||
})
|
||||
.collect();
|
||||
if names.is_empty() {
|
||||
"No skills configured.".to_owned()
|
||||
} else {
|
||||
format!("Available skills:\n{}", names.iter().map(|name| format!("- {name}")).collect::<Vec<_>>().join("\n"))
|
||||
}
|
||||
}
|
||||
|
||||
fn mcp_text(response: &Value) -> String {
|
||||
let servers = response.get("data").and_then(Value::as_array).map(Vec::as_slice).unwrap_or_default();
|
||||
if servers.is_empty() {
|
||||
return "No MCP servers configured.".to_owned();
|
||||
}
|
||||
let lines = servers
|
||||
.iter()
|
||||
.filter_map(|server| {
|
||||
let name = server.get("name").and_then(Value::as_str)?;
|
||||
let status = server
|
||||
.get("runtimeStatus")
|
||||
.and_then(Value::as_str)
|
||||
.or_else(|| server.get("authStatus").and_then(Value::as_str))
|
||||
.unwrap_or("unknown");
|
||||
let tools = server.get("tools").and_then(Value::as_object).map_or(0, serde_json::Map::len);
|
||||
Some(format!("- {name}: {status}, {tools} tools"))
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
format!("MCP servers:\n{}", lines.join("\n"))
|
||||
}
|
||||
@@ -180,24 +180,38 @@ fn settings_follow_the_thread_and_the_models() {
|
||||
let result = json!({"model": "big", "reasoningEffort": null, "approvalPolicy": "untrusted",
|
||||
"sandbox": {"type": "workspaceWrite"}});
|
||||
let mut s = Settings::of(&result, &models);
|
||||
assert_eq!(s, Settings { model: "big".into(), effort: Some("low".into()), mode: Mode::Ask });
|
||||
assert_eq!(
|
||||
s,
|
||||
Settings {
|
||||
model: "big".into(),
|
||||
effort: Some("low".into()),
|
||||
mode: Mode::Ask,
|
||||
collaboration_mode: DEFAULT_COLLABORATION_MODE.into(),
|
||||
collaboration_mode_override: None,
|
||||
}
|
||||
);
|
||||
|
||||
let options = config_options(&models, &s);
|
||||
let ids: Vec<&str> = options.as_array().unwrap().iter().map(|o| o["id"].as_str().unwrap()).collect();
|
||||
assert_eq!(ids, [MODEL, EFFORT, MODE]);
|
||||
assert_eq!(ids, [MODEL, EFFORT, MODE, COLLABORATION_MODE]);
|
||||
assert_eq!(options[0]["options"].as_array().unwrap().len(), 2, "hidden models are left out");
|
||||
assert_eq!(options[1]["category"], "thought_level");
|
||||
assert_eq!(options[1]["options"][1]["name"], "Extra high");
|
||||
assert_eq!(options[2]["currentValue"], "ask");
|
||||
assert_eq!(options[3]["currentValue"], "default");
|
||||
|
||||
// A model without efforts drops the option; its slug is what codex gets.
|
||||
s.set(&models, MODEL, "plain").unwrap();
|
||||
assert_eq!((s.effort.as_deref(), s.model_slug(&models).as_str()), (None, "plain-slug"));
|
||||
assert_eq!(config_options(&models, &s).as_array().unwrap().len(), 2);
|
||||
assert_eq!(config_options(&models, &s).as_array().unwrap().len(), 3);
|
||||
assert!(s.set(&models, EFFORT, "low").is_err());
|
||||
assert!(s.set(&models, MODEL, "nope").is_err());
|
||||
s.set(&models, MODE, "full-access").unwrap();
|
||||
assert_eq!((s.mode.approval_policy(), s.mode.sandbox_policy()), ("never", json!({"type": "dangerFullAccess"})));
|
||||
s.set(&models, COLLABORATION_MODE, PLAN_COLLABORATION_MODE).unwrap();
|
||||
assert_eq!(collaboration_mode(&s, &models)["mode"], PLAN_COLLABORATION_MODE);
|
||||
s.set(&models, COLLABORATION_MODE, DEFAULT_COLLABORATION_MODE).unwrap();
|
||||
assert_eq!(collaboration_mode(&s, &models)["mode"], DEFAULT_COLLABORATION_MODE);
|
||||
|
||||
// A model codex runs that it doesn't list is still offered.
|
||||
let s = Settings::of(&json!({"model": "custom", "sandbox": {"type": "readOnly"}}), &models);
|
||||
@@ -226,6 +240,18 @@ fn prompts_become_user_input() {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn compact_is_recognized_with_completion_whitespace_and_attachments() {
|
||||
// Completion leaves trailing whitespace and images can remain in the prompt. The first
|
||||
// text block still names the command; unknown slash-shaped text continues normally.
|
||||
assert_eq!(commands::parse(&text("/compact")).unwrap().command, BuiltinCommand::Compact);
|
||||
assert_eq!(commands::parse(&text(" /compact \n")).unwrap().command, BuiltinCommand::Compact);
|
||||
assert_eq!(commands::parse(&text("/compact now")).unwrap().rest, "now");
|
||||
let prompt = json!([{"type": "text", "text": "/compact"}, {"type": "image", "data": "AA=="}]);
|
||||
assert_eq!(commands::parse(&prompt).unwrap().command, BuiltinCommand::Compact);
|
||||
assert!(commands::parse(&text("x/compact")).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn commands_are_titled_by_what_they_do() {
|
||||
let cmd = |actions: Value| {
|
||||
@@ -453,6 +479,7 @@ fn history_replays_turns() {
|
||||
#[derive(Default)]
|
||||
struct Client {
|
||||
updates: Mutex<Vec<Value>>,
|
||||
warnings: Mutex<Vec<Value>>,
|
||||
asked: Mutex<Vec<Value>>,
|
||||
/// Option ids to choose; `None` (or none left) cancels.
|
||||
answers: Mutex<VecDeque<Option<&'static str>>>,
|
||||
@@ -462,6 +489,8 @@ impl Handler for Client {
|
||||
fn on_notification(&self, method: &str, params: Value) {
|
||||
if method == "session/update" {
|
||||
self.updates.lock().push(params);
|
||||
} else if method == "_openidea/warning" {
|
||||
self.warnings.lock().push(params);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -527,6 +556,10 @@ async fn questions_share_one_card_and_keep_their_ids() {
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
enum Scenario {
|
||||
AuthFailure,
|
||||
Command(&'static str),
|
||||
Compact,
|
||||
PlanThenPrompt,
|
||||
PlanToggleThenPrompt,
|
||||
Interrupt,
|
||||
Resume,
|
||||
Steer,
|
||||
@@ -541,6 +574,10 @@ impl Scenario {
|
||||
fn file(self) -> &'static str {
|
||||
match self {
|
||||
Scenario::AuthFailure => "auth_failure",
|
||||
Scenario::Command(_) => "simple",
|
||||
Scenario::Compact => "simple",
|
||||
Scenario::PlanThenPrompt => "simple",
|
||||
Scenario::PlanToggleThenPrompt => "simple",
|
||||
Scenario::Interrupt => "interrupt",
|
||||
Scenario::Resume => "resume",
|
||||
Scenario::Steer => "steer",
|
||||
@@ -598,6 +635,21 @@ async fn drive(scenario: Scenario, acp: &Peer, client: &Client, cwd: &str, threa
|
||||
Scenario::AuthFailure | Scenario::Simple | Scenario::UsageLimit | Scenario::Subagent => {
|
||||
out.push(("prompt", request(acp, "session/prompt", prompt("Reply with the single word: hi")).await));
|
||||
}
|
||||
Scenario::Compact => {
|
||||
out.push(("prompt", request(acp, "session/prompt", prompt("/compact")).await));
|
||||
}
|
||||
Scenario::Command(command) => {
|
||||
out.push(("prompt", request(acp, "session/prompt", prompt(command)).await));
|
||||
}
|
||||
Scenario::PlanThenPrompt => {
|
||||
out.push(("plan", request(acp, "session/prompt", prompt("/plan")).await));
|
||||
out.push(("prompt", request(acp, "session/prompt", prompt("Reply with the single word: hi")).await));
|
||||
}
|
||||
Scenario::PlanToggleThenPrompt => {
|
||||
out.push(("plan", request(acp, "session/prompt", prompt("/plan")).await));
|
||||
out.push(("default", request(acp, "session/prompt", prompt("/plan")).await));
|
||||
out.push(("prompt", request(acp, "session/prompt", prompt("Reply with the single word: hi")).await));
|
||||
}
|
||||
Scenario::Interrupt => {
|
||||
out.push(("mode", request(acp, "session/set_config_option", set(MODE, "read-only")).await));
|
||||
let running = {
|
||||
@@ -665,6 +717,37 @@ fn load(name: &str) -> Transcript {
|
||||
Transcript { meta, frames }
|
||||
}
|
||||
|
||||
/// The simple fixture through session setup. Local commands add only the app-server calls
|
||||
/// they need after it; turn commands keep the fixture's turn notifications.
|
||||
fn command_transcript(calls: &[(&'static str, Value)]) -> Transcript {
|
||||
let mut transcript = load(Scenario::Simple.file());
|
||||
let prompt = transcript
|
||||
.frames
|
||||
.iter()
|
||||
.position(|(out, frame)| *out && frame["method"] == "turn/start")
|
||||
.expect("the scenario starts a turn");
|
||||
transcript.frames.truncate(prompt);
|
||||
transcript.frames.push((true, json!({ "id": 4, "method": "skills/list" })));
|
||||
transcript.frames.push((false, json!({ "id": 4, "result": { "data": [] } })));
|
||||
for (index, (method, result)) in calls.iter().enumerate() {
|
||||
let id = 10 + index;
|
||||
transcript.frames.push((true, json!({ "id": id, "method": method })));
|
||||
transcript.frames.push((false, json!({ "id": id, "result": result })));
|
||||
}
|
||||
transcript
|
||||
}
|
||||
|
||||
fn turn_command_transcript(method: &str) -> Transcript {
|
||||
let mut transcript = load(Scenario::Simple.file());
|
||||
let start = transcript
|
||||
.frames
|
||||
.iter_mut()
|
||||
.find(|(out, frame)| *out && frame["method"] == "turn/start")
|
||||
.expect("the scenario starts a turn");
|
||||
start.1["method"] = json!(method);
|
||||
transcript
|
||||
}
|
||||
|
||||
/// Plays codex: waits for each frame the shim should send, sends what codex sent.
|
||||
/// Returns the frames the shim sent.
|
||||
async fn play<R: AsyncRead + Unpin, W: AsyncWrite + Unpin>(
|
||||
@@ -684,10 +767,10 @@ async fn play<R: AsyncRead + Unpin, W: AsyncWrite + Unpin>(
|
||||
.unwrap()
|
||||
.unwrap_or_else(|| panic!("the shim closed before {frame}"));
|
||||
let actual: Value = serde_json::from_str(&line).unwrap();
|
||||
// Older recordings predate skill discovery and thread naming; play an
|
||||
// Older recordings predate config inspection, skill discovery and thread naming; play an
|
||||
// unsupported server.
|
||||
let method = actual["method"].as_str().unwrap_or_default();
|
||||
if matches!(method, "skills/list" | "thread/sample") && frame["method"] != method {
|
||||
if matches!(method, "config/read" | "skills/list" | "thread/sample") && frame["method"] != method {
|
||||
let reply = json!({ "id": actual["id"], "error": { "code": -32601, "message": "unsupported" } });
|
||||
write.write_all(format!("{reply}\n").as_bytes()).await.unwrap();
|
||||
continue;
|
||||
@@ -760,6 +843,149 @@ fn session_of(results: &Results, label: &str) -> String {
|
||||
result(results, label).as_ref().unwrap()["sessionId"].as_str().unwrap().to_owned()
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn configuration_warnings_before_a_session_and_runtime_warnings_reach_the_client() {
|
||||
let mut transcript = load(Scenario::Simple.file());
|
||||
transcript.frames.insert(
|
||||
0,
|
||||
(
|
||||
false,
|
||||
json!({"method": "configWarning", "params": {
|
||||
"summary": "Project-local config is disabled until the project is trusted.",
|
||||
"details": "Update the project's trust setting.", "path": "/work/.codex/config.toml"
|
||||
}}),
|
||||
),
|
||||
);
|
||||
let at = transcript.frames.iter().position(|(out, f)| *out && f["method"] == "turn/start").unwrap();
|
||||
transcript
|
||||
.frames
|
||||
.insert(at, (false, json!({"method": "warning", "params": {"message": "MCP server unavailable"}})));
|
||||
let (results, client, frames, _, _codex) = replay_transcript(Scenario::Simple, transcript).await;
|
||||
assert!(result(&results, "new").is_ok());
|
||||
assert_eq!(
|
||||
*client.warnings.lock(),
|
||||
[
|
||||
json!({"message": "Project-local config is disabled until the project is trusted.\n\nUpdate the project's trust setting.\n\n/work/.codex/config.toml"}),
|
||||
json!({"message": "MCP server unavailable"}),
|
||||
]
|
||||
);
|
||||
assert!(sent(&frames, "config/value/write").is_empty());
|
||||
assert!(sent(&frames, "config/batchWrite").is_empty());
|
||||
}
|
||||
|
||||
struct TrustServer {
|
||||
cwd: String,
|
||||
disabled: bool,
|
||||
other_project: bool,
|
||||
write_error: bool,
|
||||
overridden: bool,
|
||||
calls: Mutex<Vec<(String, Value)>>,
|
||||
}
|
||||
|
||||
impl Handler for TrustServer {
|
||||
fn on_notification(&self, _: &str, _: Value) {}
|
||||
|
||||
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
|
||||
self.calls.lock().push((method.to_owned(), params));
|
||||
match method {
|
||||
"initialize" => Ok(json!({})),
|
||||
"model/list" => Ok(json!({"data": []})),
|
||||
"config/read" => {
|
||||
let cwd =
|
||||
if self.other_project { Path::new(&self.cwd).join("other") } else { PathBuf::from(&self.cwd) };
|
||||
Ok(json!({"layers": [
|
||||
{"name": {"type": "user", "profile": null}, "version": "original"},
|
||||
{"name": {"type": "project", "dotCodexFolder": cwd.join(".codex")},
|
||||
"disabledReason": self.disabled.then_some("Project config is disabled until trusted.")}
|
||||
]}))
|
||||
}
|
||||
"config/value/write" if self.write_error => Err((-32001, "Config changed concurrently".into())),
|
||||
"config/value/write" => Ok(json!({"status": if self.overridden {"okOverridden"} else {"ok"}})),
|
||||
"thread/start" | "thread/resume" | "thread/fork" => {
|
||||
Ok(json!({"thread": {"id": "s", "turns": []}, "cwd": self.cwd}))
|
||||
}
|
||||
"skills/list" => Ok(json!({"data": []})),
|
||||
_ => Err((codes::METHOD_NOT_FOUND, method.to_owned())),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn project_trust_is_confirmed_before_new_resumed_and_forked_sessions() {
|
||||
for method in ["session/new", "session/load", "session/fork"] {
|
||||
for (answer, disabled, other_project, write_error, overridden) in [
|
||||
(Some("codex-trust-project"), true, false, false, false),
|
||||
(Some("codex-keep-untrusted"), true, false, false, false),
|
||||
(None, true, false, false, false),
|
||||
(Some("codex-trust-project"), false, false, false, false),
|
||||
(Some("codex-trust-project"), true, true, false, false),
|
||||
(Some("codex-trust-project"), true, false, true, false),
|
||||
(Some("codex-trust-project"), true, false, false, true),
|
||||
] {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let cwd = tmp.path().join("project.with.dots-项目").to_string_lossy().into_owned();
|
||||
let server = Arc::new(TrustServer {
|
||||
cwd: cwd.clone(),
|
||||
disabled,
|
||||
other_project,
|
||||
write_error,
|
||||
overridden,
|
||||
calls: Mutex::default(),
|
||||
});
|
||||
let client = Arc::new(Client::default());
|
||||
client.answers.lock().push_back(answer);
|
||||
let (ours, theirs) = tokio::io::duplex(1 << 16);
|
||||
let (read, write) = tokio::io::split(theirs);
|
||||
let native = Peer::connect_framed(read, write, server.clone(), Framing::Lines);
|
||||
let acp = attach(client.clone(), |events| {
|
||||
let (read, write) = tokio::io::split(ours);
|
||||
Ok(Peer::connect_framed(read, write, events, Framing::Lines))
|
||||
})
|
||||
.unwrap();
|
||||
request(&acp, "initialize", json!({})).await.unwrap();
|
||||
let params = json!({"cwd": cwd, "sessionId": "source", "mcpServers": []});
|
||||
request(&acp, method, params.clone()).await.unwrap();
|
||||
// The same connection must not ask repeatedly after a decline.
|
||||
request(&acp, method, params).await.unwrap();
|
||||
let approved = answer == Some("codex-trust-project") && disabled && !other_project;
|
||||
{
|
||||
let asked = client.asked.lock();
|
||||
assert_eq!(asked.len(), usize::from(disabled && !other_project));
|
||||
if let Some(permission) = asked.first() {
|
||||
assert!(permission["toolCall"]["title"].as_str().unwrap().contains(&cwd));
|
||||
assert_eq!(
|
||||
permission["toolCall"]["kind"], "edit",
|
||||
"side conversations must deny persistent trust changes"
|
||||
);
|
||||
assert_eq!(
|
||||
permission["options"][0]["kind"], "allow_always",
|
||||
"task bypass must not grant permanent trust"
|
||||
);
|
||||
}
|
||||
let calls = server.calls.lock();
|
||||
let writes: Vec<_> = calls.iter().filter(|(m, _)| m == "config/value/write").collect();
|
||||
assert_eq!(writes.len(), usize::from(approved));
|
||||
if let Some((_, write)) = writes.first() {
|
||||
assert_eq!(
|
||||
*write,
|
||||
json!({"keyPath": format!("projects.{}.trust_level", json!(cwd)), "value": "trusted", "mergeStrategy": "replace", "expectedVersion": "original"})
|
||||
);
|
||||
let written = calls.iter().position(|(m, _)| m == "config/value/write").unwrap();
|
||||
let started = calls.iter().position(|(m, _)| m.starts_with("thread/")).unwrap();
|
||||
assert!(written < started, "the session must load config after the write");
|
||||
}
|
||||
}
|
||||
// Drain notifications sent before the last response.
|
||||
tokio::time::sleep(Duration::from_millis(20)).await;
|
||||
if approved && (write_error || overridden) {
|
||||
assert!(!client.warnings.lock().is_empty());
|
||||
}
|
||||
acp.kill();
|
||||
native.kill();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn auth_failure_names_auth() {
|
||||
let (results, _client, frames, _) = replay(Scenario::AuthFailure).await;
|
||||
@@ -771,7 +997,7 @@ async fn auth_failure_names_auth() {
|
||||
let categories: Vec<&str> =
|
||||
new["configOptions"].as_array().unwrap().iter().map(|o| o["category"].as_str().unwrap()).collect();
|
||||
// The model the user's codex config names; codex doesn't list it, so its efforts are unknown.
|
||||
assert_eq!(categories, ["model", "mode"]);
|
||||
assert_eq!(categories, ["model", "mode", "collaboration_mode"]);
|
||||
let model = new["configOptions"][0]["currentValue"].as_str().unwrap();
|
||||
assert_eq!(model, "gpt-6-luna");
|
||||
assert!(new["configOptions"][0]["options"].as_array().unwrap().iter().any(|o| o["value"] == model));
|
||||
@@ -1011,6 +1237,7 @@ async fn settings_apply_to_the_next_turn() {
|
||||
(starts[0]["params"]["model"].as_str(), starts[0]["params"]["effort"].as_str()),
|
||||
(Some("gpt-5.6-luna"), Some("medium"))
|
||||
);
|
||||
assert!(starts[0]["params"].get("collaborationMode").is_none());
|
||||
assert_eq!(
|
||||
(starts[1]["params"]["model"].as_str(), starts[1]["params"]["effort"].as_str()),
|
||||
(Some("gpt-5.5"), Some("high"))
|
||||
@@ -1019,6 +1246,192 @@ async fn settings_apply_to_the_next_turn() {
|
||||
assert_eq!(client.text(&session, "agent_message_chunk"), "oneOn it.\n\ntwo");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn compact_is_started_through_its_app_server_method() {
|
||||
// Play the ordinary-turn fixture with the request swapped: the notifications are the
|
||||
// same, while this pins the user-visible command to `thread/compact/start`, not a prompt.
|
||||
let mut transcript = load(Scenario::Simple.file());
|
||||
let start = transcript
|
||||
.frames
|
||||
.iter_mut()
|
||||
.find(|(out, frame)| *out && frame["method"] == "turn/start")
|
||||
.expect("the scenario starts a turn");
|
||||
start.1["method"] = json!("thread/compact/start");
|
||||
let (results, _client, frames, _meta, _codex) = replay_transcript(Scenario::Compact, transcript).await;
|
||||
|
||||
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({"stopReason": "end_turn"}));
|
||||
assert!(sent(&frames, "turn/start").is_empty());
|
||||
assert_eq!(sent(&frames, "thread/compact/start").len(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn review_commands_start_the_matching_review_target() {
|
||||
for (prompt, target) in [
|
||||
("/review", json!({ "type": "uncommittedChanges" })),
|
||||
("/review focus on errors", json!({ "type": "custom", "instructions": "focus on errors" })),
|
||||
("/review-branch origin/main", json!({ "type": "baseBranch", "branch": "origin/main" })),
|
||||
("/review-commit abc123", json!({ "type": "commit", "sha": "abc123", "title": null })),
|
||||
] {
|
||||
let (results, _client, frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::Command(prompt), turn_command_transcript("review/start")).await;
|
||||
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }), "{prompt}");
|
||||
assert!(sent(&frames, "turn/start").is_empty(), "{prompt}");
|
||||
assert_eq!(sent(&frames, "review/start")[0]["params"]["target"], target, "{prompt}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn plan_toggles_collaboration_mode_and_updates_the_composer() {
|
||||
let (results, client, _frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::Command("/plan"), command_transcript(&[])).await;
|
||||
let session = session_of(&results, "new");
|
||||
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
|
||||
let update = client.of(&session).into_iter().find(|u| u["sessionUpdate"] == "config_option_update").unwrap();
|
||||
let plan =
|
||||
update["configOptions"].as_array().unwrap().iter().find(|o| o["category"] == "collaboration_mode").unwrap();
|
||||
assert_eq!(plan["currentValue"], "plan");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn plan_applies_to_the_next_normal_turn() {
|
||||
let (results, _client, frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::PlanThenPrompt, load(Scenario::Simple.file())).await;
|
||||
assert_eq!(result(&results, "plan").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
|
||||
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
|
||||
let start = sent(&frames, "turn/start")[0];
|
||||
assert_eq!(start["params"]["collaborationMode"]["mode"], "plan");
|
||||
assert_eq!(start["params"]["collaborationMode"]["settings"]["model"], "gpt-5.6-luna");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn toggling_plan_off_sends_an_explicit_default_once() {
|
||||
let (results, _client, frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::PlanToggleThenPrompt, load(Scenario::Simple.file())).await;
|
||||
assert_eq!(result(&results, "default").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
|
||||
let start = sent(&frames, "turn/start")[0];
|
||||
assert_eq!(start["params"]["collaborationMode"]["mode"], "default");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn informational_commands_report_skills_mcp_and_status() {
|
||||
let skills = json!({ "data": [{ "skills": [
|
||||
{ "name": "review", "enabled": true, "description": "Review changes" },
|
||||
{ "name": "hidden", "enabled": false, "description": "Hidden" }
|
||||
] }] });
|
||||
let servers = json!({ "data": [
|
||||
{ "name": "github", "runtimeStatus": "connected", "authStatus": "oAuth", "tools": { "search": {} } },
|
||||
{ "name": "docs", "runtimeStatus": "failed", "authStatus": "unknown", "tools": {} }
|
||||
] });
|
||||
for (prompt, method, response, expected) in [
|
||||
("/skills", "skills/list", skills, "Available skills:\n- review: Review changes"),
|
||||
(
|
||||
"/mcp",
|
||||
"mcpServerStatus/list",
|
||||
servers,
|
||||
"MCP servers:\n- github: connected, 1 tools\n- docs: failed, 0 tools",
|
||||
),
|
||||
("/status", "", Value::Null, "**Session:**"),
|
||||
] {
|
||||
let calls: &[(&str, Value)] = if method.is_empty() { &[] } else { &[(method, response)] };
|
||||
let calls: Vec<(&'static str, Value)> = calls
|
||||
.iter()
|
||||
.map(|(method, response)| {
|
||||
let method = match *method {
|
||||
"skills/list" => "skills/list",
|
||||
"mcpServerStatus/list" => "mcpServerStatus/list",
|
||||
other => panic!("unexpected method {other}"),
|
||||
};
|
||||
(method, response.clone())
|
||||
})
|
||||
.collect();
|
||||
let (results, client, _frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::Command(prompt), command_transcript(&calls)).await;
|
||||
let session = session_of(&results, "new");
|
||||
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
|
||||
assert!(client.text(&session, "agent_message_chunk").contains(expected), "{prompt}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn rename_and_logout_use_their_app_server_actions() {
|
||||
let (results, client, frames, _meta, _codex) = replay_transcript(
|
||||
Scenario::Command("/rename Better name"),
|
||||
command_transcript(&[("thread/name/set", json!({}))]),
|
||||
)
|
||||
.await;
|
||||
let session = session_of(&results, "new");
|
||||
assert_eq!(sent(&frames, "thread/name/set")[0]["params"], json!({ "threadId": session, "name": "Better name" }));
|
||||
let info = client.of(&session).into_iter().find(|u| u["sessionUpdate"] == "session_info_update").unwrap();
|
||||
assert_eq!((info["title"].as_str(), info["userNamed"].as_bool()), (Some("Better name"), Some(true)));
|
||||
|
||||
let (results, client, frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::Command("/logout"), command_transcript(&[("account/logout", json!({}))])).await;
|
||||
let session = session_of(&results, "new");
|
||||
assert_eq!(sent(&frames, "account/logout").len(), 1);
|
||||
assert_eq!(client.text(&session, "agent_message_chunk"), "Logged out from Codex account.");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn goal_commands_set_pause_resume_and_clear_through_app_server() {
|
||||
for (prompt, method, params, result) in [
|
||||
(
|
||||
"/goal fix the failing tests",
|
||||
"thread/goal/set",
|
||||
json!({ "threadId": "s", "objective": "fix the failing tests", "status": "active", "origin": "user" }),
|
||||
json!({ "goal": { "status": "active" } }),
|
||||
),
|
||||
(
|
||||
"/goal pause",
|
||||
"thread/goal/set",
|
||||
json!({ "threadId": "s", "status": "paused", "origin": "user" }),
|
||||
json!({ "goal": { "status": "paused" } }),
|
||||
),
|
||||
(
|
||||
"/goal resume",
|
||||
"thread/goal/set",
|
||||
json!({ "threadId": "s", "status": "active", "origin": "user" }),
|
||||
json!({ "goal": { "status": "active" } }),
|
||||
),
|
||||
("/goal clear", "thread/goal/clear", json!({ "threadId": "s" }), json!({ "cleared": true })),
|
||||
] {
|
||||
let (results, _client, frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::Command(prompt), command_transcript(&[(method, result)])).await;
|
||||
let session = session_of(&results, "new");
|
||||
let sent = sent(&frames, method);
|
||||
assert_eq!(sent.len(), 1, "{prompt}");
|
||||
let mut expected = params;
|
||||
expected["threadId"] = json!(session);
|
||||
assert_eq!(sent[0]["params"], expected, "{prompt}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn missing_review_arguments_print_usage_without_starting_a_turn() {
|
||||
for prompt in ["/review-branch", "/review-commit", "/rename", "/goal"] {
|
||||
let (results, client, frames, _meta, _codex) =
|
||||
replay_transcript(Scenario::Command(prompt), command_transcript(&[])).await;
|
||||
let session = session_of(&results, "new");
|
||||
assert_eq!(result(&results, "prompt").as_ref().unwrap(), &json!({ "stopReason": "end_turn" }));
|
||||
assert!(sent(&frames, "turn/start").is_empty());
|
||||
assert!(client.text(&session, "agent_message_chunk").starts_with("Command \""), "{prompt}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn mcp_reconnect_reloads_before_reporting_status() {
|
||||
let servers =
|
||||
json!({ "data": [{ "name": "github", "runtimeStatus": "connected", "authStatus": "oAuth", "tools": {} }] });
|
||||
let (results, client, frames, _meta, _codex) = replay_transcript(
|
||||
Scenario::Command("/mcp reconnect"),
|
||||
command_transcript(&[("config/mcpServer/reload", json!({})), ("mcpServerStatus/list", servers)]),
|
||||
)
|
||||
.await;
|
||||
let session = session_of(&results, "new");
|
||||
assert_eq!(sent(&frames, "config/mcpServer/reload").len(), 1);
|
||||
assert_eq!(sent(&frames, "mcpServerStatus/list").len(), 1);
|
||||
assert!(client.text(&session, "agent_message_chunk").contains("github: connected"));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn approvals_are_asked_and_answered() {
|
||||
let (results, client, frames, _) = replay(Scenario::Approvals).await;
|
||||
|
||||
@@ -138,6 +138,12 @@ pub(super) struct Settings {
|
||||
pub model: String,
|
||||
pub effort: Option<String>,
|
||||
pub mode: Mode,
|
||||
/// Codex's Default/Plan collaboration mode. It is sent with each turn because it is
|
||||
/// part of the turn contract rather than the sandbox permission mode above.
|
||||
pub collaboration_mode: String,
|
||||
/// A mode just chosen by the user, sent once even when it is Default so a resumed Plan
|
||||
/// thread is explicitly reset. Subsequent default turns can omit the field again.
|
||||
pub collaboration_mode_override: Option<String>,
|
||||
}
|
||||
|
||||
impl Settings {
|
||||
@@ -156,6 +162,12 @@ impl Settings {
|
||||
result.get("approvalPolicy").unwrap_or(&Value::Null),
|
||||
result.get("sandbox").unwrap_or(&Value::Null),
|
||||
),
|
||||
collaboration_mode: result
|
||||
.pointer("/collaborationMode/mode")
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or(DEFAULT_COLLABORATION_MODE)
|
||||
.to_owned(),
|
||||
collaboration_mode_override: None,
|
||||
};
|
||||
s.fit_effort(models);
|
||||
s
|
||||
@@ -194,6 +206,13 @@ impl Settings {
|
||||
self.effort = Some(value.to_owned());
|
||||
}
|
||||
MODE => self.mode = Mode::parse(value).ok_or_else(|| format!("unknown mode {value}"))?,
|
||||
COLLABORATION_MODE => {
|
||||
if !matches!(value, DEFAULT_COLLABORATION_MODE | PLAN_COLLABORATION_MODE) {
|
||||
return Err(format!("unknown collaboration mode {value}"));
|
||||
}
|
||||
self.collaboration_mode = value.to_owned();
|
||||
self.collaboration_mode_override = Some(value.to_owned());
|
||||
}
|
||||
_ => return Err(format!("unknown setting {option}")),
|
||||
}
|
||||
Ok(())
|
||||
@@ -203,6 +222,9 @@ impl Settings {
|
||||
pub(super) const MODEL: &str = "model";
|
||||
pub(super) const EFFORT: &str = "reasoning_effort";
|
||||
pub(super) const MODE: &str = "mode";
|
||||
pub(super) const COLLABORATION_MODE: &str = "collaboration_mode";
|
||||
pub(super) const DEFAULT_COLLABORATION_MODE: &str = "default";
|
||||
pub(super) const PLAN_COLLABORATION_MODE: &str = "plan";
|
||||
|
||||
/// ACP `configOptions`: model, reasoning effort (for models that have it) and mode.
|
||||
pub(super) fn config_options(models: &[ModelInfo], s: &Settings) -> Value {
|
||||
@@ -235,9 +257,32 @@ pub(super) fn config_options(models: &[ModelInfo], s: &Settings) -> Value {
|
||||
"id": MODE, "name": "Mode", "category": "mode", "type": "select", "currentValue": s.mode.id(),
|
||||
"options": Mode::ALL.iter().map(|m| select_value(m.id(), m.name(), Some(m.description()))).collect::<Vec<_>>(),
|
||||
}));
|
||||
out.push(json!({
|
||||
"id": COLLABORATION_MODE,
|
||||
"name": "Collaboration mode",
|
||||
"category": "collaboration_mode",
|
||||
"type": "select",
|
||||
"currentValue": s.collaboration_mode,
|
||||
"options": [
|
||||
select_value(DEFAULT_COLLABORATION_MODE, "Default", Some("Execute changes directly")),
|
||||
select_value(PLAN_COLLABORATION_MODE, "Plan", Some("Plan before making changes")),
|
||||
],
|
||||
}));
|
||||
Value::Array(out)
|
||||
}
|
||||
|
||||
/// `turn/start.collaborationMode`: the preset plus the selected model settings.
|
||||
pub(super) fn collaboration_mode(settings: &Settings, models: &[ModelInfo]) -> Value {
|
||||
json!({
|
||||
"mode": settings.collaboration_mode_override.as_deref().unwrap_or(&settings.collaboration_mode),
|
||||
"settings": {
|
||||
"model": settings.model_slug(models),
|
||||
"reasoning_effort": settings.effort,
|
||||
"developer_instructions": null,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
fn select_value(value: &str, name: &str, description: Option<&str>) -> Value {
|
||||
let mut v = json!({ "value": value, "name": name });
|
||||
if let Some(d) = description {
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
//! A project trusted by the IDE may still be untrusted by Codex. Ask before changing
|
||||
//! Codex's own decision; only its config API writes the current project's trust entry.
|
||||
|
||||
use super::*;
|
||||
|
||||
fn disabled_project<'a>(config: &'a Value, cwd: &str) -> Option<&'a Value> {
|
||||
let folder = Path::new(cwd).join(".codex");
|
||||
config.get("layers")?.as_array()?.iter().find(|layer| {
|
||||
layer.pointer("/name/type").and_then(Value::as_str) == Some("project")
|
||||
&& layer
|
||||
.pointer("/name/dotCodexFolder")
|
||||
.and_then(Value::as_str)
|
||||
.is_some_and(|path| Path::new(path) == folder)
|
||||
&& layer.get("disabledReason").and_then(Value::as_str).is_some_and(|reason| !reason.trim().is_empty())
|
||||
})
|
||||
}
|
||||
|
||||
impl CodexShim {
|
||||
pub(super) async fn prepare_project_trust(&self, params: &Value) {
|
||||
let Some(cwd) = params.get("cwd").and_then(Value::as_str) else { return };
|
||||
if !self.state.lock().trust_checked.insert(cwd.to_owned()) {
|
||||
return;
|
||||
}
|
||||
// Old app-servers may not expose config layers. Their warnings still reach the UI.
|
||||
let Ok(Ok(config)) = tokio::time::timeout(
|
||||
Duration::from_secs(5),
|
||||
self.call("config/read", json!({ "cwd": cwd, "includeLayers": true })),
|
||||
)
|
||||
.await
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let Some(layer) = disabled_project(&config, cwd) else { return };
|
||||
let Some(client) = self.client.get() else { return };
|
||||
let title = format!(
|
||||
"Trust project in Codex: {cwd}? This saves trust in your Codex user configuration and allows \
|
||||
this project's MCP servers, hooks and exec policies to load."
|
||||
);
|
||||
let permission = json!({
|
||||
"sessionId": params.get("sessionId").and_then(Value::as_str).unwrap_or_default(),
|
||||
"toolCall": {
|
||||
"toolCallId": format!("codex-project-trust:{cwd}"),
|
||||
"title": title, "kind": "edit",
|
||||
"rawInput": { "project": cwd },
|
||||
},
|
||||
"options": [
|
||||
// Permanent trust must never be auto-approved by the task's allow-once bypass.
|
||||
{ "optionId": "codex-trust-project", "name": "Trust Project in Codex", "kind": "allow_always" },
|
||||
{ "optionId": "codex-keep-untrusted", "name": "Keep Untrusted", "kind": "reject_once" },
|
||||
],
|
||||
});
|
||||
let answer: Result<Value, RpcError> = client.request("session/request_permission", permission, None).await;
|
||||
let approved = answer.as_ref().is_ok_and(|answer| {
|
||||
answer.pointer("/outcome/outcome").and_then(Value::as_str) == Some("selected")
|
||||
&& answer.pointer("/outcome/optionId").and_then(Value::as_str) == Some("codex-trust-project")
|
||||
});
|
||||
if !approved {
|
||||
if let Some(reason) = layer.get("disabledReason").and_then(Value::as_str) {
|
||||
self.warning(reason);
|
||||
}
|
||||
return;
|
||||
}
|
||||
// Quote the path as one key segment: dots and Windows backslashes are literal.
|
||||
let mut write = json!({
|
||||
"keyPath": format!("projects.{}.trust_level", json!(cwd)),
|
||||
"value": "trusted", "mergeStrategy": "replace",
|
||||
});
|
||||
if let Some(version) = config["layers"]
|
||||
.as_array()
|
||||
.and_then(|layers| {
|
||||
layers.iter().find(|layer| {
|
||||
layer.pointer("/name/type").and_then(Value::as_str) == Some("user")
|
||||
&& layer.pointer("/name/profile").is_none_or(Value::is_null)
|
||||
})
|
||||
})
|
||||
.and_then(|layer| layer.get("version"))
|
||||
.filter(|version| version.is_string())
|
||||
{
|
||||
write["expectedVersion"] = version.clone();
|
||||
}
|
||||
match self.call("config/value/write", write).await {
|
||||
Err(error) => self.warning(format!("Codex could not save trust for {cwd}: {}", error.message)),
|
||||
Ok(reply) if reply["status"] == "okOverridden" => {
|
||||
self.warning(format!(
|
||||
"Codex saved trust for {cwd}, but a higher-priority configuration overrides it. \
|
||||
Project configuration may remain disabled; check the Codex configuration or contact your administrator."
|
||||
));
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
// start/resume/fork now load the updated config before creating the thread.
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,841 @@
|
||||
//! Model catalog, effort levels, context-window tiers, and token pricing from
|
||||
//! `copilot --headless --stdio` (`models.list` + `models.listTokenPriceUnits`).
|
||||
|
||||
use crate::model::{AgentModelPricing, AgentTokenPricing};
|
||||
use serde_json::{Value, json};
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
|
||||
pub(super) const MODEL: &str = "model";
|
||||
pub(super) const EFFORT: &str = "reasoning_effort";
|
||||
pub(super) const CONTEXT_TIER: &str = "context_tier";
|
||||
pub(super) const MODE: &str = "mode";
|
||||
pub(super) const ALLOW_ALL: &str = "allow_all";
|
||||
|
||||
const BATCH_TOKENS: f64 = 1_000_000.0;
|
||||
const NANO_AIU_PER_CREDIT: f64 = 1_000_000_000.0;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(super) enum Mode {
|
||||
Agent,
|
||||
Plan,
|
||||
Autopilot,
|
||||
}
|
||||
|
||||
impl Mode {
|
||||
pub const ALL: [Mode; 3] = [Mode::Agent, Mode::Plan, Mode::Autopilot];
|
||||
|
||||
pub fn id(self) -> &'static str {
|
||||
match self {
|
||||
Mode::Agent => "agent",
|
||||
Mode::Plan => "plan",
|
||||
Mode::Autopilot => "autopilot",
|
||||
}
|
||||
}
|
||||
|
||||
pub fn wire(self) -> &'static str {
|
||||
match self {
|
||||
Mode::Agent => "interactive",
|
||||
Mode::Plan => "plan",
|
||||
Mode::Autopilot => "autopilot",
|
||||
}
|
||||
}
|
||||
|
||||
pub fn name(self) -> &'static str {
|
||||
match self {
|
||||
Mode::Agent => "Agent",
|
||||
Mode::Plan => "Plan",
|
||||
Mode::Autopilot => "Autopilot",
|
||||
}
|
||||
}
|
||||
|
||||
pub fn description(self) -> &'static str {
|
||||
match self {
|
||||
Mode::Agent => "Default agent mode for conversational interactions",
|
||||
Mode::Plan => "Plan mode for creating and executing multi-step plans",
|
||||
Mode::Autopilot => "Autonomous mode that enables allow-all and runs until task completion",
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse(value: &str) -> Option<Mode> {
|
||||
let short = value.rsplit(['#', '/']).next().unwrap_or(value);
|
||||
match short {
|
||||
"agent" | "interactive" => Some(Mode::Agent),
|
||||
"plan" => Some(Mode::Plan),
|
||||
"autopilot" => Some(Mode::Autopilot),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub(super) struct ContextTierChoice {
|
||||
pub id: &'static str,
|
||||
pub label: String,
|
||||
pub tokens: u32,
|
||||
pub description: &'static str,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub(super) struct ModelEntry {
|
||||
pub id: String,
|
||||
pub name: String,
|
||||
pub description: Option<String>,
|
||||
pub is_default: bool,
|
||||
pub default_effort: Option<String>,
|
||||
pub efforts: Vec<String>,
|
||||
pub context_tiers: Vec<ContextTierChoice>,
|
||||
pub default_context_tokens: Option<u32>,
|
||||
pub max_context_tokens: Option<u32>,
|
||||
pub pricing: Option<AgentModelPricing>,
|
||||
}
|
||||
|
||||
impl ModelEntry {
|
||||
/// Copilot's default reasoning effort for this model: user setting (`effortLevel`) when
|
||||
/// supported, otherwise the model's `defaultReasoningEffort`, `"medium"`, or first listed.
|
||||
pub fn default_effort<'a>(&'a self, user_default: Option<&str>) -> Option<&'a str> {
|
||||
if let Some(wanted) = user_default
|
||||
&& let Some(found) = self.efforts.iter().find(|e| e.as_str() == wanted)
|
||||
{
|
||||
return Some(found.as_str());
|
||||
}
|
||||
if let Some(model_def) = self.default_effort.as_deref()
|
||||
&& let Some(found) = self.efforts.iter().find(|e| e.as_str() == model_def)
|
||||
{
|
||||
return Some(found.as_str());
|
||||
}
|
||||
self.efforts.iter().find(|e| e.as_str() == "medium").or_else(|| self.efforts.first()).map(String::as_str)
|
||||
}
|
||||
|
||||
/// Copilot's default context-window tier for this model: user setting (`contextTier`) when
|
||||
/// supported, otherwise `"default"` (`200K`), or first listed.
|
||||
pub fn default_context_tier(&self, user_default: Option<&str>) -> Option<&'static str> {
|
||||
if let Some(wanted) = user_default
|
||||
&& let Some(found) = self.context_tiers.iter().find(|t| t.id == wanted)
|
||||
{
|
||||
return Some(found.id);
|
||||
}
|
||||
self.context_tiers.iter().find(|t| t.id == "default").or_else(|| self.context_tiers.first()).map(|t| t.id)
|
||||
}
|
||||
|
||||
/// Active context window capacity in tokens for `tier`.
|
||||
pub fn context_tokens(&self, tier: Option<&str>) -> Option<u32> {
|
||||
if let Some(tier) = tier
|
||||
&& let Some(found) = self.context_tiers.iter().find(|t| t.id == tier)
|
||||
{
|
||||
return Some(found.tokens);
|
||||
}
|
||||
self.context_tiers
|
||||
.iter()
|
||||
.find(|t| t.id == "default")
|
||||
.or_else(|| self.context_tiers.first())
|
||||
.map(|t| t.tokens)
|
||||
.or(self.default_context_tokens)
|
||||
.or(self.max_context_tokens)
|
||||
}
|
||||
}
|
||||
|
||||
/// Copilot's own configured defaults from `user.settings.get` (`~/.copilot/config.json`)
|
||||
/// and optional CLI launch flags (`--model`, `--effort`, `--context`, `--allow-all`).
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq)]
|
||||
pub(super) struct UserDefaults {
|
||||
pub model: Option<String>,
|
||||
pub effort: Option<String>,
|
||||
pub context_tier: Option<String>,
|
||||
pub mode: Option<Mode>,
|
||||
pub allow_all: Option<bool>,
|
||||
}
|
||||
|
||||
impl UserDefaults {
|
||||
pub fn from_rpc_and_args(settings_rpc: Option<&Value>, args: &[String]) -> Self {
|
||||
let mut out = Self::default();
|
||||
if let Some(res) = settings_rpc {
|
||||
out.model = setting_str(res, "model");
|
||||
out.effort = setting_str(res, "effortLevel").or_else(|| setting_str(res, "reasoningEffort"));
|
||||
out.context_tier = setting_str(res, "contextTier");
|
||||
out.mode = setting_str(res, "defaultMode").and_then(|m| Mode::parse(&m));
|
||||
out.allow_all = setting_str(res, "defaultPermissionMode").and_then(|p| match p.as_str() {
|
||||
"allow-all" | "allow_all" | "bypass" | "autopilot" => Some(true),
|
||||
"manual" => Some(false),
|
||||
_ => None,
|
||||
});
|
||||
}
|
||||
let mut iter = args.iter().peekable();
|
||||
while let Some(arg) = iter.next() {
|
||||
let s = arg.as_str();
|
||||
if s == "--allow-all" || s == "--yolo" {
|
||||
out.allow_all = Some(true);
|
||||
} else if let Some(v) = flag_val(s, "--model", &mut iter) {
|
||||
out.model = Some(v);
|
||||
} else if let Some(v) =
|
||||
flag_val(s, "--effort", &mut iter).or_else(|| flag_val(s, "--reasoning-effort", &mut iter))
|
||||
{
|
||||
out.effort = Some(v);
|
||||
} else if let Some(v) = flag_val(s, "--context", &mut iter) {
|
||||
out.context_tier = Some(v);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
fn setting_str(res: &Value, key: &str) -> Option<String> {
|
||||
let settings = res.get("settings");
|
||||
let raw = settings
|
||||
.and_then(|s| s.get(key))
|
||||
.and_then(|entry| entry.get("value").or(Some(entry)))
|
||||
.or_else(|| res.get(key))?;
|
||||
raw.as_str().map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned)
|
||||
}
|
||||
|
||||
fn flag_val<'a>(
|
||||
arg: &'a str,
|
||||
flag: &str,
|
||||
iter: &mut std::iter::Peekable<std::slice::Iter<'a, String>>,
|
||||
) -> Option<String> {
|
||||
if arg == flag {
|
||||
return iter.next().map(|v| v.trim()).filter(|v| !v.is_empty()).map(str::to_owned);
|
||||
}
|
||||
let prefix = format!("{flag}=");
|
||||
arg.strip_prefix(&prefix).map(str::trim).filter(|v| !v.is_empty()).map(str::to_owned)
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub(super) struct Settings {
|
||||
pub model: String,
|
||||
pub effort: Option<String>,
|
||||
pub context_tier: Option<String>,
|
||||
pub mode: Mode,
|
||||
pub allow_all: bool,
|
||||
defaults: UserDefaults,
|
||||
/// Explicit per-session user overrides; `None` means track Copilot's default for each model.
|
||||
explicit_effort: Option<String>,
|
||||
explicit_context_tier: Option<String>,
|
||||
}
|
||||
|
||||
impl Settings {
|
||||
pub fn new(models: &[ModelEntry], defaults: &UserDefaults) -> Self {
|
||||
let model = defaults
|
||||
.model
|
||||
.as_deref()
|
||||
.filter(|id| models.iter().any(|m| m.id == *id))
|
||||
.or_else(|| models.iter().find(|m| m.is_default && m.id != "auto").map(|m| m.id.as_str()))
|
||||
.or_else(|| models.iter().find(|m| m.id != "auto").map(|m| m.id.as_str()))
|
||||
.or_else(|| models.first().map(|m| m.id.as_str()))
|
||||
.unwrap_or("auto")
|
||||
.to_owned();
|
||||
let mode = defaults.mode.unwrap_or(Mode::Agent);
|
||||
let allow_all = defaults.allow_all.unwrap_or(false) || mode == Mode::Autopilot;
|
||||
let mut s = Self {
|
||||
model,
|
||||
effort: None,
|
||||
context_tier: None,
|
||||
mode,
|
||||
allow_all,
|
||||
defaults: defaults.clone(),
|
||||
explicit_effort: None,
|
||||
explicit_context_tier: None,
|
||||
};
|
||||
s.fit_to_model(models);
|
||||
s
|
||||
}
|
||||
|
||||
pub fn fit_to_model(&mut self, models: &[ModelEntry]) {
|
||||
let Some(m) = models.iter().find(|m| m.id == self.model) else {
|
||||
self.effort = None;
|
||||
self.context_tier = None;
|
||||
return;
|
||||
};
|
||||
self.effort = if m.efforts.is_empty() {
|
||||
None
|
||||
} else if let Some(wanted) = self.explicit_effort.as_deref().filter(|w| m.efforts.iter().any(|e| e == *w)) {
|
||||
Some(wanted.to_owned())
|
||||
} else {
|
||||
m.default_effort(self.defaults.effort.as_deref()).map(str::to_owned)
|
||||
};
|
||||
|
||||
self.context_tier = if m.context_tiers.is_empty() {
|
||||
None
|
||||
} else if let Some(wanted) =
|
||||
self.explicit_context_tier.as_deref().filter(|w| m.context_tiers.iter().any(|t| t.id == *w))
|
||||
{
|
||||
Some(wanted.to_owned())
|
||||
} else {
|
||||
m.default_context_tier(self.defaults.context_tier.as_deref()).map(str::to_owned)
|
||||
};
|
||||
}
|
||||
|
||||
pub fn set(&mut self, models: &[ModelEntry], option: &str, value: &str) -> Result<(), String> {
|
||||
match option {
|
||||
MODEL => {
|
||||
if !models.is_empty() && !models.iter().any(|m| m.id == value) && value != self.model {
|
||||
return Err(format!("unknown model {value}"));
|
||||
}
|
||||
self.model = value.to_owned();
|
||||
self.fit_to_model(models);
|
||||
}
|
||||
EFFORT => {
|
||||
let m = models.iter().find(|m| m.id == self.model);
|
||||
if !m.is_some_and(|m| m.efforts.iter().any(|e| e == value)) {
|
||||
return Err(format!("{} has no reasoning effort {value}", self.model));
|
||||
}
|
||||
self.effort = Some(value.to_owned());
|
||||
self.explicit_effort = Some(value.to_owned());
|
||||
}
|
||||
CONTEXT_TIER => {
|
||||
let m = models.iter().find(|m| m.id == self.model);
|
||||
if !m.is_some_and(|m| m.context_tiers.iter().any(|t| t.id == value)) {
|
||||
return Err(format!("{} has no context tier {value}", self.model));
|
||||
}
|
||||
self.context_tier = Some(value.to_owned());
|
||||
self.explicit_context_tier = Some(value.to_owned());
|
||||
}
|
||||
MODE => {
|
||||
let mode = Mode::parse(value).ok_or_else(|| format!("unknown mode {value}"))?;
|
||||
self.mode = mode;
|
||||
if mode == Mode::Autopilot {
|
||||
self.allow_all = true;
|
||||
}
|
||||
}
|
||||
ALLOW_ALL => match value {
|
||||
"on" | "true" => self.allow_all = true,
|
||||
"off" | "false" => self.allow_all = false,
|
||||
_ => return Err(format!("unknown allow_all value {value}")),
|
||||
},
|
||||
_ => return Err(format!("unknown setting {option}")),
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn active_context_tokens(&self, models: &[ModelEntry]) -> Option<u32> {
|
||||
models.iter().find(|m| m.id == self.model).and_then(|m| m.context_tokens(self.context_tier.as_deref()))
|
||||
}
|
||||
}
|
||||
|
||||
/// Parses `models.list` + optional `models.listTokenPriceUnits` into catalog entries,
|
||||
/// prepending `"auto"` when not already in the list.
|
||||
pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<ModelEntry> {
|
||||
let units = parse_price_units(price_units);
|
||||
let raw = list
|
||||
.get("models")
|
||||
.or_else(|| list.get("data"))
|
||||
.and_then(Value::as_array)
|
||||
.map(Vec::as_slice)
|
||||
.unwrap_or_default();
|
||||
let mut out = Vec::new();
|
||||
if !raw.iter().any(|m| str_of(m, "id") == Some("auto")) && !raw.is_empty() {
|
||||
out.push(ModelEntry {
|
||||
id: "auto".into(),
|
||||
name: "Auto".into(),
|
||||
description: Some("Let Copilot pick the best model".into()),
|
||||
is_default: false,
|
||||
default_effort: None,
|
||||
efforts: Vec::new(),
|
||||
context_tiers: Vec::new(),
|
||||
default_context_tokens: None,
|
||||
max_context_tokens: None,
|
||||
pricing: None,
|
||||
});
|
||||
}
|
||||
for m in raw {
|
||||
if let Some(entry) = parse_model(m, &units) {
|
||||
out.push(entry);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn parse_model(m: &Value, units: &HashMap<String, PriceUnit>) -> Option<ModelEntry> {
|
||||
let id = str_of(m, "id")?.to_owned();
|
||||
if m.get("model_picker_enabled").and_then(Value::as_bool) == Some(false)
|
||||
|| m.get("modelPickerEnabled").and_then(Value::as_bool) == Some(false)
|
||||
{
|
||||
return None;
|
||||
}
|
||||
let name = str_of(m, "name")
|
||||
.or_else(|| str_of(m, "label"))
|
||||
.or_else(|| str_of(m, "displayName"))
|
||||
.filter(|s| !s.is_empty())
|
||||
.unwrap_or(&id)
|
||||
.to_owned();
|
||||
|
||||
let mut efforts = parse_efforts(m);
|
||||
efforts.sort_by_key(|e| effort_rank(e));
|
||||
efforts.dedup();
|
||||
|
||||
let limits = m.pointer("/capabilities/limits");
|
||||
let max_prompt =
|
||||
limits.and_then(|l| u32_of(l, "max_prompt_tokens").or_else(|| u32_of(l, "maxPromptTokens"))).filter(|&n| n > 0);
|
||||
let max_window = limits
|
||||
.and_then(|l| u32_of(l, "max_context_window_tokens").or_else(|| u32_of(l, "maxContextWindowTokens")))
|
||||
.filter(|&n| n > 0);
|
||||
|
||||
let billing = m.get("billing");
|
||||
let multiplier = billing.and_then(|b| f64_of(b, "multiplier"));
|
||||
let raw_category = str_of(m, "modelPickerPriceCategory")
|
||||
.or_else(|| str_of(m, "model_picker_price_category"))
|
||||
.or_else(|| str_of(m, "priceCategory"))
|
||||
.or_else(|| str_of(m, "price_category"))
|
||||
.or_else(|| billing.and_then(|b| str_of(b, "priceCategory").or_else(|| str_of(b, "price_category"))));
|
||||
let mut cost_tier = raw_category.and_then(normalize_cost_tier).map(str::to_owned);
|
||||
|
||||
let token_prices = billing.and_then(|b| b.get("token_prices").or_else(|| b.get("tokenPrices")));
|
||||
let unit = units.get(&id).copied().unwrap_or(PriceUnit::Credits);
|
||||
let (mut tiers, default_max, long_max) = parse_token_prices(token_prices, max_prompt, max_window, unit);
|
||||
|
||||
let mut context_tiers = Vec::new();
|
||||
if let (Some(def_tokens), Some(long_tokens)) = (default_max, long_max)
|
||||
&& def_tokens < long_tokens
|
||||
{
|
||||
context_tiers.push(ContextTierChoice {
|
||||
id: "default",
|
||||
label: format_tokens(def_tokens),
|
||||
tokens: def_tokens,
|
||||
description: "Default recommended context size",
|
||||
});
|
||||
context_tiers.push(ContextTierChoice {
|
||||
id: "long_context",
|
||||
label: format_tokens(long_tokens),
|
||||
tokens: long_tokens,
|
||||
description: "Maximum context window for longer sessions",
|
||||
});
|
||||
}
|
||||
|
||||
if cost_tier.is_none()
|
||||
&& let Some(def) = tiers.get("default")
|
||||
{
|
||||
cost_tier = Some(infer_cost_tier(def.output).to_owned());
|
||||
}
|
||||
if let Some(def_tokens) = default_max.or(max_window).or(max_prompt)
|
||||
&& let Some(def) = tiers.get_mut("default")
|
||||
&& def.context_tokens.is_none()
|
||||
{
|
||||
def.context_tokens = Some(def_tokens);
|
||||
}
|
||||
if let Some(long_tokens) = long_max
|
||||
&& let Some(long) = tiers.get_mut("long_context")
|
||||
{
|
||||
long.context_tokens = Some(long_tokens);
|
||||
}
|
||||
|
||||
let pricing = (!tiers.is_empty() || cost_tier.is_some() || multiplier.is_some()).then_some(AgentModelPricing {
|
||||
cost_tier,
|
||||
multiplier,
|
||||
tiers,
|
||||
});
|
||||
|
||||
let description = multiplier
|
||||
.map(|mul| {
|
||||
let clean = round6(mul);
|
||||
if (clean - clean.round()).abs() < 1e-6 {
|
||||
format!("{}x", clean.round() as i64)
|
||||
} else {
|
||||
format!("{clean}x")
|
||||
}
|
||||
})
|
||||
.or_else(|| str_of(m, "description").filter(|d| !d.is_empty() && *d != name).map(str::to_owned))
|
||||
.or_else(|| (id == "auto").then(|| "Let Copilot pick the best model".to_owned()));
|
||||
|
||||
let is_default = m
|
||||
.get("is_chat_default")
|
||||
.or_else(|| m.get("isChatDefault"))
|
||||
.or_else(|| m.get("isDefault"))
|
||||
.and_then(Value::as_bool)
|
||||
.unwrap_or(false);
|
||||
let default_effort = str_of(m, "defaultReasoningEffort")
|
||||
.or_else(|| str_of(m, "default_reasoning_effort"))
|
||||
.map(str::trim)
|
||||
.filter(|s| !s.is_empty())
|
||||
.map(str::to_owned);
|
||||
|
||||
Some(ModelEntry {
|
||||
id,
|
||||
name,
|
||||
description,
|
||||
is_default,
|
||||
default_effort,
|
||||
efforts,
|
||||
context_tiers,
|
||||
default_context_tokens: default_max.or(max_window).or(max_prompt),
|
||||
max_context_tokens: long_max.or(default_max).or(max_window).or(max_prompt),
|
||||
pricing,
|
||||
})
|
||||
}
|
||||
|
||||
fn parse_efforts(m: &Value) -> Vec<String> {
|
||||
let arr = m
|
||||
.get("supportedReasoningEfforts")
|
||||
.or_else(|| m.get("supported_reasoning_efforts"))
|
||||
.or_else(|| m.pointer("/capabilities/supports/reasoning_effort"))
|
||||
.or_else(|| m.pointer("/capabilities/supports/reasoningEffort"));
|
||||
arr.and_then(Value::as_array)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|v| v.as_str().filter(|s| !s.is_empty()).map(str::to_owned))
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
enum PriceUnit {
|
||||
Credits,
|
||||
NanoAiu,
|
||||
}
|
||||
|
||||
fn parse_price_units(raw: Option<&Value>) -> HashMap<String, PriceUnit> {
|
||||
let mut out = HashMap::new();
|
||||
let Some(raw) = raw else { return out };
|
||||
let unit_of = |s: &str| {
|
||||
if s.eq_ignore_ascii_case("nano_aiu") || s.eq_ignore_ascii_case("nanoaiu") || s.contains("nano") {
|
||||
Some(PriceUnit::NanoAiu)
|
||||
} else if s.to_ascii_lowercase().contains("credit") || s.eq_ignore_ascii_case("aic") {
|
||||
Some(PriceUnit::Credits)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
};
|
||||
if let Some(map) =
|
||||
raw.get("units").or_else(|| raw.get("priceUnits")).or_else(|| raw.get("models")).and_then(Value::as_object)
|
||||
{
|
||||
for (k, v) in map {
|
||||
let u = v
|
||||
.as_str()
|
||||
.and_then(unit_of)
|
||||
.or_else(|| v.get("unit").or_else(|| v.get("priceUnit")).and_then(Value::as_str).and_then(unit_of));
|
||||
if let Some(u) = u {
|
||||
out.insert(k.clone(), u);
|
||||
}
|
||||
}
|
||||
}
|
||||
for key in ["units", "priceUnits", "models"] {
|
||||
if let Some(arr) = raw.get(key).and_then(Value::as_array) {
|
||||
for item in arr {
|
||||
let id = str_of(item, "modelId").or_else(|| str_of(item, "id"));
|
||||
let u = str_of(item, "unit").or_else(|| str_of(item, "priceUnit")).and_then(unit_of);
|
||||
if let (Some(id), Some(u)) = (id, u) {
|
||||
out.insert(id.to_owned(), u);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn parse_token_prices(
|
||||
tp: Option<&Value>,
|
||||
max_prompt: Option<u32>,
|
||||
max_window: Option<u32>,
|
||||
unit: PriceUnit,
|
||||
) -> (BTreeMap<String, AgentTokenPricing>, Option<u32>, Option<u32>) {
|
||||
let mut tiers = BTreeMap::new();
|
||||
let Some(tp) = tp else {
|
||||
return (tiers, None, max_window.or(max_prompt));
|
||||
};
|
||||
let batch =
|
||||
f64_of(tp, "batch_size").or_else(|| f64_of(tp, "batchSize")).filter(|&b| b > 0.0).unwrap_or(BATCH_TOKENS);
|
||||
let batch_scale = BATCH_TOKENS / batch;
|
||||
let unit_scale = match unit {
|
||||
PriceUnit::Credits => 1.0,
|
||||
PriceUnit::NanoAiu => 1.0 / NANO_AIU_PER_CREDIT,
|
||||
};
|
||||
let scale = batch_scale * unit_scale;
|
||||
|
||||
let parse_tier = |node: &Value| -> Option<(AgentTokenPricing, Option<u32>)> {
|
||||
let input = f64_of(node, "input_price").or_else(|| f64_of(node, "inputPrice"))?;
|
||||
let output = f64_of(node, "output_price").or_else(|| f64_of(node, "outputPrice"))?;
|
||||
// Guard against raw nano-AIU numbers even if `listTokenPriceUnits` was unavailable.
|
||||
let effective = if unit == PriceUnit::Credits && (input >= 10_000_000.0 || output >= 10_000_000.0) {
|
||||
scale / NANO_AIU_PER_CREDIT
|
||||
} else {
|
||||
scale
|
||||
};
|
||||
let cache_read = f64_of(node, "cache_read_price")
|
||||
.or_else(|| f64_of(node, "cacheReadPrice"))
|
||||
.or_else(|| f64_of(node, "cache_price"))
|
||||
.or_else(|| f64_of(node, "cachePrice"))
|
||||
.map(|v| round6(v * effective));
|
||||
let cache_write = f64_of(node, "cache_write_price")
|
||||
.or_else(|| f64_of(node, "cacheWritePrice"))
|
||||
.map(|v| round6(v * effective));
|
||||
let ctx = u32_of(node, "max_prompt_tokens")
|
||||
.or_else(|| u32_of(node, "maxPromptTokens"))
|
||||
.or_else(|| u32_of(node, "context_max"))
|
||||
.or_else(|| u32_of(node, "contextMax"))
|
||||
.filter(|&n| n > 0);
|
||||
Some((
|
||||
AgentTokenPricing {
|
||||
input: round6(input * effective),
|
||||
output: round6(output * effective),
|
||||
cache_read,
|
||||
cache_write,
|
||||
context_tokens: ctx,
|
||||
},
|
||||
ctx,
|
||||
))
|
||||
};
|
||||
|
||||
// Both CAPI `/models` (`token_prices.default` + `token_prices.long_context`) and
|
||||
// `copilot --headless` `models.list` (top-level `tokenPrices` + `tokenPrices.longContext`)
|
||||
// share the same per-tier fields.
|
||||
let def_node = tp.get("default").unwrap_or(tp);
|
||||
let mut def_max = None;
|
||||
if let Some((def_pricing, ctx)) = parse_tier(def_node) {
|
||||
def_max = ctx;
|
||||
tiers.insert("default".into(), def_pricing);
|
||||
}
|
||||
|
||||
let long_node = tp.get("longContext").or_else(|| tp.get("long_context"));
|
||||
let mut long_max = None;
|
||||
if let Some(long_node) = long_node
|
||||
&& let Some((mut long_pricing, ctx)) = parse_tier(long_node)
|
||||
{
|
||||
// Use the full context window capacity (`1_000_000`) when available so models whose
|
||||
// `max_prompt_tokens` deduct `max_output_tokens` (e.g. `872_000` = `1M - 128K` on
|
||||
// GPT-6 Sol, `936_000` = `1M - 64K` on Gemini 4 Carbon) display cleanly as `1M`.
|
||||
let cap = match (ctx, max_window) {
|
||||
(Some(c), Some(w)) if w >= c => Some(w),
|
||||
(Some(c), _) => Some(c),
|
||||
(None, w) => w.or(max_prompt),
|
||||
};
|
||||
long_max = cap;
|
||||
long_pricing.context_tokens = cap;
|
||||
tiers.insert("long_context".into(), long_pricing);
|
||||
} else if let (Some(d), Some(p)) = (def_max, max_prompt)
|
||||
&& d < p
|
||||
&& let Some(def) = tiers.get("default").cloned()
|
||||
{
|
||||
let cap = max_window.filter(|&w| w >= p).unwrap_or(p);
|
||||
long_max = Some(cap);
|
||||
tiers.insert("long_context".into(), AgentTokenPricing { context_tokens: Some(cap), ..def });
|
||||
}
|
||||
|
||||
(tiers, def_max, long_max)
|
||||
}
|
||||
|
||||
fn normalize_cost_tier(raw: &str) -> Option<&'static str> {
|
||||
match raw.trim().to_ascii_lowercase().as_str() {
|
||||
"lightweight" | "low" => Some("low"),
|
||||
"versatile" | "medium" | "standard" => Some("medium"),
|
||||
"powerful" | "high" | "premium" => Some("high"),
|
||||
"very_high" | "veryhigh" => Some("very_high"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn infer_cost_tier(output_credits_per_1m: f64) -> &'static str {
|
||||
if output_credits_per_1m < 300.0 {
|
||||
"low"
|
||||
} else if output_credits_per_1m <= 1500.0 {
|
||||
"medium"
|
||||
} else {
|
||||
"high"
|
||||
}
|
||||
}
|
||||
|
||||
/// Formats token capacity matching VS Code (`200000` → `"200K"`, `1000000` → `"1M"`).
|
||||
pub(super) fn format_tokens(tokens: u32) -> String {
|
||||
if tokens >= 1_000_000 {
|
||||
let m = (f64::from(tokens) / 1_000_000.0 * 10.0).floor() / 10.0;
|
||||
if (m - m.round()).abs() < 1e-6 { format!("{}M", m.round() as u32) } else { format!("{m:.1}M") }
|
||||
} else if tokens > 900_000 {
|
||||
"1M".into()
|
||||
} else if tokens >= 1_000 {
|
||||
format!("{}K", (f64::from(tokens) / 1_000.0).round() as u32)
|
||||
} else {
|
||||
tokens.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn effort_rank(effort: &str) -> u8 {
|
||||
match effort {
|
||||
"none" => 0,
|
||||
"minimal" => 1,
|
||||
"low" => 2,
|
||||
"medium" => 3,
|
||||
"high" => 4,
|
||||
"xhigh" | "extra_high" => 5,
|
||||
"max" => 6,
|
||||
_ => 3,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn effort_label(effort: &str) -> (&'static str, &'static str) {
|
||||
match effort {
|
||||
"none" => ("None", "No additional reasoning; fastest responses."),
|
||||
"minimal" => ("Minimal", "Least reasoning; fastest responses."),
|
||||
"low" => ("Low", "Minimal reasoning before responding."),
|
||||
"medium" => ("Medium", "Balanced reasoning and speed."),
|
||||
"high" => ("High", "More thorough reasoning; slower responses."),
|
||||
"xhigh" => ("Extra High", "Extensive reasoning for the hardest problems."),
|
||||
"max" => ("Max", "Maximum reasoning; slowest but most thorough."),
|
||||
_ => ("Default", ""),
|
||||
}
|
||||
}
|
||||
|
||||
/// ACP `configOptions` for the active session settings.
|
||||
pub(super) fn config_options(models: &[ModelEntry], s: &Settings) -> Value {
|
||||
let mut model_values: Vec<Value> = models.iter().map(model_option_value).collect();
|
||||
if !s.model.is_empty() && !models.iter().any(|m| m.id == s.model) {
|
||||
model_values.push(json!({ "value": s.model, "name": s.model }));
|
||||
}
|
||||
let mut out = Vec::new();
|
||||
if !model_values.is_empty() {
|
||||
out.push(json!({
|
||||
"id": MODEL,
|
||||
"name": "Model",
|
||||
"category": "model",
|
||||
"type": "select",
|
||||
"currentValue": s.model,
|
||||
"options": model_values,
|
||||
}));
|
||||
}
|
||||
if let Some(m) = models.iter().find(|m| m.id == s.model) {
|
||||
if let (Some(opt), Some(current)) = (effort_option_for(m, s.effort.as_deref()), s.effort.as_deref()) {
|
||||
let mut o = opt;
|
||||
o["currentValue"] = json!(current);
|
||||
out.push(o);
|
||||
}
|
||||
if let (Some(opt), Some(current)) =
|
||||
(context_tier_option_for(m, s.context_tier.as_deref()), s.context_tier.as_deref())
|
||||
{
|
||||
let mut o = opt;
|
||||
o["currentValue"] = json!(current);
|
||||
out.push(o);
|
||||
}
|
||||
}
|
||||
out.push(json!({
|
||||
"id": MODE,
|
||||
"name": "Mode",
|
||||
"category": "mode",
|
||||
"type": "select",
|
||||
"currentValue": s.mode.id(),
|
||||
"options": Mode::ALL.iter().map(|m| json!({
|
||||
"value": m.id(),
|
||||
"name": m.name(),
|
||||
"description": m.description(),
|
||||
})).collect::<Vec<_>>(),
|
||||
}));
|
||||
out.push(json!({
|
||||
"id": ALLOW_ALL,
|
||||
"name": "Allow All",
|
||||
"category": "permissions",
|
||||
"type": "select",
|
||||
"currentValue": if s.allow_all { "on" } else { "off" },
|
||||
"options": [
|
||||
{ "value": "on", "name": "On", "description": "Automatically approve all tool, path, and URL requests" },
|
||||
{ "value": "off", "name": "Off", "description": "Require approval for tool, path, and URL requests" },
|
||||
],
|
||||
}));
|
||||
Value::Array(out)
|
||||
}
|
||||
|
||||
/// Per-model options (`[reasoning_effort?, context_tier?]`) for every model in `models`,
|
||||
/// each defaulted to Copilot's own defaults (respecting `user.settings.get` / CLI flags).
|
||||
pub(super) fn per_model_options(models: &[ModelEntry], defaults: &UserDefaults) -> Vec<(String, Vec<Value>)> {
|
||||
models
|
||||
.iter()
|
||||
.map(|m| {
|
||||
let mut opts = Vec::new();
|
||||
if let Some(effort) = effort_option_for(m, m.default_effort(defaults.effort.as_deref())) {
|
||||
opts.push(effort);
|
||||
}
|
||||
if let Some(ctx) = context_tier_option_for(m, m.default_context_tier(defaults.context_tier.as_deref())) {
|
||||
opts.push(ctx);
|
||||
}
|
||||
(m.id.clone(), opts)
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn model_option_value(m: &ModelEntry) -> Value {
|
||||
let mut v = json!({ "value": m.id, "name": m.name });
|
||||
if let Some(d) = &m.description {
|
||||
v["description"] = json!(d);
|
||||
}
|
||||
if let Some(pricing) = &m.pricing {
|
||||
let mut meta = serde_json::Map::new();
|
||||
meta.insert("pricing".into(), json!(pricing));
|
||||
if let Some(cat) = &pricing.cost_tier {
|
||||
meta.insert("copilotPriceCategory".into(), json!(cat));
|
||||
}
|
||||
v["_meta"] = Value::Object(meta);
|
||||
}
|
||||
v
|
||||
}
|
||||
|
||||
fn effort_option_for(m: &ModelEntry, current: Option<&str>) -> Option<Value> {
|
||||
if m.efforts.len() <= 1 && m.efforts.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let default = current.filter(|c| m.efforts.iter().any(|e| e == *c)).or_else(|| m.default_effort(None))?;
|
||||
let options: Vec<Value> = m
|
||||
.efforts
|
||||
.iter()
|
||||
.map(|e| {
|
||||
let (label, desc) = effort_label(e);
|
||||
let name = if label == "Default" { capitalize(e) } else { label.to_owned() };
|
||||
let mut item = json!({ "value": e, "name": name });
|
||||
if !desc.is_empty() {
|
||||
item["description"] = json!(desc);
|
||||
}
|
||||
item
|
||||
})
|
||||
.collect();
|
||||
Some(json!({
|
||||
"id": EFFORT,
|
||||
"name": "Effort Level",
|
||||
"description": "How much reasoning the model performs before responding. Higher effort can improve quality at the cost of speed.",
|
||||
"category": "thought_level",
|
||||
"type": "select",
|
||||
"currentValue": default,
|
||||
"options": options,
|
||||
}))
|
||||
}
|
||||
|
||||
fn context_tier_option_for(m: &ModelEntry, current: Option<&str>) -> Option<Value> {
|
||||
if m.context_tiers.len() < 2 {
|
||||
return None;
|
||||
}
|
||||
let default =
|
||||
current.filter(|c| m.context_tiers.iter().any(|t| t.id == *c)).or_else(|| m.default_context_tier(None))?;
|
||||
let options: Vec<Value> = m
|
||||
.context_tiers
|
||||
.iter()
|
||||
.map(|t| {
|
||||
json!({
|
||||
"value": t.id,
|
||||
"name": t.label,
|
||||
"description": t.description,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
Some(json!({
|
||||
"id": CONTEXT_TIER,
|
||||
"name": "Context Size",
|
||||
"description": "Context window size for this model.",
|
||||
"category": "model_config",
|
||||
"type": "select",
|
||||
"currentValue": default,
|
||||
"options": options,
|
||||
}))
|
||||
}
|
||||
|
||||
fn capitalize(s: &str) -> String {
|
||||
let mut chars = s.chars();
|
||||
chars.next().map(|c| c.to_uppercase().chain(chars).collect()).unwrap_or_default()
|
||||
}
|
||||
|
||||
fn round6(n: f64) -> f64 {
|
||||
let r = (n * 1_000_000.0).round() / 1_000_000.0;
|
||||
if r == 0.0 { 0.0 } else { r }
|
||||
}
|
||||
|
||||
fn str_of<'a>(v: &'a Value, key: &str) -> Option<&'a str> {
|
||||
v.get(key).and_then(Value::as_str)
|
||||
}
|
||||
|
||||
fn f64_of(v: &Value, key: &str) -> Option<f64> {
|
||||
v.get(key).and_then(Value::as_f64).filter(|n| n.is_finite())
|
||||
}
|
||||
|
||||
fn u32_of(v: &Value, key: &str) -> Option<u32> {
|
||||
v.get(key).and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok())
|
||||
}
|
||||
@@ -0,0 +1,540 @@
|
||||
use super::models::{self, CONTEXT_TIER, EFFORT, MODEL, Mode, Settings, UserDefaults};
|
||||
use super::{acp_args, acp_fallback_spec, attach, headless_args};
|
||||
use crate::config;
|
||||
use crate::provider::Driver;
|
||||
use ide_jsonrpc::{Framing, Handler, Peer, codes};
|
||||
use parking_lot::Mutex;
|
||||
use serde_json::{Value, json};
|
||||
use std::sync::{Arc, OnceLock};
|
||||
|
||||
fn sample_models_list() -> Value {
|
||||
json!({
|
||||
"models": [
|
||||
{
|
||||
"id": "gemini-4-carbon",
|
||||
"name": "Gemini 4 Carbon",
|
||||
"priceCategory": "versatile",
|
||||
"supportedReasoningEfforts": ["low", "medium", "high"],
|
||||
"defaultReasoningEffort": "medium",
|
||||
"capabilities": {
|
||||
"supports": { "vision": true, "reasoningEffort": true },
|
||||
"limits": {
|
||||
"max_context_window_tokens": 1_000_000,
|
||||
"max_prompt_tokens": 1_000_000,
|
||||
"max_output_tokens": 64_000
|
||||
}
|
||||
},
|
||||
"billing": {
|
||||
"is_premium": true,
|
||||
"multiplier": 1.0,
|
||||
"token_prices": {
|
||||
"batch_size": 1_000_000,
|
||||
"preferred_tier": "default",
|
||||
"default": {
|
||||
"input_price": 100.0,
|
||||
"output_price": 500.0,
|
||||
"cache_read_price": 10.0,
|
||||
"cache_write_price": 0.0,
|
||||
"max_prompt_tokens": 200_000
|
||||
},
|
||||
"long_context": {
|
||||
"input_price": 200.0,
|
||||
"output_price": 1000.0,
|
||||
"cache_read_price": 10.0,
|
||||
"cache_write_price": 0.0,
|
||||
"max_prompt_tokens": 1_000_000
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "gpt-5.6-sol",
|
||||
"name": "GPT-5.6 Sol",
|
||||
"priceCategory": "powerful",
|
||||
"supportedReasoningEfforts": ["none", "low", "medium", "high", "xhigh", "max"],
|
||||
"defaultReasoningEffort": "medium",
|
||||
"capabilities": {
|
||||
"supports": { "vision": true },
|
||||
"limits": {
|
||||
"max_context_window_tokens": 1_000_000,
|
||||
"max_prompt_tokens": 1_000_000
|
||||
}
|
||||
},
|
||||
"billing": {
|
||||
"multiplier": 2.0,
|
||||
"token_prices": {
|
||||
"batch_size": 1_000_000,
|
||||
"default": {
|
||||
"input_price": 250_000_000_000.0,
|
||||
"output_price": 1_500_000_000_000.0,
|
||||
"cache_read_price": 25_000_000_000.0,
|
||||
"cache_write_price": 0.0,
|
||||
"max_prompt_tokens": 200_000
|
||||
},
|
||||
"long_context": {
|
||||
"input_price": 500_000_000_000.0,
|
||||
"output_price": 3_000_000_000_000.0,
|
||||
"cache_read_price": 50_000_000_000.0,
|
||||
"cache_write_price": 0.0,
|
||||
"max_prompt_tokens": 1_000_000
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "mai-experimental-internal",
|
||||
"name": "MAI Experimental",
|
||||
"priceCategory": "lightweight",
|
||||
"supportedReasoningEfforts": ["low", "medium"],
|
||||
"capabilities": {
|
||||
"limits": {
|
||||
"max_context_window_tokens": 131_072,
|
||||
"max_prompt_tokens": 131_072
|
||||
}
|
||||
},
|
||||
"billing": {
|
||||
"multiplier": 0.33
|
||||
}
|
||||
}
|
||||
]
|
||||
})
|
||||
}
|
||||
|
||||
fn sample_price_units() -> Value {
|
||||
json!({
|
||||
"units": {
|
||||
"gemini-4-carbon": "ai_credits",
|
||||
"gpt-5.6-sol": "nano_aiu"
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_tiered_context_windows_pricing_and_uses_copilots_own_defaults() {
|
||||
let catalog = models::parse_catalog(&sample_models_list(), Some(&sample_price_units()));
|
||||
assert_eq!(
|
||||
catalog.iter().map(|m| m.id.as_str()).collect::<Vec<_>>(),
|
||||
["auto", "gemini-4-carbon", "gpt-5.6-sol", "mai-experimental-internal"]
|
||||
);
|
||||
|
||||
let gemini = catalog.iter().find(|m| m.id == "gemini-4-carbon").unwrap();
|
||||
assert_eq!(gemini.default_effort(None), Some("medium"));
|
||||
assert_eq!(gemini.default_context_tier(None), Some("default"));
|
||||
assert_eq!(
|
||||
gemini.context_tiers.iter().map(|t| (t.id, t.label.as_str(), t.tokens)).collect::<Vec<_>>(),
|
||||
[("default", "200K", 200_000), ("long_context", "1M", 1_000_000)]
|
||||
);
|
||||
let pricing = gemini.pricing.as_ref().unwrap();
|
||||
assert_eq!(pricing.cost_tier.as_deref(), Some("medium"));
|
||||
let long_p = &pricing.tiers["long_context"];
|
||||
assert_eq!(
|
||||
(long_p.input, long_p.output, long_p.cache_read, long_p.cache_write),
|
||||
(200.0, 1000.0, Some(10.0), Some(0.0))
|
||||
);
|
||||
let def_p = &pricing.tiers["default"];
|
||||
assert_eq!((def_p.input, def_p.output), (100.0, 500.0));
|
||||
|
||||
// Nano-AIU conversion (10^9 nano-AIU = 1 AI Credit).
|
||||
let sol = catalog.iter().find(|m| m.id == "gpt-5.6-sol").unwrap();
|
||||
assert_eq!(sol.default_effort(None), Some("medium"));
|
||||
assert_eq!(sol.default_context_tier(None), Some("default"));
|
||||
let sol_long = &sol.pricing.as_ref().unwrap().tiers["long_context"];
|
||||
assert_eq!((sol_long.input, sol_long.output, sol_long.cache_read), (500.0, 3000.0, Some(50.0)));
|
||||
|
||||
// Single-window model has no multi-tier `context_tier` toggle.
|
||||
let mai = catalog.iter().find(|m| m.id == "mai-experimental-internal").unwrap();
|
||||
assert!(mai.context_tiers.is_empty());
|
||||
assert_eq!(mai.default_effort(None), Some("medium"));
|
||||
|
||||
// Initial settings pick Copilot's own defaults (`medium` effort + `default` 200K context).
|
||||
let mut s = Settings::new(&catalog, &UserDefaults::default());
|
||||
assert_eq!(s.model, "gemini-4-carbon");
|
||||
assert_eq!(s.effort.as_deref(), Some("medium"));
|
||||
assert_eq!(s.context_tier.as_deref(), Some("default"));
|
||||
assert_eq!(s.active_context_tokens(&catalog), Some(200_000));
|
||||
|
||||
// Switching to GPT-5.6 Sol without an explicit override stays on Copilot's defaults (`medium` + `default`).
|
||||
s.set(&catalog, MODEL, "gpt-5.6-sol").unwrap();
|
||||
assert_eq!(s.effort.as_deref(), Some("medium"));
|
||||
assert_eq!(s.context_tier.as_deref(), Some("default"));
|
||||
|
||||
// Explicit session overrides (`xhigh` + `long_context`) stick across models that support them,
|
||||
// and fall back to Copilot's default when switching to a model that does not.
|
||||
s.set(&catalog, EFFORT, "xhigh").unwrap();
|
||||
s.set(&catalog, CONTEXT_TIER, "long_context").unwrap();
|
||||
assert_eq!(s.active_context_tokens(&catalog), Some(1_000_000));
|
||||
s.set(&catalog, MODEL, "mai-experimental-internal").unwrap();
|
||||
assert_eq!(s.effort.as_deref(), Some("medium"));
|
||||
assert_eq!(s.context_tier, None);
|
||||
|
||||
// User settings from `user.settings.get` (1.0.112+ `{ value, default, isDefault }` shape) and CLI flags are honored.
|
||||
let rpc_settings = json!({
|
||||
"settings": {
|
||||
"model": { "value": "gpt-5.6-sol", "default": null, "isDefault": false },
|
||||
"effortLevel": { "value": "high", "default": null, "isDefault": false },
|
||||
"contextTier": { "value": "long_context", "default": null, "isDefault": false },
|
||||
"defaultMode": { "value": "plan", "default": "interactive", "isDefault": false },
|
||||
}
|
||||
});
|
||||
let user_defs = UserDefaults::from_rpc_and_args(Some(&rpc_settings), &[]);
|
||||
let configured = Settings::new(&catalog, &user_defs);
|
||||
assert_eq!(configured.model, "gpt-5.6-sol");
|
||||
assert_eq!(configured.effort.as_deref(), Some("high"));
|
||||
assert_eq!(configured.context_tier.as_deref(), Some("long_context"));
|
||||
assert_eq!(configured.mode, Mode::Plan);
|
||||
|
||||
// Per-model discovery options preserve pricing on `model` values and emit Copilot's defaults.
|
||||
let raw = models::config_options(&catalog, &Settings::new(&catalog, &UserDefaults::default()));
|
||||
let parsed = config::parse_options(&raw);
|
||||
let model_opt = parsed.iter().find(|o| o.id == MODEL).unwrap();
|
||||
let gem_val = model_opt.values.iter().find(|v| v.value == "gemini-4-carbon").unwrap();
|
||||
assert_eq!(gem_val.pricing.as_ref().unwrap().cost_tier.as_deref(), Some("medium"));
|
||||
assert_eq!(parsed.iter().find(|o| o.id == EFFORT).unwrap().current.as_deref(), Some("medium"));
|
||||
assert_eq!(parsed.iter().find(|o| o.id == CONTEXT_TIER).unwrap().current.as_deref(), Some("default"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_headless_sdk_models_list_flat_token_prices_and_single_tier_models() {
|
||||
let sdk_list = json!({
|
||||
"models": [
|
||||
{ "id": "auto", "name": "Auto" },
|
||||
{
|
||||
"id": "gemini-4-carbon",
|
||||
"name": "Gemini 4 Carbon",
|
||||
"modelPickerCategory": "powerful",
|
||||
"modelPickerPriceCategory": "medium",
|
||||
"supportedReasoningEfforts": ["low", "medium", "high"],
|
||||
"capabilities": {
|
||||
"limits": {
|
||||
"max_context_window_tokens": 1_000_000,
|
||||
"max_output_tokens": 64_000,
|
||||
"max_prompt_tokens": 936_000
|
||||
}
|
||||
},
|
||||
"billing": {
|
||||
"tokenPrices": {
|
||||
"inputPrice": 200,
|
||||
"outputPrice": 1000,
|
||||
"cachePrice": 10,
|
||||
"cacheReadPrice": 10,
|
||||
"cacheWritePrice": 0,
|
||||
"contextMax": 200_000,
|
||||
"maxPromptTokens": 200_000,
|
||||
"batchSize": 1_000_000,
|
||||
"longContext": {
|
||||
"inputPrice": 200,
|
||||
"outputPrice": 1000,
|
||||
"cachePrice": 10,
|
||||
"cacheReadPrice": 10,
|
||||
"cacheWritePrice": 0,
|
||||
"contextMax": 936_000,
|
||||
"maxPromptTokens": 936_000
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "gpt-6-sol",
|
||||
"name": "GPT-6 Sol",
|
||||
"modelPickerPriceCategory": "medium",
|
||||
"supportedReasoningEfforts": ["none", "low", "medium", "high", "xhigh", "max"],
|
||||
"capabilities": {
|
||||
"limits": {
|
||||
"max_context_window_tokens": 1_000_000,
|
||||
"max_output_tokens": 128_000,
|
||||
"max_prompt_tokens": 872_000
|
||||
}
|
||||
},
|
||||
"billing": {
|
||||
"tokenPrices": {
|
||||
"inputPrice": 250,
|
||||
"outputPrice": 1250,
|
||||
"contextMax": 272_000,
|
||||
"maxPromptTokens": 272_000,
|
||||
"batchSize": 1_000_000,
|
||||
"longContext": {
|
||||
"inputPrice": 500,
|
||||
"outputPrice": 2500,
|
||||
"contextMax": 872_000,
|
||||
"maxPromptTokens": 872_000
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "gpt-5.3-codex",
|
||||
"name": "GPT-5.3-Codex",
|
||||
"modelPickerPriceCategory": "medium",
|
||||
"supportedReasoningEfforts": ["low", "medium", "high", "xhigh"],
|
||||
"capabilities": {
|
||||
"limits": {
|
||||
"max_context_window_tokens": 400_000,
|
||||
"max_output_tokens": 128_000,
|
||||
"max_prompt_tokens": 272_000
|
||||
}
|
||||
},
|
||||
"billing": {
|
||||
"tokenPrices": {
|
||||
"inputPrice": 150,
|
||||
"outputPrice": 600,
|
||||
"contextMax": 272_000,
|
||||
"maxPromptTokens": 272_000,
|
||||
"batchSize": 1_000_000
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
});
|
||||
let units = json!({
|
||||
"units": [
|
||||
{ "modelId": "gemini-4-carbon", "unit": "ai_credits" },
|
||||
{ "modelId": "gpt-6-sol", "unit": "ai_credits" },
|
||||
{ "modelId": "gpt-5.3-codex", "unit": "ai_credits" }
|
||||
]
|
||||
});
|
||||
|
||||
let catalog = models::parse_catalog(&sdk_list, Some(&units));
|
||||
let carbon = catalog.iter().find(|m| m.id == "gemini-4-carbon").unwrap();
|
||||
assert_eq!(
|
||||
carbon.context_tiers.iter().map(|t| (t.id, t.label.as_str())).collect::<Vec<_>>(),
|
||||
[("default", "200K"), ("long_context", "1M")]
|
||||
);
|
||||
let cp = carbon.pricing.as_ref().unwrap();
|
||||
assert_eq!(cp.cost_tier.as_deref(), Some("medium"));
|
||||
assert_eq!((cp.tiers["long_context"].input, cp.tiers["long_context"].output), (200.0, 1000.0));
|
||||
|
||||
let sol = catalog.iter().find(|m| m.id == "gpt-6-sol").unwrap();
|
||||
assert_eq!(
|
||||
sol.context_tiers.iter().map(|t| (t.id, t.label.as_str())).collect::<Vec<_>>(),
|
||||
[("default", "272K"), ("long_context", "1M")]
|
||||
);
|
||||
|
||||
let codex = catalog.iter().find(|m| m.id == "gpt-5.3-codex").unwrap();
|
||||
assert!(codex.context_tiers.is_empty(), "single-tier model must not get a synthetic long_context tier");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn headless_and_acp_args_roundtrip_while_preserving_user_flags() {
|
||||
assert_eq!(headless_args(&["--acp".into()]), vec!["--headless", "--no-auto-update", "--stdio"]);
|
||||
assert_eq!(
|
||||
headless_args(&["--log-level".into(), "debug".into(), "--headless".into(), "--stdio".into()]),
|
||||
vec!["--log-level", "debug", "--headless", "--stdio", "--no-auto-update"]
|
||||
);
|
||||
assert_eq!(
|
||||
acp_args(&[
|
||||
"--headless".into(),
|
||||
"--no-auto-update".into(),
|
||||
"--stdio".into(),
|
||||
"--context".into(),
|
||||
"long_context".into()
|
||||
]),
|
||||
vec!["--acp", "--context", "long_context"]
|
||||
);
|
||||
let spec = crate::provider::builtin_spec("copilot").unwrap();
|
||||
assert_eq!(spec.driver, Driver::Copilot);
|
||||
let fallback = acp_fallback_spec(&spec);
|
||||
assert_eq!(fallback.driver, Driver::Acp);
|
||||
assert_eq!(fallback.args, vec!["--acp"]);
|
||||
}
|
||||
|
||||
struct FakeCopilotServer {
|
||||
peer: OnceLock<Peer>,
|
||||
calls: Mutex<Vec<(String, Value)>>,
|
||||
}
|
||||
|
||||
impl Handler for FakeCopilotServer {
|
||||
fn on_notification(&self, _method: &str, _params: Value) {}
|
||||
|
||||
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
|
||||
self.calls.lock().push((method.to_owned(), params.clone()));
|
||||
match method {
|
||||
"connect" => Ok(json!({ "ok": true, "protocolVersion": 3, "version": "1.0.112" })),
|
||||
"models.list" => Ok(sample_models_list()),
|
||||
"models.listTokenPriceUnits" => Ok(sample_price_units()),
|
||||
"user.settings.get" => Ok(json!({ "settings": { "model": "gemini-4-carbon" } })),
|
||||
"commands.list" => Ok(json!({ "commands": [{ "name": "compact", "description": "Compact context" }] })),
|
||||
"skills.discover" => Ok(json!({ "skills": [] })),
|
||||
"session.create" => Ok(json!({ "sessionId": "cop-sess-1" })),
|
||||
"session.model.switchTo" => Ok(json!({ "modelId": params["modelId"] })),
|
||||
"session.mode.set" => Ok(json!({})),
|
||||
"session.permissions.setApproveAll" => {
|
||||
assert!(params.get("enabled").and_then(Value::as_bool).is_some());
|
||||
Ok(json!({ "success": true }))
|
||||
}
|
||||
"session.send" => {
|
||||
if let Some(peer) = self.peer.get().cloned() {
|
||||
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
|
||||
std::thread::spawn(move || {
|
||||
let _ = peer.notify(
|
||||
"session.event",
|
||||
json!({
|
||||
"sessionId": sid,
|
||||
"event": {
|
||||
"id": "e1",
|
||||
"type": "session.usage_info",
|
||||
"data": { "currentTokens": 42_000, "tokenLimit": 1_000_000 }
|
||||
}
|
||||
}),
|
||||
);
|
||||
let _ = peer.notify(
|
||||
"session.event",
|
||||
json!({
|
||||
"sessionId": sid,
|
||||
"event": {
|
||||
"id": "e2",
|
||||
"type": "assistant.message_delta",
|
||||
"data": { "messageId": "m1", "deltaContent": "Hello from 1M context!" }
|
||||
}
|
||||
}),
|
||||
);
|
||||
let _ = peer.notify(
|
||||
"session.event",
|
||||
json!({
|
||||
"sessionId": sid,
|
||||
"event": {
|
||||
"id": "e3",
|
||||
"type": "session.idle",
|
||||
"data": { "aborted": false, "mode": "interactive" }
|
||||
}
|
||||
}),
|
||||
);
|
||||
});
|
||||
}
|
||||
Ok(json!({ "messageId": "msg-1" }))
|
||||
}
|
||||
_ => Err((codes::METHOD_NOT_FOUND, format!("unexpected {method}"))),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct CollectUpdates(Mutex<Vec<Value>>);
|
||||
|
||||
impl Handler for CollectUpdates {
|
||||
fn on_notification(&self, method: &str, params: Value) {
|
||||
if method == "session/update" {
|
||||
self.0.lock().push(params["update"].clone());
|
||||
}
|
||||
}
|
||||
|
||||
fn on_request(&self, method: &str, _params: Value) -> Result<Value, (i64, String)> {
|
||||
Err((codes::METHOD_NOT_FOUND, format!("unexpected {method}")))
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_turns() {
|
||||
let server = Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()) });
|
||||
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
|
||||
let server_clone = server.clone();
|
||||
let client = attach(updates.clone(), move |events| {
|
||||
let (a, b) = tokio::io::duplex(1 << 16);
|
||||
let (ar, aw) = tokio::io::split(a);
|
||||
let (br, bw) = tokio::io::split(b);
|
||||
let srv_peer = Peer::connect_framed(br, bw, server_clone.clone(), Framing::ContentLength);
|
||||
let _ = server_clone.peer.set(srv_peer);
|
||||
Ok(Peer::connect_framed(ar, aw, events, Framing::ContentLength))
|
||||
})
|
||||
.unwrap();
|
||||
|
||||
let init: Value = client.request("initialize", json!({}), None).await.unwrap();
|
||||
assert_eq!(init["agentInfo"]["version"], "1.0.112");
|
||||
assert_eq!(init["agentCapabilities"]["_meta"]["openidea"]["steer"], true);
|
||||
|
||||
let created: Value = client.request("session/new", json!({ "cwd": "/tmp", "mcpServers": [] }), None).await.unwrap();
|
||||
assert_eq!(created["sessionId"], "cop-sess-1");
|
||||
|
||||
// Verify `session.create` sent `"trustWorkingDirectory": "session"`, `gemini-4-carbon`,
|
||||
// and Copilot's own defaults (`reasoningEffort: "medium"` and `contextTier: "default"`).
|
||||
{
|
||||
let calls = server.calls.lock();
|
||||
let (_, create_params) = calls.iter().find(|(m, _)| m == "session.create").unwrap();
|
||||
assert_eq!(create_params["trustWorkingDirectory"], "session");
|
||||
assert_eq!(create_params["model"], "gemini-4-carbon");
|
||||
assert_eq!(create_params["reasoningEffort"], "medium");
|
||||
assert_eq!(create_params["contextTier"], "default");
|
||||
}
|
||||
|
||||
// Switch Context Size up to 1M (`long_context`) and Effort to `high` live via `session/set_config_option`.
|
||||
let _: Value = client
|
||||
.request(
|
||||
"session/set_config_option",
|
||||
json!({
|
||||
"sessionId": "cop-sess-1",
|
||||
"configId": "reasoning_effort",
|
||||
"value": "high"
|
||||
}),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let switched_1m: Value = client
|
||||
.request(
|
||||
"session/set_config_option",
|
||||
json!({
|
||||
"sessionId": "cop-sess-1",
|
||||
"configId": "context_tier",
|
||||
"value": "long_context"
|
||||
}),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let opts_1m = config::options_of(&switched_1m);
|
||||
assert_eq!(opts_1m.iter().find(|o| o.id == "context_tier").unwrap().current.as_deref(), Some("long_context"));
|
||||
|
||||
// Run a turn and verify 1M usage_update + streamed message chunk.
|
||||
let prompt_res: Value = client
|
||||
.request(
|
||||
"session/prompt",
|
||||
json!({
|
||||
"sessionId": "cop-sess-1",
|
||||
"prompt": [{ "type": "text", "text": "Explain architecture" }]
|
||||
}),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(prompt_res["stopReason"], "end_turn");
|
||||
{
|
||||
let seen = updates.0.lock();
|
||||
assert!(
|
||||
seen.iter().any(|u| u["sessionUpdate"] == "usage_update" && u["size"] == 1_000_000 && u["used"] == 42_000)
|
||||
);
|
||||
assert!(
|
||||
seen.iter().any(
|
||||
|u| u["sessionUpdate"] == "agent_message_chunk" && u["content"]["text"] == "Hello from 1M context!"
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
// Switch Context Size back down to 200K (`default`) live via `session/set_config_option`.
|
||||
let switched: Value = client
|
||||
.request(
|
||||
"session/set_config_option",
|
||||
json!({
|
||||
"sessionId": "cop-sess-1",
|
||||
"configId": "context_tier",
|
||||
"value": "default"
|
||||
}),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let opts = config::options_of(&switched);
|
||||
assert_eq!(opts.iter().find(|o| o.id == "context_tier").unwrap().current.as_deref(), Some("default"));
|
||||
{
|
||||
let calls = server.calls.lock();
|
||||
let (_, sw_params) = calls.iter().rfind(|(m, _)| m == "session.model.switchTo").unwrap();
|
||||
assert_eq!(sw_params["modelId"], "gemini-4-carbon");
|
||||
assert_eq!(sw_params["reasoningEffort"], "high");
|
||||
assert_eq!(sw_params["contextTier"], "default");
|
||||
}
|
||||
// Switching context_tier immediately emits an updated `usage_update` with `size: 200_000`.
|
||||
assert!(
|
||||
updates
|
||||
.0
|
||||
.lock()
|
||||
.iter()
|
||||
.any(|u| u["sessionUpdate"] == "usage_update" && u["size"] == 200_000 && u["used"] == 42_000)
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,583 @@
|
||||
//! Pure translations between Copilot headless JSON-RPC payloads (`session.event`,
|
||||
//! permissions, slash commands, MCP servers) and ACP v1.
|
||||
|
||||
use crate::LIMITS_UPDATE;
|
||||
use serde_json::{Map, Value, json};
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::path::Path;
|
||||
|
||||
const MAX_OUTPUT: usize = 64 * 1024;
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct EventTranslator {
|
||||
/// Assistant message IDs that already streamed deltas, so final `assistant.message` won't duplicate them.
|
||||
streamed_messages: HashSet<String>,
|
||||
/// Tool call metadata captured on `tool.execution_start`, keyed by `toolCallId`.
|
||||
tools: HashMap<String, ToolInfo>,
|
||||
/// Subagents started in this session (`toolCallId` → subagent session id).
|
||||
subagents: HashMap<String, String>,
|
||||
/// Last reported prompt token count, used when updating context size.
|
||||
pub last_used_tokens: Option<u32>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct ToolInfo {
|
||||
kind: &'static str,
|
||||
title: String,
|
||||
locations: Vec<Value>,
|
||||
output: String,
|
||||
diffs: Vec<Value>,
|
||||
}
|
||||
|
||||
/// An ACP notification `(session_id, update)` produced from a Copilot `session.event`.
|
||||
pub(super) struct Translated {
|
||||
pub updates: Vec<(String, Value)>,
|
||||
pub terminal: Option<TurnTerminal>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub(super) enum TurnTerminal {
|
||||
Idle { aborted: bool },
|
||||
Error { message: String, data: Option<Value> },
|
||||
}
|
||||
|
||||
impl EventTranslator {
|
||||
pub fn reset_turn(&mut self) {
|
||||
self.streamed_messages.clear();
|
||||
}
|
||||
|
||||
pub fn translate(&mut self, main_session: &str, event: &Value, fallback_limit: Option<u32>) -> Translated {
|
||||
let mut out = Translated { updates: Vec::new(), terminal: None };
|
||||
let event_type = str_of(event, "type").unwrap_or_default();
|
||||
let data = event.get("data").unwrap_or(&Value::Null);
|
||||
let agent_id = str_of(event, "agentId").filter(|s| !s.is_empty());
|
||||
let target_session =
|
||||
agent_id.map(|id| format!("{main_session}:sub:{id}")).unwrap_or_else(|| main_session.to_owned());
|
||||
|
||||
match event_type {
|
||||
"assistant.reasoning_delta" => {
|
||||
let delta = str_of(data, "deltaContent").or_else(|| str_of(data, "content")).unwrap_or_default();
|
||||
if !delta.is_empty() {
|
||||
out.updates.push((
|
||||
target_session,
|
||||
json!({ "sessionUpdate": "agent_thought_chunk", "content": { "type": "text", "text": delta } }),
|
||||
));
|
||||
}
|
||||
}
|
||||
"assistant.message_delta" => {
|
||||
if data.get("parentToolCallId").and_then(Value::as_str).is_some() && agent_id.is_none() {
|
||||
return out;
|
||||
}
|
||||
if let Some(mid) = str_of(data, "messageId") {
|
||||
self.streamed_messages.insert(mid.to_owned());
|
||||
}
|
||||
let delta = str_of(data, "deltaContent").unwrap_or_default();
|
||||
if !delta.is_empty() {
|
||||
out.updates.push((
|
||||
target_session,
|
||||
json!({ "sessionUpdate": "agent_message_chunk", "content": { "type": "text", "text": delta } }),
|
||||
));
|
||||
}
|
||||
}
|
||||
"assistant.message" => {
|
||||
if data.get("parentToolCallId").and_then(Value::as_str).is_some() && agent_id.is_none() {
|
||||
return out;
|
||||
}
|
||||
let already = str_of(data, "messageId").is_some_and(|mid| self.streamed_messages.contains(mid));
|
||||
if !already && let Some(content) = str_of(data, "content").filter(|c| !c.is_empty()) {
|
||||
out.updates.push((
|
||||
target_session,
|
||||
json!({ "sessionUpdate": "agent_message_chunk", "content": { "type": "text", "text": content } }),
|
||||
));
|
||||
}
|
||||
}
|
||||
"tool.execution_start" => {
|
||||
let tool_name = str_of(data, "toolName").unwrap_or_default();
|
||||
if matches!(tool_name, "report_intent" | "tool_search_tool" | "tool_search_tool_regex") {
|
||||
return out;
|
||||
}
|
||||
let Some(call_id) = str_of(data, "toolCallId").filter(|s| !s.is_empty()) else { return out };
|
||||
let args = data.get("arguments").unwrap_or(&Value::Null);
|
||||
if tool_name == "task" && agent_id.is_none() {
|
||||
let sub_id = format!("{main_session}:task:{call_id}");
|
||||
self.subagents.insert(call_id.to_owned(), sub_id.clone());
|
||||
let title = str_of(args, "name").or_else(|| str_of(args, "agent_type")).unwrap_or("Subagent");
|
||||
let desc = str_of(args, "description");
|
||||
let prompt = str_of(args, "prompt");
|
||||
out.updates.push((
|
||||
main_session.to_owned(),
|
||||
json!({
|
||||
"sessionUpdate": "subagent_update",
|
||||
"subagentId": sub_id,
|
||||
"title": title,
|
||||
"description": desc,
|
||||
"prompt": prompt,
|
||||
"status": "running",
|
||||
"cancellable": false,
|
||||
}),
|
||||
));
|
||||
return out;
|
||||
}
|
||||
let info = describe_tool(tool_name, args);
|
||||
let mut update = json!({
|
||||
"sessionUpdate": "tool_call",
|
||||
"toolCallId": call_id,
|
||||
"title": info.title,
|
||||
"kind": info.kind,
|
||||
"status": "in_progress",
|
||||
});
|
||||
if !info.locations.is_empty() {
|
||||
update["locations"] = Value::Array(info.locations.clone());
|
||||
}
|
||||
if !info.diffs.is_empty() {
|
||||
update["content"] = Value::Array(info.diffs.clone());
|
||||
}
|
||||
self.tools.insert(call_id.to_owned(), info);
|
||||
out.updates.push((target_session, update));
|
||||
}
|
||||
"tool.execution_partial_result" | "tool.shell_output" => {
|
||||
let Some(call_id) = str_of(data, "toolCallId") else { return out };
|
||||
let chunk = str_of(data, "partialOutput")
|
||||
.or_else(|| str_of(data, "output"))
|
||||
.or_else(|| str_of(data, "chunk"))
|
||||
.unwrap_or_default();
|
||||
if chunk.is_empty() {
|
||||
return out;
|
||||
}
|
||||
if let Some(info) = self.tools.get_mut(call_id) {
|
||||
info.output.push_str(chunk);
|
||||
trim_tail(&mut info.output);
|
||||
let content = tool_content(&info.output, &info.diffs);
|
||||
out.updates.push((
|
||||
target_session,
|
||||
json!({
|
||||
"sessionUpdate": "tool_call_update",
|
||||
"toolCallId": call_id,
|
||||
"content": content,
|
||||
}),
|
||||
));
|
||||
}
|
||||
}
|
||||
"tool.execution_complete" => {
|
||||
let Some(call_id) = str_of(data, "toolCallId") else { return out };
|
||||
let success = data.get("success").and_then(Value::as_bool).unwrap_or(true);
|
||||
let result_text = extract_tool_result_text(data);
|
||||
if let Some(sub_id) = self.subagents.remove(call_id) {
|
||||
out.updates.push((
|
||||
main_session.to_owned(),
|
||||
json!({
|
||||
"sessionUpdate": "subagent_update",
|
||||
"subagentId": sub_id,
|
||||
"status": if success { "done" } else { "failed" },
|
||||
"reply": result_text,
|
||||
"error": (!success).then(|| result_text.clone()).flatten(),
|
||||
}),
|
||||
));
|
||||
return out;
|
||||
}
|
||||
let Some(mut info) = self.tools.remove(call_id) else { return out };
|
||||
if info.output.is_empty()
|
||||
&& let Some(t) = result_text
|
||||
&& info.kind != "edit"
|
||||
{
|
||||
info.output = t;
|
||||
trim_tail(&mut info.output);
|
||||
}
|
||||
let mut update = json!({
|
||||
"sessionUpdate": "tool_call_update",
|
||||
"toolCallId": call_id,
|
||||
"status": if success { "completed" } else { "failed" },
|
||||
});
|
||||
let content = tool_content(&info.output, &info.diffs);
|
||||
if !content.is_empty() {
|
||||
update["content"] = Value::Array(content);
|
||||
}
|
||||
out.updates.push((target_session, update));
|
||||
}
|
||||
"subagent.started" => {
|
||||
if let Some(call_id) = str_of(data, "toolCallId") {
|
||||
let sub_id = self
|
||||
.subagents
|
||||
.entry(call_id.to_owned())
|
||||
.or_insert_with(|| format!("{main_session}:task:{call_id}"))
|
||||
.clone();
|
||||
let title = str_of(data, "agentDisplayName").or_else(|| str_of(data, "agentName"));
|
||||
let desc = str_of(data, "agentDescription");
|
||||
out.updates.push((
|
||||
main_session.to_owned(),
|
||||
json!({
|
||||
"sessionUpdate": "subagent_update",
|
||||
"subagentId": sub_id,
|
||||
"title": title,
|
||||
"description": desc,
|
||||
"status": "running",
|
||||
}),
|
||||
));
|
||||
}
|
||||
}
|
||||
"subagent.failed" => {
|
||||
if let Some(call_id) = str_of(data, "toolCallId")
|
||||
&& let Some(sub_id) = self.subagents.get(call_id).cloned()
|
||||
{
|
||||
out.updates.push((
|
||||
main_session.to_owned(),
|
||||
json!({
|
||||
"sessionUpdate": "subagent_update",
|
||||
"subagentId": sub_id,
|
||||
"status": "failed",
|
||||
"error": str_of(data, "error").or_else(|| str_of(data, "message")),
|
||||
}),
|
||||
));
|
||||
}
|
||||
}
|
||||
"session.title_changed" => {
|
||||
if let Some(title) = str_of(data, "title").map(str::trim).filter(|t| !t.is_empty()) {
|
||||
out.updates.push((
|
||||
main_session.to_owned(),
|
||||
json!({ "sessionUpdate": "session_info_update", "title": title }),
|
||||
));
|
||||
}
|
||||
}
|
||||
"session.usage_info" => {
|
||||
let used = data.get("currentTokens").and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok());
|
||||
let limit = data
|
||||
.get("tokenLimit")
|
||||
.and_then(Value::as_u64)
|
||||
.and_then(|n| u32::try_from(n).ok())
|
||||
.filter(|&n| n > 0)
|
||||
.or(fallback_limit);
|
||||
if let (Some(used), Some(size)) = (used, limit) {
|
||||
self.last_used_tokens = Some(used);
|
||||
out.updates.push((
|
||||
main_session.to_owned(),
|
||||
json!({ "sessionUpdate": "usage_update", "used": used, "size": size }),
|
||||
));
|
||||
}
|
||||
}
|
||||
"assistant.usage" => {
|
||||
if agent_id.is_none() {
|
||||
let used = data.get("inputTokens").and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok());
|
||||
if let (Some(used), Some(size)) = (used, fallback_limit.filter(|&s| s > 0)) {
|
||||
self.last_used_tokens = Some(used);
|
||||
out.updates.push((
|
||||
main_session.to_owned(),
|
||||
json!({ "sessionUpdate": "usage_update", "used": used, "size": size }),
|
||||
));
|
||||
}
|
||||
}
|
||||
if let Some(limits) = quota_limits(data.get("quotaSnapshots")) {
|
||||
out.updates.push((main_session.to_owned(), limits));
|
||||
}
|
||||
}
|
||||
"session.idle" if agent_id.is_none() => {
|
||||
let mode = str_of(data, "mode").unwrap_or_default();
|
||||
if mode != "autopilot" {
|
||||
let aborted = data.get("aborted").and_then(Value::as_bool).unwrap_or(false);
|
||||
out.terminal = Some(TurnTerminal::Idle { aborted });
|
||||
}
|
||||
}
|
||||
"session.autopilot_stopped" if agent_id.is_none() => {
|
||||
let reason = str_of(data, "reason").unwrap_or_default();
|
||||
if reason == "error" {
|
||||
out.terminal = Some(TurnTerminal::Error { message: "Autopilot request failed".into(), data: None });
|
||||
} else {
|
||||
out.terminal = Some(TurnTerminal::Idle { aborted: reason == "aborted" });
|
||||
}
|
||||
}
|
||||
"session.error" if agent_id.is_none() => {
|
||||
let message = str_of(data, "message").unwrap_or("Copilot reported an error.").to_owned();
|
||||
out.terminal = Some(TurnTerminal::Error { message, data: Some(data.clone()) });
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
fn describe_tool(name: &str, args: &Value) -> ToolInfo {
|
||||
let mut locations = Vec::new();
|
||||
let mut diffs = Vec::new();
|
||||
if let Some(p) = str_of(args, "path").or_else(|| str_of(args, "filePath")).filter(|p| !p.is_empty()) {
|
||||
locations.push(json!({ "path": p }));
|
||||
}
|
||||
let (kind, title) = match name {
|
||||
"bash" | "powershell" | "shell" => {
|
||||
let cmd = str_of(args, "command").or_else(|| str_of(args, "description")).unwrap_or("Run command");
|
||||
("execute", cmd.to_owned())
|
||||
}
|
||||
"view" | "read_file" => {
|
||||
let label = str_of(args, "path")
|
||||
.and_then(|p| Path::new(p).file_name().and_then(|n| n.to_str()))
|
||||
.unwrap_or("Read file");
|
||||
("read", format!("Read {label}"))
|
||||
}
|
||||
"grep" | "glob" | "semantic_search" => {
|
||||
let pat = str_of(args, "pattern").or_else(|| str_of(args, "query")).unwrap_or(name);
|
||||
("search", format!("Search {pat}"))
|
||||
}
|
||||
"edit" => {
|
||||
let path = str_of(args, "path").unwrap_or_default();
|
||||
let old = str_of(args, "old_str").unwrap_or_default();
|
||||
let new = str_of(args, "new_str").unwrap_or_default();
|
||||
if !path.is_empty() {
|
||||
diffs.push(json!({ "type": "diff", "path": path, "oldText": old, "newText": new }));
|
||||
}
|
||||
let label = Path::new(path).file_name().and_then(|n| n.to_str()).unwrap_or("file");
|
||||
("edit", format!("Edit {label}"))
|
||||
}
|
||||
"create" => {
|
||||
let path = str_of(args, "path").unwrap_or_default();
|
||||
let new = str_of(args, "file_text").unwrap_or_default();
|
||||
if !path.is_empty() {
|
||||
diffs.push(json!({ "type": "diff", "path": path, "oldText": "", "newText": new }));
|
||||
}
|
||||
let label = Path::new(path).file_name().and_then(|n| n.to_str()).unwrap_or("file");
|
||||
("edit", format!("Create {label}"))
|
||||
}
|
||||
"web_fetch" => {
|
||||
let url = str_of(args, "url").unwrap_or("URL");
|
||||
("fetch", format!("Fetch {url}"))
|
||||
}
|
||||
_ => ("other", str_of(args, "description").unwrap_or(name).to_owned()),
|
||||
};
|
||||
ToolInfo { kind, title, locations, output: String::new(), diffs }
|
||||
}
|
||||
|
||||
fn extract_tool_result_text(data: &Value) -> Option<String> {
|
||||
if let Some(err) = data.pointer("/error/message").and_then(Value::as_str).filter(|s| !s.is_empty()) {
|
||||
return Some(err.to_owned());
|
||||
}
|
||||
let result = data.get("result")?;
|
||||
if let Some(s) = result.as_str() {
|
||||
return (!s.is_empty()).then(|| s.to_owned());
|
||||
}
|
||||
str_of(result, "content")
|
||||
.or_else(|| str_of(result, "detailedContent"))
|
||||
.or_else(|| str_of(result, "textResultForLlm"))
|
||||
.filter(|s| !s.is_empty())
|
||||
.map(str::to_owned)
|
||||
}
|
||||
|
||||
fn tool_content(output: &str, diffs: &[Value]) -> Vec<Value> {
|
||||
let mut out = diffs.to_vec();
|
||||
if !output.is_empty() {
|
||||
out.push(json!({ "type": "content", "content": { "type": "text", "text": output } }));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn quota_limits(snapshots: Option<&Value>) -> Option<Value> {
|
||||
let map = snapshots?.as_object()?;
|
||||
let mut limits = Vec::new();
|
||||
for (window, snap) in map {
|
||||
let used_pct = snap
|
||||
.get("percentageUsed")
|
||||
.and_then(Value::as_f64)
|
||||
.or_else(|| snap.get("remainingPercentage").and_then(Value::as_f64).map(|rem| 100.0 - rem));
|
||||
let Some(used_pct) = used_pct.filter(|p| p.is_finite()) else { continue };
|
||||
let resets_ms = snap.get("resetsAt").and_then(Value::as_f64);
|
||||
let mut entry = json!({
|
||||
"window": window,
|
||||
"usedPercent": used_pct.clamp(0.0, 100.0),
|
||||
});
|
||||
if let Some(ms) = resets_ms {
|
||||
entry["resetsMs"] = json!(ms);
|
||||
}
|
||||
limits.push(entry);
|
||||
}
|
||||
(!limits.is_empty()).then(|| json!({ "sessionUpdate": LIMITS_UPDATE, "limits": limits }))
|
||||
}
|
||||
|
||||
/// Builds an ACP `session/request_permission` payload from Copilot's `permission.requested` data.
|
||||
pub(super) fn permission_request(session_id: &str, perm: &Value) -> Value {
|
||||
let kind = str_of(perm, "kind").unwrap_or("other");
|
||||
let tool_call_id = str_of(perm, "toolCallId").unwrap_or("permission");
|
||||
let (acp_kind, title, raw_input) = match kind {
|
||||
"shell" => {
|
||||
let cmd = str_of(perm, "fullCommandText").or_else(|| str_of(perm, "command")).unwrap_or_default();
|
||||
let title = str_of(perm, "intention")
|
||||
.filter(|s| !s.is_empty())
|
||||
.map(str::to_owned)
|
||||
.unwrap_or_else(|| if cmd.is_empty() { "Run shell command".into() } else { format!("Run {cmd}") });
|
||||
("execute", title, json!({ "command": cmd }))
|
||||
}
|
||||
"write" => {
|
||||
let path = str_of(perm, "fileName").or_else(|| str_of(perm, "path")).unwrap_or("file");
|
||||
("edit", format!("Edit {path}"), json!({ "path": path }))
|
||||
}
|
||||
"read" => {
|
||||
let path = str_of(perm, "path").unwrap_or("file");
|
||||
("read", format!("Read {path}"), json!({ "path": path }))
|
||||
}
|
||||
"url" => {
|
||||
let url = str_of(perm, "url").unwrap_or("URL");
|
||||
("fetch", format!("Allow network access to {url}"), json!({ "url": url }))
|
||||
}
|
||||
"mcp" => {
|
||||
let server = str_of(perm, "serverName").unwrap_or("MCP");
|
||||
let tool = str_of(perm, "toolName").unwrap_or("tool");
|
||||
("other", format!("Run {server}: {tool}"), perm.clone())
|
||||
}
|
||||
_ => {
|
||||
let t = str_of(perm, "intention").or_else(|| str_of(perm, "message")).unwrap_or("Allow action");
|
||||
("other", t.to_owned(), perm.clone())
|
||||
}
|
||||
};
|
||||
json!({
|
||||
"sessionId": session_id,
|
||||
"toolCall": {
|
||||
"toolCallId": tool_call_id,
|
||||
"kind": acp_kind,
|
||||
"title": title,
|
||||
"rawInput": raw_input,
|
||||
},
|
||||
"options": [
|
||||
{ "optionId": "approve-once", "name": "Allow once", "kind": "allow_once" },
|
||||
{ "optionId": "approved", "name": "Always allow", "kind": "allow_always" },
|
||||
{ "optionId": "denied", "name": "Reject", "kind": "reject_once" },
|
||||
],
|
||||
})
|
||||
}
|
||||
|
||||
/// Builds an ACP `session/request_permission` question card for Copilot's `userInput.request`.
|
||||
pub(super) fn user_input_permission_request(session_id: &str, req: &Value) -> Value {
|
||||
let question = str_of(req, "question").unwrap_or("Provide input");
|
||||
let choices: Vec<Value> = req
|
||||
.get("choices")
|
||||
.and_then(Value::as_array)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|c| c.as_str().map(|label| json!({ "label": label, "description": "" })))
|
||||
.collect();
|
||||
json!({
|
||||
"sessionId": session_id,
|
||||
"toolCall": {
|
||||
"toolCallId": str_of(req, "toolCallId").unwrap_or("ask_user"),
|
||||
"kind": "other",
|
||||
"title": question,
|
||||
"_meta": {
|
||||
"questions": [{
|
||||
"header": "Question",
|
||||
"question": question,
|
||||
"multiSelect": false,
|
||||
"options": choices,
|
||||
}]
|
||||
}
|
||||
},
|
||||
"options": [
|
||||
{ "optionId": "submit", "name": "Submit", "kind": "allow_once" },
|
||||
{ "optionId": "cancel", "name": "Cancel", "kind": "reject_once" },
|
||||
],
|
||||
})
|
||||
}
|
||||
|
||||
/// Converts ACP `mcpServers` array into Copilot's `mcpServers` object map.
|
||||
pub(super) fn wire_mcp_servers(acp_servers: Option<&Value>) -> Option<Value> {
|
||||
let list = acp_servers?.as_array()?;
|
||||
let mut out = Map::new();
|
||||
for item in list {
|
||||
let Some(name) = str_of(item, "name").filter(|n| !n.is_empty()) else { continue };
|
||||
let transport = str_of(item, "type").unwrap_or("stdio");
|
||||
match transport {
|
||||
"http" | "sse" => {
|
||||
let Some(url) = str_of(item, "url").filter(|u| !u.is_empty()) else { continue };
|
||||
let mut headers = Map::new();
|
||||
for kv in item.get("headers").and_then(Value::as_array).into_iter().flatten() {
|
||||
if let (Some(k), Some(v)) = (str_of(kv, "name"), str_of(kv, "value")) {
|
||||
headers.insert(k.to_owned(), json!(v));
|
||||
}
|
||||
}
|
||||
out.insert(
|
||||
name.to_owned(),
|
||||
json!({
|
||||
"type": transport,
|
||||
"url": url,
|
||||
"headers": headers,
|
||||
"tools": ["*"],
|
||||
}),
|
||||
);
|
||||
}
|
||||
_ => {
|
||||
let Some(cmd) = str_of(item, "command").filter(|c| !c.is_empty()) else { continue };
|
||||
let args: Vec<Value> = item.get("args").and_then(Value::as_array).cloned().unwrap_or_default();
|
||||
let mut env = Map::new();
|
||||
for kv in item.get("env").and_then(Value::as_array).into_iter().flatten() {
|
||||
if let (Some(k), Some(v)) = (str_of(kv, "name"), str_of(kv, "value")) {
|
||||
env.insert(k.to_owned(), json!(v));
|
||||
}
|
||||
}
|
||||
out.insert(
|
||||
name.to_owned(),
|
||||
json!({
|
||||
"type": "local",
|
||||
"command": cmd,
|
||||
"args": args,
|
||||
"env": env,
|
||||
"tools": ["*"],
|
||||
}),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
(!out.is_empty()).then_some(Value::Object(out))
|
||||
}
|
||||
|
||||
/// Converts `commands.list` + `skills.discover` results into ACP `availableCommands`.
|
||||
pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Option<&Value>) -> Vec<Value> {
|
||||
let mut seen = HashSet::new();
|
||||
let mut out = Vec::new();
|
||||
for cmd in commands_res.and_then(|v| v.get("commands")).and_then(Value::as_array).into_iter().flatten() {
|
||||
let Some(name) = str_of(cmd, "name").map(|n| n.trim_start_matches('/')).filter(|n| !n.is_empty()) else {
|
||||
continue;
|
||||
};
|
||||
if !seen.insert(name.to_owned()) {
|
||||
continue;
|
||||
}
|
||||
let hint = cmd.pointer("/input/hint").and_then(Value::as_str).filter(|h| !h.is_empty());
|
||||
out.push(json!({
|
||||
"name": name,
|
||||
"description": str_of(cmd, "description").unwrap_or_default(),
|
||||
"source": "command",
|
||||
"input": hint.map(|h| json!({ "hint": h })),
|
||||
}));
|
||||
}
|
||||
for skill in skills_res.and_then(|v| v.get("skills")).and_then(Value::as_array).into_iter().flatten() {
|
||||
if skill.get("enabled").and_then(Value::as_bool) == Some(false)
|
||||
|| skill.get("userInvocable").and_then(Value::as_bool) == Some(false)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let Some(name) = str_of(skill, "commandName")
|
||||
.or_else(|| str_of(skill, "name"))
|
||||
.map(|n| n.trim_start_matches('/'))
|
||||
.filter(|n| !n.is_empty())
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
if !seen.insert(name.to_owned()) {
|
||||
continue;
|
||||
}
|
||||
let hint = str_of(skill, "argumentHint").filter(|h| !h.is_empty());
|
||||
out.push(json!({
|
||||
"name": name,
|
||||
"description": str_of(skill, "description").unwrap_or_default(),
|
||||
"source": "skill",
|
||||
"input": hint.map(|h| json!({ "hint": h })),
|
||||
}));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn trim_tail(text: &mut String) {
|
||||
if text.len() > MAX_OUTPUT {
|
||||
let mut cut = text.len() - MAX_OUTPUT;
|
||||
while !text.is_char_boundary(cut) {
|
||||
cut += 1;
|
||||
}
|
||||
text.replace_range(..cut, "");
|
||||
}
|
||||
}
|
||||
|
||||
fn str_of<'a>(v: &'a Value, key: &str) -> Option<&'a str> {
|
||||
v.get(key).and_then(Value::as_str)
|
||||
}
|
||||
@@ -13,6 +13,7 @@
|
||||
|
||||
pub(crate) mod claude;
|
||||
pub(crate) mod codex;
|
||||
pub(crate) mod copilot;
|
||||
|
||||
use ide_jsonrpc::{Framing, Handler, Peer};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
@@ -20,6 +20,8 @@ pub(crate) enum Driver {
|
||||
Codex,
|
||||
/// `claude` in stream-json mode.
|
||||
Claude,
|
||||
/// `copilot --headless --no-auto-update --stdio`.
|
||||
Copilot,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
@@ -55,7 +57,13 @@ const BUILTIN: &[(&str, &str, Driver, &[&str], &str)] = &[
|
||||
"Run `codex login` in a terminal.",
|
||||
),
|
||||
("gemini", "Gemini CLI", Driver::Acp, &["gemini", "--experimental-acp"], "Run `gemini` in a terminal and sign in."),
|
||||
("copilot", "GitHub Copilot", Driver::Acp, &["copilot", "--acp"], "Run `copilot` in a terminal and sign in."),
|
||||
(
|
||||
"copilot",
|
||||
"GitHub Copilot",
|
||||
Driver::Copilot,
|
||||
&["copilot", "--headless", "--no-auto-update", "--stdio"],
|
||||
"Run `copilot` in a terminal and sign in.",
|
||||
),
|
||||
("cursor", "Cursor", Driver::Acp, &["cursor-agent", "acp"], "Run `cursor-agent login` in a terminal."),
|
||||
("opencode", "OpenCode", Driver::Acp, &["opencode", "acp"], "Run `opencode auth login` in a terminal."),
|
||||
("qwen", "Qwen Code", Driver::Acp, &["qwen", "--experimental-acp"], "Run `qwen` in a terminal and sign in."),
|
||||
@@ -242,10 +250,13 @@ fn render_login_command<'a>(program: &Path, args: impl IntoIterator<Item = &'a s
|
||||
}
|
||||
|
||||
/// Whether `id` names a built-in agent that needs no registry install (native drivers
|
||||
/// and `npx -y` adapters). CLI built-ins (`copilot`, `gemini`, …) can be installed and
|
||||
/// updated from the ACP Registry into `<config>/agents/<id>.toml`.
|
||||
/// other than `copilot`, and `npx -y` adapters). CLI built-ins (`copilot`, `gemini`, …)
|
||||
/// can be installed and updated from the ACP Registry into `<config>/agents/<id>.toml`.
|
||||
pub(crate) fn is_builtin(id: &str) -> bool {
|
||||
BUILTIN.iter().any(|&(bid, _, driver, cmd, _)| bid == id && (driver != Driver::Acp || cmd.first() == Some(&"npx")))
|
||||
id != "copilot"
|
||||
&& BUILTIN
|
||||
.iter()
|
||||
.any(|&(bid, _, driver, cmd, _)| bid == id && (driver != Driver::Acp || cmd.first() == Some(&"npx")))
|
||||
}
|
||||
|
||||
/// Display name of a built-in agent, when `id` is one.
|
||||
@@ -618,6 +629,10 @@ pub(crate) fn load(custom_dir: Option<&Path>, secrets: Option<&dyn EnvSecrets>)
|
||||
files.sort();
|
||||
for path in files {
|
||||
let Some(id) = path.file_stem().and_then(|s| s.to_str()).map(str::to_owned) else { continue };
|
||||
let explicit_driver = std::fs::read_to_string(&path)
|
||||
.ok()
|
||||
.and_then(|t| toml::from_str::<toml::Table>(&t).ok())
|
||||
.is_some_and(|t| t.contains_key("driver"));
|
||||
let agent = match CustomAgent::read_with(&path, &id, secrets) {
|
||||
Ok(a) => a,
|
||||
Err(e) => {
|
||||
@@ -643,6 +658,14 @@ pub(crate) fn load(custom_dir: Option<&Path>, secrets: Option<&dyn EnvSecrets>)
|
||||
match specs.iter_mut().find(|s| s.id == spec.id) {
|
||||
Some(existing) => {
|
||||
spec.login_hint = existing.login_hint.clone();
|
||||
if !explicit_driver && existing.driver == Driver::Copilot && spec.driver == Driver::Acp {
|
||||
// Registry installs (`github-copilot-cli`) record `args = ["--acp"]` with no
|
||||
// `driver`; upgrade them in place to the native headless driver (which
|
||||
// automatically falls back to `--acp`) while keeping the installed executable
|
||||
// path and registry version tracking. Explicit `driver = "acp"` stays ACP.
|
||||
spec.driver = Driver::Copilot;
|
||||
spec.args = crate::native::copilot::headless_args(&spec.args);
|
||||
}
|
||||
if spec.source == AgentSource::Custom {
|
||||
spec.source = AgentSource::Builtin;
|
||||
}
|
||||
|
||||
@@ -64,6 +64,7 @@ async fn create(mgr: &AgentManager, provider: &str, prompt: &str) -> String {
|
||||
config: config(provider),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
};
|
||||
mgr.create(req).await.unwrap().id
|
||||
}
|
||||
|
||||
@@ -54,6 +54,8 @@ struct FakeAgent {
|
||||
/// Advertises steering as OMP does (`_meta.steering` at the top of `initialize`)
|
||||
/// instead of `_meta.openidea.steer`.
|
||||
session_steering: bool,
|
||||
/// Records the `mcpServers` array passed to `session/new`, `session/load`, and `session/fork`.
|
||||
mcp_calls: Mutex<Vec<(String, Vec<String>)>>,
|
||||
}
|
||||
|
||||
impl FakeAgent {
|
||||
@@ -153,6 +155,18 @@ impl Handler for FakeAgent {
|
||||
// Let the prompt's permission request reach the task before the mode changes.
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
if matches!(method, "session/new" | "session/load" | "session/fork") {
|
||||
let names = params
|
||||
.get("mcpServers")
|
||||
.and_then(Value::as_array)
|
||||
.map(|arr| {
|
||||
arr.iter()
|
||||
.filter_map(|v| v.get("name").and_then(Value::as_str).map(str::to_owned))
|
||||
.collect::<Vec<_>>()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
self.mcp_calls.lock().push((method.to_owned(), names));
|
||||
}
|
||||
let session = params.get("sessionId").and_then(Value::as_str).unwrap_or("s1").to_owned();
|
||||
match method {
|
||||
"initialize" => {
|
||||
@@ -456,6 +470,7 @@ async fn saved_conversation_reads_do_not_start_or_load_the_agent() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -649,6 +664,7 @@ async fn authentication_failures_name_the_session_executable_at_start_and_during
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -699,6 +715,7 @@ async fn sign_in_errors_preserve_details_and_leave_unrelated_errors_unchanged()
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -754,6 +771,7 @@ async fn registry_sign_in_errors_use_the_advertised_terminal_login() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -801,6 +819,7 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -883,14 +902,30 @@ async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr_a, &task.id, AgentStatus::NeedsInput).await;
|
||||
assert_eq!(names(mgr_a.commands("claude", None).await.unwrap()), ["review", "triage"]);
|
||||
assert_eq!(names(mgr_a.commands("claude", Some(&task.id)).await.unwrap()), ["review", "triage"]);
|
||||
// Other agents get only what they offered.
|
||||
assert!(mgr_a.commands("codex", None).await.unwrap().is_empty());
|
||||
// Other agents get only what they offered, plus verified native builtins.
|
||||
assert_eq!(
|
||||
names(mgr_a.commands("codex", None).await.unwrap()),
|
||||
[
|
||||
"plan",
|
||||
"mcp",
|
||||
"skills",
|
||||
"status",
|
||||
"review",
|
||||
"review-branch",
|
||||
"review-commit",
|
||||
"compact",
|
||||
"goal",
|
||||
"rename",
|
||||
"logout",
|
||||
]
|
||||
);
|
||||
mgr_a.cancel(&task.id, None).unwrap();
|
||||
wait_for(&mgr_a, &task.id, AgentStatus::Ready).await;
|
||||
mgr_a.shutdown();
|
||||
@@ -910,9 +945,27 @@ async fn builtin_commands_only_fill_verified_gaps_and_preserve_advertised_metada
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager_at(tmp.path(), &tmp.path().join("models.json"), agent);
|
||||
for provider in ["claude", "claude-acp", "opencode2", "codex", "custom"] {
|
||||
for provider in ["claude", "claude-acp", "opencode2", "custom"] {
|
||||
assert!(mgr.commands(provider, None).await.unwrap().is_empty(), "{provider}");
|
||||
}
|
||||
let commands = mgr.commands("codex", None).await.unwrap();
|
||||
assert_eq!(
|
||||
commands.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(),
|
||||
[
|
||||
"plan",
|
||||
"mcp",
|
||||
"skills",
|
||||
"status",
|
||||
"review",
|
||||
"review-branch",
|
||||
"review-commit",
|
||||
"compact",
|
||||
"goal",
|
||||
"rename",
|
||||
"logout",
|
||||
]
|
||||
);
|
||||
assert_eq!(commands[1].hint.as_deref(), Some("[reconnect]"));
|
||||
let commands = mgr.commands("opencode", None).await.unwrap();
|
||||
assert_eq!(commands.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["compact"]);
|
||||
let task = mgr
|
||||
@@ -923,6 +976,7 @@ async fn builtin_commands_only_fill_verified_gaps_and_preserve_advertised_metada
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -981,6 +1035,7 @@ async fn a_task_runs_asks_for_permission_and_survives_a_restart() {
|
||||
config: vec![AgentConfigChoice { id: "model".into(), value: "small".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1104,6 +1159,7 @@ async fn steers_through_session_steering() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1140,6 +1196,7 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1195,6 +1252,7 @@ async fn subagents_get_their_own_conversation() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1290,6 +1348,7 @@ async fn claude_questions_keep_the_answer_object_as_the_option_id() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1339,6 +1398,7 @@ async fn qwen_questions_answer_by_index_beside_the_submit_option() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1407,6 +1467,7 @@ async fn skipped_qwen_questions_cancel_the_request() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1446,6 +1507,7 @@ async fn cancelling_resolves_the_open_permission_and_delete_forgets_the_task() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1467,7 +1529,8 @@ async fn cancelling_resolves_the_open_permission_and_delete_forgets_the_task() {
|
||||
provider: "codex".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.is_err()
|
||||
@@ -1516,6 +1579,7 @@ async fn real_claude_task_in_a_worktree() {
|
||||
config: vec![AgentConfigChoice { id: "model".into(), value: "haiku".into() }],
|
||||
isolation: Isolation::Worktree,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1566,11 +1630,18 @@ async fn renamed_titles_survive_updates_forks_and_restart() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
// `/rename` reports an explicit title through the same update; later automatic names
|
||||
// must not replace it even though AgentManager.rename was not called.
|
||||
handle
|
||||
.on_update(None, &json!({"sessionUpdate": "session_info_update", "title": "Command title", "userNamed": true}));
|
||||
handle.on_update(None, &json!({"sessionUpdate": "session_info_update", "title": "Automatic title"}));
|
||||
assert_eq!(handle.state.lock().task.title, "Command title");
|
||||
assert!(mgr.rename(&task.id, " ").is_err());
|
||||
let initial = handle.state.lock().task.title.clone();
|
||||
for title in [initial, "My task".to_owned(), "名".repeat(205)] {
|
||||
@@ -1591,6 +1662,67 @@ async fn renamed_titles_survive_updates_forks_and_restart() {
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn startup_warnings_survive_replay_and_restart_without_failing_the_task() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask { provider: "claude".into(), prompt: text("again"), ..Default::default() })
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
handle.replaying.store(true, Ordering::Release);
|
||||
handle.turn_started.store(false, Ordering::Release);
|
||||
let client = Client { task: Arc::downgrade(&handle) };
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({"message": "Project MCP config is disabled until trusted."}));
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({"message": " "}));
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({}));
|
||||
assert_eq!(handle.state.lock().task.status, AgentStatus::Ready);
|
||||
assert!(!handle.turn_started.load(Ordering::Acquire));
|
||||
mgr.shutdown();
|
||||
let restored = manager(tmp.path(), agent);
|
||||
let handle = restored.task(&task.id).unwrap();
|
||||
assert_eq!(handle.state.lock().conversation.main.entries.iter().filter(|entry| matches!(entry, AgentEntry::Error {message} if message == "Project MCP config is disabled until trusted.")).count(), 1);
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn persistent_project_trust_needs_confirmation_even_with_bypass_and_is_denied_in_side_chats() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
.create(NewAgentTask { provider: "claude".into(), prompt: text("again"), ..Default::default() })
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
handle.state.lock().task.config = config::options_of(&json!({"configOptions": [{
|
||||
"id": "mode", "category": "mode", "type": "select", "currentValue": "full-access",
|
||||
"options": [{"value": "full-access", "name": "Full Access"}]
|
||||
}]}));
|
||||
assert!(config::bypass_approvals(&handle.state.lock().task.config));
|
||||
let params = json!({"toolCall": {"toolCallId": "trust", "kind": "edit", "title": "Trust Project in Codex"},
|
||||
"options": [
|
||||
{"optionId": "codex-trust-project", "name": "Trust Project in Codex", "kind": "allow_always"},
|
||||
{"optionId": "codex-keep-untrusted", "name": "Keep Untrusted", "kind": "reject_once"}
|
||||
]});
|
||||
let asking = {
|
||||
let handle = handle.clone();
|
||||
let params = params.clone();
|
||||
tokio::task::spawn_blocking(move || handle.ask_permission(¶ms))
|
||||
};
|
||||
wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
|
||||
assert!(!asking.is_finished());
|
||||
let id = *handle.permissions.lock().keys().next().unwrap();
|
||||
mgr.respond(&task.id, id, Some("codex-keep-untrusted".into())).unwrap();
|
||||
assert_eq!(asking.await.unwrap()["outcome"]["optionId"], "codex-keep-untrusted");
|
||||
handle.state.lock().ephemeral = true;
|
||||
assert_eq!(handle.ask_permission(¶ms)["outcome"]["optionId"], "codex-keep-untrusted");
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn forks_rollbacks_and_steering() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -1603,6 +1735,7 @@ async fn forks_rollbacks_and_steering() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
};
|
||||
let task = mgr.create(new("again")).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
@@ -1682,6 +1815,7 @@ async fn usage_limits_and_late_settings() {
|
||||
config: vec![AgentConfigChoice { id: "effort".into(), value: "high".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1735,6 +1869,7 @@ async fn remembered_settings_drop_per_model_choices_for_the_next_task() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1769,6 +1904,7 @@ async fn thinking_levels_are_remembered_per_provider_and_model() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1815,6 +1951,7 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1856,6 +1993,7 @@ async fn upfront_effort_is_validated_after_changing_model_before_the_prompt() {
|
||||
],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1887,6 +2025,7 @@ async fn unreported_model_switch_does_not_cache_the_previous_models_levels() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1911,6 +2050,7 @@ async fn cached_effort_is_not_sent_without_real_session_options() {
|
||||
config,
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
};
|
||||
let warm = mgr.create(new(vec![])).await.unwrap();
|
||||
wait_for(&mgr, &warm.id, AgentStatus::Ready).await;
|
||||
@@ -1946,6 +2086,7 @@ async fn reported_levels_refresh_even_without_a_model_option() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -1999,6 +2140,7 @@ async fn cursor_approval_switch_resolves_pending_and_survives_restart() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
};
|
||||
let task = mgr.create(new()).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
|
||||
@@ -2052,6 +2194,7 @@ async fn bypass_approvals_keeps_both_question_dialects_pending_but_allows_permis
|
||||
},
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2113,6 +2256,7 @@ async fn an_agent_form_is_answered_declined_or_cancelled_even_when_approvals_are
|
||||
config: vec![AgentConfigChoice { id: config::CURSOR_APPROVAL.into(), value: "bypass".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2155,6 +2299,7 @@ async fn cursor_approval_choice_applies_before_first_prompt() {
|
||||
config: vec![AgentConfigChoice { id: config::CURSOR_APPROVAL.into(), value: "bypass".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2179,6 +2324,7 @@ async fn a_full_access_mode_approves_tool_requests() {
|
||||
config: vec![AgentConfigChoice { id: "mode".into(), value: "full-access".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2200,6 +2346,7 @@ async fn a_full_access_mode_approves_tool_requests() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2228,6 +2375,7 @@ async fn a_late_full_access_option_approves_a_pending_request() {
|
||||
config: vec![AgentConfigChoice { id: "mode".into(), value: "full-access".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2275,6 +2423,7 @@ async fn an_allow_all_permissions_option_approves_tool_requests() {
|
||||
config: vec![AgentConfigChoice { id: "allow_all".into(), value: "on".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2302,6 +2451,7 @@ async fn archived_tasks_can_be_restored_and_continue_their_session() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2354,6 +2504,7 @@ async fn task_project_root_controls_local_and_worktree_repositories() {
|
||||
config: vec![],
|
||||
isolation,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2560,6 +2711,7 @@ async fn idle_agents_stop_and_resume_their_session_on_the_next_message() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
};
|
||||
let live =
|
||||
|mgr: &AgentManager, id: &str| mgr.task(id).unwrap().live.lock().as_ref().is_some_and(|l| !l.peer.is_closed());
|
||||
@@ -2638,6 +2790,7 @@ async fn an_idle_agent_waits_for_its_background_tasks_before_it_stops() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -2672,6 +2825,7 @@ async fn the_task_shows_what_runs_in_the_background() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2724,6 +2878,7 @@ async fn a_background_task_is_stopped_on_its_own() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2811,6 +2966,7 @@ async fn delete_running_agent(no_load: bool) {
|
||||
config: vec![],
|
||||
isolation: Isolation::Worktree,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -2926,6 +3082,7 @@ async fn config_choice_shows_before_the_agent_answers() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3031,6 +3188,7 @@ async fn rolling_back_restores_the_start_of_the_task_and_keeps_the_users_own_edi
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3137,6 +3295,7 @@ impl Checkout {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3343,6 +3502,7 @@ async fn security_policy_auto_approves_whitelist_and_rejects_blacklist() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3373,6 +3533,7 @@ async fn security_policy_auto_approves_whitelist_and_rejects_blacklist() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3410,6 +3571,7 @@ async fn security_policy_never_auto_approves_a_request_that_only_reads_like_a_co
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3447,6 +3609,7 @@ async fn ephemeral_tasks_stay_in_memory_only() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3461,6 +3624,7 @@ async fn ephemeral_tasks_stay_in_memory_only() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
},
|
||||
&source.id,
|
||||
)
|
||||
@@ -3562,6 +3726,7 @@ async fn ephemeral_tasks_deny_write_permissions() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3587,6 +3752,7 @@ async fn ephemeral_tasks_deny_write_permissions() {
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
},
|
||||
&source.id,
|
||||
)
|
||||
@@ -3659,6 +3825,7 @@ async fn attention_finished_not_cancelled() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3674,6 +3841,7 @@ async fn attention_finished_not_cancelled() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3710,6 +3878,7 @@ async fn attention_failed() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3735,6 +3904,7 @@ async fn attention_input_not_auto_bypass() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3752,6 +3922,7 @@ async fn attention_input_not_auto_bypass() {
|
||||
config: vec![AgentConfigChoice { id: config::CURSOR_APPROVAL.into(), value: "bypass".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3778,6 +3949,7 @@ async fn attention_not_emitted_on_restore() {
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -3793,3 +3965,287 @@ async fn attention_not_emitted_on_restore() {
|
||||
assert!(attention_reasons(&events.lock()).is_empty(), "snapshot restore must not re-notify: {:?}", *events.lock());
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn per_session_mcp_overrides_filter_session_and_reload_when_idle() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
mgr.set_mcp_servers_hook(Box::new(|| {
|
||||
vec![
|
||||
McpServer {
|
||||
id: "user::github".into(),
|
||||
name: "github".into(),
|
||||
scope: McpScope::User,
|
||||
transport: McpTransport::Stdio,
|
||||
enabled: true,
|
||||
command: Some("npx".into()),
|
||||
args: vec!["gh-mcp".into()],
|
||||
env: Vec::new(),
|
||||
url: None,
|
||||
headers: Vec::new(),
|
||||
agents: Vec::new(),
|
||||
unapproved: false,
|
||||
},
|
||||
McpServer {
|
||||
id: "user::slack".into(),
|
||||
name: "slack".into(),
|
||||
scope: McpScope::User,
|
||||
transport: McpTransport::Stdio,
|
||||
enabled: true,
|
||||
command: Some("npx".into()),
|
||||
args: vec!["slack-mcp".into()],
|
||||
env: Vec::new(),
|
||||
url: None,
|
||||
headers: Vec::new(),
|
||||
agents: Vec::new(),
|
||||
unapproved: false,
|
||||
},
|
||||
]
|
||||
}));
|
||||
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
mcp_overrides: BTreeMap::from([("slack".into(), false)]),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
|
||||
let first_mcp = agent.mcp_calls.lock().last().cloned().unwrap();
|
||||
assert_eq!(first_mcp.0, "session/new");
|
||||
assert!(first_mcp.1.contains(&"github".to_string()));
|
||||
assert!(!first_mcp.1.contains(&"slack".to_string()));
|
||||
|
||||
// Toggle `slack` back on and `github` off while idle -> recycles the resumable session,
|
||||
// so the next prompt calls `session/load` with the updated MCP servers.
|
||||
let updated =
|
||||
mgr.set_mcp_overrides(&task.id, BTreeMap::from([("github".into(), false), ("slack".into(), true)])).unwrap();
|
||||
assert_eq!(updated.mcp_overrides.get("github"), Some(&false));
|
||||
assert_eq!(updated.mcp_overrides.get("slack"), Some(&true));
|
||||
|
||||
mgr.prompt(&task.id, text("again"), false).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
|
||||
let reloaded = agent.mcp_calls.lock().last().cloned().unwrap();
|
||||
assert_eq!(reloaded.0, "session/load");
|
||||
assert!(!reloaded.1.contains(&"github".to_string()));
|
||||
assert!(reloaded.1.contains(&"slack".to_string()));
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails() {
|
||||
#[derive(Clone, Copy)]
|
||||
enum BreakAt {
|
||||
Initialize,
|
||||
SessionNew,
|
||||
Prompt,
|
||||
}
|
||||
|
||||
struct BrokenHeadless(BreakAt);
|
||||
|
||||
impl ide_jsonrpc::Handler for BrokenHeadless {
|
||||
fn on_notification(&self, _: &str, _: Value) {}
|
||||
|
||||
fn on_request(&self, method: &str, _: Value) -> Result<Value, (i64, String)> {
|
||||
match (self.0, method) {
|
||||
(BreakAt::Initialize, "initialize") => {
|
||||
Err((ide_jsonrpc::codes::METHOD_NOT_FOUND, "connect unsupported".into()))
|
||||
}
|
||||
(_, "initialize") => Ok(json!({
|
||||
"protocolVersion": 1,
|
||||
"agentCapabilities": { "loadSession": true },
|
||||
"agentInfo": { "name": "copilot", "version": "2.0.0" },
|
||||
})),
|
||||
(BreakAt::SessionNew, "session/new") => {
|
||||
Err((ide_jsonrpc::codes::INVALID_PARAMS, "session.create schema changed".into()))
|
||||
}
|
||||
(BreakAt::Prompt, "session/new") => Ok(json!({ "sessionId": "headless-sess" })),
|
||||
(BreakAt::Prompt, "session/prompt") => {
|
||||
Err((ide_jsonrpc::codes::INVALID_PARAMS, "session.send schema changed".into()))
|
||||
}
|
||||
_ => Err((ide_jsonrpc::codes::METHOD_NOT_FOUND, format!("unexpected {method}"))),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let build_mgr = |dir: &Path, break_at: BreakAt| {
|
||||
let acp_agent = Arc::new(FakeAgent::default());
|
||||
let seen_drivers = Arc::new(Mutex::new(Vec::<(provider::Driver, Vec<String>)>::new()));
|
||||
let connector: Connector = {
|
||||
let acp_agent = acp_agent.clone();
|
||||
let seen_drivers = seen_drivers.clone();
|
||||
Arc::new(move |spec, _cwd, client, _stderr| {
|
||||
seen_drivers.lock().push((spec.driver, spec.args.clone()));
|
||||
let (a, b) = duplex(1 << 20);
|
||||
let (ar, aw) = tokio::io::split(a);
|
||||
let (br, bw) = tokio::io::split(b);
|
||||
let server = match spec.driver {
|
||||
provider::Driver::Copilot => {
|
||||
Peer::connect_framed(br, bw, Arc::new(BrokenHeadless(break_at)), Framing::Lines)
|
||||
}
|
||||
_ => Peer::connect_framed(br, bw, acp_agent.clone(), Framing::Lines),
|
||||
};
|
||||
acp_agent.servers.lock().push(server);
|
||||
Ok(Peer::connect_framed(ar, aw, client, Framing::Lines))
|
||||
})
|
||||
};
|
||||
let mgr = AgentManager::with_connector(
|
||||
AgentPaths {
|
||||
project_root: dir.to_path_buf(),
|
||||
store_dir: dir.join("store"),
|
||||
worktrees_dir: dir.join("worktrees"),
|
||||
models_file: dir.join("models.json"),
|
||||
custom_agents_dir: None,
|
||||
home_dir: None,
|
||||
env_secrets: None,
|
||||
catalogs: Arc::default(),
|
||||
},
|
||||
tokio::runtime::Handle::current(),
|
||||
connector,
|
||||
);
|
||||
(mgr, seen_drivers)
|
||||
};
|
||||
|
||||
// 1. Probe failure on headless falls back to `copilot --acp`.
|
||||
let tmp1 = tempfile::tempdir().unwrap();
|
||||
let (mgr1, seen1) = build_mgr(tmp1.path(), BreakAt::Initialize);
|
||||
let probe = mgr1.probe("copilot", false).await.unwrap();
|
||||
assert!(probe.error.is_none(), "{probe:?}");
|
||||
assert!(probe.protocol.starts_with("ACP v"), "{probe:?}");
|
||||
{
|
||||
let launches = seen1.lock().clone();
|
||||
assert_eq!(launches.len(), 2, "{launches:?}");
|
||||
assert_eq!(launches[0].0, provider::Driver::Copilot);
|
||||
assert_eq!(launches[1], (provider::Driver::Acp, vec!["--acp".to_owned()]));
|
||||
}
|
||||
mgr1.shutdown();
|
||||
|
||||
// 2. `session/new` (`session.create`) failure on headless falls back to `copilot --acp`.
|
||||
let tmp2 = tempfile::tempdir().unwrap();
|
||||
let (mgr2, seen2) = build_mgr(tmp2.path(), BreakAt::SessionNew);
|
||||
let task2 = mgr2
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "copilot".into(),
|
||||
config: vec![AgentConfigChoice { id: "context_tier".into(), value: "long_context".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr2, &task2.id, AgentStatus::Ready).await;
|
||||
{
|
||||
let launches = seen2.lock().clone();
|
||||
assert_eq!(launches.len(), 2, "{launches:?}");
|
||||
assert_eq!(launches[0].0, provider::Driver::Copilot);
|
||||
assert_eq!(launches[1], (provider::Driver::Acp, vec!["--acp".to_owned()]));
|
||||
}
|
||||
mgr2.shutdown();
|
||||
|
||||
// 3. `session/prompt` (`session.send`) protocol error before streaming falls back to `copilot --acp`.
|
||||
let tmp3 = tempfile::tempdir().unwrap();
|
||||
let (mgr3, seen3) = build_mgr(tmp3.path(), BreakAt::Prompt);
|
||||
let task3 = mgr3
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "copilot".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr3, &task3.id, AgentStatus::Ready).await;
|
||||
{
|
||||
let launches = seen3.lock().clone();
|
||||
assert_eq!(launches.len(), 2, "{launches:?}");
|
||||
assert_eq!(launches[0].0, provider::Driver::Copilot);
|
||||
assert_eq!(launches[1], (provider::Driver::Acp, vec!["--acp".to_owned()]));
|
||||
}
|
||||
mgr3.shutdown();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn copilot_catalog_discovery_falls_back_to_acp_when_headless_exits() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agents_dir = tmp.path().join("agents");
|
||||
std::fs::create_dir_all(&agents_dir).unwrap();
|
||||
let fake_copilot = tmp.path().join("copilot");
|
||||
let script = r#"#!/bin/sh
|
||||
for arg in "$@"; do
|
||||
if [ "$arg" = "--headless" ]; then
|
||||
echo "unknown option: --headless" >&2
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
while IFS= read -r line; do
|
||||
case "$line" in
|
||||
*'"initialize"'*)
|
||||
echo '{"jsonrpc":"2.0","id":1,"result":{"protocolVersion":1,"agentCapabilities":{"loadSession":true},"agentInfo":{"name":"copilot","version":"1.0.112"}}}'
|
||||
;;
|
||||
*'"session/new"'*)
|
||||
echo '{"jsonrpc":"2.0","id":2,"result":{"sessionId":"acp-disc-1","configOptions":[{"id":"model","name":"Model","category":"model","type":"select","currentValue":"claude-sonnet-5.5","options":[{"value":"claude-sonnet-5.5","name":"Claude Sonnet 5.5","_meta":{"copilotPriceCategory":"medium"}}]},{"id":"reasoning_effort","name":"Effort","category":"thought_level","type":"select","currentValue":"medium","options":[{"value":"low","name":"Low"},{"value":"medium","name":"Medium"},{"value":"high","name":"High"}]}]}}'
|
||||
;;
|
||||
esac
|
||||
done
|
||||
"#;
|
||||
std::fs::write(&fake_copilot, script).unwrap();
|
||||
std::fs::set_permissions(&fake_copilot, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
std::fs::write(
|
||||
agents_dir.join("copilot.toml"),
|
||||
format!("name = \"GitHub Copilot\"\ncommand = {:?}\nargs = [\"--acp\"]\n", fake_copilot.to_string_lossy()),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let mgr = AgentManager::new(
|
||||
AgentPaths {
|
||||
project_root: tmp.path().to_path_buf(),
|
||||
store_dir: tmp.path().join("store"),
|
||||
worktrees_dir: tmp.path().join("worktrees"),
|
||||
models_file: tmp.path().join("models.json"),
|
||||
custom_agents_dir: Some(agents_dir),
|
||||
home_dir: None,
|
||||
env_secrets: None,
|
||||
catalogs: Arc::default(),
|
||||
},
|
||||
tokio::runtime::Handle::current(),
|
||||
);
|
||||
mgr.commands("copilot", None).await.unwrap();
|
||||
let copilot = mgr.providers().into_iter().find(|p| p.id == "copilot").unwrap();
|
||||
let models = copilot.config.iter().find(|o| o.category.as_deref() == Some("model")).expect("ACP fallback models");
|
||||
assert_eq!(models.current.as_deref(), Some("claude-sonnet-5.5"));
|
||||
assert_eq!(
|
||||
copilot.thought_levels["claude-sonnet-5.5"]
|
||||
.iter()
|
||||
.find(|o| o.id == "reasoning_effort")
|
||||
.and_then(|o| o.current.as_deref()),
|
||||
Some("medium")
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn session_params_name_the_servers_off() {
|
||||
let mcp = McpForSession { servers: vec![json!({ "name": "docs" })], off: vec!["github".into()] };
|
||||
let params = session_params("/p", &mcp);
|
||||
assert_eq!(params["cwd"], "/p");
|
||||
assert_eq!(params["mcpServers"][0]["name"], "docs");
|
||||
assert_eq!(params["_meta"]["openidea"]["mcpServersOff"], json!(["github"]));
|
||||
let none = McpForSession { servers: Vec::new(), off: Vec::new() };
|
||||
assert!(session_params("/p", &none).get("_meta").is_none());
|
||||
}
|
||||
@@ -310,6 +310,8 @@ fn artifact_steps(
|
||||
.find(|f| f.module == artifact.module || f.module.is_empty() && artifact.module == ".")
|
||||
.or_else(|| ps.facets.iter().find(|f| f.kind == "web"));
|
||||
let staging = cache.join("artifacts").join(file_name(&artifact.name));
|
||||
// What the last build laid out in a folder the user chose, so the next one replaces only that.
|
||||
let record = cache.join("artifacts").join(format!("{}.files", file_name(&artifact.name)));
|
||||
let mut steps = Vec::new();
|
||||
match (artifact.kind, war) {
|
||||
(ArtifactKind::Jar, None) => {
|
||||
@@ -324,7 +326,11 @@ fn artifact_steps(
|
||||
manifest.push_str(&format!("Class-Path: {}\r\n", names.join(" ")));
|
||||
}
|
||||
steps.push(BuildStep::action(
|
||||
Action::Layout { into: staging.clone(), entries: vec![(classes.to_path_buf(), PathBuf::new())] },
|
||||
Action::Layout {
|
||||
into: staging.clone(),
|
||||
entries: vec![(classes.to_path_buf(), PathBuf::new())],
|
||||
record: None,
|
||||
},
|
||||
root,
|
||||
));
|
||||
// The jar's Class-Path names the libraries next to it.
|
||||
@@ -332,6 +338,7 @@ fn artifact_steps(
|
||||
Action::Layout {
|
||||
into: out.clone(),
|
||||
entries: libraries.iter().map(|l| (l.clone(), file_of(l))).collect(),
|
||||
record: Some(record),
|
||||
},
|
||||
root,
|
||||
));
|
||||
@@ -353,7 +360,9 @@ fn artifact_steps(
|
||||
for lib in &libraries {
|
||||
entries.push((lib.clone(), Path::new("WEB-INF/lib").join(file_of(lib))));
|
||||
}
|
||||
steps.push(BuildStep::action(Action::Layout { into: exploded.clone(), entries }, root));
|
||||
// The exploded output may be a folder the user chose; the staging folder is the IDE's own.
|
||||
let record = (exploded != staging).then_some(record);
|
||||
steps.push(BuildStep::action(Action::Layout { into: exploded.clone(), entries, record }, root));
|
||||
let archive = war
|
||||
.map(Path::to_path_buf)
|
||||
.or_else(|| (kind != ArtifactKind::WarExploded).then(|| artifact_file(root, artifact)));
|
||||
@@ -407,15 +416,17 @@ pub(crate) enum Action {
|
||||
/// relative paths; files that are already up to date are left alone.
|
||||
CopyResources { from: Vec<PathBuf>, to: PathBuf },
|
||||
/// Lays out an artifact in `into`: each folder's content or file goes to its relative
|
||||
/// place (`""` = the top). What is no longer laid out is removed.
|
||||
Layout { into: PathBuf, entries: Vec<(PathBuf, PathBuf)> },
|
||||
/// place (`""` = the top). What is no longer laid out is removed: without `record`, `into`
|
||||
/// is the IDE's own folder and is laid out afresh; with it, `into` is a folder the user chose
|
||||
/// and only the files the previous layout recorded there are removed, never anything else.
|
||||
Layout { into: PathBuf, entries: Vec<(PathBuf, PathBuf)>, record: Option<PathBuf> },
|
||||
/// Zips the folder `from` into the archive `to`, with this manifest first.
|
||||
Archive { from: PathBuf, to: PathBuf, manifest: Option<String> },
|
||||
}
|
||||
|
||||
impl Action {
|
||||
pub(crate) fn display(&self, root: &Path) -> String {
|
||||
let rel = |p: &Path| p.strip_prefix(root).unwrap_or(p).to_string_lossy().into_owned();
|
||||
let rel = |p: &Path| p.strip_prefix(root).unwrap_or(p).to_string_lossy().replace('\\', "/");
|
||||
match self {
|
||||
Action::Clean(dirs) => format!("Clean {}", dirs.iter().map(|d| rel(d)).collect::<Vec<_>>().join(", ")),
|
||||
Action::CopyResources { to, .. } => format!("Copy resources to {}", rel(to)),
|
||||
@@ -441,29 +452,39 @@ impl Action {
|
||||
}
|
||||
Ok(format!("{copied} resource file(s) copied"))
|
||||
}
|
||||
Action::Layout { into, entries } => {
|
||||
// A fresh layout: files dropped from the sources must not linger in the artifact.
|
||||
Action::Layout { into, entries, record } => {
|
||||
if entries.iter().any(|(from, _)| from.starts_with(into)) {
|
||||
return Err(IdeError::invalid(format!(
|
||||
"The artifact output folder {} holds files the artifact is made of",
|
||||
into.display()
|
||||
)));
|
||||
}
|
||||
if into.exists() {
|
||||
if record.is_none() && into.exists() {
|
||||
fs::remove_dir_all(into)
|
||||
.map_err(|e| IdeError::internal(format!("cannot delete {} ({e})", into.display())))?;
|
||||
}
|
||||
let mut copied = 0;
|
||||
let mut written = Vec::new();
|
||||
for (from, to) in entries {
|
||||
let target = into.join(to);
|
||||
// The folders of the output it goes into (and a folder entry's own) are
|
||||
// never links; a file in a link's place replaces the link.
|
||||
let mut at = into.to_path_buf();
|
||||
let folders = to.components().count().saturating_sub(usize::from(!from.is_dir()));
|
||||
for c in to.components().take(folders) {
|
||||
at.push(c);
|
||||
refuse_link(&at)?;
|
||||
}
|
||||
if from.is_dir() {
|
||||
copied += copy_tree(from, &target, cancel)?;
|
||||
copy_tree(from, &target, &mut written, cancel)?;
|
||||
} else if from.is_file() {
|
||||
copy_file(from, &target)?;
|
||||
copied += 1;
|
||||
written.push(target);
|
||||
}
|
||||
}
|
||||
Ok(format!("{copied} file(s) laid out"))
|
||||
if let Some(record) = record {
|
||||
replace_recorded(into, record, &written)?;
|
||||
}
|
||||
Ok(format!("{} file(s) laid out", written.len()))
|
||||
}
|
||||
Action::Archive { from, to, manifest } => {
|
||||
archive(from, to, manifest.as_deref(), cancel)?;
|
||||
@@ -474,6 +495,10 @@ impl Action {
|
||||
}
|
||||
|
||||
fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
|
||||
// A link in the artifact's place is replaced, not written through.
|
||||
if fs::symlink_metadata(to).is_ok_and(|m| m.file_type().is_symlink()) {
|
||||
fs::remove_file(to).map_err(|e| IdeError::internal(format!("cannot replace {} ({e})", to.display())))?;
|
||||
}
|
||||
if let Some(parent) = to.parent() {
|
||||
fs::create_dir_all(parent)
|
||||
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
|
||||
@@ -482,23 +507,80 @@ fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn copy_tree(from: &Path, to: &Path, cancel: &CancellationToken) -> IdeResult<usize> {
|
||||
fn refuse_link(folder: &Path) -> IdeResult<()> {
|
||||
if fs::symlink_metadata(folder).is_ok_and(|m| m.file_type().is_symlink()) {
|
||||
return Err(IdeError::invalid(format!(
|
||||
"{} links to another folder; the artifact is not laid out through it",
|
||||
folder.display()
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn copy_tree(from: &Path, to: &Path, written: &mut Vec<PathBuf>, cancel: &CancellationToken) -> IdeResult<()> {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let Ok(entries) = fs::read_dir(from) else { return Ok(0) };
|
||||
let mut copied = 0;
|
||||
let Ok(entries) = fs::read_dir(from) else { return Ok(()) };
|
||||
for e in entries.flatten() {
|
||||
let Ok(t) = e.file_type() else { continue };
|
||||
let target = to.join(e.file_name());
|
||||
if t.is_dir() {
|
||||
copied += copy_tree(&e.path(), &target, cancel)?;
|
||||
refuse_link(&target)?;
|
||||
copy_tree(&e.path(), &target, written, cancel)?;
|
||||
} else if t.is_file() {
|
||||
copy_file(&e.path(), &target)?;
|
||||
copied += 1;
|
||||
written.push(target);
|
||||
}
|
||||
}
|
||||
Ok(copied)
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Removes the files the previous layout recorded in `into` that this one didn't write
|
||||
/// (and the folders that leaves empty), then records `written` for the next layout.
|
||||
fn replace_recorded(into: &Path, record: &Path, written: &[PathBuf]) -> IdeResult<()> {
|
||||
let now: std::collections::HashSet<PathBuf> =
|
||||
written.iter().filter_map(|p| p.strip_prefix(into).ok().map(Path::to_path_buf)).collect();
|
||||
let before = fs::read_to_string(record).unwrap_or_default();
|
||||
let mut lines = before.lines();
|
||||
// The record names its folder first: one made for another output folder removes nothing.
|
||||
let same = lines.next().is_some_and(|dir| Path::new(dir) == into);
|
||||
for rel in lines.filter(|_| same).map(PathBuf::from) {
|
||||
// Only plain relative paths inside `into`: a damaged record must not reach elsewhere.
|
||||
if rel.as_os_str().is_empty()
|
||||
|| now.contains(&rel)
|
||||
|| rel.components().any(|c| !matches!(c, std::path::Component::Normal(_)))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let file = into.join(&rel);
|
||||
// Never through a link: a folder of the output that now links elsewhere (or a file that
|
||||
// is a link) leads out of what the layout wrote.
|
||||
let mut at = into.to_path_buf();
|
||||
let linked = rel.components().any(|c| {
|
||||
at.push(c);
|
||||
fs::symlink_metadata(&at).is_ok_and(|m| m.file_type().is_symlink())
|
||||
});
|
||||
if !linked && file.is_file() {
|
||||
let _ = fs::remove_file(&file);
|
||||
let mut dir = file.parent();
|
||||
while let Some(d) = dir.filter(|d| *d != into && d.starts_with(into)) {
|
||||
if fs::remove_dir(d).is_err() {
|
||||
break;
|
||||
}
|
||||
dir = d.parent();
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut list: Vec<String> = now.iter().map(|p| p.to_string_lossy().into_owned()).collect();
|
||||
list.sort();
|
||||
list.insert(0, into.to_string_lossy().into_owned());
|
||||
if let Some(parent) = record.parent() {
|
||||
fs::create_dir_all(parent)
|
||||
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
|
||||
}
|
||||
fs::write(record, list.join("\n"))
|
||||
.map_err(|e| IdeError::internal(format!("cannot write {} ({e})", record.display())))
|
||||
}
|
||||
|
||||
fn archive(from: &Path, to: &Path, manifest: Option<&str>, cancel: &CancellationToken) -> IdeResult<()> {
|
||||
@@ -646,15 +728,15 @@ mod tests {
|
||||
let main_cp = cp(javac);
|
||||
let entries: Vec<&str> = main_cp.split(sep).collect();
|
||||
assert_eq!(entries.len(), 2, "{main_cp}");
|
||||
assert!(entries[0].ends_with("lib/*"));
|
||||
assert!(entries[1].ends_with("WEB-INF/lib/*"));
|
||||
assert!(Path::new(entries[0]).ends_with("lib/*"));
|
||||
assert!(Path::new(entries[1]).ends_with("WEB-INF/lib/*"));
|
||||
assert!(javac.args.windows(2).any(|w| w == ["--release", "17"]));
|
||||
let args = fs::read_to_string(tmp.path().join("cache/javac/production.args")).unwrap();
|
||||
assert!(args.contains("A.java") && !args.contains("ATest.java"));
|
||||
assert_eq!(shown[2], "Copy resources to out/production/shop");
|
||||
let test = &plan.steps[3];
|
||||
let test_cp = cp(test);
|
||||
assert!(test_cp.starts_with(&root.join("out/production/shop").to_string_lossy().into_owned()));
|
||||
assert_eq!(Path::new(test_cp.split(sep).next().unwrap()), root.join("out/production/shop"));
|
||||
assert!(test_cp.contains("junit.jar"));
|
||||
}
|
||||
|
||||
@@ -693,7 +775,9 @@ mod tests {
|
||||
let javac = &plan.steps[0];
|
||||
assert!(!javac.args.iter().any(|a| a == "-cp"), "{:?}", javac.args);
|
||||
assert!(javac.args.windows(4).any(|w| w == ["-source", "1.8", "-target", "1.8"]));
|
||||
assert!(javac.args.windows(2).any(|w| w[0] == "-d" && w[1].ends_with("build/classes/production/p")));
|
||||
assert!(
|
||||
javac.args.windows(2).any(|w| w[0] == "-d" && Path::new(&w[1]).ends_with("build/classes/production/p"))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -810,8 +894,71 @@ mod tests {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let web = tmp.path().join("WebRoot");
|
||||
write(&web.join("a.jsp"), "");
|
||||
let action = Action::Layout { into: tmp.path().to_path_buf(), entries: vec![(web.clone(), PathBuf::new())] };
|
||||
let action = Action::Layout {
|
||||
into: tmp.path().to_path_buf(),
|
||||
entries: vec![(web.clone(), PathBuf::new())],
|
||||
record: None,
|
||||
};
|
||||
assert!(action.run(&CancellationToken::new()).is_err());
|
||||
assert!(web.join("a.jsp").is_file());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_chosen_output_folder_keeps_what_the_artifact_did_not_put_there() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let project = tmp.path().join("project");
|
||||
write(&project.join("src/A.java"), "class A {}");
|
||||
write(&project.join(".git/HEAD"), "ref: refs/heads/main");
|
||||
let libs = tmp.path().join("libs");
|
||||
write(&libs.join("a.jar"), "a");
|
||||
write(&libs.join("b.jar"), "b");
|
||||
let record = tmp.path().join("cache/artifacts/app.files");
|
||||
let layout = |names: &[&str]| Action::Layout {
|
||||
into: project.clone(),
|
||||
entries: names.iter().map(|n| (libs.join(n), PathBuf::from(n))).collect(),
|
||||
record: Some(record.clone()),
|
||||
};
|
||||
layout(&["a.jar", "b.jar"]).run(&CancellationToken::new()).unwrap();
|
||||
assert!(project.join("a.jar").is_file() && project.join("b.jar").is_file());
|
||||
// A library dropped from the artifact goes; the project's own files stay.
|
||||
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
|
||||
assert!(project.join("a.jar").is_file() && !project.join("b.jar").exists());
|
||||
assert!(project.join("src/A.java").is_file() && project.join(".git/HEAD").is_file());
|
||||
// A damaged record never reaches outside the folder.
|
||||
write(&record, &format!("{}\n../outside.txt", project.display()));
|
||||
write(&tmp.path().join("outside.txt"), "x");
|
||||
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
|
||||
assert!(tmp.path().join("outside.txt").is_file());
|
||||
// Nor through a folder of the output that now links elsewhere.
|
||||
#[cfg(unix)]
|
||||
{
|
||||
write(&project.join("assets/x.txt"), "laid out");
|
||||
write(&record, &format!("{}\nassets/x.txt", project.display()));
|
||||
fs::remove_dir_all(project.join("assets")).unwrap();
|
||||
std::os::unix::fs::symlink(project.join("src"), project.join("assets")).unwrap();
|
||||
write(&project.join("src/x.txt"), "source");
|
||||
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
|
||||
assert!(project.join("src/x.txt").is_file());
|
||||
}
|
||||
// An entry's own folder that links elsewhere stops the layout instead of copying through it.
|
||||
#[cfg(unix)]
|
||||
{
|
||||
fs::remove_file(project.join("assets")).unwrap();
|
||||
std::os::unix::fs::symlink(project.join("src"), project.join("classes")).unwrap();
|
||||
write(&tmp.path().join("out/A.class"), "compiled");
|
||||
let into_link = Action::Layout {
|
||||
into: project.clone(),
|
||||
entries: vec![(tmp.path().join("out"), PathBuf::from("classes"))],
|
||||
record: Some(record.clone()),
|
||||
};
|
||||
assert!(into_link.run(&CancellationToken::new()).is_err());
|
||||
assert!(!project.join("src/A.class").exists());
|
||||
fs::remove_file(project.join("classes")).unwrap();
|
||||
}
|
||||
// Nor does one made for another output folder.
|
||||
write(&project.join("c.jar"), "mine");
|
||||
write(&record, "/elsewhere\nc.jar");
|
||||
layout(&["a.jar"]).run(&CancellationToken::new()).unwrap();
|
||||
assert!(project.join("c.jar").is_file());
|
||||
}
|
||||
}
|
||||
@@ -1463,7 +1463,7 @@ dependencies {
|
||||
model.projects.push(project);
|
||||
}
|
||||
assert!(build_files(root, &model).contains(&root.join("included/deps.gradle")));
|
||||
let model = crate::BuildModel { maven: None, gradle: vec![model] };
|
||||
let model = crate::BuildModel { maven: None, gradle: vec![model], sbt: Vec::new() };
|
||||
assert_eq!(crate::dependency_coordinates(root, &model)[0].artifact_id, "included");
|
||||
}
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
//! Build tool models for the Maven and Gradle tool windows, and Build › Build
|
||||
//! Build tool models for the Maven, Gradle and sbt tool windows, and Build › Build
|
||||
//! Project ([`compile`]) for Maven, Gradle, Cargo, Go and TypeScript projects.
|
||||
//!
|
||||
//! [`load`] reads the project's build files (instant, no build tool involved)
|
||||
@@ -13,6 +13,7 @@ pub mod kotlin_bridge;
|
||||
pub mod maven;
|
||||
pub mod pom_edit;
|
||||
mod process;
|
||||
pub mod sbt;
|
||||
mod sync;
|
||||
pub mod web;
|
||||
mod xml;
|
||||
@@ -20,6 +21,7 @@ mod xml;
|
||||
pub use gradle::{GradleModel, GradleProject, GradleTask};
|
||||
pub use gradle_deps::{GradleDependency, gradle_dependencies};
|
||||
pub use maven::{MavenDependency, MavenModel, MavenPlugin, MavenProfile, MavenProject, Omission};
|
||||
pub use sbt::{SbtBuild, SbtProject};
|
||||
pub use sync::{
|
||||
SyncOptions, SyncProgress, maven_profiles, save_maven_profiles, sync_gradle, sync_gradle_model, sync_maven,
|
||||
};
|
||||
@@ -42,6 +44,9 @@ pub struct BuildModel {
|
||||
pub maven: Option<MavenModel>,
|
||||
#[serde(default)]
|
||||
pub gradle: Vec<GradleModel>,
|
||||
/// sbt builds, read from their `build.sbt` (sbt is not started).
|
||||
#[serde(default)]
|
||||
pub sbt: Vec<SbtBuild>,
|
||||
}
|
||||
|
||||
impl BuildModel {
|
||||
@@ -96,7 +101,7 @@ pub fn load_linked(
|
||||
g
|
||||
})
|
||||
.collect();
|
||||
BuildModel { maven, gradle }
|
||||
BuildModel { maven, gradle, sbt: sbt::load(root) }
|
||||
}
|
||||
|
||||
/// Gradle project folders outside `root` as of the last sync (`includeFlat` siblings):
|
||||
@@ -329,7 +334,7 @@ mod tests {
|
||||
..Default::default()
|
||||
};
|
||||
let gradle = gradle::load(root).into_iter().collect();
|
||||
let model = BuildModel { maven: Some(maven), gradle };
|
||||
let model = BuildModel { maven: Some(maven), gradle, sbt: Vec::new() };
|
||||
let names: Vec<String> = dependency_coordinates(root, &model)
|
||||
.into_iter()
|
||||
.map(|c| format!("{}{}:{}:{}", if c.gradle { "G " } else { "M " }, c.group_id, c.artifact_id, c.version))
|
||||
@@ -348,7 +353,7 @@ mod tests {
|
||||
"ext { gson = '2.8.9' }\ndependencies { implementation \"com.google.code.gson:gson:${gson}\" }\n",
|
||||
)
|
||||
.unwrap();
|
||||
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect() };
|
||||
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect(), sbt: Vec::new() };
|
||||
let names: Vec<String> = dependency_coordinates(root, &model)
|
||||
.into_iter()
|
||||
.map(|c| format!("{}:{}:{}", c.group_id, c.artifact_id, c.version))
|
||||
@@ -367,7 +372,7 @@ mod tests {
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::write(root.join("gradle.properties"), "# versions\nv = 1.2\nonlyInProperties: 2.3\n").unwrap();
|
||||
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect() };
|
||||
let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect(), sbt: Vec::new() };
|
||||
let versions: Vec<_> = dependency_coordinates(root, &model).into_iter().map(|c| c.version).collect();
|
||||
assert_eq!(versions, ["1.2", "2.3"]);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,301 @@
|
||||
//! sbt builds for the sbt tool window: each `build.sbt` build under the project root
|
||||
//! with the projects its definition declares (`lazy val core = project`,
|
||||
//! `(project in file("core"))`, `Project("core", file("core"))`), read statically —
|
||||
//! sbt itself is not started.
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::path::Path;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct SbtBuild {
|
||||
/// Folder of `build.sbt`, relative to the project root (`""` for the root itself).
|
||||
pub dir: String,
|
||||
/// The launcher: a `sbt` / `sbtx` script in the build folder, else `sbt` on `PATH`.
|
||||
pub command: String,
|
||||
/// `sbt.version` of `project/build.properties`.
|
||||
pub version: Option<String>,
|
||||
/// The root project first, then the declared projects in source order.
|
||||
pub projects: Vec<SbtProject>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct SbtProject {
|
||||
/// The project id tasks are scoped with (`core/compile`).
|
||||
pub id: String,
|
||||
/// Base folder relative to the build folder (`""` for the build's own).
|
||||
pub dir: String,
|
||||
/// The build's root project: its tasks run unscoped (and aggregate when sbt does).
|
||||
pub root: bool,
|
||||
}
|
||||
|
||||
/// The sbt builds under `root` (outermost `build.sbt` folders).
|
||||
pub fn load(root: &Path) -> Vec<SbtBuild> {
|
||||
ide_core::project_roots::discover(root, &["build.sbt"])
|
||||
.into_iter()
|
||||
.filter_map(|dir| {
|
||||
let text = std::fs::read_to_string(dir.join("build.sbt")).ok()?;
|
||||
let rel = dir.strip_prefix(root).unwrap_or(&dir).to_string_lossy().replace('\\', "/");
|
||||
let name = dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| "root".to_owned());
|
||||
Some(SbtBuild {
|
||||
dir: rel,
|
||||
command: launcher(&dir),
|
||||
version: build_version(&dir),
|
||||
projects: projects(&text, &name),
|
||||
})
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn launcher(dir: &Path) -> String {
|
||||
for script in ["sbt", "sbtx"] {
|
||||
if !cfg!(windows) && dir.join(script).is_file() {
|
||||
return format!("./{script}");
|
||||
}
|
||||
}
|
||||
if cfg!(windows) && dir.join("sbt.bat").is_file() {
|
||||
return "sbt.bat".to_owned();
|
||||
}
|
||||
"sbt".to_owned()
|
||||
}
|
||||
|
||||
fn build_version(dir: &Path) -> Option<String> {
|
||||
let text = std::fs::read_to_string(dir.join("project/build.properties")).ok()?;
|
||||
text.lines().find_map(|line| {
|
||||
let (key, value) = line.split_once('=')?;
|
||||
(key.trim() == "sbt.version").then(|| value.trim().to_owned())
|
||||
})
|
||||
}
|
||||
|
||||
/// `text` with comments and the contents of string literals blanked (quotes kept),
|
||||
/// byte for byte, so offsets into it are offsets into `text`.
|
||||
fn mask(text: &str) -> String {
|
||||
let mut out = String::with_capacity(text.len());
|
||||
let blank = |out: &mut String, c: char| {
|
||||
if c == '\n' {
|
||||
out.push('\n');
|
||||
} else {
|
||||
out.extend(std::iter::repeat_n(' ', c.len_utf8()));
|
||||
}
|
||||
};
|
||||
let mut chars = text.chars().peekable();
|
||||
while let Some(c) = chars.next() {
|
||||
match c {
|
||||
'"' => {
|
||||
out.push('"');
|
||||
let mut ahead = chars.clone();
|
||||
if ahead.next() == Some('"') && ahead.next() == Some('"') {
|
||||
// `"""…"""`: no escapes inside.
|
||||
chars.next();
|
||||
chars.next();
|
||||
out.push_str("\"\"");
|
||||
let mut quotes = 0;
|
||||
for c in chars.by_ref() {
|
||||
quotes = if c == '"' { quotes + 1 } else { 0 };
|
||||
if quotes > 0 {
|
||||
out.push('"')
|
||||
} else {
|
||||
blank(&mut out, c)
|
||||
}
|
||||
if quotes == 3 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
while let Some(c) = chars.next() {
|
||||
if c == '"' || c == '\n' {
|
||||
out.push(c);
|
||||
break;
|
||||
}
|
||||
blank(&mut out, c);
|
||||
if c == '\\'
|
||||
&& let Some(n) = chars.next()
|
||||
{
|
||||
blank(&mut out, n);
|
||||
}
|
||||
}
|
||||
}
|
||||
'/' if chars.peek() == Some(&'/') => {
|
||||
blank(&mut out, c);
|
||||
for c in chars.by_ref() {
|
||||
blank(&mut out, c);
|
||||
if c == '\n' {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
'/' if chars.peek() == Some(&'*') => {
|
||||
blank(&mut out, c);
|
||||
let mut prev = ' ';
|
||||
for c in chars.by_ref() {
|
||||
blank(&mut out, c);
|
||||
if prev == '*' && c == '/' {
|
||||
break;
|
||||
}
|
||||
prev = c;
|
||||
}
|
||||
}
|
||||
_ => out.push(c),
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn identifier(s: &str) -> Option<(&str, &str)> {
|
||||
let s = s.trim_start();
|
||||
if let Some(rest) = s.strip_prefix('`') {
|
||||
let end = rest.find('`')?;
|
||||
return Some((&rest[..end], &rest[end + 1..]));
|
||||
}
|
||||
let end = s.find(|c: char| !(c.is_alphanumeric() || c == '_')).unwrap_or(s.len());
|
||||
(end > 0).then(|| (&s[..end], &s[end..]))
|
||||
}
|
||||
|
||||
/// The string literal at the start of `s` (after spaces), and the rest.
|
||||
fn string_literal(s: &str) -> Option<(&str, &str)> {
|
||||
let rest = s.trim_start().strip_prefix('"')?;
|
||||
let end = rest.find('"')?;
|
||||
Some((&rest[..end], &rest[end + 1..]))
|
||||
}
|
||||
|
||||
/// The folder of a `file("x")` / `new File("x")` at the start of `s`.
|
||||
fn file_arg(s: &str) -> Option<&str> {
|
||||
let s = s.trim_start();
|
||||
let s = s.strip_prefix("file").or_else(|| s.strip_prefix("new File"))?;
|
||||
let s = s.trim_start().strip_prefix('(')?;
|
||||
string_literal(s).map(|(dir, _)| dir)
|
||||
}
|
||||
|
||||
fn normalize_dir(dir: &str) -> String {
|
||||
let dir = dir.trim_start_matches("./").trim_end_matches('/');
|
||||
if dir == "." { String::new() } else { dir.to_owned() }
|
||||
}
|
||||
|
||||
/// What a `lazy val <id> = <rhs>` declares: a project and its base folder. `rhs` is
|
||||
/// masked (see [`mask`]); `original` is the same text unmasked, for the folder names.
|
||||
fn project_of(id: &str, rhs: &str, original: &str) -> Option<String> {
|
||||
let at = |s: &str| original.get(rhs.len() - s.len()..).unwrap_or_default();
|
||||
let rhs = rhs.trim_start().trim_start_matches('(').trim_start();
|
||||
if let Some(rest) = rhs.strip_prefix("Project") {
|
||||
// `Project("id", file("dir"))` / `Project(id = "x", base = file("dir"))`.
|
||||
let args = rest.trim_start().strip_prefix('(')?;
|
||||
let base = args.find("file(").or_else(|| args.find("new File("))?;
|
||||
return file_arg(at(&args[base..])).map(normalize_dir);
|
||||
}
|
||||
let rest = rhs.strip_prefix("project")?;
|
||||
if rest.starts_with(|c: char| c.is_alphanumeric() || c == '_') {
|
||||
return None;
|
||||
}
|
||||
let rest = rest.trim_start();
|
||||
let located = rest
|
||||
.strip_prefix(".in")
|
||||
.and_then(|r| r.trim_start().strip_prefix('('))
|
||||
.or_else(|| rest.strip_prefix("in ").or_else(|| rest.strip_prefix("in\t")));
|
||||
Some(match located.and_then(|l| file_arg(at(l))) {
|
||||
Some(dir) => normalize_dir(dir),
|
||||
None => id.to_owned(),
|
||||
})
|
||||
}
|
||||
|
||||
/// The projects a build definition declares; `name` is the build folder's name, the id
|
||||
/// sbt gives an implicit root project.
|
||||
pub fn projects(text: &str, name: &str) -> Vec<SbtProject> {
|
||||
let masked = mask(text);
|
||||
let mut out: Vec<SbtProject> = Vec::new();
|
||||
let mut from = 0;
|
||||
while let Some(found) = masked[from..].find("val ") {
|
||||
let at = from + found;
|
||||
from = at + 4;
|
||||
if masked[..at].chars().last().is_some_and(|c| c.is_alphanumeric() || c == '_') {
|
||||
continue;
|
||||
}
|
||||
let Some((id, tail)) = identifier(&masked[from..]) else { continue };
|
||||
let Some(rhs) = tail.trim_start().strip_prefix('=') else { continue };
|
||||
if rhs.starts_with('=') || rhs.starts_with('>') {
|
||||
continue;
|
||||
}
|
||||
let Some(dir) = project_of(id, rhs, &text[masked.len() - rhs.len()..]) else { continue };
|
||||
if !out.iter().any(|p| p.id == id) {
|
||||
out.push(SbtProject { id: id.to_owned(), root: dir.is_empty(), dir });
|
||||
}
|
||||
}
|
||||
match out.iter().position(|p| p.root) {
|
||||
Some(i) => {
|
||||
let root = out.remove(i);
|
||||
out.insert(0, root);
|
||||
}
|
||||
None => out.insert(0, SbtProject { id: name.to_owned(), dir: String::new(), root: true }),
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn ids(text: &str) -> Vec<(String, String, bool)> {
|
||||
projects(text, "shop").into_iter().map(|p| (p.id, p.dir, p.root)).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn single_project_builds_have_an_implicit_root() {
|
||||
assert_eq!(
|
||||
ids("ThisBuild / scalaVersion := \"3.3.4\"\nname := \"shop\"\n"),
|
||||
[("shop".into(), "".into(), true)]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn declared_projects_and_their_folders() {
|
||||
let text = r#"
|
||||
// lazy val commented = project
|
||||
lazy val root = (project in file("."))
|
||||
.aggregate(core, `web-app`, util)
|
||||
.settings(name := "shop")
|
||||
|
||||
lazy val core = project
|
||||
lazy val `web-app` = (project in file("modules/web")).dependsOn(core)
|
||||
lazy val util = project.in(file("libs/util/"))
|
||||
lazy val legacy = Project("legacy", file("old"))
|
||||
/* lazy val hidden = project */
|
||||
val description = "lazy val fake = project"
|
||||
lazy val projectSettings = Seq(scalacOptions += "-deprecation")
|
||||
"#;
|
||||
assert_eq!(
|
||||
ids(text),
|
||||
[
|
||||
("root".into(), "".into(), true),
|
||||
("core".into(), "core".into(), false),
|
||||
("web-app".into(), "modules/web".into(), false),
|
||||
("util".into(), "libs/util".into(), false),
|
||||
("legacy".into(), "old".into(), false),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_root_declared_last_is_listed_first() {
|
||||
let text = "lazy val api = project\nlazy val all = (project in file(\".\")).aggregate(api)\n";
|
||||
assert_eq!(ids(text), [("all".into(), "".into(), true), ("api".into(), "api".into(), false)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn builds_are_found_with_their_launcher_and_version() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path();
|
||||
std::fs::create_dir_all(root.join("svc/project")).unwrap();
|
||||
std::fs::create_dir_all(root.join("svc/core")).unwrap();
|
||||
std::fs::write(root.join("svc/build.sbt"), "lazy val core = project\n").unwrap();
|
||||
// A project's own build.sbt is part of the outer build.
|
||||
std::fs::write(root.join("svc/core/build.sbt"), "libraryDependencies += \"a\" % \"b\" % \"1\"\n").unwrap();
|
||||
std::fs::write(root.join("svc/project/build.properties"), "sbt.version = 1.10.7\n").unwrap();
|
||||
let builds = load(root);
|
||||
assert_eq!(builds.len(), 1);
|
||||
let b = &builds[0];
|
||||
assert_eq!((b.dir.as_str(), b.command.as_str(), b.version.as_deref()), ("svc", "sbt", Some("1.10.7")));
|
||||
assert_eq!(b.projects.iter().map(|p| p.id.as_str()).collect::<Vec<_>>(), ["svc", "core"]);
|
||||
}
|
||||
}
|
||||
@@ -279,6 +279,18 @@ type Session = Arc<tokio::sync::Mutex<Option<Held>>>;
|
||||
|
||||
const MAX_META_ROWS: usize = 100_000;
|
||||
|
||||
/// Rows of catalog query `q`, run again as [`sql::postgres_legacy`] when a PostgreSQL server's
|
||||
/// catalog lacks a column it reads (openGauss, PostgreSQL 9).
|
||||
async fn catalog_rows(pool: &Pool, q: &str) -> IdeResult<Vec<Vec<Option<String>>>> {
|
||||
match pool.rows(q, MAX_META_ROWS).await {
|
||||
Err(e) if pool.driver() == DbDriver::Postgres => match sql::postgres_legacy(q) {
|
||||
Some(legacy) => pool.rows(&legacy, MAX_META_ROWS).await.map_err(|_| e),
|
||||
None => Err(e),
|
||||
},
|
||||
rows => rows,
|
||||
}
|
||||
}
|
||||
|
||||
fn flag(v: &Option<String>) -> bool {
|
||||
matches!(v.as_deref(), Some("1" | "t" | "true" | "YES"))
|
||||
}
|
||||
@@ -1079,8 +1091,7 @@ impl DbManager {
|
||||
let driver = pool.driver();
|
||||
let mut out = SchemaObjects::default();
|
||||
if let Some(q) = sql::routines(driver, schema) {
|
||||
out.routines = pool
|
||||
.rows(&q, MAX_META_ROWS)
|
||||
out.routines = catalog_rows(&pool, &q)
|
||||
.await?
|
||||
.into_iter()
|
||||
.filter_map(|r| {
|
||||
|
||||
@@ -219,6 +219,9 @@ pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {
|
||||
}
|
||||
|
||||
/// Rows: `index name, unique (0/1), column` (one row per indexed column, in order).
|
||||
// Key columns are paired from one series up to `max_index_keys` (the server's INDEX_MAX_KEYS, the
|
||||
// most columns an index or key has): unlike a series per catalog row, it lets the planner find the
|
||||
// table's rows through the catalog's index first.
|
||||
pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
|
||||
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
|
||||
match driver {
|
||||
@@ -236,8 +239,8 @@ pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
|
||||
"SELECT i.relname, CASE WHEN ix.indisunique THEN 1 ELSE 0 END, a.attname \
|
||||
FROM pg_index ix JOIN pg_class t ON t.oid = ix.indrelid JOIN pg_class i ON i.oid = ix.indexrelid \
|
||||
JOIN pg_namespace n ON n.oid = t.relnamespace \
|
||||
JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord) ON true \
|
||||
JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum \
|
||||
JOIN generate_series(0, current_setting('max_index_keys')::int - 1) AS k(ord) ON k.ord < ix.indnatts \
|
||||
JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ix.indkey[k.ord] \
|
||||
WHERE n.nspname = {s} AND t.relname = {t} ORDER BY i.relname, k.ord"
|
||||
),
|
||||
DbDriver::Mysql => format!(
|
||||
@@ -284,12 +287,15 @@ pub fn completion_columns(driver: DbDriver) -> &'static str {
|
||||
FROM sqlite_master m JOIN pragma_table_info(m.name) p \
|
||||
WHERE m.type IN ('table', 'view') AND m.name NOT LIKE 'sqlite\\_%' ESCAPE '\\' ORDER BY m.name, p.cid"
|
||||
}
|
||||
// Identity columns own their sequence through an internal dependency (`attidentity` is PostgreSQL 10+).
|
||||
DbDriver::Postgres => {
|
||||
"SELECT n.nspname, c.relname, CASE c.relkind WHEN 'v' THEN 'view' WHEN 'm' THEN 'materialized view' ELSE 'table' END, a.attname, \
|
||||
format_type(a.atttypid, a.atttypmod), CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END, \
|
||||
CASE WHEN EXISTS (SELECT 1 FROM pg_index i WHERE i.indrelid = c.oid AND i.indisprimary \
|
||||
AND a.attnum = ANY(i.indkey)) THEN 1 ELSE 0 END, \
|
||||
CASE WHEN a.atthasdef OR a.attidentity <> '' THEN 1 ELSE 0 END \
|
||||
CASE WHEN a.atthasdef OR EXISTS (SELECT 1 FROM pg_depend d WHERE d.refclassid = 'pg_class'::regclass \
|
||||
AND d.refobjid = c.oid AND d.refobjsubid = a.attnum AND d.classid = 'pg_class'::regclass \
|
||||
AND d.deptype = 'i') THEN 1 ELSE 0 END \
|
||||
FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace JOIN pg_attribute a ON a.attrelid = c.oid \
|
||||
WHERE c.relkind IN ('r', 'v', 'm', 'p', 'f') AND a.attnum > 0 AND NOT a.attisdropped \
|
||||
AND n.nspname NOT IN ('pg_catalog', 'information_schema') \
|
||||
@@ -363,9 +369,9 @@ pub fn foreign_keys(driver: DbDriver) -> &'static str {
|
||||
FROM pg_constraint con \
|
||||
JOIN pg_class sc ON sc.oid = con.conrelid JOIN pg_namespace sn ON sn.oid = sc.relnamespace \
|
||||
JOIN pg_class tc ON tc.oid = con.confrelid JOIN pg_namespace tn ON tn.oid = tc.relnamespace \
|
||||
CROSS JOIN LATERAL unnest(con.conkey, con.confkey) WITH ORDINALITY AS k(s, t, ord) \
|
||||
JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = k.s \
|
||||
JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = k.t \
|
||||
JOIN generate_series(1, current_setting('max_index_keys')::int) AS k(ord) ON k.ord <= array_upper(con.conkey, 1) \
|
||||
JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = con.conkey[k.ord] \
|
||||
JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = con.confkey[k.ord] \
|
||||
WHERE con.contype = 'f' AND sn.nspname NOT IN ('pg_catalog', 'information_schema') \
|
||||
ORDER BY 1, 2, 3, k.ord LIMIT 20000"
|
||||
}
|
||||
@@ -408,7 +414,7 @@ pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String
|
||||
"SELECT {s}, {t}, f.id, f.\"from\", {s}, f.\"table\", f.\"to\" FROM pragma_foreign_key_list({t}, {s}) f ORDER BY f.id, f.seq"
|
||||
),
|
||||
DbDriver::Postgres => format!(
|
||||
"SELECT sn.nspname, sc.relname, con.conname, sa.attname, tn.nspname, tc.relname, ta.attname FROM pg_constraint con JOIN pg_class sc ON sc.oid = con.conrelid JOIN pg_namespace sn ON sn.oid = sc.relnamespace JOIN pg_class tc ON tc.oid = con.confrelid JOIN pg_namespace tn ON tn.oid = tc.relnamespace CROSS JOIN LATERAL unnest(con.conkey, con.confkey) WITH ORDINALITY AS k(s, t, ord) JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = k.s JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = k.t WHERE con.contype = 'f' AND sn.nspname = {s} AND sc.relname = {t} ORDER BY 3, k.ord"
|
||||
"SELECT sn.nspname, sc.relname, con.conname, sa.attname, tn.nspname, tc.relname, ta.attname FROM pg_constraint con JOIN pg_class sc ON sc.oid = con.conrelid JOIN pg_namespace sn ON sn.oid = sc.relnamespace JOIN pg_class tc ON tc.oid = con.confrelid JOIN pg_namespace tn ON tn.oid = tc.relnamespace JOIN generate_series(1, current_setting('max_index_keys')::int) AS k(ord) ON k.ord <= array_upper(con.conkey, 1) JOIN pg_attribute sa ON sa.attrelid = sc.oid AND sa.attnum = con.conkey[k.ord] JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = con.confkey[k.ord] WHERE con.contype = 'f' AND sn.nspname = {s} AND sc.relname = {t} ORDER BY 3, k.ord"
|
||||
),
|
||||
DbDriver::Mysql => format!(
|
||||
"SELECT table_schema, table_name, constraint_name, column_name, referenced_table_schema, referenced_table_name, referenced_column_name FROM information_schema.key_column_usage WHERE referenced_table_name IS NOT NULL AND table_schema = {s} AND table_name = {t} ORDER BY constraint_name, ordinal_position"
|
||||
@@ -671,6 +677,16 @@ pub fn sqlite_trigger_event(sql: &str) -> (String, String) {
|
||||
(timing.to_owned(), event.to_ascii_lowercase())
|
||||
}
|
||||
|
||||
/// PostgreSQL catalog query `sql` of this module for servers whose catalog predates a column
|
||||
/// it reads: PostgreSQL before 11 (`prokind`), and the servers built on an older PostgreSQL
|
||||
/// (openGauss, GaussDB). `None` when it reads none.
|
||||
pub fn postgres_legacy(sql: &str) -> Option<String> {
|
||||
let legacy = sql
|
||||
.replace("CASE WHEN p.prokind = 'p' THEN 'procedure' ELSE 'function' END", "'function'")
|
||||
.replace("p.prokind IN ('f', 'p')", "NOT p.proisagg AND NOT p.proiswindow");
|
||||
(legacy != sql).then_some(legacy)
|
||||
}
|
||||
|
||||
/// Rows: `name, kind (function/procedure), arguments, result` of a schema's routines (none in SQLite).
|
||||
pub fn routines(driver: DbDriver, schema: &str) -> Option<String> {
|
||||
let s = quote_literal(driver, schema);
|
||||
@@ -1172,4 +1188,32 @@ mod tests {
|
||||
assert_eq!(crate::conn::begin_statement(driver), "BEGIN");
|
||||
assert_eq!(crate::plan::explain_statement(driver, "select 1;"), "EXPLAIN USING TABULAR select 1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn postgres_catalog_queries_run_on_older_servers() {
|
||||
let pg = DbDriver::Postgres;
|
||||
// Neither LATERAL (9.3), WITH ORDINALITY (9.4) nor attidentity (10) in any metadata query:
|
||||
// openGauss / GaussDB parse 9.2's grammar and catalog. `prokind` (11) has its legacy rerun.
|
||||
let queries = [
|
||||
schemas(pg, false).to_owned(),
|
||||
schemas(pg, true).to_owned(),
|
||||
tables(pg, "s"),
|
||||
columns(pg, "s", "t"),
|
||||
indexes(pg, "s", "t"),
|
||||
completion_columns(pg).to_owned(),
|
||||
foreign_keys(pg).to_owned(),
|
||||
table_foreign_keys(pg, "s", "t"),
|
||||
triggers(pg, "s", "t"),
|
||||
routines(pg, "s").unwrap(),
|
||||
sequences(pg, "s").unwrap(),
|
||||
];
|
||||
for q in queries {
|
||||
let upper = q.to_uppercase();
|
||||
assert!(!["LATERAL", "ORDINALITY", "ATTIDENTITY"].iter().any(|w| upper.contains(w)), "{q}");
|
||||
}
|
||||
assert_eq!(postgres_legacy(completion_columns(pg)), None);
|
||||
let routines = postgres_legacy(&routines(pg, "s").unwrap()).unwrap();
|
||||
assert!(!routines.contains("prokind") && routines.contains("NOT p.proisagg"));
|
||||
assert_eq!(postgres_legacy(&indexes(pg, "s", "t")), None);
|
||||
}
|
||||
}
|
||||
@@ -133,3 +133,98 @@ async fn a_reused_physical_connection_restores_the_full_default_path() -> IdeRes
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Indexes, foreign keys, routines and completion read the catalog with queries every
|
||||
/// PostgreSQL-protocol server answers, back to the 9.2 core of openGauss / GaussDB (#3637).
|
||||
#[tokio::test]
|
||||
async fn table_details_routines_and_completion_on_older_catalogs() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let Some(db) = manager(&tmp).await else { return Ok(()) };
|
||||
let c = CancellationToken::new();
|
||||
for stmt in [
|
||||
"DROP SCHEMA IF EXISTS oi_meta CASCADE",
|
||||
"CREATE SCHEMA oi_meta",
|
||||
"CREATE TABLE oi_meta.orders (region INT, id INT, note TEXT DEFAULT 'x', PRIMARY KEY (region, id))",
|
||||
"CREATE TABLE oi_meta.lines (n INT PRIMARY KEY, o_region INT, o_id INT, \
|
||||
FOREIGN KEY (o_region, o_id) REFERENCES oi_meta.orders (region, id))",
|
||||
"CREATE INDEX lines_order ON oi_meta.lines (o_id, o_region)",
|
||||
"CREATE FUNCTION oi_meta.twice(v INT) RETURNS INT AS 'SELECT v * 2' LANGUAGE sql",
|
||||
] {
|
||||
db.execute("p", stmt, 10, &c).await?;
|
||||
}
|
||||
let details = db.table_details("p", "oi_meta", "lines").await?;
|
||||
let index = details.indexes.iter().find(|i| i.name == "lines_order").expect("lines_order");
|
||||
assert_eq!(index.columns, ["o_id", "o_region"]);
|
||||
assert!(!index.unique);
|
||||
assert_eq!(details.foreign_keys.len(), 1, "{:?}", details.foreign_keys);
|
||||
assert_eq!(details.foreign_keys[0].columns, ["o_region", "o_id"]);
|
||||
assert_eq!(details.foreign_keys[0].ref_columns, ["region", "id"]);
|
||||
let orders = db.table_details("p", "oi_meta", "orders").await?;
|
||||
let key = orders.indexes.iter().find(|i| i.unique).expect("primary key index");
|
||||
assert_eq!(key.columns, ["region", "id"]);
|
||||
|
||||
let objects = db.schema_objects("p", "oi_meta").await?;
|
||||
assert!(objects.routines.iter().any(|r| r.name == "twice"), "{:?}", objects.routines);
|
||||
let completion = db.completion("p").await?;
|
||||
assert!(completion.tables.iter().any(|t| t.schema == "oi_meta" && t.name == "orders"));
|
||||
db.execute("p", "DROP SCHEMA oi_meta CASCADE", 10, &c).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Opening a table pairs the columns of composite keys in order, also when a foreign key lists
|
||||
/// them in another order than the key it references; its data page and DDL read the same catalog,
|
||||
/// and completion tells identity columns apart in one query (#3637).
|
||||
#[tokio::test]
|
||||
async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let Some(db) = manager(&tmp).await else { return Ok(()) };
|
||||
let c = CancellationToken::new();
|
||||
for stmt in [
|
||||
"DROP SCHEMA IF EXISTS oi_keys CASCADE",
|
||||
"CREATE SCHEMA oi_keys",
|
||||
"CREATE TABLE oi_keys.pairs (a INT, b INT, PRIMARY KEY (b, a))",
|
||||
"CREATE TABLE oi_keys.refs (id INT PRIMARY KEY, x INT, y INT, FOREIGN KEY (y, x) REFERENCES oi_keys.pairs (b, a))",
|
||||
"CREATE UNIQUE INDEX refs_yx ON oi_keys.refs (y, x)",
|
||||
"INSERT INTO oi_keys.pairs VALUES (1, 2)",
|
||||
"INSERT INTO oi_keys.refs VALUES (7, 1, 2)",
|
||||
] {
|
||||
db.execute("p", stmt, 10, &c).await?;
|
||||
}
|
||||
|
||||
let details = db.table_details("p", "oi_keys", "refs").await?;
|
||||
let indexes: Vec<_> = details.indexes.iter().map(|i| (i.name.as_str(), i.unique, i.columns.join(","))).collect();
|
||||
assert_eq!(indexes, [("refs_pkey", true, "id".into()), ("refs_yx", true, "y,x".into())]);
|
||||
let key = |k: &ide_db::ForeignKey| (k.columns.join(","), k.ref_table.clone(), k.ref_columns.join(","));
|
||||
assert_eq!(
|
||||
details.foreign_keys.iter().map(key).collect::<Vec<_>>(),
|
||||
[("y,x".into(), "pairs".into(), "b,a".into())]
|
||||
);
|
||||
let pairs = db.table_details("p", "oi_keys", "pairs").await?;
|
||||
assert_eq!(pairs.indexes[0].columns, ["b", "a"]);
|
||||
|
||||
let page = db.table_page("p", "oi_keys", "refs", None, &[], 0, 10, &c).await?;
|
||||
assert_eq!(page.result.rows.len(), 1);
|
||||
// Identity columns (PostgreSQL 10+; openGauss has none) are optional in INSERT.
|
||||
let identity =
|
||||
db.execute("p", "CREATE TABLE oi_keys.ids (n INT GENERATED ALWAYS AS IDENTITY, v INT)", 10, &c).await;
|
||||
let completion = db.completion("p").await?;
|
||||
if identity.is_ok() {
|
||||
let ids = completion.tables.iter().find(|t| t.schema == "oi_keys" && t.name == "ids").expect("ids");
|
||||
let defaults: Vec<_> = ids.columns.iter().map(|c| (c.name.as_str(), c.has_default)).collect();
|
||||
assert_eq!(defaults, [("n", true), ("v", false)]);
|
||||
}
|
||||
assert!(
|
||||
completion.foreign_keys.iter().any(|k| k.table == "refs" && key(k).2 == "b,a"),
|
||||
"{:?}",
|
||||
completion.foreign_keys
|
||||
);
|
||||
// The other catalog reads of the tree and its DDL actions, on the same server.
|
||||
assert!(db.schemas("p").await?.iter().any(|s| s == "oi_keys"));
|
||||
assert_eq!(db.tables("p", "oi_keys").await?.len(), if identity.is_ok() { 3 } else { 2 });
|
||||
db.execute("p", "CREATE SEQUENCE oi_keys.seq", 10, &c).await?;
|
||||
let objects = db.schema_objects("p", "oi_keys").await?;
|
||||
assert_eq!(objects.sequences.len(), 1);
|
||||
assert!(db.ddl("p", "oi_keys", "refs").await?.contains("FOREIGN KEY"));
|
||||
db.execute("p", "DROP SCHEMA oi_keys CASCADE", 10, &c).await?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -320,7 +320,8 @@ fn rename_failure(error: &io::Error) -> RenameFailure {
|
||||
}
|
||||
|
||||
/// Only Windows splits these paths. Renames are cheap; cross-volume copies run in
|
||||
/// the background. Consumers always use Local, even when migration fails.
|
||||
/// the background. Consumers always use Local, even when migration fails. On every
|
||||
/// system, tool virtual environments moved from elsewhere are dropped (#3581).
|
||||
pub fn migrate(data: &Path, local: &Path) {
|
||||
if cfg!(target_os = "windows") && data != local {
|
||||
migrate_entries(data, local);
|
||||
@@ -328,6 +329,7 @@ pub fn migrate(data: &Path, local: &Path) {
|
||||
if cfg!(target_os = "windows") {
|
||||
relative_tool_shims(&local.join("tools"));
|
||||
}
|
||||
ide_tools::drop_moved_venvs(&local.join("tools"));
|
||||
}
|
||||
|
||||
/// Wrappers written before they named their tool relative to themselves hold its absolute
|
||||
|
||||
@@ -532,6 +532,14 @@ impl Host {
|
||||
}
|
||||
}
|
||||
|
||||
impl Host {
|
||||
/// Lists the JDKs added by hand (global Settings › SDKs) with the detected ones.
|
||||
pub fn apply_added_jdks(&self) {
|
||||
let homes = self.global_settings.effective().languages.java.added_jdks;
|
||||
ide_sdk::java::set_added_jdks(homes.into_iter().map(PathBuf::from));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -565,11 +573,3 @@ mod tests {
|
||||
host.close_project("main");
|
||||
}
|
||||
}
|
||||
|
||||
impl Host {
|
||||
/// Lists the JDKs added by hand (global Settings › SDKs) with the detected ones.
|
||||
pub fn apply_added_jdks(&self) {
|
||||
let homes = self.global_settings.effective().languages.java.added_jdks;
|
||||
ide_sdk::java::set_added_jdks(homes.into_iter().map(PathBuf::from));
|
||||
}
|
||||
}
|
||||
@@ -167,7 +167,10 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
|
||||
}
|
||||
call.confirm(&subject, Some(detail)).await?;
|
||||
|
||||
let exchange = ide_http::run(input, &call.cancel).await?;
|
||||
// Exactly the request the user approved: preparing it again would read the
|
||||
// environment files again, which may name another destination by now.
|
||||
let redact_url = prepared.url.clone();
|
||||
let exchange = ide_http::send(prepared, Some(&path), &call.cancel).await?;
|
||||
let history = call.project().http_history.clone();
|
||||
let saved = exchange.clone();
|
||||
let _ = call.host().blocking(move || history.add(&saved)).await;
|
||||
@@ -188,7 +191,7 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
|
||||
"status": response.map(|r| r.status),
|
||||
"statusText": response.map(|r| r.status_text.clone()),
|
||||
"totalMs": response.map(|r| r.total_ms).or(exchange.entry.total_ms),
|
||||
"error": redact_transport_error(exchange.entry.error.clone(), &prepared.url),
|
||||
"error": redact_transport_error(exchange.entry.error.clone(), &redact_url),
|
||||
"body": body,
|
||||
"bodyTruncated": body_truncated,
|
||||
}))
|
||||
|
||||
@@ -128,9 +128,11 @@ pub fn run_command() -> Tool {
|
||||
&format!(
|
||||
"Runs a shell command line in a new or reused tab of OpenIDEA's Run tool window, with the shell of \
|
||||
Settings › Tools › Terminal. The user is asked first (unless the IDE runs tools without \
|
||||
confirmation). Waits up to `timeout` milliseconds (default {RUN_TIMEOUT_MS}) for the command to finish; a command \
|
||||
still running then keeps running, and `wait_for_run`, `read_run_output`, `get_run_status`, `send_run_input` and \
|
||||
`stop_run` follow it up by name. Returns the tab's status (`state`: starting, running, stopping, succeeded, failed, \
|
||||
confirmation). Waits up to `timeout` milliseconds (default {RUN_TIMEOUT_MS}) for the command to finish, or until its \
|
||||
output matches `pattern`; a command still running then keeps running, and `wait_for_run`, `read_run_output`, \
|
||||
`get_run_status`, `send_run_input` and `stop_run` follow it up by name. A server, watcher or app never finishes: to \
|
||||
start one, pass `pattern` for the line it prints once ready (e.g. `Listening on|Started .* in|ready in`) rather than \
|
||||
a long `timeout`, so the call returns as soon as it is up. Returns the tab's status (`state`: starting, running, stopping, succeeded, failed, \
|
||||
crashed, stoppedByAgent, stoppedByUser or startFailed; `exitCode`; `crash` with the signal or exception of a crashed \
|
||||
process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
|
||||
),
|
||||
@@ -152,6 +154,7 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
|
||||
};
|
||||
let env = call.args.get("envs").filter(|v| !v.is_null()).map(|_| call.str_map("envs")).transpose()?;
|
||||
let deadline = deadline(&call, RUN_TIMEOUT_MS)?;
|
||||
let ready = pattern(&call)?;
|
||||
let host = call.host();
|
||||
let runs = &host.mcp_agent_runs;
|
||||
if let Some(run) = runs.get(call.root(), &name).filter(|r| r.running()) {
|
||||
@@ -185,7 +188,7 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
|
||||
return Err(IdeError::invalid(format!("`{name}` did not start: {error}")));
|
||||
}
|
||||
let from = run.process_offset();
|
||||
let end = run.wait(deadline, None, from, &call.cancel).await?;
|
||||
let end = run.wait(deadline, ready.as_ref(), from, &call.cancel).await?;
|
||||
let mut extra = output_view(&call, &run, from)?;
|
||||
extra.insert("waitEnded".into(), end.as_str().into());
|
||||
result(&run, extra)
|
||||
@@ -209,6 +212,12 @@ process) and its output so far.{OUTPUT}{SEQUENCE}{INTERVENTIONS}"
|
||||
ParamType::Integer,
|
||||
"Milliseconds to wait for the command to finish before returning (0 returns once it started); the command \
|
||||
keeps running after it",
|
||||
))
|
||||
.param(Param::optional(
|
||||
"pattern",
|
||||
ParamType::String,
|
||||
"Regular expression that ends the wait when the command's output matches it: the ready line of a server or \
|
||||
watcher. `waitEnded` is then `matched`",
|
||||
))
|
||||
.param(Param::optional("maxLinesCount", ParamType::Integer, MAX_LINES))
|
||||
.param(Param::optional("truncateMode", ParamType::String, TRUNCATE_MODE))
|
||||
|
||||
@@ -748,9 +748,15 @@ async fn file_search(call: Call) -> IdeResult<Output> {
|
||||
// Ignored names and "Exclude files" patterns, which `read_dir` does not flag.
|
||||
let excludes = if include_excluded { None } else { Some(FileMask::new(&[], &call.project().search_excludes())?) };
|
||||
let root = call.root().to_path_buf();
|
||||
// The project folder and the content roots outside it.
|
||||
// The project folder and the content roots its walk does not cover: those outside it and
|
||||
// those inside it that it skips as ignored.
|
||||
let roots: Vec<PathBuf> = std::iter::once(root.clone())
|
||||
.chain(call.project().content_roots().into_iter().filter(|r| relative_to_root(&root, r).is_none()))
|
||||
.chain(
|
||||
call.project()
|
||||
.content_roots()
|
||||
.into_iter()
|
||||
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r)),
|
||||
)
|
||||
.collect();
|
||||
let host = call.host();
|
||||
let walk = Walk {
|
||||
|
||||
@@ -8,7 +8,8 @@ use ide_agent::registry::{AgentRegistry, RegistryPaths};
|
||||
use ide_agent::{
|
||||
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentEntry,
|
||||
AgentEvent, AgentModelCatalog, AgentProbe, AgentPrompt, AgentProvider, AgentQueued, AgentTask, CustomAgentInput,
|
||||
ExternalSession, McpScope, McpServer, McpServerInput, NewAgentTask,
|
||||
ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput,
|
||||
McpTransport, NewAgentTask,
|
||||
};
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::{IdeError, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
|
||||
@@ -477,19 +478,21 @@ fn persist_mcp_map(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn update_mcp_maps<F>(host: &Host, window: &str, approve: Option<&str>, f: F) -> IdeResult<Vec<McpServer>>
|
||||
fn update_mcp_maps<F>(host: &Host, window: &str, approve: &[String], f: F) -> IdeResult<Vec<McpServer>>
|
||||
where
|
||||
F: FnOnce(&mut McpServerMap, &mut McpServerMap, Option<&std::path::Path>) -> Result<(), String>,
|
||||
F: FnOnce(&mut McpServerMap, &mut McpServerMap, Option<&std::path::Path>) -> Result<Vec<String>, String>,
|
||||
{
|
||||
let (mut user, mut workspace, project) = mcp_maps(host, window);
|
||||
let prev_user = user.clone();
|
||||
let prev_workspace = workspace.clone();
|
||||
let project_root = project.as_ref().map(|p| p.root.as_path());
|
||||
f(&mut user, &mut workspace, project_root).map_err(IdeError::invalid)?;
|
||||
if let (Some(name), Some(p)) = (approve, &project)
|
||||
&& let Some(server) = workspace.get(name)
|
||||
{
|
||||
host.mcp_approvals.approve(&p.root, name, server)?;
|
||||
let extra_approved = f(&mut user, &mut workspace, project_root).map_err(IdeError::invalid)?;
|
||||
if let Some(p) = &project {
|
||||
for name in approve.iter().chain(extra_approved.iter()) {
|
||||
if let Some(server) = workspace.get(name.as_str()) {
|
||||
host.mcp_approvals.approve(&p.root, name, server)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
if workspace != prev_workspace {
|
||||
persist_mcp_map(host, project.as_ref(), McpScope::Workspace, &workspace)?;
|
||||
@@ -507,11 +510,22 @@ fn listed(
|
||||
user: &McpServerMap,
|
||||
workspace: McpServerMap,
|
||||
) -> Vec<McpServer> {
|
||||
let raw_workspace = workspace.clone();
|
||||
let workspace = match project {
|
||||
Some(p) => host.mcp_approvals.apply(&p.root, workspace),
|
||||
None => workspace,
|
||||
};
|
||||
ide_agent::mcp::servers_from_settings(user, &workspace)
|
||||
let mut out = ide_agent::mcp::servers_from_settings(user, &workspace);
|
||||
if let Some(p) = project {
|
||||
for srv in &mut out {
|
||||
if srv.scope == McpScope::Workspace
|
||||
&& let Some(raw) = raw_workspace.get(&srv.name)
|
||||
{
|
||||
srv.unapproved = !host.mcp_approvals.approved(&p.root, &srv.name, raw);
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The MCP servers agent sessions of the project at `root` get: the user's, values filled in, and
|
||||
@@ -525,7 +539,8 @@ pub(crate) fn session_mcp_servers(
|
||||
use ide_workspace::settings::SettingsScope;
|
||||
let mut user = settings.layer(SettingsScope::Global).agents.mcp_servers;
|
||||
fill_mcp_values(secrets, &mut user);
|
||||
let workspace = approvals.apply(root, settings.layer(SettingsScope::Project).agents.mcp_servers);
|
||||
let mut workspace = settings.layer(SettingsScope::Project).agents.mcp_servers;
|
||||
workspace.retain(|name, srv| approvals.approved(root, name, srv));
|
||||
ide_agent::mcp::servers_from_settings(&user, &workspace)
|
||||
}
|
||||
|
||||
@@ -538,39 +553,289 @@ pub fn mcp_list(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
|
||||
/// Creates or updates a User or Workspace MCP server and returns the updated list. A Workspace
|
||||
/// server saved here is one the user turned on.
|
||||
pub fn mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<Vec<McpServer>> {
|
||||
let approve = (input.scope == McpScope::Workspace).then(|| input.name.trim().to_owned());
|
||||
update_mcp_maps(host, window, approve.as_deref(), |user, workspace, project_root| {
|
||||
ide_agent::mcp::apply_save(user, workspace, project_root.is_some(), input)
|
||||
let approve: Vec<String> =
|
||||
(input.scope == McpScope::Workspace).then(|| input.name.trim().to_owned()).into_iter().collect();
|
||||
update_mcp_maps(host, window, &approve, |user, workspace, project_root| {
|
||||
ide_agent::mcp::apply_save(user, workspace, project_root.is_some(), input).map(|()| Vec::new())
|
||||
})
|
||||
}
|
||||
|
||||
/// Parses and saves one or more MCP servers from a pasted JSON snippet (`{"mcpServers": {...}}` or
|
||||
/// single server object). Workspace servers explicitly saved here by the user are approved.
|
||||
pub fn mcp_save_json(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
scope: McpScope,
|
||||
raw_json: String,
|
||||
fallback_name: Option<String>,
|
||||
agents: Vec<String>,
|
||||
) -> IdeResult<Vec<McpServer>> {
|
||||
update_mcp_maps(host, window, &[], |user, workspace, project_root| {
|
||||
let saved = ide_agent::mcp::apply_save_json(
|
||||
user,
|
||||
workspace,
|
||||
project_root.is_some(),
|
||||
scope,
|
||||
&raw_json,
|
||||
fallback_name.as_deref(),
|
||||
agents,
|
||||
)?;
|
||||
Ok(if scope == McpScope::Workspace { saved } else { Vec::new() })
|
||||
})
|
||||
}
|
||||
|
||||
/// Enables or disables an MCP server and returns the updated list.
|
||||
pub fn mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) -> IdeResult<Vec<McpServer>> {
|
||||
let approve = ide_agent::mcp::parse_server_id(&id)
|
||||
let approve: Vec<String> = ide_agent::mcp::parse_server_id(&id)
|
||||
.filter(|(scope, _)| enabled && *scope == McpScope::Workspace)
|
||||
.map(|(_, name)| name.to_owned());
|
||||
update_mcp_maps(host, window, approve.as_deref(), |user, workspace, _| {
|
||||
ide_agent::mcp::apply_set_enabled(user, workspace, &id, enabled).map(|_| ())
|
||||
.map(|(_, name)| name.to_owned())
|
||||
.into_iter()
|
||||
.collect();
|
||||
update_mcp_maps(host, window, &approve, |user, workspace, _| {
|
||||
ide_agent::mcp::apply_set_enabled(user, workspace, &id, enabled).map(|_| Vec::new())
|
||||
})
|
||||
}
|
||||
|
||||
/// Removes a User or Workspace MCP server and returns the updated list.
|
||||
pub fn mcp_remove(host: &Host, window: &str, id: String) -> IdeResult<Vec<McpServer>> {
|
||||
update_mcp_maps(host, window, None, |user, workspace, _| {
|
||||
ide_agent::mcp::apply_remove(user, workspace, &id).map(|_| ())
|
||||
update_mcp_maps(host, window, &[], |user, workspace, _| {
|
||||
ide_agent::mcp::apply_remove(user, workspace, &id).map(|_| Vec::new())
|
||||
})
|
||||
}
|
||||
|
||||
/// Copies MCP servers from `.mcp.json` and `.vscode/mcp.json` into the workspace settings once;
|
||||
/// they stay off until the user turns them on.
|
||||
pub fn mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
|
||||
update_mcp_maps(host, window, None, |_, workspace, project_root| {
|
||||
update_mcp_maps(host, window, &[], |_, workspace, project_root| {
|
||||
let root = project_root.ok_or_else(|| "Open a project to import workspace MCP servers".to_string())?;
|
||||
ide_agent::mcp::apply_import(workspace, root);
|
||||
Ok(())
|
||||
Ok(Vec::new())
|
||||
})
|
||||
}
|
||||
|
||||
/// Discovers external MCP configuration files on disk (CLI user configs + workspace `.mcp.json`).
|
||||
pub async fn mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<McpExternalSource>> {
|
||||
let project_root = host.project(window).ok().filter(|p| !p.light).map(|p| p.root.clone());
|
||||
let home = dirs::home_dir();
|
||||
tokio::task::spawn_blocking(move || {
|
||||
ide_agent::mcp::discover_external_sources(home.as_deref(), project_root.as_deref())
|
||||
})
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))
|
||||
}
|
||||
|
||||
/// Imports selected servers from discovered external MCP configuration files into User or Workspace scope.
|
||||
/// Imported Workspace entries remain unapproved (disabled) until the user explicitly enables them.
|
||||
pub async fn mcp_import_selected(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
scope: McpScope,
|
||||
selections: Vec<McpImportSelection>,
|
||||
overwrite: bool,
|
||||
) -> IdeResult<Vec<McpServer>> {
|
||||
let home = dirs::home_dir();
|
||||
update_mcp_maps(host, window, &[], move |user, workspace, project_root| {
|
||||
ide_agent::mcp::apply_import_selected(
|
||||
user,
|
||||
workspace,
|
||||
home.as_deref(),
|
||||
project_root,
|
||||
scope,
|
||||
&selections,
|
||||
overwrite,
|
||||
)?;
|
||||
Ok(Vec::new())
|
||||
})
|
||||
}
|
||||
|
||||
/// Tests an MCP server by connecting (`initialize`) and listing its tools (`tools/list`).
|
||||
pub async fn mcp_test(host: &Host, window: &str, id: String) -> IdeResult<McpProbeResult> {
|
||||
host.require_trust(window)?;
|
||||
let (user, workspace, project) = mcp_maps(host, window);
|
||||
let (scope, name) = ide_agent::mcp::parse_server_id(&id)
|
||||
.ok_or_else(|| IdeError::not_found(format!("MCP server `{id}` not found")))?;
|
||||
let server = match scope {
|
||||
McpScope::User => user.get(name),
|
||||
McpScope::Workspace => workspace.get(name),
|
||||
}
|
||||
.cloned()
|
||||
.ok_or_else(|| IdeError::not_found(format!("MCP server `{name}` not found")))?;
|
||||
if scope == McpScope::Workspace {
|
||||
let p = project.as_ref().ok_or_else(|| IdeError::invalid("Open a project to test workspace MCP servers"))?;
|
||||
if !host.mcp_approvals.approved(&p.root, name, &server) {
|
||||
return Err(IdeError::invalid("Enable this workspace MCP server first before testing it"));
|
||||
}
|
||||
}
|
||||
let cwd = project.as_ref().map(|p| p.root.clone()).or_else(dirs::home_dir).unwrap_or_else(std::env::temp_dir);
|
||||
match server.transport {
|
||||
McpTransport::Stdio => Ok(ide_agent::mcp::probe_stdio_server(&server, &cwd).await),
|
||||
McpTransport::Http | McpTransport::Sse => Ok(probe_http_mcp_server(&server).await),
|
||||
}
|
||||
}
|
||||
|
||||
async fn probe_http_mcp_server(server: &ide_core::settings::AgentMcpServer) -> McpProbeResult {
|
||||
let started = std::time::Instant::now();
|
||||
let elapsed_ms = || u32::try_from(started.elapsed().as_millis()).unwrap_or(u32::MAX);
|
||||
let Some(url) = server.url.as_deref().map(str::trim).filter(|u| !u.is_empty()) else {
|
||||
return McpProbeResult {
|
||||
ok: false,
|
||||
server_name: None,
|
||||
server_version: None,
|
||||
protocol_version: None,
|
||||
tools: Vec::new(),
|
||||
duration_ms: elapsed_ms(),
|
||||
error: Some("URL is empty".into()),
|
||||
};
|
||||
};
|
||||
let mut headers = reqwest::header::HeaderMap::new();
|
||||
headers.insert(
|
||||
reqwest::header::ACCEPT,
|
||||
reqwest::header::HeaderValue::from_static("application/json, text/event-stream"),
|
||||
);
|
||||
for (k, v) in &server.headers {
|
||||
if let (Ok(name), Ok(val)) =
|
||||
(reqwest::header::HeaderName::from_bytes(k.as_bytes()), reqwest::header::HeaderValue::from_str(v))
|
||||
{
|
||||
headers.insert(name, val);
|
||||
}
|
||||
}
|
||||
let client =
|
||||
match reqwest::Client::builder().default_headers(headers).timeout(std::time::Duration::from_secs(12)).build() {
|
||||
Ok(c) => c,
|
||||
Err(e) => {
|
||||
return McpProbeResult {
|
||||
ok: false,
|
||||
server_name: None,
|
||||
server_version: None,
|
||||
protocol_version: None,
|
||||
tools: Vec::new(),
|
||||
duration_ms: elapsed_ms(),
|
||||
error: Some(format!("HTTP client error: {e}")),
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
let post_rpc = |session_id: Option<String>, body: serde_json::Value| {
|
||||
let client = client.clone();
|
||||
let url = url.to_owned();
|
||||
async move {
|
||||
let mut req =
|
||||
client.post(&url).header(reqwest::header::CONTENT_TYPE, "application/json").body(body.to_string());
|
||||
if let Some(sid) = session_id.as_deref() {
|
||||
req = req.header("Mcp-Session-Id", sid);
|
||||
}
|
||||
let resp = req.send().await.map_err(|e| format!("Request to `{url}` failed: {e}"))?;
|
||||
let status = resp.status();
|
||||
let next_session =
|
||||
resp.headers().get("mcp-session-id").and_then(|v| v.to_str().ok()).map(str::to_owned).or(session_id);
|
||||
let text = resp.text().await.map_err(|e| format!("Failed reading response: {e}"))?;
|
||||
if !status.is_success() {
|
||||
let detail = text.trim();
|
||||
let msg = if detail.is_empty() {
|
||||
format!("HTTP {status}")
|
||||
} else {
|
||||
format!("HTTP {status}: {}", detail.chars().take(240).collect::<String>())
|
||||
};
|
||||
return Err(msg);
|
||||
}
|
||||
Ok((next_session, parse_mcp_http_response(&text)?))
|
||||
}
|
||||
};
|
||||
|
||||
let init_req = serde_json::json!({
|
||||
"jsonrpc": "2.0",
|
||||
"id": 1,
|
||||
"method": "initialize",
|
||||
"params": {
|
||||
"protocolVersion": "2024-11-05",
|
||||
"capabilities": {},
|
||||
"clientInfo": { "name": "OpenIDEA", "version": env!("CARGO_PKG_VERSION") },
|
||||
}
|
||||
});
|
||||
|
||||
let (session_id, init_res) = match post_rpc(None, init_req).await {
|
||||
Ok(v) => v,
|
||||
Err(err) => {
|
||||
return McpProbeResult {
|
||||
ok: false,
|
||||
server_name: None,
|
||||
server_version: None,
|
||||
protocol_version: None,
|
||||
tools: Vec::new(),
|
||||
duration_ms: elapsed_ms(),
|
||||
error: Some(err),
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
// Best-effort `notifications/initialized` + `tools/list`.
|
||||
let mut not_req = client.post(url).header(reqwest::header::CONTENT_TYPE, "application/json").body(
|
||||
serde_json::json!({
|
||||
"jsonrpc": "2.0",
|
||||
"method": "notifications/initialized",
|
||||
"params": {},
|
||||
})
|
||||
.to_string(),
|
||||
);
|
||||
if let Some(sid) = session_id.as_deref() {
|
||||
not_req = not_req.header("Mcp-Session-Id", sid);
|
||||
}
|
||||
let _ = not_req.send().await;
|
||||
|
||||
let tools_res = post_rpc(
|
||||
session_id,
|
||||
serde_json::json!({
|
||||
"jsonrpc": "2.0",
|
||||
"id": 2,
|
||||
"method": "tools/list",
|
||||
"params": {},
|
||||
}),
|
||||
)
|
||||
.await
|
||||
.map(|(_, v)| v)
|
||||
.unwrap_or_else(|_| serde_json::json!({}));
|
||||
|
||||
ide_agent::mcp::parse_probe_payloads(&init_res, &tools_res, elapsed_ms())
|
||||
}
|
||||
|
||||
fn parse_mcp_http_response(body: &str) -> Result<serde_json::Value, String> {
|
||||
let trimmed = body.trim();
|
||||
if trimmed.is_empty() {
|
||||
return Ok(serde_json::json!({}));
|
||||
}
|
||||
if let Ok(msg) = serde_json::from_str::<serde_json::Value>(trimmed) {
|
||||
if let Some(err) = msg.get("error") {
|
||||
let em = err.get("message").and_then(serde_json::Value::as_str).unwrap_or("JSON-RPC error");
|
||||
return Err(em.to_owned());
|
||||
}
|
||||
return Ok(msg.get("result").cloned().unwrap_or(msg));
|
||||
}
|
||||
// Streamable HTTP SSE frames (`data: {...}`).
|
||||
for line in trimmed.lines() {
|
||||
if let Some(rest) = line.strip_prefix("data:")
|
||||
&& let Ok(msg) = serde_json::from_str::<serde_json::Value>(rest.trim())
|
||||
&& (msg.get("result").is_some() || msg.get("error").is_some())
|
||||
{
|
||||
if let Some(err) = msg.get("error") {
|
||||
let em = err.get("message").and_then(serde_json::Value::as_str).unwrap_or("JSON-RPC error");
|
||||
return Err(em.to_owned());
|
||||
}
|
||||
return Ok(msg.get("result").cloned().unwrap_or(msg));
|
||||
}
|
||||
}
|
||||
Err("Unexpected non-JSON MCP response".into())
|
||||
}
|
||||
|
||||
/// Updates per-session MCP server enable/disable overrides on task `task`.
|
||||
pub fn set_mcp_overrides(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
overrides: std::collections::BTreeMap<String, bool>,
|
||||
) -> IdeResult<AgentTask> {
|
||||
host.project(window)?.agents.set_mcp_overrides(&task, overrides)
|
||||
}
|
||||
|
||||
/// Commands of this module the remote server answers.
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("agent_subscribe", |c| async move { subscribe(&c.host, &c.window, c.channel("onEvent")?) });
|
||||
@@ -587,12 +852,23 @@ pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("agent_registry_remove", |c| async move { registry_remove(&c.host, &c.window, c.arg("id")?).await });
|
||||
d.add("agent_mcp_list", |c| async move { mcp_list(&c.host, &c.window) });
|
||||
d.add("agent_mcp_save", |c| async move { mcp_save(&c.host, &c.window, c.arg("input")?) });
|
||||
d.add("agent_mcp_save_json", |c| async move {
|
||||
mcp_save_json(&c.host, &c.window, c.arg("scope")?, c.arg("rawJson")?, c.arg("fallbackName")?, c.arg("agents")?)
|
||||
});
|
||||
d.add(
|
||||
"agent_mcp_set_enabled",
|
||||
|c| async move { mcp_set_enabled(&c.host, &c.window, c.arg("id")?, c.arg("enabled")?) },
|
||||
);
|
||||
d.add("agent_mcp_remove", |c| async move { mcp_remove(&c.host, &c.window, c.arg("id")?) });
|
||||
d.add("agent_mcp_import", |c| async move { mcp_import(&c.host, &c.window) });
|
||||
d.add("agent_mcp_discover_sources", |c| async move { mcp_discover_sources(&c.host, &c.window).await });
|
||||
d.add("agent_mcp_import_selected", |c| async move {
|
||||
mcp_import_selected(&c.host, &c.window, c.arg("scope")?, c.arg("selections")?, c.arg("overwrite")?).await
|
||||
});
|
||||
d.add("agent_mcp_test", |c| async move { mcp_test(&c.host, &c.window, c.arg("id")?).await });
|
||||
d.add("agent_set_mcp_overrides", |c| async move {
|
||||
set_mcp_overrides(&c.host, &c.window, c.arg("task")?, c.arg("overrides")?)
|
||||
});
|
||||
d.add("agent_commands", |c| async move { commands(&c.host, &c.window, c.arg("provider")?, c.arg("task")?).await });
|
||||
d.add("agent_entries", |c| async move { entries(&c.host, &c.window, c.arg("task")?, c.arg("subagent")?) });
|
||||
d.add("agent_create", |c| async move { create(&c.host, &c.window, c.arg("request")?).await });
|
||||
|
||||
@@ -0,0 +1,115 @@
|
||||
//! Cucumber sources: the project's `.feature` files and the JavaScript / TypeScript files
|
||||
//! (`@cucumber/cucumber`, `playwright-bdd`) and Java / Kotlin files (cucumber-jvm's
|
||||
//! `@Given("…")` annotations and Java 8 lambdas) that could define steps, with their text. The UI
|
||||
//! owns the Gherkin and step-expression parsing and the index it feeds (as for `routes`),
|
||||
//! so this side stays a cheap scan.
|
||||
|
||||
use crate::Host;
|
||||
use ide_core::IdeResult;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::path::Path;
|
||||
use std::sync::Mutex;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
/// Files handed out at most, and bytes in total: a test suite's features and step
|
||||
/// files fit well inside these, and the UI indexes them once.
|
||||
const MAX_FILES: usize = 4096;
|
||||
const MAX_BYTES: usize = 64 << 20;
|
||||
/// A single source bigger than this is a bundle, not a step file.
|
||||
const MAX_FILE_BYTES: u64 = 2 << 20;
|
||||
|
||||
/// What a step definition call starts with (`Given('…'`, `defineStep(/…/`).
|
||||
const STEP_CALLS: [&str; 5] = ["Given(", "When(", "Then(", "Step(", "defineStep("];
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct StepSource {
|
||||
pub path: ide_core::IpcPath,
|
||||
pub text: String,
|
||||
/// A Gherkin `.feature` file; otherwise a script defining steps.
|
||||
pub feature: bool,
|
||||
}
|
||||
|
||||
fn is_feature(path: &Path) -> bool {
|
||||
path.extension().and_then(|e| e.to_str()).is_some_and(|e| e.eq_ignore_ascii_case("feature"))
|
||||
}
|
||||
|
||||
fn is_script(path: &Path) -> bool {
|
||||
matches!(
|
||||
path.extension().and_then(|e| e.to_str()),
|
||||
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt")
|
||||
)
|
||||
}
|
||||
|
||||
/// The feature files and step definition files under `root`.
|
||||
pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
|
||||
let found: Mutex<Vec<StepSource>> = Mutex::new(Vec::new());
|
||||
let bytes = AtomicUsize::new(0);
|
||||
ide_vfs::walk_files(root, excludes, |path| {
|
||||
let feature = is_feature(path);
|
||||
if !(feature || is_script(path)) || bytes.load(Ordering::Relaxed) >= MAX_BYTES {
|
||||
return;
|
||||
}
|
||||
if std::fs::metadata(path).map_or(true, |m| m.len() > MAX_FILE_BYTES) {
|
||||
return;
|
||||
}
|
||||
let Ok(text) = std::fs::read_to_string(path) else { return };
|
||||
if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) {
|
||||
return;
|
||||
}
|
||||
let Ok(mut found) = found.lock() else { return };
|
||||
if found.len() >= MAX_FILES {
|
||||
return;
|
||||
}
|
||||
bytes.fetch_add(text.len(), Ordering::Relaxed);
|
||||
found.push(StepSource { path: path.to_path_buf().into(), text, feature });
|
||||
});
|
||||
let mut files = found.into_inner().unwrap_or_default();
|
||||
files.sort_by(|a, b| a.path.cmp(&b.path));
|
||||
files
|
||||
}
|
||||
|
||||
/// Every Cucumber source of the project (its folder and the content roots outside it).
|
||||
pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>> {
|
||||
let project = host.project(window)?;
|
||||
let mut excludes = project.search_excludes();
|
||||
// Cucumber's own sources (and every other package's) are not the project's steps.
|
||||
excludes.push("node_modules".to_owned());
|
||||
let mut out = Vec::new();
|
||||
for root in std::iter::once(project.root.clone()).chain(project.content_roots()) {
|
||||
out.extend(sources_in(&root, &excludes));
|
||||
}
|
||||
out.sort_by(|a, b| a.path.cmp(&b.path));
|
||||
out.dedup_by(|a, b| a.path == b.path);
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn features_and_step_files_are_read_and_nothing_else() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path();
|
||||
for dir in ["features", "steps", "src", "node_modules/@cucumber/cucumber/lib"] {
|
||||
std::fs::create_dir_all(root.join(dir)).unwrap();
|
||||
}
|
||||
std::fs::write(root.join("features/cart.feature"), "Feature: Cart\n").unwrap();
|
||||
std::fs::write(root.join("steps/cart.steps.ts"), "Given('an empty cart', () => {});").unwrap();
|
||||
std::fs::write(root.join("steps/bdd.mjs"), "const { When } = createBdd();\nWhen(/^I add (\\d+)$/, f);")
|
||||
.unwrap();
|
||||
std::fs::write(root.join("src/app.ts"), "export const app = 1;").unwrap();
|
||||
std::fs::write(root.join("src/CartSteps.java"), "@Given(\"an empty cart\")\npublic void empty() {}").unwrap();
|
||||
std::fs::write(root.join("src/App.java"), "class App {}").unwrap();
|
||||
std::fs::write(root.join("src/notes.md"), "Given('x')").unwrap();
|
||||
std::fs::write(root.join("node_modules/@cucumber/cucumber/lib/index.js"), "Given('x')").unwrap();
|
||||
let files = sources_in(root, &["node_modules".to_owned()]);
|
||||
let names: Vec<String> =
|
||||
files.iter().map(|f| f.path.0.strip_prefix(root).unwrap().to_string_lossy().replace('\\', "/")).collect();
|
||||
assert_eq!(names, ["features/cart.feature", "src/CartSteps.java", "steps/bdd.mjs", "steps/cart.steps.ts"]);
|
||||
assert!(files[0].feature && !files[1].feature);
|
||||
assert!(files[3].text.contains("an empty cart"));
|
||||
}
|
||||
}
|
||||
@@ -88,6 +88,10 @@ pub(super) fn load_scopes(root: &Path, scopes: &[Scope]) -> BuildModel {
|
||||
}
|
||||
}
|
||||
combined.gradle.extend(model.gradle);
|
||||
for b in model.sbt.iter_mut().filter(|_| scope.root != root) {
|
||||
b.dir = absolute(&scope.root, &b.dir);
|
||||
}
|
||||
combined.sbt.extend(model.sbt);
|
||||
}
|
||||
combined
|
||||
}
|
||||
|
||||
@@ -97,6 +97,8 @@ async fn resolve_launch(
|
||||
tokio::task::spawn_blocking(move || {
|
||||
let _external_build = external_build;
|
||||
let local_repo = ide_sdk::apply::maven_local_repository(&project.root, &settings);
|
||||
// Module outputs the launch runs from a snapshot of: the originals must not come back.
|
||||
let mut snapshotted = Vec::new();
|
||||
let built = if delegated {
|
||||
let rebuild_on_jdt_errors = rebuild_on_jdt_errors(policy, prefer_maven, info.error_count);
|
||||
let outputs = project.java_launch_snapshots.lock().build(
|
||||
@@ -109,6 +111,7 @@ async fn resolve_launch(
|
||||
)?;
|
||||
let copies = use_snapshot(&mut info, &outputs.originals, &outputs.snapshot);
|
||||
apply_external_build_result(&mut info, outputs.failure, outputs.authoritative);
|
||||
snapshotted = outputs.originals;
|
||||
copies
|
||||
} else if external {
|
||||
let built = compile::build_for_launch(&project.root, &model, &module, test, build_kind, &cancel)?;
|
||||
@@ -137,7 +140,7 @@ async fn resolve_launch(
|
||||
&project.build_cache_dir(),
|
||||
&cancel,
|
||||
);
|
||||
merge_maven_launch_classpath(&mut class_paths, &mut info, maven_cp)?;
|
||||
merge_maven_launch_classpath(&mut class_paths, &mut info, maven_cp, &snapshotted)?;
|
||||
} else {
|
||||
append_unique_class_paths(&mut class_paths, std::mem::take(&mut info.class_paths));
|
||||
}
|
||||
@@ -298,17 +301,23 @@ fn same_entry(a: &str, b: &str, windows: bool) -> bool {
|
||||
|
||||
/// Merge the Maven launch classpath without turning a recoverable probe failure into a
|
||||
/// failed launch. Cancellation still propagates; ordinary failures keep jdtls' classpath
|
||||
/// and leave the reason in the run console.
|
||||
/// and leave the reason in the run console. Maven lists the module's and its reactor
|
||||
/// siblings' `target/classes`; those in `snapshotted` already run from their snapshot,
|
||||
/// and listing both would make every resource (MyBatis mapper XML) load twice.
|
||||
fn merge_maven_launch_classpath(
|
||||
class_paths: &mut Vec<String>,
|
||||
info: &mut JavaLaunchInfo,
|
||||
classpath: IdeResult<String>,
|
||||
snapshotted: &[PathBuf],
|
||||
) -> IdeResult<()> {
|
||||
match classpath {
|
||||
Ok(classpath) => {
|
||||
let snapshotted: Vec<_> = snapshotted.iter().map(|p| p.to_string_lossy()).collect();
|
||||
append_unique_class_paths(
|
||||
class_paths,
|
||||
std::env::split_paths(&classpath).map(|path| path.to_string_lossy().into_owned()),
|
||||
std::env::split_paths(&classpath)
|
||||
.map(|path| path.to_string_lossy().into_owned())
|
||||
.filter(|path| !snapshotted.iter().any(|original| same_entry(path, original, cfg!(windows)))),
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
@@ -471,20 +480,46 @@ mod tests {
|
||||
let mut class_paths = vec!["snapshot.jar".to_owned()];
|
||||
let mut info =
|
||||
JavaLaunchInfo { class_paths: vec!["snapshot.jar".into(), "jdtls.jar".into()], ..Default::default() };
|
||||
merge_maven_launch_classpath(&mut class_paths, &mut info, Ok(maven)).unwrap();
|
||||
merge_maven_launch_classpath(&mut class_paths, &mut info, Ok(maven), &[]).unwrap();
|
||||
assert_eq!(class_paths, ["snapshot.jar", "maven.jar"]);
|
||||
|
||||
merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::internal("offline dependency")))
|
||||
merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::internal("offline dependency")), &[])
|
||||
.unwrap();
|
||||
assert_eq!(class_paths, ["snapshot.jar", "maven.jar", "jdtls.jar"]);
|
||||
assert!(info.hints[0].contains("offline dependency"), "{:?}", info.hints);
|
||||
}
|
||||
|
||||
/// Maven's launch classpath lists the module's and its reactor siblings' outputs, which
|
||||
/// the launch already runs from a snapshot: listed twice, MyBatis loads each mapper XML
|
||||
/// twice and fails with "XML fragments parsed from previous mappers already contains value".
|
||||
#[test]
|
||||
fn maven_classpath_leaves_out_outputs_the_launch_runs_from_a_snapshot() {
|
||||
let web = PathBuf::from("/work/haoke/haoke-web/target/classes");
|
||||
let service = PathBuf::from("/work/haoke/haoke-service/target/classes");
|
||||
let maven = std::env::join_paths([
|
||||
"/work/haoke/haoke-web/target/classes/",
|
||||
"/work/haoke/haoke-service/target/classes",
|
||||
"/work/haoke/haoke-api/target/classes",
|
||||
"/m2/mybatis.jar",
|
||||
])
|
||||
.unwrap()
|
||||
.to_string_lossy()
|
||||
.into_owned();
|
||||
let mut class_paths = vec!["/cache/launch-x/0".to_owned(), "/cache/launch-x/1".to_owned()];
|
||||
let mut info = JavaLaunchInfo::default();
|
||||
merge_maven_launch_classpath(&mut class_paths, &mut info, Ok(maven), &[web, service]).unwrap();
|
||||
assert_eq!(
|
||||
class_paths,
|
||||
["/cache/launch-x/0", "/cache/launch-x/1", "/work/haoke/haoke-api/target/classes", "/m2/mybatis.jar"]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancelled_maven_classpath_probe_propagates_without_fallback() {
|
||||
let mut class_paths = vec!["snapshot.jar".to_owned()];
|
||||
let mut info = JavaLaunchInfo { class_paths: vec!["jdtls.jar".into()], ..Default::default() };
|
||||
let error = merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::cancelled())).unwrap_err();
|
||||
let error =
|
||||
merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::cancelled()), &[]).unwrap_err();
|
||||
assert_eq!(error.kind, ErrorKind::Cancelled);
|
||||
assert_eq!(class_paths, ["snapshot.jar"]);
|
||||
assert!(info.hints.is_empty());
|
||||
|
||||
@@ -550,6 +550,24 @@ pub async fn lsp_implementations(
|
||||
result
|
||||
}
|
||||
|
||||
/// Refines the implementations `targets` of the method at `pos` to their declarations (Java
|
||||
/// dependencies' class files point at the start of the class). Cancel with
|
||||
/// `cancel_request(request)`.
|
||||
pub async fn lsp_implementation_locations(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
targets: Vec<Location>,
|
||||
) -> IdeResult<Vec<Location>> {
|
||||
let lsp = host.project(window)?.lsp.clone();
|
||||
let (_, cancel) = begin_position_request(host, window, request, doc, pos).await?;
|
||||
let result = lsp.implementation_locations(doc, pos, targets, cancel).await;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
/// Go to Implementation of the symbol at `pos`. Implementations found before a slower
|
||||
/// search for the rest (Java: the project's, before the dependencies') arrive on
|
||||
/// `on_partial`; the result has them all. Cancel with `cancel_request(request)`.
|
||||
@@ -1173,6 +1191,166 @@ pub async fn lsp_hierarchy_refactor(
|
||||
.await
|
||||
}
|
||||
|
||||
/// The signature of the method at `pos`, for Change Signature.
|
||||
pub async fn lsp_signature_info(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
) -> IdeResult<MethodSignature> {
|
||||
let project = host.project(window)?;
|
||||
let cancel = host.begin_request(request);
|
||||
let result = project.lsp.change_signature_info(doc, pos, cancel).await;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
/// Checks changing the method at `pos` to `signature` and computes the edit without applying it.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub async fn lsp_change_signature(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
signature: MethodSignature,
|
||||
delegate: bool,
|
||||
confirmation: Option<String>,
|
||||
) -> IdeResult<ServerRefactored> {
|
||||
let project = host.project(window)?;
|
||||
let documents = project.documents.clone();
|
||||
let version = blocking(move || documents.version(doc)).await?;
|
||||
let cancel = host.begin_request(request);
|
||||
let result = project.lsp.change_signature(doc, pos, signature, delegate, confirmation, cancel).await;
|
||||
host.end_request(request);
|
||||
let mut changed = result?;
|
||||
blocking(move || {
|
||||
if project.documents.version(doc)? != version {
|
||||
return Err(ide_core::IdeError::new(
|
||||
ide_core::error::ErrorKind::OutOfSync,
|
||||
"document changed while computing the refactoring; request it again",
|
||||
));
|
||||
}
|
||||
if let Some(edit) = &mut changed.edit {
|
||||
project.documents.prepare_workspace_edit(edit)?;
|
||||
}
|
||||
Ok(changed)
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
fn json_argument(args: &str) -> IdeResult<serde_json::Value> {
|
||||
serde_json::from_str(args).map_err(|e| IdeError::invalid(format!("invalid refactoring arguments: {e}")))
|
||||
}
|
||||
|
||||
fn json_strings(values: Vec<serde_json::Value>) -> Vec<String> {
|
||||
values.iter().map(serde_json::Value::to_string).collect()
|
||||
}
|
||||
|
||||
/// Where a Java Move code action of `kind` can go; `args` (JSON) carries the code action's own
|
||||
/// arguments back unchanged, and each destination comes back as JSON.
|
||||
pub async fn lsp_java_move_destinations(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
doc: DocId,
|
||||
kind: String,
|
||||
args: String,
|
||||
) -> IdeResult<Vec<String>> {
|
||||
let args = json_argument(&args)?;
|
||||
let project = host.project(window)?;
|
||||
let cancel = host.begin_request(request);
|
||||
let result = project.lsp.java_move_destinations(doc, kind, args, cancel).await;
|
||||
host.end_request(request);
|
||||
result.map(json_strings)
|
||||
}
|
||||
|
||||
/// The project's Java source types, for moving a member or type into a class.
|
||||
pub async fn lsp_java_source_types(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
doc: DocId,
|
||||
project_name: Option<String>,
|
||||
) -> IdeResult<Vec<String>> {
|
||||
let project = host.project(window)?;
|
||||
let cancel = host.begin_request(request);
|
||||
let result = project.lsp.java_source_types(doc, project_name, cancel).await;
|
||||
host.end_request(request);
|
||||
result.map(json_strings)
|
||||
}
|
||||
|
||||
/// Checks a Java move and computes its edit without applying it.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub async fn lsp_java_move(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
doc: DocId,
|
||||
kind: String,
|
||||
args: String,
|
||||
confirmation: Option<String>,
|
||||
) -> IdeResult<ServerRefactored> {
|
||||
let args = json_argument(&args)?;
|
||||
let project = host.project(window)?;
|
||||
let cancel = host.begin_request(request);
|
||||
let result = project.lsp.java_move(doc, kind, args, confirmation, cancel).await;
|
||||
host.end_request(request);
|
||||
let mut moved = result?;
|
||||
blocking(move || {
|
||||
if let Some(edit) = &mut moved.edit {
|
||||
project.documents.prepare_workspace_edit(edit)?;
|
||||
}
|
||||
Ok(moved)
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
/// The Java class to extract an interface from: its members and the packages for the interface.
|
||||
pub async fn lsp_extract_interface_info(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
) -> IdeResult<ExtractInterfaceInfo> {
|
||||
let project = host.project(window)?;
|
||||
let cancel = host.begin_request(request);
|
||||
let result = project.lsp.extract_interface_info(doc, pos, cancel).await;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
/// Checks extracting a Java interface and computes its edit without applying it; `destination`
|
||||
/// is one of the info's packages.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub async fn lsp_extract_interface(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
members: Vec<String>,
|
||||
name: String,
|
||||
destination: String,
|
||||
confirmation: Option<String>,
|
||||
) -> IdeResult<ServerRefactored> {
|
||||
let destination = json_argument(&destination)?;
|
||||
let project = host.project(window)?;
|
||||
let cancel = host.begin_request(request);
|
||||
let result = project.lsp.extract_interface(doc, pos, members, name, destination, confirmation, cancel).await;
|
||||
host.end_request(request);
|
||||
let mut extracted = result?;
|
||||
blocking(move || {
|
||||
if let Some(edit) = &mut extracted.edit {
|
||||
project.documents.prepare_workspace_edit(edit)?;
|
||||
}
|
||||
Ok(extracted)
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn lsp_rename(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1827,6 +2005,17 @@ pub(crate) fn register(d: &mut Dispatcher) {
|
||||
let on_partial = c.sender("onPartial")?;
|
||||
lsp_goto_implementation(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, on_partial).await
|
||||
});
|
||||
d.add("lsp_implementation_locations", |c| async move {
|
||||
lsp_implementation_locations(
|
||||
&c.host,
|
||||
&c.window,
|
||||
c.arg("request")?,
|
||||
c.arg("doc")?,
|
||||
c.arg("pos")?,
|
||||
c.arg("targets")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add(
|
||||
"lsp_resolve_class_file",
|
||||
|c| async move { lsp_resolve_class_file(&c.host, &c.window, c.arg("path")?).await },
|
||||
@@ -1896,6 +2085,58 @@ pub(crate) fn register(d: &mut Dispatcher) {
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("lsp_signature_info", |c| async move {
|
||||
lsp_signature_info(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?).await
|
||||
});
|
||||
d.add("lsp_change_signature", |c| async move {
|
||||
lsp_change_signature(
|
||||
&c.host,
|
||||
&c.window,
|
||||
c.arg("request")?,
|
||||
c.arg("doc")?,
|
||||
c.arg("pos")?,
|
||||
c.arg("signature")?,
|
||||
c.arg("delegate")?,
|
||||
c.arg("confirmation")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("lsp_extract_interface_info", |c| async move {
|
||||
lsp_extract_interface_info(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?).await
|
||||
});
|
||||
d.add("lsp_extract_interface", |c| async move {
|
||||
lsp_extract_interface(
|
||||
&c.host,
|
||||
&c.window,
|
||||
c.arg("request")?,
|
||||
c.arg("doc")?,
|
||||
c.arg("pos")?,
|
||||
c.arg("members")?,
|
||||
c.arg("name")?,
|
||||
c.arg("destination")?,
|
||||
c.arg("confirmation")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("lsp_java_move_destinations", |c| async move {
|
||||
lsp_java_move_destinations(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("kind")?, c.arg("args")?)
|
||||
.await
|
||||
});
|
||||
d.add("lsp_java_source_types", |c| async move {
|
||||
lsp_java_source_types(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("projectName")?).await
|
||||
});
|
||||
d.add("lsp_java_move", |c| async move {
|
||||
lsp_java_move(
|
||||
&c.host,
|
||||
&c.window,
|
||||
c.arg("request")?,
|
||||
c.arg("doc")?,
|
||||
c.arg("kind")?,
|
||||
c.arg("args")?,
|
||||
c.arg("confirmation")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("lsp_format", |c| async move {
|
||||
lsp_format(&c.host, &c.window, c.arg("doc")?, c.arg("range")?, c.arg("options")?).await
|
||||
});
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
|
||||
pub mod agent;
|
||||
pub mod analysis;
|
||||
pub mod bdd;
|
||||
pub mod build;
|
||||
pub mod bytes;
|
||||
pub mod coverage;
|
||||
|
||||
@@ -95,8 +95,12 @@ pub(crate) fn search_project(
|
||||
cancel,
|
||||
&|mut file| {
|
||||
if dir != root {
|
||||
let name = dir.file_name().unwrap_or_default().to_string_lossy();
|
||||
file.rel_path = format!("{name}/{}", file.rel_path);
|
||||
// A root inside the project (one its walk skips) goes by its path there.
|
||||
let prefix = match dir.strip_prefix(root) {
|
||||
Ok(rel) if include_root => rel.to_string_lossy().replace('\\', "/"),
|
||||
_ => dir.file_name().unwrap_or_default().to_string_lossy().into_owned(),
|
||||
};
|
||||
file.rel_path = format!("{prefix}/{}", file.rel_path);
|
||||
}
|
||||
emit(file);
|
||||
},
|
||||
|
||||
@@ -2831,7 +2831,7 @@ impl HostApi for PluginApi {
|
||||
}
|
||||
|
||||
fn post_view_message(&self, view: &str, message: String) -> Result<(), HostError> {
|
||||
let declared = [super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
|
||||
let declared = super::ui_points::WEB_POINTS
|
||||
.iter()
|
||||
.any(|point| self.shared.ui.items(point, Some(self.id())).iter().any(|i| i.key == view));
|
||||
if !declared {
|
||||
|
||||
@@ -1489,9 +1489,8 @@ impl PluginHost {
|
||||
}
|
||||
|
||||
fn declared_view(&self, id: &str, view: &str) -> IdeResult<()> {
|
||||
let declared = [ui_points::VIEWS, ui_points::CUSTOM_EDITORS]
|
||||
.iter()
|
||||
.any(|point| self.ui.items(point, Some(id)).iter().any(|i| i.key == view));
|
||||
let declared =
|
||||
ui_points::WEB_POINTS.iter().any(|point| self.ui.items(point, Some(id)).iter().any(|i| i.key == view));
|
||||
if declared { Ok(()) } else { Err(IdeError::not_found(format!("plugin {id:?} declares no view {view:?}"))) }
|
||||
}
|
||||
|
||||
|
||||
@@ -89,6 +89,7 @@ pub fn register_builtin_points(
|
||||
registry.register(Arc::new(UiPoint::new(p::SETTINGS, ui.clone(), p::settings)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::VIEWS, ui.clone(), p::view)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::CUSTOM_EDITORS, ui.clone(), p::custom_editor)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::EDITOR_PANELS, ui.clone(), p::editor_panel)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::MARKER_ICONS, ui.clone(), p::marker_icon)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::FILE_ICONS, ui.clone(), p::file_icon)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::FILE_TEMPLATES, ui.clone(), p::file_template)))?;
|
||||
|
||||
@@ -36,6 +36,12 @@
|
||||
//! layout = "tab" # or "split" / "preview": beside the text editor
|
||||
//! web = "web/index.html" # a web page from the package instead of rendered content
|
||||
//!
|
||||
//! [[contributes.editorPanels]]
|
||||
//! id = "minimap"
|
||||
//! web = "web/index.html" # beside each editor group's text editor; needs `editor.read`
|
||||
//! width = 110 # pixels, 40–400
|
||||
//! when = "plugin.<id>.enabled" # optional
|
||||
//!
|
||||
//! [[contributes.fileIcons]]
|
||||
//! id = "drawing"
|
||||
//! patterns = ["*.excalidraw"]
|
||||
@@ -73,6 +79,9 @@ pub const STATUS_BAR: &str = "statusBar";
|
||||
pub const SETTINGS: &str = "settings";
|
||||
pub const VIEWS: &str = "views";
|
||||
pub const CUSTOM_EDITORS: &str = "customEditors";
|
||||
pub const EDITOR_PANELS: &str = "editorPanels";
|
||||
/// The points whose declarations can name a `web` page (served, messaged, sent view events).
|
||||
pub const WEB_POINTS: [&str; 3] = [VIEWS, CUSTOM_EDITORS, EDITOR_PANELS];
|
||||
pub const FILE_ICONS: &str = "fileIcons";
|
||||
pub const MARKER_ICONS: &str = "markerIcons";
|
||||
pub const FILE_TEMPLATES: &str = "fileTemplates";
|
||||
@@ -745,6 +754,41 @@ pub(super) fn custom_editor(pkg: &Package, decl: toml::Value) -> Result<UiDecl,
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct EditorPanelDecl {
|
||||
id: String,
|
||||
web: String,
|
||||
width: u32,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
when: Option<String>,
|
||||
}
|
||||
|
||||
const EDITOR_PANEL_WIDTH: std::ops::RangeInclusive<u32> = 40..=400;
|
||||
|
||||
/// `[[contributes.editorPanels]]` (API 1.9): a web page at the right edge of every
|
||||
/// editor group, beside its text editor. It sees each file the group shows, so it
|
||||
/// needs `editor.read`.
|
||||
pub(super) fn editor_panel(pkg: &Package, decl: toml::Value) -> Result<UiDecl, String> {
|
||||
let d: EditorPanelDecl = decode(EDITOR_PANELS, decl)?;
|
||||
pkg.manifest.needs_api(&format!("contributes.{EDITOR_PANELS}"), 9)?;
|
||||
validate_item_id(&d.id, "editor panel id")?;
|
||||
let what = format!("editor panel {:?}", d.id);
|
||||
if !EDITOR_PANEL_WIDTH.contains(&d.width) {
|
||||
return Err(format!("{what}: `width` is {}–{} pixels", EDITOR_PANEL_WIDTH.start(), EDITOR_PANEL_WIDTH.end()));
|
||||
}
|
||||
if let Some(when) = &d.when {
|
||||
validate_when(when).map_err(|e| format!("{what}: {e}"))?;
|
||||
}
|
||||
if !pkg.manifest.capabilities.all().any(|c| *c == ide_extension::Capability::EditorRead) {
|
||||
return Err(format!("{what}: needs the `editor.read` capability (the page sees the files editors show)"));
|
||||
}
|
||||
let files = super::web::web_files(pkg, &d.web, &what)?;
|
||||
let mut out = UiDecl::new(d.id.clone(), d.id.clone(), json(&d)?);
|
||||
out.files = files;
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
#[serde(rename_all = "camelCase", deny_unknown_fields)]
|
||||
struct FileIconDecl {
|
||||
@@ -1196,6 +1240,46 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn editor_panels_validate_api_width_when_capability_and_page() {
|
||||
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/editor-panel");
|
||||
let source = std::fs::read_to_string(root.join("plugin.toml")).unwrap();
|
||||
let check = |source: &str| {
|
||||
let manifest = ide_extension::Manifest::parse(source)?;
|
||||
let decl = manifest.declarations(EDITOR_PANELS).into_iter().next().unwrap();
|
||||
editor_panel(&Package::new(manifest, root.clone()), decl)
|
||||
};
|
||||
let valid = check(&source).unwrap();
|
||||
assert_eq!(valid.key, "minimap");
|
||||
assert_eq!(valid.json, serde_json::json!({ "id": "minimap", "web": "web/index.html", "width": 110 }));
|
||||
assert_eq!(valid.files, [PathBuf::from("web/index.html")]);
|
||||
let when = source.replace("width = 110", "width = 110\nwhen = \"plugin.editor-panel.enabled\"");
|
||||
assert_eq!(check(&when).unwrap().json["when"], "plugin.editor-panel.enabled");
|
||||
for width in ["40", "400"] {
|
||||
assert!(check(&source.replace("width = 110", &format!("width = {width}"))).is_ok(), "{width}");
|
||||
}
|
||||
for (bad, error) in [
|
||||
(source.replace("^1.9", "^1.8"), "1.9"),
|
||||
(source.replace("width = 110", "width = 39"), "40–400"),
|
||||
(source.replace("width = 110", "width = 401"), "40–400"),
|
||||
(source.replace("width = 110", "width = -1"), "u32"),
|
||||
(source.replace("width = 110\n", ""), "width"),
|
||||
(source.replace("width = 110", "width = 110\nwhen = \"a &&\""), "when"),
|
||||
(source.replace("width = 110", "width = 110\nside = \"left\""), "side"),
|
||||
(source.replace(r#"required = ["editor.read"]"#, "required = []"), "editor.read"),
|
||||
(source.replace("web/index.html", "index.html"), "directory of its own"),
|
||||
(source.replace("web/index.html", "web/missing.html"), "no such file"),
|
||||
(source.replace("web/index.html", "../web/index.html"), "web"),
|
||||
(source.replace(r#"id = "minimap""#, r#"id = "Mini Map""#), "id"),
|
||||
] {
|
||||
let err = check(&bad).unwrap_err();
|
||||
assert!(err.contains(error), "{bad}\n→ {err}");
|
||||
}
|
||||
// Declared as optional, the capability is still shown at install.
|
||||
let optional = source.replace("required = [", "optional = [");
|
||||
assert!(check(&optional).is_ok());
|
||||
}
|
||||
|
||||
fn package_with_catalogs(files: &[(&str, &str)]) -> (tempfile::TempDir, Package) {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
std::fs::create_dir(dir.path().join(LOCALES_DIR)).unwrap();
|
||||
|
||||
@@ -335,7 +335,7 @@ impl PluginHost {
|
||||
|
||||
/// The web roots `plugin` declares (entry directories, package-relative, `/`-terminated).
|
||||
fn web_dirs(&self, plugin: &str) -> Vec<String> {
|
||||
[super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
|
||||
super::ui_points::WEB_POINTS
|
||||
.iter()
|
||||
.flat_map(|point| self.ui.items(point, Some(plugin)))
|
||||
.filter_map(|item| item.decl.get("web").and_then(|w| w.as_str()).map(str::to_owned))
|
||||
@@ -356,7 +356,7 @@ impl PluginHost {
|
||||
if !plugin.status().is_live() {
|
||||
return Err(IdeError::unavailable(format!("plugin {plugin_id:?} is not enabled")));
|
||||
}
|
||||
let entry = [super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
|
||||
let entry = super::ui_points::WEB_POINTS
|
||||
.iter()
|
||||
.flat_map(|point| self.ui.items(point, Some(plugin_id)))
|
||||
.find(|item| item.key == view)
|
||||
|
||||
@@ -1350,15 +1350,20 @@ pub(crate) fn workspace_member_roots(root: &Path) -> Vec<PathBuf> {
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Workspace members in manifest order, or extra Project Structure directories, Gradle
|
||||
/// project folders outside the project, and directories of Maven POMs linked from
|
||||
/// outside it (`build_cache` is the Gradle sync cache).
|
||||
/// Workspace members in manifest order, or the attached projects outside the project and
|
||||
/// those inside it that its walk skips as ignored (a git worktree under an ignored folder),
|
||||
/// extra Project Structure directories, Gradle project folders outside the project, and
|
||||
/// directories of Maven POMs linked from outside it (`build_cache` is the Gradle sync cache).
|
||||
fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cache: &Path) -> Vec<PathBuf> {
|
||||
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root) {
|
||||
if workspace.is_container(root) {
|
||||
return workspace.projects;
|
||||
}
|
||||
let mut roots = workspace.projects.into_iter().filter(|p| !p.starts_with(root)).collect::<Vec<_>>();
|
||||
let mut roots = workspace
|
||||
.projects
|
||||
.into_iter()
|
||||
.filter(|p| !p.starts_with(root) || ide_index::walk_skips(root, p))
|
||||
.collect::<Vec<_>>();
|
||||
for path in extra_content_roots(settings, root, build_cache) {
|
||||
if !roots.contains(&path) {
|
||||
roots.push(path);
|
||||
|
||||
@@ -547,9 +547,13 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
|
||||
| "agent_registry_remove"
|
||||
| "agent_mcp_list"
|
||||
| "agent_mcp_save"
|
||||
| "agent_mcp_save_json"
|
||||
| "agent_mcp_set_enabled"
|
||||
| "agent_mcp_remove"
|
||||
| "agent_mcp_import"
|
||||
| "agent_mcp_discover_sources"
|
||||
| "agent_mcp_import_selected"
|
||||
| "agent_set_mcp_overrides"
|
||||
| "coverage_import"
|
||||
| "system_font_families"
|
||||
| "user_font_data"
|
||||
|
||||
@@ -594,6 +594,31 @@ fn agent_process(h: &Harness, name: &str) -> ide_core::RunId {
|
||||
h.host.processes.list().into_iter().filter(|r| r.config_id == id && r.running).map(|r| r.id).max().unwrap()
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn run_command_returns_once_a_server_prints_its_ready_line() {
|
||||
let h = Harness::new();
|
||||
h.trust().await;
|
||||
h.host.mcp_requests.set_ready("main", true);
|
||||
h.host
|
||||
.global_settings
|
||||
.set(ide_workspace::SettingsScope::Global, "mcpServer.runWithoutConfirmation", json!(true))
|
||||
.unwrap();
|
||||
let _started = run_tool_window(&h);
|
||||
// A server started with its ready line returns once it prints it, long before the timeout.
|
||||
let started_at = std::time::Instant::now();
|
||||
let up = h
|
||||
.json(
|
||||
"run_command",
|
||||
json!({"name": "web", "command": "sleep 1; echo Listening on 8080; sleep 30", "pattern": "Listening on", "timeout": 60000}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!((up["waitEnded"].as_str(), up["state"].as_str()), (Some("matched"), Some("running")), "{up}");
|
||||
assert!(up["output"].as_str().unwrap().contains("Listening on 8080"), "{up}");
|
||||
assert!(started_at.elapsed() < std::time::Duration::from_secs(20), "returned after {:?}", started_at.elapsed());
|
||||
h.json("stop_run", json!({"name": "web", "force": true, "timeout": 10000})).await;
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
|
||||
|
||||
@@ -105,6 +105,70 @@ async fn linked_projects_share_navigation_but_keep_files_repositories_and_run_di
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_project_attached_inside_the_root_is_searched_and_indexed_once() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let root = base.join("app");
|
||||
// `.wt/feature` is its own repository, which the outer one ignores; `lib` is not ignored.
|
||||
let (ignored, covered) = (root.join(".wt/feature"), root.join("lib"));
|
||||
for dir in [&root, &ignored, &covered] {
|
||||
std::fs::create_dir_all(dir).unwrap();
|
||||
}
|
||||
for repo in [&root, &ignored] {
|
||||
assert!(std::process::Command::new("git").args(["init", "-q"]).current_dir(repo).status().unwrap().success());
|
||||
}
|
||||
std::fs::write(root.join(".git/info/exclude"), "/.wt/\n").unwrap();
|
||||
std::fs::write(root.join("main.txt"), "needle\n").unwrap();
|
||||
std::fs::write(ignored.join("feature.txt"), "needle\n").unwrap();
|
||||
std::fs::write(covered.join("lib.txt"), "needle\n").unwrap();
|
||||
let host = Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("data"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(NullSink)),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
});
|
||||
for dir in [&root, &ignored, &covered] {
|
||||
host.trust.decide(dir, true, false).unwrap();
|
||||
}
|
||||
let project = host.open_project("main", &root).unwrap();
|
||||
ops::project::attach_workspace(&host, "main", &ignored).unwrap();
|
||||
ops::project::attach_workspace(&host, "main", &covered).unwrap();
|
||||
assert_eq!(project.content_roots(), vec![ignored.clone()], "the root's walk covers `lib`");
|
||||
|
||||
assert!(project.index.wait_idle(Duration::from_secs(10)));
|
||||
let files = project.index.find_files(".txt", 100);
|
||||
let mut indexed = files.iter().map(|f| f.rel_path.clone()).collect::<Vec<_>>();
|
||||
indexed.sort();
|
||||
assert_eq!(indexed, [".wt/feature/feature.txt", "lib/lib.txt", "main.txt"]);
|
||||
|
||||
let hits = Arc::new(Mutex::new(Vec::new()));
|
||||
let out = hits.clone();
|
||||
let query = serde_json::from_value(serde_json::json!({"pattern":"needle", "isRegex":false, "caseSensitive":false,"wholeWord":false,"include":[],"exclude":[],"scope":{"kind":"project"},"maxMatches":100})).unwrap();
|
||||
ops::search::start(
|
||||
&host,
|
||||
"main",
|
||||
RequestId::next(),
|
||||
query,
|
||||
Arc::new(move |event| {
|
||||
if let ops::search::SearchEvent::File { file } = event {
|
||||
out.lock().unwrap().push(file.rel_path);
|
||||
}
|
||||
}),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let mut found = hits.lock().unwrap().clone();
|
||||
found.sort();
|
||||
assert_eq!(found, [".wt/feature/feature.txt", "lib/lib.txt", "main.txt"]);
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn python_effective_interpreter_falls_back_to_the_primary_project() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -34,6 +34,16 @@ pub struct RunInput<'a> {
|
||||
/// variables, missing includes) fail; transport errors are part of the exchange.
|
||||
pub async fn run(input: RunInput<'_>, cancel: &CancellationToken) -> IdeResult<HttpExchange> {
|
||||
let request = prepare(&input)?;
|
||||
send(request, input.file, cancel).await
|
||||
}
|
||||
|
||||
/// Sends an already prepared request (one the user approved as shown); `file` is the
|
||||
/// request file it came from, for the history.
|
||||
pub async fn send(
|
||||
request: PreparedRequest,
|
||||
file: Option<&Path>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<HttpExchange> {
|
||||
let time_ms = std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|d| d.as_secs_f64() * 1000.0)
|
||||
@@ -57,7 +67,7 @@ pub async fn run(input: RunInput<'_>, cancel: &CancellationToken) -> IdeResult<H
|
||||
url: request.url.clone(),
|
||||
status: response.as_ref().map(|r| r.status),
|
||||
total_ms: response.as_ref().map(|r| r.total_ms),
|
||||
file: input.file.map(IpcPath::from),
|
||||
file: file.map(IpcPath::from),
|
||||
error,
|
||||
},
|
||||
request,
|
||||
|
||||
@@ -52,6 +52,29 @@ fn root_ignores(root: &Path) -> Gitignore {
|
||||
gi.build().unwrap_or_else(|_| Gitignore::empty())
|
||||
}
|
||||
|
||||
/// Whether walking `root` leaves out `dir`, a folder below it: `dir` or a folder between
|
||||
/// them is ignored (`.gitignore`, `.ignore`, `info/exclude`, the global excludes). Such a
|
||||
/// folder can be a root of its own, with its own rules, without its files being walked twice.
|
||||
pub fn walk_skips(root: &Path, dir: &Path) -> bool {
|
||||
if dir == root || !dir.starts_with(root) || !dir.is_dir() {
|
||||
return false;
|
||||
}
|
||||
let target = dir.to_path_buf();
|
||||
let walker = WalkBuilder::new(root)
|
||||
.hidden(false)
|
||||
.parents(true)
|
||||
.ignore(true)
|
||||
.git_ignore(true)
|
||||
.git_global(true)
|
||||
.git_exclude(true)
|
||||
.require_git(ide_core::ignored::inside_git_repo(root))
|
||||
.follow_links(false)
|
||||
// Only the folders on the way down to `dir`.
|
||||
.filter_entry(move |e| target.starts_with(e.path()))
|
||||
.build();
|
||||
!walker.flatten().any(|e| e.path() == dir)
|
||||
}
|
||||
|
||||
fn rel_string(rel: &Path) -> String {
|
||||
let mut out = String::new();
|
||||
for c in rel.components() {
|
||||
@@ -115,12 +138,18 @@ impl PathFilter {
|
||||
let mut extra: Vec<ExtraRoot> = Vec::new();
|
||||
for r in &extra_roots.folders {
|
||||
let path = dunce::canonicalize(r).unwrap_or_else(|_| r.clone());
|
||||
let nested = (extra_roots.include_root && (path.starts_with(root) || root.starts_with(&path)))
|
||||
// A folder inside the root is a root of its own only when the root's walk skips it.
|
||||
let inside = path.starts_with(root) && !walk_skips(root, &path);
|
||||
let nested = (extra_roots.include_root && (inside || root.starts_with(&path)))
|
||||
|| extra.iter().any(|e| path.starts_with(&e.path) || e.path.starts_with(&path));
|
||||
if nested || !path.is_dir() {
|
||||
continue;
|
||||
}
|
||||
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
|
||||
// Inside the root it goes by its path there, elsewhere by its folder name.
|
||||
let name = match path.strip_prefix(root) {
|
||||
Ok(rel) if extra_roots.include_root => rel_string(rel),
|
||||
_ => path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),
|
||||
};
|
||||
extra.push(ExtraRoot { gitignore: root_ignores(&path), name, path });
|
||||
}
|
||||
Self {
|
||||
@@ -176,13 +205,11 @@ impl PathFilter {
|
||||
|
||||
/// The root containing `path`, its display prefix (`None` for the project root) and ignore rules.
|
||||
fn base_of(&self, path: &Path) -> Option<(&Path, Option<&str>, &Gitignore)> {
|
||||
if self.include_root && path.starts_with(&self.root) {
|
||||
return Some((&self.root, None, &self.gitignore));
|
||||
// An extra root inside the project root wins: its own rules apply below it.
|
||||
if let Some(e) = self.extra.iter().find(|e| path.starts_with(&e.path)) {
|
||||
return Some((e.path.as_path(), Some(e.name.as_str()), &e.gitignore));
|
||||
}
|
||||
self.extra
|
||||
.iter()
|
||||
.find(|e| path.starts_with(&e.path))
|
||||
.map(|e| (e.path.as_path(), Some(e.name.as_str()), &e.gitignore))
|
||||
(self.include_root && path.starts_with(&self.root)).then_some((self.root.as_path(), None, &self.gitignore))
|
||||
}
|
||||
|
||||
/// Whether `path` is (at or) below one of the roots.
|
||||
@@ -207,7 +234,7 @@ impl PathFilter {
|
||||
/// Key of `path` in the persistent store: only files below the project root
|
||||
/// are persisted (extra content roots are rescanned when the project opens).
|
||||
pub(crate) fn store_key(&self, path: &Path) -> Option<String> {
|
||||
if !self.include_root {
|
||||
if !self.include_root || self.extra.iter().any(|e| path.starts_with(&e.path)) {
|
||||
return None;
|
||||
}
|
||||
let rel = rel_string(path.strip_prefix(&self.root).ok()?);
|
||||
@@ -537,4 +564,35 @@ src/local/
|
||||
assert!(filter.same_config(&vec![shared.clone(), root.join("src")].into(), &["target".into()]));
|
||||
assert!(!filter.same_config(&vec![shared].into(), &["target".into()]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_ignored_folder_inside_the_root_is_a_root_with_its_own_rules() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(dir.path()).unwrap();
|
||||
let nested = root.join(".wt/feature");
|
||||
for f in ["src/a.rs", "lib/d.rs", ".wt/feature/src/b.rs", ".wt/feature/out/c.rs"] {
|
||||
touch(&root, f);
|
||||
}
|
||||
// A git worktree kept inside the repository it belongs to, which ignores it.
|
||||
std::fs::create_dir_all(root.join(".git/info")).unwrap();
|
||||
std::fs::write(root.join(".git/info/exclude"), "/.wt/\n").unwrap();
|
||||
std::fs::write(nested.join(".git"), "gitdir: ../../.git/worktrees/feature\n").unwrap();
|
||||
std::fs::write(nested.join(".gitignore"), "out/\n").unwrap();
|
||||
assert!(walk_skips(&root, &nested));
|
||||
assert!(!walk_skips(&root, &root.join("lib")));
|
||||
|
||||
let filter = PathFilter::new(&root, &vec![nested.clone(), root.join("lib")].into(), &[]);
|
||||
assert_eq!(filter.roots().count(), 2, "a folder the root's walk covers is not a root of its own");
|
||||
let mut found: Vec<String> = filter
|
||||
.roots()
|
||||
.flat_map(|r| filter.walk(r, &AtomicBool::new(false)))
|
||||
.filter_map(|f| filter.rel(&f.path))
|
||||
.collect();
|
||||
found.sort();
|
||||
assert_eq!(found, [".wt/feature/.gitignore", ".wt/feature/src/b.rs", "lib/d.rs", "src/a.rs"]);
|
||||
assert_eq!(filter.store_key(&nested.join("src/b.rs")), None, "extra roots are not persisted");
|
||||
assert!(!filter.is_excluded(&nested.join("src/new.rs"), false));
|
||||
assert!(filter.is_excluded(&nested.join("out/new.rs"), false));
|
||||
assert!(filter.is_excluded(&root.join(".wt/other/x.rs"), false));
|
||||
}
|
||||
}
|
||||
@@ -21,6 +21,7 @@ mod matching;
|
||||
mod store;
|
||||
mod worker;
|
||||
|
||||
pub use filter::walk_skips;
|
||||
pub use worker::MAX_SYMBOL_FILE;
|
||||
use worker::{Job, MAX_RECENT, Shared};
|
||||
|
||||
|
||||
@@ -627,6 +627,7 @@ mod tests {
|
||||
"Vue",
|
||||
"Angular Template",
|
||||
"Angular TypeScript",
|
||||
"Thymeleaf",
|
||||
"ERB",
|
||||
"JSP",
|
||||
"Astro",
|
||||
@@ -840,6 +841,23 @@ mod tests {
|
||||
assert!(!reg.is_framework_marker(&root.join("apps/admin/package.json")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spring_template_folders_make_html_thymeleaf() {
|
||||
let reg = reg();
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path();
|
||||
let mode = |file: &str| reg.framework_ui_mode(&LanguageId::new("html"), &root.join(file), Some(root));
|
||||
std::fs::create_dir_all(root.join("web/src/main/resources/templates/fragments")).unwrap();
|
||||
std::fs::create_dir_all(root.join("docs")).unwrap();
|
||||
for file in
|
||||
["web/src/main/resources/templates/index.html", "web/src/main/resources/templates/fragments/nav.html"]
|
||||
{
|
||||
assert_eq!(mode(file).as_deref(), Some("Thymeleaf"), "{file}");
|
||||
}
|
||||
assert_eq!(mode("docs/index.html"), None);
|
||||
assert!(reg.is_framework_marker(&root.join("web/src/main/resources/templates")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn django_projects_make_html_in_templates_folders_templates() {
|
||||
let reg = reg();
|
||||
|
||||
@@ -19,10 +19,13 @@ use std::time::{Duration, Instant};
|
||||
pub(crate) const SERVER: &str = "jdtls";
|
||||
|
||||
pub(crate) mod configuration;
|
||||
mod extract_interface;
|
||||
mod formatter;
|
||||
mod hierarchy;
|
||||
pub(crate) mod jvm_inspect;
|
||||
mod move_refactoring;
|
||||
pub(crate) mod reserved_names;
|
||||
mod signature;
|
||||
pub use formatter::configure_formatter;
|
||||
/// First start imports the Maven / Gradle model, which can take minutes.
|
||||
const READY_TIMEOUT: Duration = Duration::from_secs(240);
|
||||
|
||||
@@ -0,0 +1,128 @@
|
||||
//! Extract Interface through jdtls' own requests: `java/checkExtractInterfaceStatus` lists the
|
||||
//! members of the file's class an interface can declare and the packages it can go to,
|
||||
//! `java/getRefactorEdit` (`extractInterface`) creates the interface, makes the class implement
|
||||
//! it and uses it where possible. The UI picks the name, package and members and applies the edit.
|
||||
use super::COMMAND_TIMEOUT;
|
||||
use super::signature::{RefactorEdit, changed};
|
||||
use crate::types::{ExtractInterfaceInfo, InterfaceMember, ProblemSeverity, RefactoringProblem, ServerRefactored};
|
||||
use crate::{LspManager, convert};
|
||||
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, Pos};
|
||||
use serde::Deserialize;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
const FEATURE: &str = "Extract Interface";
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct Status {
|
||||
#[serde(default)]
|
||||
members: Vec<InterfaceMember>,
|
||||
#[serde(default)]
|
||||
sub_type_name: String,
|
||||
#[serde(default)]
|
||||
destination_response: Destinations,
|
||||
}
|
||||
|
||||
#[derive(Default, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct Destinations {
|
||||
#[serde(default)]
|
||||
destinations: Vec<Value>,
|
||||
}
|
||||
|
||||
fn info_of(status: Option<Status>) -> IdeResult<ExtractInterfaceInfo> {
|
||||
let status = status
|
||||
.filter(|s| !s.sub_type_name.is_empty())
|
||||
.ok_or_else(|| IdeError::invalid("The file should declare a class"))?;
|
||||
Ok(ExtractInterfaceInfo {
|
||||
class_name: status.sub_type_name,
|
||||
members: status.members,
|
||||
packages: status.destination_response.destinations.iter().map(Value::to_string).collect(),
|
||||
})
|
||||
}
|
||||
|
||||
impl LspManager {
|
||||
/// The class of the file at `doc`, its members and the packages for the interface.
|
||||
pub async fn extract_interface_info(
|
||||
&self,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<ExtractInterfaceInfo> {
|
||||
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let params = Self::signature_context(&snap, &t, pos);
|
||||
let status: Option<Status> =
|
||||
self.call(&t, "java/checkExtractInterfaceStatus", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
info_of(status)
|
||||
}
|
||||
|
||||
/// Checks extracting `members` into the interface `name` in `package` (a package from
|
||||
/// [`Self::extract_interface_info`]) and computes the edit without applying it.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub async fn extract_interface(
|
||||
&self,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
members: Vec<String>,
|
||||
name: String,
|
||||
package: Value,
|
||||
confirmation: Option<String>,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<ServerRefactored> {
|
||||
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let mut params = json!({
|
||||
"command": "extractInterface",
|
||||
"context": Self::signature_context(&snap, &t, pos),
|
||||
"options": { "tabSize": 4, "insertSpaces": true },
|
||||
"commandArguments": [members, name, package],
|
||||
});
|
||||
if let Some(token) = confirmation {
|
||||
params["confirmationToken"] = json!(token);
|
||||
}
|
||||
let answer: Option<RefactorEdit> =
|
||||
self.call(&t, "java/getRefactorEdit", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
// jdtls answers nothing when its checks fail, and reports why in a message of its own.
|
||||
let Some(answer) = answer else {
|
||||
return Ok(ServerRefactored {
|
||||
problems: vec![RefactoringProblem {
|
||||
severity: ProblemSeverity::Fatal,
|
||||
message: "The interface could not be extracted".to_owned(),
|
||||
}],
|
||||
edit: None,
|
||||
confirmation: None,
|
||||
});
|
||||
};
|
||||
let conv = self.conv(t.enc());
|
||||
Ok(changed(answer, |e| convert::workspace_edit(&conv, e)))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn reads_the_members_and_packages() {
|
||||
let status: Status = serde_json::from_value(json!({
|
||||
"members": [
|
||||
{ "name": "area", "typeName": "double", "parameters": [], "handleIdentifier": "=p/src<a{Shape.java[Shape~area" },
|
||||
{ "name": "UNIT", "typeName": "int", "handleIdentifier": "=p/src<a{Shape.java[Shape^UNIT" },
|
||||
],
|
||||
"subTypeName": "Shape",
|
||||
"destinationResponse": { "destinations": [{ "displayName": "a", "isParentOfSelectedFile": true }] },
|
||||
}))
|
||||
.unwrap();
|
||||
let info = info_of(Some(status)).unwrap();
|
||||
assert_eq!(info.class_name, "Shape");
|
||||
assert_eq!(info.members[0].parameters.as_deref(), Some(&[][..]));
|
||||
assert_eq!(info.members[1].parameters, None);
|
||||
assert_eq!(serde_json::from_str::<Value>(&info.packages[0]).unwrap()["displayName"], "a");
|
||||
assert!(info_of(None).is_err());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,116 @@
|
||||
//! Move (F6) through jdtls' own requests. jdtls offers Move as code actions whose command the
|
||||
//! client runs (`java.action.applyRefactoringCommand` with `moveFile`, `moveType`,
|
||||
//! `moveStaticMember` or `moveInstanceMethod`); the UI picks the destination from
|
||||
//! `java/getMoveDestinations` or `java/searchSymbols` and `java/move` checks the move and
|
||||
//! computes the edit, which the UI applies itself. Requests carry the code action's own
|
||||
//! arguments back unchanged.
|
||||
use super::COMMAND_TIMEOUT;
|
||||
use super::signature::{RefactorEdit, changed};
|
||||
use crate::types::ServerRefactored;
|
||||
use crate::{LspManager, convert};
|
||||
use ide_core::{CancellationToken, DocId, IdeError, IdeResult};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
const FEATURE: &str = "Move";
|
||||
/// What `java/getMoveDestinations` and `java/move` accept as `moveKind`.
|
||||
const KINDS: [&str; 6] =
|
||||
["moveResource", "moveInstanceMethod", "moveStaticMember", "moveTypeToNewFile", "moveTypeToClass", "moveType"];
|
||||
|
||||
fn move_params(kind: &str, request: &Value) -> IdeResult<Value> {
|
||||
if !KINDS.contains(&kind) {
|
||||
return Err(IdeError::invalid(format!("unknown move kind `{kind}`")));
|
||||
}
|
||||
let mut params = json!({
|
||||
"moveKind": kind,
|
||||
"sourceUris": request.get("sourceUris").cloned().unwrap_or(json!([])),
|
||||
"params": request.get("params").cloned().unwrap_or(Value::Null),
|
||||
});
|
||||
if let Some(destination) = request.get("destination").filter(|d| !d.is_null()) {
|
||||
params["destination"] = destination.clone();
|
||||
}
|
||||
Ok(params)
|
||||
}
|
||||
|
||||
impl LspManager {
|
||||
/// Where the move of `kind` can go (packages, or the fields and parameters an instance
|
||||
/// method can move to); an invalid-input error carries jdtls' reason when there is none.
|
||||
pub async fn java_move_destinations(
|
||||
&self,
|
||||
doc: DocId,
|
||||
kind: String,
|
||||
request: Value,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<Vec<Value>> {
|
||||
let (_, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let params = move_params(&kind, &request)?;
|
||||
let answer: Value = self.call(&t, "java/getMoveDestinations", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
if let Some(message) = answer.get("errorMessage").and_then(Value::as_str).filter(|m| !m.is_empty()) {
|
||||
return Err(IdeError::invalid(message.to_owned()));
|
||||
}
|
||||
Ok(answer.get("destinations").and_then(Value::as_array).cloned().unwrap_or_default())
|
||||
}
|
||||
|
||||
/// The project's source types (`java/searchSymbols`), for moving a member or type into a class.
|
||||
pub async fn java_source_types(
|
||||
&self,
|
||||
doc: DocId,
|
||||
project: Option<String>,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<Vec<Value>> {
|
||||
let (_, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let params = json!({ "query": "*", "projectName": project, "sourceOnly": true });
|
||||
let answer: Option<Vec<Value>> =
|
||||
self.call(&t, "java/searchSymbols", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
Ok(answer.unwrap_or_default())
|
||||
}
|
||||
|
||||
/// Checks the move and computes the edit without applying it; `confirmation` accepts the
|
||||
/// warnings an earlier check returned with it.
|
||||
pub async fn java_move(
|
||||
&self,
|
||||
doc: DocId,
|
||||
kind: String,
|
||||
request: Value,
|
||||
confirmation: Option<String>,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<ServerRefactored> {
|
||||
let (_, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let mut params = move_params(&kind, &request)?;
|
||||
params["updateReferences"] = json!(true);
|
||||
if let Some(token) = confirmation {
|
||||
params["confirmationToken"] = json!(token);
|
||||
}
|
||||
let answer: Option<RefactorEdit> = self.call(&t, "java/move", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let conv = self.conv(t.enc());
|
||||
Ok(changed(answer.unwrap_or_default(), |e| convert::workspace_edit(&conv, e)))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn passes_the_code_action_arguments_back_for_known_kinds_only() {
|
||||
let request = json!({
|
||||
"sourceUris": ["file:///p/A.java"],
|
||||
"params": { "textDocument": { "uri": "file:///p/A.java" } },
|
||||
"destination": { "displayName": "com.example" },
|
||||
});
|
||||
let params = move_params("moveResource", &request).unwrap();
|
||||
assert_eq!(params["moveKind"], "moveResource");
|
||||
assert_eq!(params["sourceUris"][0], "file:///p/A.java");
|
||||
assert_eq!(params["destination"]["displayName"], "com.example");
|
||||
assert!(move_params("moveResource", &json!({})).unwrap().get("destination").is_none());
|
||||
assert!(move_params("deleteEverything", &request).is_err());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,181 @@
|
||||
//! Change Signature through jdtls' own requests: `java/getChangeSignatureInfo` reads the method at
|
||||
//! a position, `java/getRefactorEdit` (`changeSignature`) checks the new signature and computes the
|
||||
//! edit. The UI edits the signature and applies the edit itself.
|
||||
use super::{COMMAND_TIMEOUT, SERVER};
|
||||
use crate::types::{MethodSignature, ProblemSeverity, RefactoringProblem, ServerRefactored};
|
||||
use crate::{DocSnap, LspManager, Target, convert};
|
||||
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, Pos};
|
||||
use serde::Deserialize;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
const FEATURE: &str = "Change Signature";
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct Info {
|
||||
#[serde(flatten)]
|
||||
signature: Option<MethodSignature>,
|
||||
error_message: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Default, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub(super) struct RefactorEdit {
|
||||
edit: Option<lsp_types::WorkspaceEdit>,
|
||||
error_message: Option<String>,
|
||||
confirmation_token: Option<String>,
|
||||
}
|
||||
|
||||
/// A `java/getRefactorEdit` or `java/move` answer as the result: an error message alone is fatal;
|
||||
/// with a confirmation token it lists warnings to accept before the edit is computed.
|
||||
pub(super) fn changed(
|
||||
answer: RefactorEdit,
|
||||
convert_edit: impl FnOnce(lsp_types::WorkspaceEdit) -> ide_core::WorkspaceEdit,
|
||||
) -> ServerRefactored {
|
||||
let problem = |severity| {
|
||||
answer
|
||||
.error_message
|
||||
.as_deref()
|
||||
.filter(|m| !m.trim().is_empty())
|
||||
.map(|message| RefactoringProblem { severity, message: message.trim().to_owned() })
|
||||
};
|
||||
if let Some(token) = answer.confirmation_token {
|
||||
return ServerRefactored {
|
||||
problems: problem(ProblemSeverity::Warning).into_iter().collect(),
|
||||
edit: None,
|
||||
confirmation: Some(token),
|
||||
};
|
||||
}
|
||||
match answer.edit {
|
||||
Some(edit) if answer.error_message.is_none() => {
|
||||
ServerRefactored { problems: Vec::new(), edit: Some(convert_edit(edit)), confirmation: None }
|
||||
}
|
||||
_ => ServerRefactored {
|
||||
problems: problem(ProblemSeverity::Fatal).into_iter().collect(),
|
||||
edit: None,
|
||||
confirmation: None,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
impl LspManager {
|
||||
pub(super) async fn jdtls_target(&self, doc: DocId, feature: &str) -> IdeResult<(DocSnap, Target)> {
|
||||
let (snap, targets) = self.doc_targets(doc, feature, |_| true).await?;
|
||||
let t = targets
|
||||
.into_iter()
|
||||
.find(|t| t.server.name == SERVER)
|
||||
.ok_or_else(|| IdeError::unavailable(format!("{feature} needs the Java language server (jdtls)")))?;
|
||||
Ok((snap, t))
|
||||
}
|
||||
|
||||
pub(super) fn signature_context(snap: &DocSnap, t: &Target, pos: Pos) -> Value {
|
||||
let at = snap.position(t, pos);
|
||||
json!({
|
||||
"textDocument": { "uri": snap.uri },
|
||||
"range": { "start": at, "end": at },
|
||||
"context": { "diagnostics": [] },
|
||||
})
|
||||
}
|
||||
|
||||
/// The signature of the method at `pos`; an invalid-input error says why it can't be changed.
|
||||
pub async fn change_signature_info(
|
||||
&self,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<MethodSignature> {
|
||||
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let params = Self::signature_context(&snap, &t, pos);
|
||||
let info: Option<Info> =
|
||||
self.call(&t, "java/getChangeSignatureInfo", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
match info {
|
||||
Some(Info { error_message: Some(message), .. }) => Err(IdeError::invalid(message)),
|
||||
Some(Info { signature: Some(signature), .. }) => Ok(signature),
|
||||
_ => Err(IdeError::invalid("Caret should be on a method declaration")),
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks changing the method at `pos` to `signature` and computes the edit without applying it.
|
||||
/// `confirmation` accepts the warnings an earlier check returned with it.
|
||||
pub async fn change_signature(
|
||||
&self,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
signature: MethodSignature,
|
||||
delegate: bool,
|
||||
confirmation: Option<String>,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<ServerRefactored> {
|
||||
let (snap, t) = self.jdtls_target(doc, FEATURE).await?;
|
||||
let MethodSignature { method_identifier, modifier, return_type, method_name, parameters, exceptions } =
|
||||
signature;
|
||||
let mut params = json!({
|
||||
"command": "changeSignature",
|
||||
"context": Self::signature_context(&snap, &t, pos),
|
||||
"options": { "tabSize": 4, "insertSpaces": true },
|
||||
"commandArguments": [
|
||||
method_identifier, delegate, method_name, modifier, return_type, parameters, exceptions, false
|
||||
],
|
||||
});
|
||||
if let Some(token) = confirmation {
|
||||
params["confirmationToken"] = json!(token);
|
||||
}
|
||||
let answer: Option<RefactorEdit> =
|
||||
self.call(&t, "java/getRefactorEdit", params, Some(&cancel), COMMAND_TIMEOUT).await?;
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let answer = answer.unwrap_or_default();
|
||||
let conv = self.conv(t.enc());
|
||||
Ok(changed(answer, |e| convert::workspace_edit(&conv, e)))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn answer(v: Value) -> RefactorEdit {
|
||||
serde_json::from_value(v).unwrap()
|
||||
}
|
||||
fn no_edit(_: lsp_types::WorkspaceEdit) -> ide_core::WorkspaceEdit {
|
||||
ide_core::WorkspaceEdit::default()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_the_signature_or_why_there_is_none() {
|
||||
let info: Info = serde_json::from_value(json!({
|
||||
"methodIdentifier": "=p/src<p{A.java[A~m~I",
|
||||
"modifier": "public",
|
||||
"returnType": "void",
|
||||
"methodName": "m",
|
||||
"parameters": [{ "type": "int", "name": "a", "defaultValue": "null", "originalIndex": 0 }],
|
||||
"exceptions": [{ "type": "java.io.IOException", "typeHandleIdentifier": "=x" }],
|
||||
"errorMessage": null,
|
||||
}))
|
||||
.unwrap();
|
||||
let s = info.signature.unwrap();
|
||||
assert_eq!((s.method_name.as_str(), s.parameters[0].type_name.as_str()), ("m", "int"));
|
||||
assert_eq!(s.exceptions[0].type_name, "java.io.IOException");
|
||||
let refused: Info = serde_json::from_value(json!({ "errorMessage": "Cannot change signature." })).unwrap();
|
||||
assert!(refused.signature.is_none());
|
||||
assert_eq!(refused.error_message.as_deref(), Some("Cannot change signature."));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn errors_are_fatal_and_tokens_ask_for_confirmation() {
|
||||
let fatal = changed(answer(json!({ "errorMessage": "Duplicate parameter name" })), no_edit);
|
||||
assert_eq!(fatal.problems[0].severity, ProblemSeverity::Fatal);
|
||||
assert!(fatal.edit.is_none() && fatal.confirmation.is_none());
|
||||
|
||||
let warn = changed(answer(json!({ "errorMessage": "Overrides a method", "confirmationToken": "t1" })), no_edit);
|
||||
assert_eq!(warn.problems[0].severity, ProblemSeverity::Warning);
|
||||
assert_eq!(warn.confirmation.as_deref(), Some("t1"));
|
||||
|
||||
let ok = changed(answer(json!({ "edit": { "changes": {} } })), no_edit);
|
||||
assert!(ok.problems.is_empty() && ok.edit.is_some());
|
||||
}
|
||||
}
|
||||
@@ -434,6 +434,11 @@ async fn library_sources(snap: &DocSnap, root: &Path, pos: Pos, locs: Vec<Locati
|
||||
|
||||
const JAVA_IMPLEMENTATIONS: &str = "openidea.java.implementations";
|
||||
|
||||
/// jdtls' locations of the implementations of the method at a position in the classes named
|
||||
/// with it, for implementation classes in dependencies: its standard request puts those at the
|
||||
/// start of the decompiled class instead of at the method.
|
||||
const JAVA_IMPLEMENTATION_LOCATIONS: &str = "openidea.java.implementationLocations";
|
||||
|
||||
/// The answer of [`JAVA_IMPLEMENTATIONS`]: `complete` when the type is declared in the
|
||||
/// sources, so no dependency can implement it.
|
||||
#[derive(serde::Deserialize)]
|
||||
@@ -442,6 +447,13 @@ struct SourceImplementations {
|
||||
complete: bool,
|
||||
}
|
||||
|
||||
/// The answer of [`JAVA_IMPLEMENTATION_LOCATIONS`]: one entry per requested class, `None` when
|
||||
/// it has no implementation of the method.
|
||||
#[derive(serde::Deserialize)]
|
||||
struct TargetImplementations {
|
||||
locations: Vec<Option<lsp::Location>>,
|
||||
}
|
||||
|
||||
/// Receives the implementations found so far, before a slower search for the rest.
|
||||
type Partial<'a> = Option<&'a (dyn Fn(Vec<Location>) + Send + Sync)>;
|
||||
|
||||
@@ -1810,6 +1822,84 @@ impl LspManager {
|
||||
out
|
||||
}
|
||||
|
||||
/// jdtls: where the implementation methods of the method at `pos` are declared in the
|
||||
/// dependency classes `locs` point at. Its standard request answers those with `0:0`, the
|
||||
/// start of the class file's decompiled source; [`JAVA_IMPLEMENTATION_LOCATIONS`] resolves
|
||||
/// the declaration itself.
|
||||
async fn java_implementation_locations(
|
||||
&self,
|
||||
snap: &DocSnap,
|
||||
t: &Target,
|
||||
pos: Pos,
|
||||
locs: Vec<Location>,
|
||||
cancel: Option<&CancellationToken>,
|
||||
) -> Vec<Location> {
|
||||
if t.server.name != "jdtls" || !t.caps().commands().iter().any(|c| c == JAVA_IMPLEMENTATION_LOCATIONS) {
|
||||
return locs;
|
||||
}
|
||||
let targets: Vec<(usize, String)> = locs
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(i, l)| {
|
||||
let uri = l.uri.as_deref()?;
|
||||
(virtual_doc::scheme(uri) == "jdt" && l.range.start.line == 0).then(|| (i, uri.to_owned()))
|
||||
})
|
||||
.collect();
|
||||
if targets.is_empty() {
|
||||
return locs;
|
||||
}
|
||||
let params = snap.pos_params(t, pos);
|
||||
let arguments = json!([
|
||||
params["textDocument"]["uri"],
|
||||
params["position"]["line"],
|
||||
params["position"]["character"],
|
||||
targets.iter().map(|(_, uri)| uri).collect::<Vec<_>>(),
|
||||
]);
|
||||
let result: IdeResult<TargetImplementations> = self
|
||||
.call(
|
||||
t,
|
||||
"workspace/executeCommand",
|
||||
json!({ "command": JAVA_IMPLEMENTATION_LOCATIONS, "arguments": arguments }),
|
||||
cancel,
|
||||
LONG_TIMEOUT,
|
||||
)
|
||||
.await;
|
||||
let found = match result {
|
||||
Ok(found) if found.locations.len() == targets.len() => found,
|
||||
Ok(_) => return locs,
|
||||
Err(e) => {
|
||||
tracing::debug!("{JAVA_IMPLEMENTATION_LOCATIONS}: {}", e.message);
|
||||
return locs;
|
||||
}
|
||||
};
|
||||
let mut out = locs;
|
||||
for ((i, _), loc) in targets.into_iter().zip(found.locations) {
|
||||
if let Some(loc) = loc.as_ref().and_then(|l| self.conv(t.enc()).location(l)) {
|
||||
out[i] = loc;
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Refines the implementation `locs` of the method at `pos`: jdtls puts an implementation in
|
||||
/// a dependency at the start of its decompiled class instead of at the method, which matters
|
||||
/// when the gutter marker's targets are opened one by one.
|
||||
pub async fn implementation_locations(
|
||||
&self,
|
||||
doc: DocId,
|
||||
pos: Pos,
|
||||
locs: Vec<Location>,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<Vec<Location>> {
|
||||
let (_, cap, feature) = goto_method(GotoKind::Implementation);
|
||||
let (snap, targets) = self.doc_targets(doc, feature, |c| c.has(cap)).await?;
|
||||
let mut out = locs;
|
||||
for t in &targets {
|
||||
out = self.java_implementation_locations(&snap, t, pos, out, Some(&cancel)).await;
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
async fn goto_in(
|
||||
&self,
|
||||
snap: &DocSnap,
|
||||
@@ -1849,6 +1939,12 @@ impl LspManager {
|
||||
Ok(Some(r)) => {
|
||||
let locs = convert::goto_response(&self.conv(t.enc()), r);
|
||||
let locs = library_sources(snap, &self.project_root, pos, locs).await;
|
||||
// Only explicit Go to Implementation: gutter markers ask for every line.
|
||||
let locs = if method == "textDocument/implementation" && partial.is_some() {
|
||||
self.java_implementation_locations(snap, t, pos, locs, cancel).await
|
||||
} else {
|
||||
locs
|
||||
};
|
||||
self.note_virtual(&t.server, locs.iter().map(|l| l.uri.as_deref()));
|
||||
self.note_arduino_sources(&t.server, &locs);
|
||||
let locs = self.jdt_library_classes(snap, pos, locs).await;
|
||||
|
||||
@@ -504,6 +504,74 @@ pub struct HierarchyRefactored {
|
||||
pub edit: Option<WorkspaceEdit>,
|
||||
}
|
||||
|
||||
/// A parameter in Change Signature: its type, name, the value passed at existing calls when it is
|
||||
/// added, and its index in the current signature (-1 for an added one).
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct SignatureParameter {
|
||||
#[serde(rename = "type")]
|
||||
pub type_name: String,
|
||||
pub name: String,
|
||||
pub default_value: String,
|
||||
pub original_index: i32,
|
||||
}
|
||||
|
||||
/// A declared exception (`throws`), with the server's handle of its type.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct SignatureException {
|
||||
#[serde(rename = "type")]
|
||||
pub type_name: String,
|
||||
pub type_handle_identifier: String,
|
||||
}
|
||||
|
||||
/// The signature of the method at a position, as Change Signature edits it.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct MethodSignature {
|
||||
/// The server's handle of the method, passed back unchanged.
|
||||
pub method_identifier: String,
|
||||
/// `public`, `protected`, `private`, or empty for package-private.
|
||||
pub modifier: String,
|
||||
pub return_type: String,
|
||||
pub method_name: String,
|
||||
pub parameters: Vec<SignatureParameter>,
|
||||
pub exceptions: Vec<SignatureException>,
|
||||
}
|
||||
|
||||
/// A member Extract Interface can declare in the new interface.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct InterfaceMember {
|
||||
pub name: String,
|
||||
/// The method's return type or the field's type.
|
||||
pub type_name: String,
|
||||
/// The method's parameter types; `None` for a field.
|
||||
pub parameters: Option<Vec<String>>,
|
||||
/// The server's handle of the member, passed back unchanged.
|
||||
pub handle_identifier: String,
|
||||
}
|
||||
|
||||
/// What Extract Interface starts from: the file's class, the members the interface can declare and
|
||||
/// the packages it can go to (as JSON, passed back unchanged).
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ExtractInterfaceInfo {
|
||||
pub class_name: String,
|
||||
pub members: Vec<InterfaceMember>,
|
||||
pub packages: Vec<String>,
|
||||
}
|
||||
|
||||
/// A refactoring checked by the server (Change Signature, Move, Extract Interface): problems to show, the edit when
|
||||
/// none is fatal, and the token that confirms going on despite warnings.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ServerRefactored {
|
||||
pub problems: Vec<RefactoringProblem>,
|
||||
pub edit: Option<WorkspaceEdit>,
|
||||
pub confirmation: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct CallHierarchy {
|
||||
|
||||
@@ -3483,6 +3483,52 @@ async fn java_implementations_come_from_sources_first() {
|
||||
assert_eq!(s.requested("textDocument/implementation").len(), 3);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn java_dependency_implementations_point_at_the_method() {
|
||||
let caps = json!({
|
||||
"textDocumentSync": 1,
|
||||
"implementationProvider": true,
|
||||
"executeCommandProvider": { "commands": ["openidea.java.implementations", "openidea.java.implementationLocations"] },
|
||||
});
|
||||
let h = harness_for("java", "java", &[("jdtls", caps)], &[]);
|
||||
let (doc, _) = h.open("Repo.java", "interface Repo {\n void save(String item);\n}\n");
|
||||
h.wait_status("jdtls", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("jdtls");
|
||||
let class_uri = "jdt://contents/lib.jar/zoo/RepoImpl.java?=p/lib.jar%3Czoo%28RepoImpl.class";
|
||||
let method = json!({
|
||||
"uri": class_uri,
|
||||
"range": {"start":{"line":4,"character":4},"end":{"line":6,"character":5}},
|
||||
});
|
||||
let at_zero = json!({
|
||||
"uri": class_uri,
|
||||
"range": {"start":{"line":0,"character":0},"end":{"line":0,"character":0}},
|
||||
});
|
||||
let refined = method.clone();
|
||||
*s.responder.lock() = Some(Arc::new(move |_, method, params| match method {
|
||||
"workspace/executeCommand" if params["command"] == "openidea.java.implementations" => {
|
||||
Some(json!({ "locations": [], "complete": false }))
|
||||
}
|
||||
"workspace/executeCommand" if params["command"] == "openidea.java.implementationLocations" => {
|
||||
assert_eq!(params["arguments"][3], json!([class_uri]));
|
||||
Some(json!({ "locations": [refined] }))
|
||||
}
|
||||
"textDocument/implementation" => Some(json!([at_zero])),
|
||||
_ => None,
|
||||
}));
|
||||
let partial = Mutex::new(Vec::new());
|
||||
let found = h
|
||||
.mgr
|
||||
.goto_implementation(doc, Pos::new(1, 9), Default::default(), &|locs| partial.lock().push(locs.to_vec()))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(found.len(), 1);
|
||||
assert_eq!(found[0].uri.as_deref(), Some(class_uri));
|
||||
assert_eq!(found[0].range.start.line, 4);
|
||||
assert_eq!(s.requested("textDocument/implementation").len(), 1);
|
||||
let commands = s.requested("workspace/executeCommand");
|
||||
assert!(commands.iter().any(|r| r["command"] == "openidea.java.implementationLocations"));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn navigation_rename_format_and_decorations() {
|
||||
let h = harness(&[("mock", incremental_caps())]);
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
id = "editor-panel"
|
||||
name = "Editor Panel Probe"
|
||||
version = "0.1.0"
|
||||
description = "Test fixture for [[contributes.editorPanels]]: a minimal minimap page, no code."
|
||||
engines.openidea = "^1.9"
|
||||
|
||||
[capabilities]
|
||||
required = ["editor.read"]
|
||||
|
||||
[[contributes.editorPanels]]
|
||||
id = "minimap"
|
||||
web = "web/index.html"
|
||||
width = 110
|
||||
@@ -0,0 +1,196 @@
|
||||
<!doctype html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8" />
|
||||
<title>Minimap probe</title>
|
||||
<style>
|
||||
html,
|
||||
body {
|
||||
margin: 0;
|
||||
height: 100%;
|
||||
overflow: hidden;
|
||||
}
|
||||
canvas {
|
||||
display: block;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
cursor: default;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<canvas id="map"></canvas>
|
||||
<script>
|
||||
// A minimal minimap over `openidea.editor`: each line 2px high, each character 1px wide,
|
||||
// in its highlight colour; the visible area as a frame that can be dragged; the wheel
|
||||
// scrolls the editor.
|
||||
const editor = window.openidea.editor;
|
||||
const canvas = document.getElementById("map");
|
||||
const ctx = canvas.getContext("2d");
|
||||
const LINE = 2;
|
||||
const CHUNK = 2000;
|
||||
let text = [];
|
||||
let colors = new Map();
|
||||
let loading = new Set();
|
||||
let view = null;
|
||||
let drag = null;
|
||||
let queued = false;
|
||||
|
||||
const grey = (color) => {
|
||||
const m = /rgba?\((\d+),\s*(\d+),\s*(\d+)/.exec(color);
|
||||
return !!m && Math.max(m[1], m[2], m[3]) - Math.min(m[1], m[2], m[3]) < 24;
|
||||
};
|
||||
const cssVar = (name) => (window.openidea.theme && window.openidea.theme.vars[name]) || "";
|
||||
|
||||
function layout() {
|
||||
const H = canvas.clientHeight;
|
||||
if (!view) return { H, offset: 0, top: 0, height: 0, range: 1, visible: 0 };
|
||||
const L = Math.max(1, view.lineCount);
|
||||
const visible = Math.max(0, view.lastLine - view.firstLine);
|
||||
const scrollable = Math.max(1, view.scrollHeight - view.clientHeight);
|
||||
const p = Math.min(1, Math.max(0, view.scrollTop / scrollable));
|
||||
const mapH = L * LINE;
|
||||
const offset = p * Math.max(0, mapH - H);
|
||||
const range = Math.max(1, Math.min(H, mapH) - visible * LINE);
|
||||
return { H, offset, top: view.firstLine * LINE - offset, height: visible * LINE, range, visible, L };
|
||||
}
|
||||
|
||||
function redraw() {
|
||||
if (queued) return;
|
||||
queued = true;
|
||||
requestAnimationFrame(draw);
|
||||
}
|
||||
|
||||
function draw() {
|
||||
queued = false;
|
||||
const dpr = window.devicePixelRatio || 1;
|
||||
const W = canvas.clientWidth;
|
||||
const { H, offset, top, height } = layout();
|
||||
if (canvas.width !== Math.round(W * dpr) || canvas.height !== Math.round(H * dpr)) {
|
||||
canvas.width = Math.round(W * dpr);
|
||||
canvas.height = Math.round(H * dpr);
|
||||
}
|
||||
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
|
||||
ctx.clearRect(0, 0, W, H);
|
||||
if (!view) return;
|
||||
const first = Math.floor(offset / LINE);
|
||||
const last = Math.min(text.length, Math.ceil((offset + H) / LINE));
|
||||
const missing = [];
|
||||
const muted = cssVar("--openidea-fg-muted");
|
||||
for (let i = first; i < last; i++) {
|
||||
const y = i * LINE - offset;
|
||||
const line = text[i] || "";
|
||||
// Text without a syntax colour: faint, so the coloured spans stand out.
|
||||
ctx.globalAlpha = 0.2;
|
||||
ctx.fillStyle = muted;
|
||||
for (const m of line.matchAll(/\S+/g)) ctx.fillRect(m.index, y, m[0].length, LINE - 0.5);
|
||||
ctx.globalAlpha = 1;
|
||||
const spans = colors.get(i);
|
||||
if (!spans) missing.push(i);
|
||||
else
|
||||
for (const s of spans) {
|
||||
// Greys (the plain text colour, comments) stay as faint as uncoloured text.
|
||||
if (grey(s.color)) continue;
|
||||
ctx.fillStyle = s.color;
|
||||
ctx.fillRect(s.from, y, s.to - s.from, LINE - 0.5);
|
||||
}
|
||||
}
|
||||
// The visible area: a light accent tint and a 1px border, stronger while dragged.
|
||||
const frameH = Math.max(height, 4);
|
||||
ctx.fillStyle = cssVar("--openidea-accent");
|
||||
ctx.globalAlpha = drag ? 0.16 : 0.08;
|
||||
ctx.fillRect(0, top, W, frameH);
|
||||
ctx.strokeStyle = ctx.fillStyle;
|
||||
ctx.globalAlpha = drag ? 0.9 : 0.5;
|
||||
ctx.lineWidth = 1;
|
||||
ctx.strokeRect(0.5, top + 0.5, W - 1, frameH - 1);
|
||||
ctx.globalAlpha = 1;
|
||||
if (missing.length) load(missing[0], missing[missing.length - 1] + 1);
|
||||
}
|
||||
|
||||
async function load(from, to) {
|
||||
const key = `${from}:${to}`;
|
||||
if (loading.has(key)) return;
|
||||
loading.add(key);
|
||||
const target = view && view.version;
|
||||
try {
|
||||
for (let at = from; at < to; at += CHUNK) {
|
||||
const lines = await editor.highlights(at, Math.min(to, at + CHUNK));
|
||||
lines.forEach((spans, i) => colors.set(at + i, spans));
|
||||
}
|
||||
} finally {
|
||||
loading.delete(key);
|
||||
}
|
||||
if (view && view.version === target) redraw();
|
||||
}
|
||||
|
||||
async function reload() {
|
||||
const target = await editor.get();
|
||||
colors = new Map();
|
||||
text = [];
|
||||
if (!target) {
|
||||
view = null;
|
||||
return redraw();
|
||||
}
|
||||
const doc = await editor.document.get();
|
||||
text = doc.text.split("\n");
|
||||
view = Object.assign(await editor.viewport(), { version: target.version });
|
||||
redraw();
|
||||
}
|
||||
|
||||
editor.onTarget(() => void reload());
|
||||
editor.document.onChange((doc) => {
|
||||
text = doc.text.split("\n");
|
||||
redraw();
|
||||
});
|
||||
editor.onViewport((v) => {
|
||||
view = Object.assign(v, { version: view ? view.version : 0 });
|
||||
redraw();
|
||||
});
|
||||
editor.onHighlights(({ fromLine, toLine }) => {
|
||||
for (const k of [...colors.keys()]) if (k >= fromLine && k < toLine) colors.delete(k);
|
||||
redraw();
|
||||
});
|
||||
window.openidea.onThemeChange(redraw);
|
||||
new ResizeObserver(redraw).observe(canvas);
|
||||
|
||||
// Dragging the frame (or pressing beside it, which centres it there) scrolls the editor.
|
||||
const scrollToFrameTop = (frameTop) => {
|
||||
const { range, visible, L } = layout();
|
||||
const p = Math.min(1, Math.max(0, frameTop / range));
|
||||
void editor.scrollTo(p * Math.max(0, L - visible));
|
||||
};
|
||||
canvas.addEventListener("pointerdown", (e) => {
|
||||
if (!view) return;
|
||||
const { top, height } = layout();
|
||||
const grab = e.offsetY >= top && e.offsetY <= top + height ? e.offsetY - top : height / 2;
|
||||
drag = { grab };
|
||||
try {
|
||||
canvas.setPointerCapture(e.pointerId);
|
||||
} catch {
|
||||
// A pointer that isn't down (an event a test dispatched).
|
||||
}
|
||||
scrollToFrameTop(e.offsetY - grab);
|
||||
});
|
||||
canvas.addEventListener("pointermove", (e) => {
|
||||
if (drag) scrollToFrameTop(e.offsetY - drag.grab);
|
||||
});
|
||||
const stop = () => {
|
||||
drag = null;
|
||||
redraw();
|
||||
};
|
||||
canvas.addEventListener("pointerup", stop);
|
||||
canvas.addEventListener("pointercancel", stop);
|
||||
canvas.addEventListener(
|
||||
"wheel",
|
||||
(e) => {
|
||||
e.preventDefault();
|
||||
void editor.scrollBy(e.deltaY);
|
||||
},
|
||||
{ passive: false },
|
||||
);
|
||||
|
||||
void reload();
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -56,6 +56,16 @@ pub(crate) fn detect_with_profiles(
|
||||
detect_projects_matching(root, ruby_project, detect_ruby, &mut out);
|
||||
detect_projects(root, &["rebar.config"], detect_rebar, &mut out);
|
||||
detect_projects(root, &["mix.exs"], detect_mix, &mut out);
|
||||
// A project's own `build.sbt` belongs to the build above it.
|
||||
detect_projects_matching(
|
||||
root,
|
||||
|dir| {
|
||||
dir.join("build.sbt").is_file()
|
||||
&& !dir.ancestors().skip(1).take_while(|a| a.starts_with(root)).any(|a| a.join("build.sbt").is_file())
|
||||
},
|
||||
detect_sbt,
|
||||
&mut out,
|
||||
);
|
||||
for dir in ide_core::project_roots::discover(root, &["CMakeLists.txt"]) {
|
||||
let start = out.len();
|
||||
cmake::detect(&dir, if dir == root { profiles } else { None }, &mut out);
|
||||
@@ -1362,6 +1372,14 @@ fn detect_mix(root: &Path, out: &mut Vec<RunConfig>) {
|
||||
out.push(config("mix:test", "mix test", "mix", "mix", &["test"]).test());
|
||||
}
|
||||
|
||||
/// sbt (Scala): `sbt run` and `sbt test` on the build's root project, with the build's
|
||||
/// own launcher script when it has one. Other tasks run from the sbt tool window.
|
||||
fn detect_sbt(root: &Path, out: &mut Vec<RunConfig>) {
|
||||
let sbt = wrapper(root, "sbt", "sbt.bat", "sbt");
|
||||
out.push(config("sbt:run", "sbt run", "sbt", &sbt, &["run"]));
|
||||
out.push(config("sbt:test", "sbt test", "sbt", &sbt, &["test"]).test());
|
||||
}
|
||||
|
||||
/// Godot projects (`project.godot`) at the root or one level down: "Godot Project"
|
||||
/// runs the main scene (`godot --path .`), debuggable through the editor's adapter.
|
||||
fn detect_godot(root: &Path, out: &mut Vec<RunConfig>) {
|
||||
|
||||
@@ -1206,3 +1206,21 @@ fn mix_projects() {
|
||||
let dir = project(&[("mix.exs", "defp deps do\n [{:phoenix, \"~> 1.7\"}]\nend\n")]);
|
||||
assert_eq!(cmdline(&detect(dir.path())[0]), "iex -S mix phx.server");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sbt_projects() {
|
||||
let dir = project(&[
|
||||
("build.sbt", "lazy val core = project\n"),
|
||||
("core/build.sbt", "libraryDependencies += \"a\" % \"b\" % \"1\"\n"),
|
||||
("core/src/main/scala/App.scala", "object App\n"),
|
||||
]);
|
||||
let c = detect(dir.path());
|
||||
assert_eq!(ids(&c), ["sbt:run", "sbt:test"]);
|
||||
assert_eq!(cmdline(&c[0]), "sbt run");
|
||||
assert!(c[1].is_test && c.iter().all(|c| c.kind == "sbt"));
|
||||
|
||||
let dir = project(&[("build.sbt", ""), ("sbt", "#!/bin/sh\n")]);
|
||||
if !cfg!(windows) {
|
||||
assert_eq!(cmdline(&detect(dir.path())[1]), "./sbt test");
|
||||
}
|
||||
}
|
||||
@@ -745,7 +745,8 @@ pub fn native_tsdk(root: &Path, s: &Settings) -> Option<PathBuf> {
|
||||
}
|
||||
}
|
||||
|
||||
const PYTHON_SERVERS: [&str; 7] = ["basedpyright", "pyright", "ty", "pyrefly", "pylsp", "jedi-language-server", "ruff"];
|
||||
const PYTHON_SERVERS: [&str; 8] =
|
||||
["basedpyright", "pyright", "ty", "pyrefly", "pylsp", "jedi-language-server", "ruff", "djlsp"];
|
||||
|
||||
pub(crate) fn merge(base: &mut Value, layer: Value) {
|
||||
match (base, layer) {
|
||||
@@ -979,6 +980,16 @@ pub fn resolve_run_command(config: &mut RunConfig, root: &Path, s: &Settings) {
|
||||
}
|
||||
}
|
||||
|
||||
/// The environment folder holding `python` (`<env>/bin/python`, `<env>/Scripts/python.exe`):
|
||||
/// a virtualenv, or a conda or pixi environment.
|
||||
fn environment_of(python: &Path) -> Option<PathBuf> {
|
||||
venv_of(python).or_else(|| {
|
||||
let bin = python.parent()?;
|
||||
let env = bin.parent()?;
|
||||
matches!(bin.file_name()?.to_str()?, "bin" | "Scripts").then(|| env.to_path_buf())
|
||||
})
|
||||
}
|
||||
|
||||
pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root: &Path, s: &Settings) {
|
||||
let mut path_dirs: Vec<PathBuf> = Vec::new();
|
||||
if let Some(custom) = tool_command(root, s, &cfg.command) {
|
||||
@@ -1002,6 +1013,13 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
|
||||
"basedpyright" | "pyright" => merge_init_options(cfg, json!({ "python": { "pythonPath": p } })),
|
||||
"pylsp" => merge_init_options(cfg, json!({ "pylsp": { "plugins": { "jedi": { "environment": p } } } })),
|
||||
"jedi-language-server" => merge_init_options(cfg, json!({ "workspace": { "environmentPath": p } })),
|
||||
// Django's template tags, filters and template folders are read by running a script
|
||||
// with the interpreter in one of these environment folders.
|
||||
"djlsp" => {
|
||||
if let Some(env) = environment_of(&python) {
|
||||
merge_init_options(cfg, json!({ "env_directories": [env.to_string_lossy()] }));
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
if let Some(venv) = venv_of(&python) {
|
||||
|
||||
@@ -1588,7 +1588,7 @@ pub fn usages_bundle(data_dir: &Path) -> Option<PathBuf> {
|
||||
install_bundle(
|
||||
data_dir,
|
||||
"java-usages",
|
||||
"1.14.0",
|
||||
"1.15.0",
|
||||
include_bytes!("../../../java/java-usages/openidea-java-usages.jar"),
|
||||
)
|
||||
}
|
||||
|
||||
@@ -190,6 +190,18 @@ fn pyright_gets_python_path_and_venv_env() {
|
||||
assert!(cfg.env["PATH"].starts_with(&*tmp.path().join(".venv").join(bin_dir()).to_string_lossy()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn djlsp_reads_django_from_the_project_environment() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let python = fake_venv(tmp.path(), "venvs/web");
|
||||
let mut s = Settings::default();
|
||||
s.languages.python.interpreter = python.to_string_lossy().into_owned();
|
||||
let mut cfg = server("djlsp");
|
||||
configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
|
||||
let opts = serde_json::to_value(cfg.initialization_options.unwrap()).unwrap();
|
||||
assert_eq!(opts["env_directories"], serde_json::json!([tmp.path().join("venvs/web").to_string_lossy()]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_run_target_interpreter_hides_local_pythons() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -536,15 +536,16 @@ mod tests {
|
||||
let dest = tmp.path().join("install with spaces");
|
||||
extract(&archive, ArchiveKind::Zip, &dest, "unity-debug", &CancellationToken::new()).unwrap();
|
||||
let target = locate(&dest, &["UnityDebug.exe".into()]).unwrap();
|
||||
let wrapper =
|
||||
link_executable_with_runtime(&dest.join("bin"), "unity-debug", &target, cfg!(unix).then_some("mono"))
|
||||
.unwrap();
|
||||
let bin = dest.join("bin");
|
||||
let wrapper = link_executable_with_runtime(&bin, "unity-debug", &target, cfg!(unix).then_some("mono")).unwrap();
|
||||
let script = fs::read_to_string(wrapper).unwrap();
|
||||
#[cfg(unix)]
|
||||
assert!(script.contains(&*target.to_string_lossy()));
|
||||
#[cfg(unix)]
|
||||
assert!(script.contains("exec mono '") && script.contains("\"$@\""));
|
||||
// The shim names the adapter relative to itself (see `cmd_path`).
|
||||
#[cfg(windows)]
|
||||
assert!(script.contains("\" %*") && !script.contains("mono "));
|
||||
assert!(script.contains(&format!("\"{}\" %*", cmd_path(&bin, &target))) && !script.contains("mono "));
|
||||
assert_eq!(fs::read(target.with_extension("exe.config")).unwrap(), b"runtime config");
|
||||
assert_eq!(fs::read(target.parent().unwrap().join("Mono.Debugger.Soft.dll")).unwrap(), b"dependency");
|
||||
}
|
||||
|
||||
@@ -19,6 +19,7 @@ pub mod archive;
|
||||
mod bundled;
|
||||
pub mod formatter;
|
||||
pub mod jdk;
|
||||
mod moved_venv;
|
||||
pub mod platform;
|
||||
#[cfg(any(windows, test))]
|
||||
pub mod portable_update;
|
||||
@@ -47,6 +48,8 @@ use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::sync::mpsc;
|
||||
use std::time::Duration;
|
||||
|
||||
pub use moved_venv::drop_moved_venvs;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum ToolStatus {
|
||||
@@ -1456,7 +1459,9 @@ impl Tools {
|
||||
let pkg = staging.join("pkg");
|
||||
let kind = archive::ArchiveKind::from_name(&dl.name);
|
||||
let main = spec.commands[0];
|
||||
let exe_name = self.platform.exe(main);
|
||||
// A PHP archive keeps its name and runs through `php` (Windows can't launch it itself).
|
||||
let phar = dl.name.ends_with(".phar");
|
||||
let exe_name = if phar { format!("{main}.phar") } else { self.platform.exe(main) };
|
||||
match kind {
|
||||
archive::ArchiveKind::Gz | archive::ArchiveKind::Raw => {
|
||||
archive::extract(&archive, kind, &pkg.join("bin"), &exe_name, cancel)?
|
||||
@@ -1500,6 +1505,8 @@ impl Tools {
|
||||
if self.exe_in(&bin, main).as_deref() != Some(target.as_path()) {
|
||||
if spec.name == "unity-debug" && cfg!(unix) {
|
||||
archive::link_executable_with_runtime(&bin, main, &target, Some("mono"))?;
|
||||
} else if phar {
|
||||
archive::link_executable_with_runtime(&bin, main, &target, Some("php"))?;
|
||||
} else {
|
||||
archive::link_executable(&bin, main, &target)?;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,124 @@
|
||||
//! Managed virtual environments only work where they were created: their launchers
|
||||
//! (uv's `.exe` trampolines, script shebangs) name the interpreter by absolute path.
|
||||
//! One moved from outside the IDE (a copied data directory, a relocated AppData) fails
|
||||
//! to start, so it is removed and installed afresh when next needed.
|
||||
|
||||
use crate::registry::{Method, TOOLS};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
/// Removes the managed virtual-environment tools under `tools_root` that no longer sit
|
||||
/// where they were created. Call at start-up, before language servers start.
|
||||
pub fn drop_moved_venvs(tools_root: &Path) {
|
||||
for spec in TOOLS.iter().filter(|spec| matches!(spec.method, Method::PipVenv { .. })) {
|
||||
let dir = tools_root.join(spec.name);
|
||||
if !venv_moved(&dir.join("venv")) {
|
||||
continue;
|
||||
}
|
||||
tracing::info!(?dir, "virtual environment was moved from where it was created; removing it to reinstall");
|
||||
if let Err(error) = std::fs::remove_dir_all(&dir) {
|
||||
tracing::warn!(?dir, %error, "cannot remove the moved virtual environment");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn venv_moved(venv: &Path) -> bool {
|
||||
let Some(created) = venv_origin(venv) else { return false };
|
||||
match (std::fs::canonicalize(&created), std::fs::canonicalize(venv)) {
|
||||
(Ok(created), Ok(venv)) => created != venv,
|
||||
// The interpreter path its launchers hold is gone.
|
||||
(Err(_), Ok(_)) => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Where a virtual environment was created: the `VIRTUAL_ENV` its activation script sets.
|
||||
fn venv_origin(venv: &Path) -> Option<PathBuf> {
|
||||
let script =
|
||||
if cfg!(windows) { venv.join("Scripts").join("activate.bat") } else { venv.join("bin").join("activate") };
|
||||
let text = std::fs::read_to_string(script).ok()?;
|
||||
text.lines().find_map(virtual_env).map(PathBuf::from)
|
||||
}
|
||||
|
||||
/// The path a line of an activation script assigns to `VIRTUAL_ENV`, as uv and CPython write them:
|
||||
/// `VIRTUAL_ENV='/v'`, `VIRTUAL_ENV="/v"`, `export VIRTUAL_ENV=$(cygpath "/v")`,
|
||||
/// `set "VIRTUAL_ENV=C:\v"`, and uv's `@for %%i in ("C:\v") do @set "VIRTUAL_ENV=%%~fi"`.
|
||||
fn virtual_env(line: &str) -> Option<&str> {
|
||||
let at = line.find("VIRTUAL_ENV=")?;
|
||||
if let Some(start) = line[..at].find("in (\"") {
|
||||
let rest = &line[start + 5..];
|
||||
return rest.find('"').map(|end| &rest[..end]).filter(|value| !value.is_empty());
|
||||
}
|
||||
let rest = line[at + "VIRTUAL_ENV=".len()..].trim_start_matches("$(cygpath ");
|
||||
let value = match rest.chars().next()? {
|
||||
quote @ ('"' | '\'') => rest[1..].split(quote).next()?,
|
||||
_ if line[..at].ends_with('"') => rest.split('"').next()?,
|
||||
_ => rest.split_whitespace().next()?.trim_end_matches(')'),
|
||||
};
|
||||
(!value.is_empty() && !value.starts_with(['$', '%'])).then_some(value)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn reads_virtual_env_as_uv_and_cpython_write_it() {
|
||||
assert_eq!(virtual_env("VIRTUAL_ENV='/data/tools/ty/venv'"), Some("/data/tools/ty/venv"));
|
||||
assert_eq!(virtual_env("VIRTUAL_ENV=\"/a b/venv\""), Some("/a b/venv"));
|
||||
assert_eq!(virtual_env(" export VIRTUAL_ENV=$(cygpath \"/a/venv\")"), Some("/a/venv"));
|
||||
assert_eq!(virtual_env(" export VIRTUAL_ENV=$(cygpath /a/venv)"), Some("/a/venv"));
|
||||
assert_eq!(virtual_env(r#"set "VIRTUAL_ENV=E:\App Data\tools\ty\venv""#), Some(r"E:\App Data\tools\ty\venv"));
|
||||
assert_eq!(
|
||||
virtual_env(r#"@for %%i in ("E:\data\tools\ty\venv") do @set "VIRTUAL_ENV=%%~fi""#),
|
||||
Some(r"E:\data\tools\ty\venv")
|
||||
);
|
||||
assert_eq!(virtual_env(" export VIRTUAL_ENV"), None);
|
||||
assert_eq!(virtual_env("unset VIRTUAL_ENV_PROMPT"), None);
|
||||
assert_eq!(virtual_env("set VIRTUAL_ENV=%~dp0.."), None);
|
||||
}
|
||||
|
||||
fn venv_created_at(tools: &Path, name: &str, origin: &Path) {
|
||||
let venv = tools.join(name).join("venv");
|
||||
let script =
|
||||
if cfg!(windows) { venv.join("Scripts").join("activate.bat") } else { venv.join("bin").join("activate") };
|
||||
std::fs::create_dir_all(script.parent().unwrap()).unwrap();
|
||||
let line = if cfg!(windows) {
|
||||
format!("@for %%i in (\"{}\") do @set \"VIRTUAL_ENV=%%~fi\"\r\n", origin.display())
|
||||
} else {
|
||||
format!("VIRTUAL_ENV='{}'\nexport VIRTUAL_ENV\n", origin.display())
|
||||
};
|
||||
std::fs::write(script, line).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn removes_only_virtual_environments_moved_from_where_they_were_created() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let tools = tmp.path().join("tools");
|
||||
// Created here.
|
||||
venv_created_at(&tools, "ty", &tools.join("ty").join("venv"));
|
||||
// Copied from another data directory that is gone.
|
||||
venv_created_at(&tools, "basedpyright", &tmp.path().join("old/tools/basedpyright/venv"));
|
||||
// Copied, the original still in place.
|
||||
let old_ruff = tmp.path().join("old-kept/tools/ruff/venv");
|
||||
std::fs::create_dir_all(&old_ruff).unwrap();
|
||||
venv_created_at(&tools, "ruff", &old_ruff);
|
||||
// No activation script to tell.
|
||||
std::fs::create_dir_all(tools.join("pyrefly").join("venv")).unwrap();
|
||||
// Not a virtual-environment tool.
|
||||
std::fs::create_dir_all(tools.join("gopls").join("bin")).unwrap();
|
||||
|
||||
drop_moved_venvs(&tools);
|
||||
|
||||
assert!(tools.join("ty").exists());
|
||||
assert!(!tools.join("basedpyright").exists());
|
||||
assert!(!tools.join("ruff").exists());
|
||||
assert!(tools.join("pyrefly").exists());
|
||||
assert!(tools.join("gopls").exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_missing_tools_directory_is_left_alone() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
drop_moved_venvs(&tmp.path().join("missing"));
|
||||
}
|
||||
}
|
||||
@@ -322,6 +322,17 @@ pub static TOOLS: &[ToolSpec] = &[
|
||||
homepage: "https://docs.astral.sh/ruff/",
|
||||
needs: &[],
|
||||
},
|
||||
ToolSpec {
|
||||
name: "djlsp",
|
||||
display: "Django Template LSP",
|
||||
kind: LanguageServer,
|
||||
commands: &["djlsp"],
|
||||
method: Method::PipVenv { package: "django-template-lsp" },
|
||||
fallback: None,
|
||||
version: ver("djlsp"),
|
||||
homepage: "https://github.com/fourdigits/django-template-lsp",
|
||||
needs: &[],
|
||||
},
|
||||
ToolSpec {
|
||||
name: "bash-language-server",
|
||||
display: "Bash Language Server",
|
||||
@@ -466,6 +477,26 @@ pub static TOOLS: &[ToolSpec] = &[
|
||||
homepage: "https://intelephense.com",
|
||||
needs: &[],
|
||||
},
|
||||
ToolSpec {
|
||||
name: "phpactor",
|
||||
display: "Phpactor (PHP)",
|
||||
kind: LanguageServer,
|
||||
commands: &["phpactor"],
|
||||
// One PHP archive for every platform, run through the project's PHP.
|
||||
method: Method::Release {
|
||||
source: ReleaseSource::GitHub { repo: "phpactor/phpactor" },
|
||||
assets: &[
|
||||
any_arch(Mac, "phpactor.phar"),
|
||||
any_arch(Linux, "phpactor.phar"),
|
||||
any_arch(Windows, "phpactor.phar"),
|
||||
],
|
||||
locate: &["phpactor.phar"],
|
||||
},
|
||||
fallback: None,
|
||||
version: ver("phpactor"),
|
||||
homepage: "https://phpactor.readthedocs.io",
|
||||
needs: &[("php", "Phpactor runs on PHP")],
|
||||
},
|
||||
ToolSpec {
|
||||
name: "laravel-lsp",
|
||||
display: "Laravel LSP",
|
||||
|
||||
@@ -315,9 +315,10 @@ fn concurrent_installs_of_one_tool_are_rejected() {
|
||||
|
||||
/// A second caller mid-install joins the run (the other Settings window's
|
||||
/// duplicate install) and shares the result instead of `AlreadyExists`.
|
||||
// Slot names no real install in other tests uses: tests share the process-wide slots.
|
||||
#[test]
|
||||
fn second_install_joins_the_running_one() {
|
||||
let slot = match install_slot("sqls", &CancellationToken::new()) {
|
||||
let slot = match install_slot("join-test-slot", &CancellationToken::new()) {
|
||||
Ok(slot) => slot,
|
||||
Err(_) => panic!("no install is running"),
|
||||
};
|
||||
@@ -328,7 +329,7 @@ fn second_install_joins_the_running_one() {
|
||||
slot.broadcast(InstallEvent::Line { text: format!("line {i}") });
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
release_install_slot("sqls", &slot);
|
||||
release_install_slot("join-test-slot", &slot);
|
||||
slot.finish(Err(IdeError::new(ErrorKind::Io, "compile failed")));
|
||||
})
|
||||
};
|
||||
@@ -348,8 +349,8 @@ fn second_install_joins_the_running_one() {
|
||||
assert!(texts.contains(&"Joined the install already in progress…".to_string()), "{texts:?}");
|
||||
assert!(texts.iter().any(|l| l == "line 2"), "{texts:?}");
|
||||
// The slot is released: a fresh install can start.
|
||||
match install_slot("sqls", &CancellationToken::new()) {
|
||||
Ok(fresh) => release_install_slot("sqls", &fresh),
|
||||
match install_slot("join-test-slot", &CancellationToken::new()) {
|
||||
Ok(fresh) => release_install_slot("join-test-slot", &fresh),
|
||||
Err(_) => panic!("the finished install still holds its slot"),
|
||||
}
|
||||
}
|
||||
@@ -357,7 +358,7 @@ fn second_install_joins_the_running_one() {
|
||||
/// A late caller gets the finished result without waiting.
|
||||
#[test]
|
||||
fn install_joined_after_it_finished_returns_the_result() {
|
||||
let slot = match install_slot("marksman", &CancellationToken::new()) {
|
||||
let slot = match install_slot("finished-test-slot", &CancellationToken::new()) {
|
||||
Ok(slot) => slot,
|
||||
Err(_) => panic!("no install is running"),
|
||||
};
|
||||
@@ -382,7 +383,7 @@ fn install_joined_after_it_finished_returns_the_result() {
|
||||
alternatives: vec![],
|
||||
companion: false,
|
||||
};
|
||||
release_install_slot("marksman", &slot);
|
||||
release_install_slot("finished-test-slot", &slot);
|
||||
slot.finish(Ok(ok));
|
||||
let info = join_install(&slot, &CancellationToken::new(), &|_| {}).unwrap();
|
||||
assert_eq!(info.version.as_deref(), Some("1.0"));
|
||||
@@ -460,6 +461,51 @@ esac"#,
|
||||
assert!(exe.exists());
|
||||
}
|
||||
|
||||
/// A PHP archive release (phpactor) keeps its `.phar` name and is launched through `php`.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn phar_release_installs_with_a_php_launcher() {
|
||||
let env = Env::new();
|
||||
let fixtures = env.root.parent().unwrap().join("fixtures");
|
||||
fs::create_dir_all(&fixtures).unwrap();
|
||||
let phar = fixtures.join("phpactor.phar");
|
||||
fs::write(&phar, b"<?php __HALT_COMPILER();").unwrap();
|
||||
let digest = sources::sha256_file(&phar).unwrap();
|
||||
let json = fixtures.join("release.json");
|
||||
fs::write(
|
||||
&json,
|
||||
format!(
|
||||
r#"{{"tag_name":"2026.10.07.0","assets":[{{"name":"phpactor.phar","browser_download_url":"https://example.invalid/phpactor.phar","size":{},"digest":"sha256:{digest}"}}]}}"#,
|
||||
fs::metadata(&phar).unwrap().len()
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
env.script(
|
||||
&env.sys,
|
||||
"curl",
|
||||
&format!(
|
||||
r#"out=""; url=""
|
||||
while [ $# -gt 0 ]; do case "$1" in -o) out="$2"; shift 2;; -A|-H|--retry|--connect-timeout) shift 2;; -*) shift;; *) url="$1"; shift;; esac; done
|
||||
case "$url" in
|
||||
https://api.github.com/*) /bin/cat '{json}';;
|
||||
*) /bin/cp '{phar}' "$out";;
|
||||
esac"#,
|
||||
json = json.display(),
|
||||
phar = phar.display()
|
||||
),
|
||||
);
|
||||
env.script(&env.sys, "php", r#"echo "php $*""#);
|
||||
|
||||
let info = env.tools().install("phpactor", &langs(), &CancellationToken::new(), &|_| {}).unwrap();
|
||||
assert_eq!(info.status, ToolStatus::Installed);
|
||||
let launcher = env.root.join("phpactor/bin/phpactor");
|
||||
assert_eq!(info.path.as_deref(), Some(launcher.as_path()));
|
||||
let archive = env.root.join("phpactor/bin/phpactor.phar");
|
||||
assert_eq!(fs::read(&archive).unwrap(), b"<?php __HALT_COMPILER();");
|
||||
let out = Command::new(&launcher).arg("language-server").env("PATH", &env.sys).output().unwrap();
|
||||
assert_eq!(String::from_utf8_lossy(&out.stdout).trim(), format!("php {} language-server", archive.display()));
|
||||
}
|
||||
|
||||
/// npm installs go to `<tools>/node_modules` with `--prefix`.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
|
||||
@@ -12,7 +12,9 @@ use std::path::Path;
|
||||
use std::sync::{Arc, Mutex, OnceLock, Weak};
|
||||
use std::time::SystemTime;
|
||||
|
||||
pub(crate) const COMMITS: TableDefinition<&str, &[u8]> = TableDefinition::new("summaries-v2");
|
||||
// v3: summaries follow git's subject (the first paragraph on one line), not the first line.
|
||||
pub(crate) const COMMITS: TableDefinition<&str, &[u8]> = TableDefinition::new("summaries-v3");
|
||||
const STALE_COMMITS: TableDefinition<&str, &[u8]> = TableDefinition::new("summaries-v2");
|
||||
const MESSAGES: TableDefinition<&str, &str> = TableDefinition::new("messages-v1");
|
||||
const MAX_MEMORY_COMMITS: usize = 4096;
|
||||
const MAX_MEMORY_MESSAGES: usize = 1024;
|
||||
@@ -268,6 +270,7 @@ impl LogIndex {
|
||||
let mut databases = DATABASES.get_or_init(Mutex::default).lock().unwrap_or_else(|p| p.into_inner());
|
||||
self.db = databases.get(&path).and_then(Weak::upgrade).or_else(|| {
|
||||
let db = Arc::new(std::fs::create_dir_all(dir).ok().and_then(|_| Database::create(&path).ok())?);
|
||||
drop_stale_tables(&db);
|
||||
databases.insert(path, Arc::downgrade(&db));
|
||||
Some(db)
|
||||
});
|
||||
@@ -309,8 +312,8 @@ impl LogIndex {
|
||||
let author = commit.author().map_err(gx)?;
|
||||
let committer = commit.committer().map_err(gx)?;
|
||||
let raw = commit.message_raw_sloppy();
|
||||
let summary = raw.split(|b| *b == b'\n').find(|l| !l.trim().is_empty()).unwrap_or_default().trim();
|
||||
let summary_text = to_string(summary.as_bstr());
|
||||
let summary_text = subject(raw.as_bstr());
|
||||
let message_truncated = raw.trim() != summary_text.as_bytes();
|
||||
let record = Arc::new(Commit {
|
||||
id: key.clone(),
|
||||
short_id: key[..key.len().min(8)].to_string(),
|
||||
@@ -327,7 +330,7 @@ impl LogIndex {
|
||||
commit_time_ms: committer.time().map(|t| t.seconds as f64 * 1000.0).unwrap_or(0.0),
|
||||
summary: summary_text.clone(),
|
||||
message: summary_text,
|
||||
message_truncated: raw.trim() != summary,
|
||||
message_truncated,
|
||||
history_path: None,
|
||||
log_position: None,
|
||||
log_total: None,
|
||||
@@ -425,6 +428,23 @@ pub(crate) fn matches_user(query: &str, name: &str, email: &str) -> bool {
|
||||
.any(|alias| target.contains(&normalize_user(alias)))
|
||||
}
|
||||
|
||||
/// git's subject (`%s`, `git log --oneline`): the message's first paragraph on one line.
|
||||
/// A whitespace-only line ends the paragraph, as in git; `\r\n` endings count as newlines.
|
||||
fn subject(message: &gix::bstr::BStr) -> String {
|
||||
let lines = message.lines().map(|l| l.trim_end()).skip_while(|l| l.is_empty());
|
||||
let paragraph: Vec<String> = lines.take_while(|l| !l.is_empty()).map(|l| to_string(l.as_bstr())).collect();
|
||||
// git skips leading whitespace (blank lines and the first line's indent) before the subject.
|
||||
paragraph.join(" ").trim_start().to_owned()
|
||||
}
|
||||
|
||||
/// Drops tables an older version wrote, so outdated summaries don't stay on disk.
|
||||
fn drop_stale_tables(db: &Database) {
|
||||
let Ok(txn) = db.begin_write() else { return };
|
||||
if txn.delete_table(STALE_COMMITS).unwrap_or(false) {
|
||||
let _ = txn.commit();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -487,4 +507,39 @@ mod tests {
|
||||
assert_eq!(branches[1], vec!["feature".to_string(), "main".to_string()]);
|
||||
assert_eq!(branches[2], vec!["main".to_string()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn summary_is_git_subject_first_paragraph_on_one_line() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let dir = tmp.path();
|
||||
git(dir, &["init", "-q"]);
|
||||
let messages = [
|
||||
// The reporter's template: one paragraph of field lines (#3680).
|
||||
"[所属项目]:能力平台-订单\n[发布版本]:v1.2\n[需求单号]:REQ-1\n[需求描述]:导出\n[修改内容]:修复",
|
||||
"Subject only",
|
||||
"Subject\n\nBody that stays in the details",
|
||||
"Wrapped subject\ncontinues here\n\nBody",
|
||||
"CRLF subject\r\nsecond line\r\n\r\nBody",
|
||||
"Ends at a blank line\n \t\nBody",
|
||||
"\n\n Leading blank lines \nand indent kept\n",
|
||||
"Trailing spaces \n",
|
||||
];
|
||||
let mut ids = Vec::new();
|
||||
for (i, message) in messages.iter().enumerate() {
|
||||
std::fs::write(dir.join("a.txt"), i.to_string()).unwrap();
|
||||
std::fs::write(dir.join(".git/msg.txt"), message).unwrap();
|
||||
git(dir, &["add", "-A"]);
|
||||
git(dir, &["commit", "-q", "--cleanup=verbatim", "-F", ".git/msg.txt"]);
|
||||
ids.push(ObjectId::from_hex(git(dir, &["rev-parse", "HEAD"]).as_bytes()).unwrap());
|
||||
}
|
||||
let repo = gix::open(dir).unwrap();
|
||||
let mut index = LogIndex::default();
|
||||
for (id, message) in ids.iter().zip(messages) {
|
||||
let expected = git(dir, &["log", "-1", "--format=%s", &id.to_string()]);
|
||||
let commit = index.get(&repo, *id).unwrap();
|
||||
assert_eq!(commit.summary, expected, "{message:?}");
|
||||
assert_eq!(commit.message_truncated, message.trim() != expected, "{message:?}");
|
||||
}
|
||||
assert_eq!(index.get(&repo, ids[0]).unwrap().summary, messages[0].replace('\n', " "));
|
||||
}
|
||||
}
|
||||
@@ -43,7 +43,7 @@ User-visible text is written in English at the call site and goes through the te
|
||||
|
||||
## WebKit compatibility
|
||||
|
||||
On macOS and Linux the app runs in WebKit, and the supported floor is Safari 15.4, the engine of macOS 12 (the app's minimum). `pnpm build` runs `scripts/check-webkit.ts` on the bundle, and `src/platform/webkitCompatibility.test.ts` checks application regexes. Avoid:
|
||||
On macOS and Linux the app runs in WebKit, and the supported floor is Safari 15.4, the engine of macOS 12 (the app's minimum). On macOS 11 and on macOS 12 before 12.3, `src-tauri/src/macos_webview.rs` loads the newer WebKit staged by a Safari update, provided that update is installed. `pnpm build` runs `scripts/check-webkit.ts` on the bundle, and `src/platform/webkitCompatibility.test.ts` checks application regexes. Avoid:
|
||||
|
||||
- regex lookbehind (`(?<=…)`, `(?<!…)`), which needs Safari 16.4, and the regex `v` flag;
|
||||
- import attributes;
|
||||
|
||||
@@ -44,6 +44,8 @@ You don't need a JDK to build: the Java extension bundles in `java/` are checked
|
||||
|
||||
`pnpm dev:app` is the same as `pnpm tauri dev`, plus the global Tauri API (`window.__TAURI__`, from `src-tauri/tauri.dev.conf.json`), which is useful when you drive the app from scripts.
|
||||
|
||||
On macOS, `.cargo/config.toml` defaults `MACOSX_DEPLOYMENT_TARGET` to 11.0 (export your own value to override), so debug builds launch on older systems too. When the system WebKit predates Safari 15.4, `src-tauri/src/macos_webview.rs` re-execs once into the newer WebKit staged by a Safari update; set `OPENIDEA_DISABLE_STAGED_WEBKIT=1` to keep the system engine while debugging.
|
||||
|
||||
Other everyday commands:
|
||||
|
||||
| Command | What it does |
|
||||
|
||||
@@ -32,6 +32,8 @@ These agents are built in. Install the agent's own CLI and sign in once in a ter
|
||||
|
||||
Agents are unavailable in a project you have not marked as trusted.
|
||||
|
||||
Codex keeps its own project trust decision. If it disables the current project's `.codex` configuration, the task asks whether to **Trust Project in Codex** or **Keep Untrusted**. Trusting saves only that project's trust entry through Codex's configuration API before the session loads its configuration, including MCP servers, hooks and exec policies. This confirmation is required even in Full Access mode; declining keeps the configuration disabled and shows the reason without stopping the conversation. Codex configuration and runtime warnings also appear in the task.
|
||||
|
||||
## Start a task
|
||||
|
||||
| Action | macOS | Windows / Linux |
|
||||
@@ -121,6 +123,15 @@ Tasks are saved per project and survive restarts. When the agent supports resumi
|
||||
|
||||
**Settings › Tools › Agents › Chat** chooses what the task header shows: **Context window usage**, **Time spent on the task**, **Usage limits** (when the agent reports them, such as Claude Code) and **Session cost**.
|
||||
|
||||
### External MCP servers
|
||||
|
||||
**Settings › Agents › External MCP Servers** configures MCP servers across three persistent levels, while the composer's **MCP** picker (or `/mcp`) controls them per session:
|
||||
|
||||
- **Global (`User`)**: saved in `settings.toml` with environment variable and HTTP header values stored in the OS credential store, shared across projects and agents (or scoped to selected agents).
|
||||
- **Project (`Workspace`)**: saved in `.openidea/settings.toml`; entries with the same name override Global servers, and servers added outside OpenIDEA stay off until approved.
|
||||
- **Agent Configs**: discovers servers already configured in `~/.copilot/mcp-config.json`, `~/.claude.json`, `~/.codex/config.toml`, `~/.cursor/mcp.json`, `~/.gemini/settings.json`, `~/.jetbrains/mcp/mcp.json`, `.mcp.json`, and `.vscode/mcp.json` so you can import them into Global or Project settings with one click. You can also add or edit servers via structured fields or raw `mcpServers` JSON (**Add from JSON**), and run **Test Connection** to inspect the tools a server advertises.
|
||||
- **Per-session (`MCP` / `/mcp`)**: in both **New Agent Task** and active task conversations, open **MCP** in the composer toolbar (or run `/mcp`) to enable or disable individual servers—including the built-in `openidea` server—for that task only, or click **Reset** to return to the inherited defaults.
|
||||
|
||||
While the agent works, the line under the conversation says what it is doing: thinking, reading, editing, running a command, writing its reply. **Settings › Agents › Working Status** can show playful words for what it does there instead; they are off by default. Once turned on, they take turns from the moment the work changes, or only after the agent reports nothing new for a number of seconds (0 to 600, 0 by default); screen readers still hear what the agent is doing. Each word stays eight seconds while the agent keeps at the same work, and at least three when it moves on, so the line doesn't flicker. The same page replaces the words: pick what the status says (**Reading…**, **Running a command…**…) and add or remove its words. **Restore Built-in Words** brings back OpenIDEA's; an activity left without words keeps its plain status.
|
||||
|
||||
## Add a custom agent
|
||||
|
||||
@@ -52,6 +52,7 @@ Language servers that support LSP inline completion show a grey suggestion at th
|
||||
| **Go to Type Declaration** | `⇧⌘B` | `Ctrl+Shift+B` |
|
||||
| **Super Method** | `⌘U` | `Ctrl+U` |
|
||||
| **Navigate › Test** | `⇧⌘T` | `Ctrl+Shift+T` |
|
||||
| **Navigate › Related Symbol…** | `⌃⌘↑` | `Ctrl+Alt+Home` |
|
||||
| **Back** / **Forward** | `⌘[` / `⌘]` | `Ctrl+Alt+Left` / `Ctrl+Alt+Right` |
|
||||
| **Next Method** / **Previous Method** | `⌃⇧↓` / `⌃⇧↑` | `Alt+Down` / `Alt+Up` |
|
||||
|
||||
@@ -59,6 +60,8 @@ Language servers that support LSP inline completion show a grey suggestion at th
|
||||
- Hold `⌘` / `Ctrl` and hover over a name to see it underlined as a link, with brief information about it.
|
||||
- Gutter icons mark types and methods that are implemented or overridden (↓) and methods that implement or override another (↑). Click one to go there.
|
||||
- **Navigate › Test** jumps between a class and its tests by naming convention and offers **Create New Test…** when there is none.
|
||||
- **Navigate › Related Symbol…** goes to the files tied to the current one by convention: a C, C++ or Objective-C header and its source file, and in Rails a controller action and its views, a view and its action, a controller and its helper and model, a model and its controller and migrations. With several targets it shows a chooser.
|
||||
- In Rails, **Go to Declaration** also follows method symbols in callbacks (`before_action :load_user`, `if: :admin?`) to their `def`, and controller actions in `config/routes.rb` (`to: "users#index"`, `resources :users`) to the controller.
|
||||
|
||||
Going to files, classes and symbols by name is covered in [Search and navigation](/en/guide/search).
|
||||
|
||||
|
||||
@@ -9,7 +9,7 @@ In the file names below, `<version>` is the release version, for example `0.1.40
|
||||
|
||||
## macOS
|
||||
|
||||
macOS 12 Monterey or later.
|
||||
macOS 12 Monterey or later. macOS 11 Big Sur also works: install the latest Safari update in Software Update first, and OpenIDEA will load the newer WebKit Apple stages alongside it (the system engine predates Safari 15.4). On macOS 12, install that update too if its system WebKit is older than Safari 15.4; otherwise the built-in engine is used as is.
|
||||
|
||||
| Mac | File |
|
||||
| ------------- | -------------------------------- |
|
||||
|
||||
@@ -114,6 +114,7 @@ Notes on what they do:
|
||||
|
||||
As JetBrains IDEs do, the command runs on pipes, not a terminal: programs print plain lines instead of progress bars and redraws. The agent gets that output cleaned of escape sequences and cut to 2000 lines (`maxLinesCount`); beyond that the end stays, or the start or both ends with `truncateMode`. The tab's raw output log stays complete.
|
||||
|
||||
- **Servers return once they are up.** The call waits 10 seconds by default for the command to finish. A server, watcher or app never finishes: the agent passes `pattern` with its ready line (`Listening on`, `Started … in`) and gets the answer as soon as the line appears, while the command keeps running.
|
||||
- **One tab per name.** A name whose command finished runs the next command in the same tab. A name whose command is still running is refused, with that command and its last output: the agent has to stop it with `stop_run` first or pick another name. Nothing is stopped behind your back.
|
||||
- **Following a command up.** `wait_for_run` waits for the command to end or for a pattern in its output (a server's "listening" line), `read_run_output` reads the output from any point, `get_run_status` tells whether it is running, succeeded, failed, crashed or was stopped by the agent or by you, and `send_run_input` writes text and Enter to its input; Ctrl+C stops it and Ctrl+D ends its input.
|
||||
- **You can step in.** What you type into the tab's input line, a rerun, a Stop and closing the tab are reported to the agent with their time. A wait ends at once, and the agent is advised to stop what it is doing, tell you it received the intervention and wait for your confirmation.
|
||||
|
||||
@@ -18,12 +18,13 @@ The **Refactor** menu has IntelliJ IDEA's refactorings with their usual shortcut
|
||||
| Refactoring | macOS | Windows / Linux | Works through |
|
||||
| ------------------------ | ----- | --------------- | ------------------------------------------------------ |
|
||||
| **Rename…** | `⇧F6` | `Shift+F6` | Language server; local variables also without one |
|
||||
| **Change Signature…** | `⌘F6` | `Ctrl+F6` | Language server |
|
||||
| **Change Signature…** | `⌘F6` | `Ctrl+F6` | Java (dialog); other languages: language server |
|
||||
| **Introduce Variable…** | `⌥⌘V` | `Ctrl+Alt+V` | Language server; simple cases also without one |
|
||||
| **Introduce Constant…** | `⌥⌘C` | `Ctrl+Alt+C` | Language server; simple cases also without one |
|
||||
| **Introduce Field…** | `⌥⌘F` | `Ctrl+Alt+F` | Language server |
|
||||
| **Introduce Parameter…** | `⌥⌘P` | `Ctrl+Alt+P` | Language server |
|
||||
| **Extract Method…** | `⌥⌘M` | `Ctrl+Alt+M` | Language server |
|
||||
| **Extract Interface…** | — | — | Java |
|
||||
| **Inline…** | `⌥⌘N` | `Ctrl+Alt+N` | Language server |
|
||||
| **Move…** | `F6` | `F6` | Language server (symbols); the IDE (files and folders) |
|
||||
| **Safe Delete…** | `⌘⌦` | `Alt+Delete` | The IDE, using the server's references |
|
||||
@@ -63,7 +64,7 @@ When the language server cannot help, Introduce Variable and Introduce Constant
|
||||
|
||||
In the Project view, **Rename…** (`⇧F6` / `Shift+F6`), **Move…** (`F6`, drag and drop, or cut and paste) and **Copy…** (`F5`, copy and paste, or `⌥`-drag / `Alt`-drag) open a dialog. With **Search for references** on, references to the file are updated through the language servers that support it (for example imports in TypeScript); **Search in comments and strings** also looks there. The changes are shown in a preview first.
|
||||
|
||||
In the editor, **Move…** on a symbol runs the server's move refactoring, where the language has one.
|
||||
In the editor, **Move…** on a symbol runs the server's move refactoring, where the language has one. In Java it asks where to: a top-level class goes to another package (its package declaration, imports and every reference follow), a static member or nested class to another class, an instance method to the class of one of its fields or parameters; warnings are confirmed in **Problems Detected** first.
|
||||
|
||||
## Safe Delete
|
||||
|
||||
@@ -82,6 +83,14 @@ In the editor, **Move…** on a symbol runs the server's move refactoring, where
|
||||
|
||||
These move fields and methods between a class and its superclasses or subclasses, in Java and, with Phoxite as the PHP server, in PHP (methods, properties and constants). A dialog lets you pick the members and the destination; problems the move would cause are listed in **Problems Detected** before you continue. For Java they are provided by the extension bundled with OpenIDEA, for PHP by Phoxite; they are not available for other languages or other PHP servers.
|
||||
|
||||
## Extract Interface
|
||||
|
||||
In Java, **Refactor › Extract Interface…** creates an interface from the class of the current file. In the dialog, enter the interface name, choose its package and check the methods (and constants) it should declare. **Refactor** creates the interface, makes the class implement it, replaces the class with the interface wherever that is possible, and opens the new file; **Preview** lists the changes first.
|
||||
|
||||
## Change Signature
|
||||
|
||||
In Java, **Change Signature…** (`⌘F6`) on a method opens a dialog to change its visibility, return type and name, and to add, remove and reorder its parameters. A new parameter needs a default value, which is passed at every existing call; **Delegate via overloading method** keeps the old signature as an overload that calls the new one. The preview line shows the resulting declaration. **Refactor** updates the method, its overrides and all calls in one step; **Preview** lists the changes first. In other languages it appears when the server offers a signature rewrite as a code action.
|
||||
|
||||
## Undo
|
||||
|
||||
A refactoring is one undo step, even when it changed several files. After a multi-file refactoring, a notification offers **Undo** (and then **Redo**).
|
||||
@@ -89,5 +98,5 @@ A refactoring is one undo step, even when it changed several files. After a mult
|
||||
## Limits
|
||||
|
||||
- Refactorings other than Rename, Safe Delete and the syntax-based fallbacks need a running language server that offers them. Check the **Language Services** widget in the status bar if one is missing.
|
||||
- Change Signature appears only when the server offers a signature rewrite as a code action.
|
||||
- Outside Java, Change Signature appears only when the server offers a signature rewrite as a code action.
|
||||
- There is no structural search-and-replace refactoring in this menu; see **Edit › Find › Replace Structurally…** in [Inspections](/en/guide/inspections).
|
||||
@@ -107,7 +107,7 @@ The table lists every built-in language definition. Server and debugger names in
|
||||
| D | `d` | `.d`, `.di` | Yes | — | serve-d | — |
|
||||
| Dart | `dart` | `.dart` | Yes | Yes | dart | dart |
|
||||
| Diff | `diff` | `.diff`, `.patch`, `.rej` | Yes | — | — | — |
|
||||
| Django Template | `django-html` | `.djhtml`, `templates/*.html`, `*.txt` | Yes | Yes | **vscode-html-language-server** | — |
|
||||
| Django Template | `django-html` | `.djhtml`, `templates/*.html`, `*.txt` | Yes | Yes | **vscode-html-language-server**, **djlsp** | — |
|
||||
| Dockerfile | `dockerfile` | `.dockerfile`, `.containerfile` | Yes | — | **dockerfile-language-server** | — |
|
||||
| Elixir | `elixir` | `.ex`, `.exs` | Yes | Yes | **elixir-ls** | **elixir-ls-debugger** |
|
||||
| ERB | `erb` | `.erb`, `.html.erb`, `.rhtml`, `.js.erb`, `.text.erb`, … | Yes | — | — | — |
|
||||
@@ -200,6 +200,7 @@ Run configurations are detected from the build files in your project. The table
|
||||
| Ruby | `Gemfile`, `Rakefile`, `*.gemspec`, `config.ru` | Rails server, Rake tasks, RSpec, Minitest |
|
||||
| C / C++ | `CMakeLists.txt` | CMake targets |
|
||||
| C# | `.sln`, `.slnx`, `.csproj` | .NET Project, `dotnet test` |
|
||||
| Scala | `build.sbt` | `sbt run`, `sbt test`; every project's tasks in the **sbt** tool window |
|
||||
| GDScript | `project.godot` | Godot |
|
||||
| Any | `justfile`, `Makefile` | just recipes, Make targets |
|
||||
|
||||
|
||||
@@ -129,6 +129,7 @@ See [Debugging](/en/guide/debugging).
|
||||
|
||||
- **Spring Boot run configurations** are created from `@SpringBootApplication` classes, and they are listed in the **Services** tool window by default.
|
||||
- **Configuration navigation**: Go to Definition on a key in `application.yml` or `.properties` opens the Java members bound to it (`@ConfigurationProperties`, `@Value`, `Environment.getProperty`). It also works the other way, from `${…}` placeholders in Java, YAML, properties or Spring XML. Keys described by `spring-configuration-metadata.json` in dependencies resolve to their source classes. **Find Usages** on a key lists configuration declarations and Java usages together.
|
||||
- **Thymeleaf templates**: `.html` files in a project with `src/main/resources/templates` highlight `th:*` and `data-th-*` values as Thymeleaf expressions and complete the attribute names after `th:`. Go to Declaration on a fragment expression (`~{fragments/nav :: menu}`, or the bare form in `th:replace` / `th:insert`) opens the template or its `th:fragment`; on a message key (`#{home.title}`) it lists the key in each `messages*.properties` of the bundles set by `spring.messages.basename`.
|
||||
- **Spring Web endpoints**: request mappings in Java and Kotlin controllers get a gutter icon, plus **Generate Request in HTTP Client** and **Generate Requests for Controller** actions that write requests to a scratch `.http` file. Search Everywhere matches request paths in its **All** tab. See [HTTP Client](/en/guide/http-client).
|
||||
- **Facets** in **Project Structure** (`⌘;` / `Ctrl+Alt+Shift+S`) record the frameworks a module uses (Web, Spring, JPA). A Web facet also adds its `WEB-INF/lib/*.jar` to the jdtls classpath.
|
||||
|
||||
|
||||
@@ -140,6 +140,8 @@ Django is the only framework with dedicated support: the `manage.py runserver` a
|
||||
|
||||
The HTML and text files in a `templates` folder of a Django project (one with a `manage.py` above it) open as **Django Template** files: the template tags, variables, filters and comments are highlighted on top of the HTML, and block tags (`{% block %}`, `{% if %}`, `{% for %}`, `{% with %}` and the others of Django and its contrib libraries) fold, indent their content and highlight their end tag. Typing `{%`, `{{` or `{#` closes the pair, finishing a block tag adds its end tag, and `{% end` completes the end tags of the open blocks. **Comment with Line Comment** puts each line in its own `{# … #}`, and **Comment with Block Comment** over several lines uses `{% comment %}`. The HTML language server and Emmet work in the markup between the tags.
|
||||
|
||||
With **Django Template LSP** (`djlsp`, installed from **Settings › Languages & Frameworks › Language Servers**), the template tags, filters, template names (`{% extends %}`, `{% include %}`), static files and URL names of the project complete, show their documentation on hover, and **Go to Declaration** opens the template or the tag's Python source. It reads them by running Django with the project interpreter, so Django has to be installed there.
|
||||
|
||||
An HTML file elsewhere with Django tags shows a banner that switches it to Django Template or keeps it as HTML; either choice is the file's **Override File Type**.
|
||||
|
||||
## Limitations
|
||||
|
||||
@@ -114,6 +114,7 @@ Each contribution point is a table (`[contributes.settings]`) or an array of tab
|
||||
| `views` | `id`, `title`, `icon?`, `location`, `web?`, `group?`, `when?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
|
||||
| `customEditors` | `id`, `title`, `patterns`, `priority`, `layout?`, `web?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
|
||||
| `markerIcons` | `id`, `icon`, `iconDark?`, `markers?`, `tooltip?` (API 1.3): gutter marker icons | no | [Language features](/en/plugins/guides/language-features) |
|
||||
| `editorPanels` | `id`, `web`, `width`, `when?` (API 1.9; needs `editor.read`) | no | [README: Editor panels](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#editor-panels) |
|
||||
| `fileIcons` | `id`, `patterns`, `icon`, `iconDark?` | no | [Icon themes](/en/plugins/guides/icon-themes) |
|
||||
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables` | no | [File actions](/en/plugins/guides/file-actions) |
|
||||
| `snippets` | `language`, `path` (API 1.4) | no | [Language features](/en/plugins/guides/language-features) |
|
||||
|
||||
@@ -38,6 +38,7 @@ Some shortcuts depend on where the focus is. For example `⌘N` / `Alt+Insert` i
|
||||
| Go to Type Declaration | `⇧⌘B` / `⌃⇧B` | `Ctrl+Shift+B` |
|
||||
| Navigate › Super Method | `⌘U` | `Ctrl+U` |
|
||||
| Navigate › Test | `⇧⌘T` | `Ctrl+Shift+T` |
|
||||
| Navigate › Related Symbol… | `⌃⌘↑` | `Ctrl+Alt+Home` |
|
||||
| Find Usages | `⌥F7` | `Alt+F7` |
|
||||
| Show Usages | `⌥⌘F7` | `Ctrl+Alt+F7` |
|
||||
| Highlight Usages in File | `⇧⌘F7` | `Ctrl+Shift+F7` |
|
||||
|
||||
@@ -43,7 +43,7 @@ description: "前端 UI 代码的规则:设计 token、CSS Modules、图标、
|
||||
|
||||
## WebKit 兼容性
|
||||
|
||||
在 macOS 和 Linux 上应用运行于 WebKit,最低支持 Safari 15.4,即 macOS 12 的引擎(应用的最低系统版本)。`pnpm build` 会对产物运行 `scripts/check-webkit.ts`,`src/platform/webkitCompatibility.test.ts` 会检查应用中的正则。请避免:
|
||||
在 macOS 和 Linux 上应用运行于 WebKit,最低支持 Safari 15.4,即 macOS 12 的引擎(应用的最低系统版本)。在 macOS 11 以及 12.3 之前的 macOS 12 上,`src-tauri/src/macos_webview.rs` 会加载 Safari 更新暂存的新版 WebKit,前提是已安装该更新。`pnpm build` 会对产物运行 `scripts/check-webkit.ts`,`src/platform/webkitCompatibility.test.ts` 会检查应用中的正则。请避免:
|
||||
|
||||
- 正则后行断言(`(?<=…)`、`(?<!…)`,需要 Safari 16.4)和正则 `v` 标志;
|
||||
- import attributes;
|
||||
|
||||
@@ -44,6 +44,8 @@ sudo apt-get install -y libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librs
|
||||
|
||||
`pnpm dev:app` 与 `pnpm tauri dev` 相同,只是额外开启全局 Tauri API(`window.__TAURI__`,来自 `src-tauri/tauri.dev.conf.json`),用脚本驱动应用时比较方便。
|
||||
|
||||
在 macOS 上,`.cargo/config.toml` 默认把 `MACOSX_DEPLOYMENT_TARGET` 设为 11.0(自己导出该变量即可覆盖),让 debug 构建也能在旧系统启动。当系统 WebKit 低于 Safari 15.4 时,`src-tauri/src/macos_webview.rs` 会重新 exec 到 Safari 更新暂存的新版 WebKit;调试时可设 `OPENIDEA_DISABLE_STAGED_WEBKIT=1` 继续用系统引擎。
|
||||
|
||||
其他常用命令:
|
||||
|
||||
| 命令 | 作用 |
|
||||
|
||||
@@ -32,6 +32,8 @@ OpenIDEA 本身不带模型或账号:它启动你已安装并登录的 agent
|
||||
|
||||
未被标记为受信任的项目中无法使用 agent。
|
||||
|
||||
Codex 有自己的项目信任设置。如果它禁用了当前项目的 `.codex` 配置,任务会询问选择**在 Codex 中信任项目**还是**保持不信任**。选择信任后,会在会话加载配置(包括 MCP 服务器、hooks 和 exec policies)之前,通过 Codex 的配置 API 只写入这个项目的信任条目。即使在 Full Access 模式下也需要这一步确认;选择不信任时配置保持禁用,任务中会显示原因,对话照常进行。Codex 的配置警告和运行时警告也会显示在任务中。
|
||||
|
||||
## 新建任务
|
||||
|
||||
| 操作 | macOS | Windows / Linux |
|
||||
@@ -121,6 +123,15 @@ agent 运行过一个任务后,新任务会以它自动批准所有操作的
|
||||
|
||||
**设置 › 工具 › 智能体 › 聊天** 决定任务标题栏显示哪些信息:**上下文窗口用量**、**任务耗时**、**用量限额**(agent 报告时,例如 Claude Code)和 **会话花费**。
|
||||
|
||||
### 外部 MCP 服务器
|
||||
|
||||
**设置 › 智能体 › 外部 MCP 服务器** 按三个持久层级管理 MCP 服务器,输入框底部的 **MCP** 选择器(或 `/mcp` 命令)则按单个会话控制它们:
|
||||
|
||||
- **全局(`用户`)**:保存在 `settings.toml` 中,环境变量与 HTTP 请求头的值保存在系统凭据存储里,跨项目与各智能体共享(也可限定给选定的智能体)。
|
||||
- **项目(`工作区`)**:保存在 `.openidea/settings.toml` 中,同名服务器覆盖全局配置;在 OpenIDEA 外部写入的项目服务器在批准启用前保持关闭。
|
||||
- **智能体配置**:自动发现 `~/.copilot/mcp-config.json`、`~/.claude.json`、`~/.codex/config.toml`、`~/.cursor/mcp.json`、`~/.gemini/settings.json`、`~/.jetbrains/mcp/mcp.json`、`.mcp.json` 和 `.vscode/mcp.json` 中已配置的服务器,可一键导入到全局或项目设置。添加或编辑服务器时既可使用表单,也可直接粘贴 `mcpServers` JSON(**从 JSON 添加**),并可通过 **测试连接** 查看服务器声明的工具列表。
|
||||
- **按会话覆盖(`MCP` / `/mcp`)**:在 **新建 Agent 任务** 和进行中的任务对话中,单击输入框工具栏的 **MCP**(或输入 `/mcp`),即可仅针对当前任务开启或关闭任意服务器(包括内置的 `openidea` 服务器),或点击 **重置** 恢复继承的默认状态。
|
||||
|
||||
agent 工作时,对话下方的状态行显示它正在做什么:思考、读取、编辑、运行命令、输出回复。在 **设置 › 智能体 › 工作状态** 中可以让这里改为显示与当前工作相关的趣味文字,默认关闭。开启后,工作一变化就轮换显示,也可以设置在 agent 无新进展多少秒后才显示(0 到 600,默认 0);屏幕阅读器读出的仍是 agent 实际在做的事。agent 持续做同一类工作时,每条文字停留八秒;转向其他工作时也至少停留三秒,状态行不会频繁跳动。同一页面还可以替换这些文字:选择状态(**正在读取…**、**正在运行命令…**…),再添加或移除对应的文字。**恢复内置文字** 会换回 OpenIDEA 自带的文字;没有任何文字的状态只显示实际进展。
|
||||
|
||||
## 添加自定义 agent
|
||||
|
||||
@@ -52,6 +52,7 @@ description: "代码补全、导航、查找用法、文档、层次结构与文
|
||||
| **转到类型声明** | `⇧⌘B` | `Ctrl+Shift+B` |
|
||||
| **超方法** | `⌘U` | `Ctrl+U` |
|
||||
| **导航 › 测试** | `⇧⌘T` | `Ctrl+Shift+T` |
|
||||
| **导航 › 相关符号…** | `⌃⌘↑` | `Ctrl+Alt+Home` |
|
||||
| **后退** / **前进** | `⌘[` / `⌘]` | `Ctrl+Alt+Left` / `Ctrl+Alt+Right` |
|
||||
| **下一个方法** / **上一个方法** | `⌃⇧↓` / `⌃⇧↑` | `Alt+Down` / `Alt+Up` |
|
||||
|
||||
@@ -59,6 +60,8 @@ description: "代码补全、导航、查找用法、文档、层次结构与文
|
||||
- 按住 `⌘` / `Ctrl` 把鼠标悬停在名称上,名称会显示为链接,并附带简要信息。
|
||||
- 装订区域的图标标出被实现或被重写的类型和方法(↓),以及实现或重写了其他方法的方法(↑),单击即可跳转。
|
||||
- **导航 › 测试** 按命名约定在类和它的测试之间跳转;还没有测试时会提供 **创建新测试…**。
|
||||
- **导航 › 相关符号…** 跳到按约定与当前文件相关的文件:C、C++、Objective-C 的头文件和源文件,以及 Rails 中控制器动作与其视图、视图与其动作、控制器与其辅助模块和模型、模型与其控制器和迁移。有多个目标时显示选择列表。
|
||||
- 在 Rails 中,**转到声明** 还能从回调里的方法符号(`before_action :load_user`、`if: :admin?`)跳到对应的 `def`,从 `config/routes.rb` 里的控制器动作(`to: "users#index"`、`resources :users`)跳到控制器。
|
||||
|
||||
按名称跳转到文件、类和符号,见 [搜索与导航](/zh/guide/search)。
|
||||
|
||||
|
||||
@@ -9,7 +9,7 @@ description: "在 macOS、Windows 或 Linux 上下载并安装 OpenIDEA,以及
|
||||
|
||||
## macOS
|
||||
|
||||
需要 macOS 12 Monterey 或更高版本。
|
||||
需要 macOS 12 Monterey 或更高版本。macOS 11 Big Sur 也可运行:请先通过「软件更新」安装最新的 Safari 更新,OpenIDEA 会加载 Apple 随该更新暂存的新版 WebKit(系统自带的引擎低于 Safari 15.4)。macOS 12 若尚未更新到 Safari 15.4 及以上,同样需要先安装该更新;之后直接使用系统引擎。
|
||||
|
||||
| Mac | 文件 |
|
||||
| ---------- | -------------------------------- |
|
||||
|
||||
@@ -113,6 +113,7 @@ stdio 配置大致如下(路径以你机器上的为准):
|
||||
|
||||
和 JetBrains 的 IDE 一样,命令通过管道运行,而不是在终端里运行:程序输出的是普通文本行,不会有进度条和屏幕重绘。智能体拿到的输出会去掉控制字符,并截断到 2000 行(`maxLinesCount`);超出部分默认保留结尾,也可以用 `truncateMode` 改为保留开头或两头。标签页的原始输出日志保持完整。
|
||||
|
||||
- **服务启动好就返回。** 调用默认最多等 10 秒让命令结束。服务器、监视进程或应用不会结束:智能体传入 `pattern`(它就绪时输出的那一行,如 `Listening on`、`Started … in`),这一行一出现就返回,命令继续运行。
|
||||
- **一个名称对应一个标签。** 名称对应的命令已结束时,下一条命令在同一标签中运行。命令仍在运行时会被拒绝,并返回该命令和它最后的输出:智能体必须先用 `stop_run` 停止它,或者换一个名称。任何进程都不会被悄悄停掉。
|
||||
- **跟进命令。** `wait_for_run` 等待命令结束,或等待输出中出现指定文本(例如服务器的“正在监听”一行);`read_run_output` 从任意位置读取输出;`get_run_status` 报告命令是在运行、成功、失败、崩溃,还是被智能体或你停止;`send_run_input` 向命令的输入写入文本和 Enter,Ctrl+C 会停止命令,Ctrl+D 结束它的输入。
|
||||
- **你可以随时干预。** 你在标签输入行中输入的内容、重新运行、停止和关闭标签,都会连同时间一起告诉智能体。正在进行的等待会立即返回,并建议智能体停下手头的工作,回复你已收到干预,等你确认后再继续。
|
||||
|
||||
@@ -18,12 +18,13 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
|
||||
| 重构 | macOS | Windows / Linux | 实现方式 |
|
||||
| ------------- | ----- | --------------- | --------------------------------------- |
|
||||
| **重命名…** | `⇧F6` | `Shift+F6` | 语言服务器;局部变量没有服务器也可以 |
|
||||
| **更改签名…** | `⌘F6` | `Ctrl+F6` | 语言服务器 |
|
||||
| **更改签名…** | `⌘F6` | `Ctrl+F6` | Java(对话框);其他语言:语言服务器 |
|
||||
| **引入变量…** | `⌥⌘V` | `Ctrl+Alt+V` | 语言服务器;简单情况没有服务器也可以 |
|
||||
| **引入常量…** | `⌥⌘C` | `Ctrl+Alt+C` | 语言服务器;简单情况没有服务器也可以 |
|
||||
| **引入字段…** | `⌥⌘F` | `Ctrl+Alt+F` | 语言服务器 |
|
||||
| **引入参数…** | `⌥⌘P` | `Ctrl+Alt+P` | 语言服务器 |
|
||||
| **提取方法…** | `⌥⌘M` | `Ctrl+Alt+M` | 语言服务器 |
|
||||
| **提取接口…** | — | — | Java |
|
||||
| **内联…** | `⌥⌘N` | `Ctrl+Alt+N` | 语言服务器 |
|
||||
| **移动…** | `F6` | `F6` | 语言服务器(符号);IDE(文件和文件夹) |
|
||||
| **安全删除…** | `⌘⌦` | `Alt+Delete` | IDE,借助服务器查找引用 |
|
||||
@@ -58,7 +59,7 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
|
||||
|
||||
在项目视图中,**重命名…**(`⇧F6` / `Shift+F6`)、**移动…**(`F6`、拖放或剪切后粘贴)和 **复制…**(`F5`、复制后粘贴,或按住 `⌥` / `Alt` 拖动)会打开对话框。勾选 **搜索引用** 后,支持此功能的语言服务器会更新对该文件的引用(例如 TypeScript 的 import);**在注释和字符串中搜索** 会把注释和字符串也算进去。改动会先显示预览。
|
||||
|
||||
在编辑器中对符号执行 **移动…**,会调用该语言服务器的移动重构(如果有的话)。
|
||||
在编辑器中对符号执行 **移动…**,会调用该语言服务器的移动重构(如果有的话)。在 Java 中会先询问目标:顶层类移动到其他包(包声明、import 和所有引用随之更新),静态成员或嵌套类移动到其他类,实例方法移动到其某个字段或形参的类;有警告时先在 **检测到问题** 中确认。
|
||||
|
||||
## 安全删除
|
||||
|
||||
@@ -75,6 +76,14 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
|
||||
|
||||
用于在类和它的父类或子类之间移动字段和方法:支持 Java,以及使用 Phoxite 作为 PHP 服务器时的 PHP(方法、属性和常量)。在对话框中选择成员和目标类;移动会引起的问题会先在 **检测到问题** 中列出,再决定是否继续。Java 由 OpenIDEA 自带的扩展提供,PHP 由 Phoxite 提供;其他语言和其他 PHP 服务器不可用。
|
||||
|
||||
## 提取接口
|
||||
|
||||
在 Java 中,**重构 › 提取接口…** 会从当前文件的类创建一个接口。在对话框中输入接口名称,选择所在软件包,并勾选接口要声明的方法(以及常量)。**重构** 会创建接口、让该类实现它、在可行的地方把对该类的使用替换为接口,并打开新文件;**预览** 会先列出所有改动。
|
||||
|
||||
## 更改签名
|
||||
|
||||
在 Java 方法上执行 **更改签名…**(`⌘F6`)会打开对话框,可以修改可见性、返回类型和方法名,添加、删除和调整形参顺序。新形参需要填写默认值,所有已有调用处都会传入这个值;勾选 **通过重载方法委托** 会保留旧签名作为重载并调用新方法。签名预览显示修改后的声明。**重构** 会一次更新方法本身、覆盖它的方法和所有调用;**预览** 先列出改动。其他语言在服务器把签名重写作为代码操作提供时才会出现。
|
||||
|
||||
## 撤销
|
||||
|
||||
一次重构就是一步撤销,即使它改了多个文件。多文件重构完成后,通知中会提供 **撤消**(撤销后变为 **重做**)。
|
||||
@@ -82,5 +91,5 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
|
||||
## 限制
|
||||
|
||||
- 除了重命名、安全删除和基于语法树的兜底实现,其他重构都需要语言服务器运行并提供相应功能。缺少时先看状态栏的 **语言服务** 微件。
|
||||
- 只有当服务器把签名重写作为代码操作提供时,才会出现更改签名。
|
||||
- 除 Java 外,只有当服务器把签名重写作为代码操作提供时,才会出现更改签名。
|
||||
- 这个菜单里没有结构化搜索替换;见 [代码检查](/zh/guide/inspections) 中的 **编辑 › 查找 › 结构化替换…**。
|
||||
@@ -102,7 +102,7 @@ IDE 安装工具从不需要 `sudo`。工具装在本地数据目录下 IDE 自
|
||||
| D | `d` | `.d`, `.di` | 是 | — | serve-d | — |
|
||||
| Dart | `dart` | `.dart` | 是 | 是 | dart | dart |
|
||||
| Diff | `diff` | `.diff`, `.patch`, `.rej` | 是 | — | — | — |
|
||||
| Django Template | `django-html` | `.djhtml`, `templates/*.html`, `*.txt` | 是 | 是 | **vscode-html-language-server** | — |
|
||||
| Django Template | `django-html` | `.djhtml`, `templates/*.html`, `*.txt` | 是 | 是 | **vscode-html-language-server**, **djlsp** | — |
|
||||
| Dockerfile | `dockerfile` | `.dockerfile`, `.containerfile` | 是 | — | **dockerfile-language-server** | — |
|
||||
| Elixir | `elixir` | `.ex`, `.exs` | 是 | 是 | **elixir-ls** | **elixir-ls-debugger** |
|
||||
| ERB | `erb` | `.erb`, `.html.erb`, `.rhtml`, `.js.erb`, `.text.erb`, … | 是 | — | — | — |
|
||||
@@ -195,6 +195,7 @@ IDE 安装工具从不需要 `sudo`。工具装在本地数据目录下 IDE 自
|
||||
| Ruby | `Gemfile`、`Rakefile`、`*.gemspec`、`config.ru` | Rails server、Rake 任务、RSpec、Minitest |
|
||||
| C / C++ | `CMakeLists.txt` | CMake 目标 |
|
||||
| C# | `.sln`、`.slnx`、`.csproj` | .NET Project、`dotnet test` |
|
||||
| Scala | `build.sbt` | `sbt run`、`sbt test`;各项目的任务在 **sbt** 工具窗口中 |
|
||||
| GDScript | `project.godot` | Godot |
|
||||
| 任意 | `justfile`、`Makefile` | just 配方、Make 目标 |
|
||||
|
||||
|
||||
@@ -129,6 +129,7 @@ Java 调试使用 jdtls 内的 Microsoft java-debug,Kotlin 调试使用 Kotlin
|
||||
|
||||
- **Spring Boot 运行配置**:根据 `@SpringBootApplication` 类创建,默认显示在 **服务** 工具窗口中。
|
||||
- **配置导航**:在 `application.yml` 或 `.properties` 的键上转到定义,会打开绑定到它的 Java 成员(`@ConfigurationProperties`、`@Value`、`Environment.getProperty`);反过来,从 Java、YAML、properties 或 Spring XML 里的 `${…}` 占位符也能跳到配置键。依赖中 `spring-configuration-metadata.json` 描述的键会跳到对应的源类。对配置键执行 **查找用法**,会同时列出配置声明和 Java 中的使用处。
|
||||
- **Thymeleaf 模板**:项目中有 `src/main/resources/templates` 时,`.html` 文件里 `th:*` 和 `data-th-*` 的值按 Thymeleaf 表达式高亮,输入 `th:` 后补全属性名。在片段表达式(`~{fragments/nav :: menu}`,或 `th:replace` / `th:insert` 中不带 `~{}` 的写法)上转到声明,打开对应模板或其 `th:fragment`;在消息键(`#{home.title}`)上转到声明,列出 `spring.messages.basename` 所设消息包中每个 `messages*.properties` 里的该键。
|
||||
- **Spring Web 端点**:Java 和 Kotlin 控制器中的请求映射旁有边栏图标,还有 **在 HTTP 客户端中生成请求** 和 **为控制器生成请求** 两个操作,会把请求写进一个临时 `.http` 文件。随处搜索的 **全部** 标签页可以按请求路径搜索。见 [HTTP Client](/zh/guide/http-client)。
|
||||
- **Facet**:在 **项目结构**(`⌘;` / `Ctrl+Alt+Shift+S`)里记录模块使用的框架(Web、Spring、JPA)。添加 Web Facet 还会把其中的 `WEB-INF/lib/*.jar` 加入 jdtls 的类路径。
|
||||
|
||||
|
||||
@@ -140,6 +140,8 @@ Python 调试使用 debugpy。开始调试时如果缺少 debugpy,OpenIDEA 会
|
||||
|
||||
Django 项目(上层目录有 `manage.py`)中 `templates` 目录里的 HTML 和文本文件以 **Django Template** 打开:模板标签、变量、过滤器和注释在 HTML 之上高亮,块标签(`{% block %}`、`{% if %}`、`{% for %}`、`{% with %}` 以及 Django 和其 contrib 库的其他块标签)可以折叠、缩进内容并高亮对应的结束标签。输入 `{%`、`{{` 或 `{#` 会自动补全成对符号,写完块标签会自动添加结束标签,输入 `{% end` 会补全当前打开块的结束标签。**使用行注释** 会把每一行放进各自的 `{# … #}`,多行的 **使用块注释** 则用 `{% comment %}`。HTML 语言服务器和 Emmet 在标签之间的标记中照常工作。
|
||||
|
||||
安装 **Django Template LSP**(`djlsp`,在 **设置 › 语言和框架 › 语言服务器** 中安装)后,项目的模板标签、过滤器、模板名(`{% extends %}`、`{% include %}`)、静态文件和 URL 名可以补全、悬停查看文档,**转到声明** 会打开对应模板或标签的 Python 源码。它通过项目解释器运行 Django 读取这些信息,因此解释器中需要装有 Django。
|
||||
|
||||
其他位置含有 Django 标签的 HTML 文件会显示一个横幅,可以切换为 Django Template 或保留为 HTML;两种选择都会成为该文件的 **覆盖文件类型**。
|
||||
|
||||
## 限制
|
||||
|
||||
@@ -114,6 +114,7 @@ optional = ["net:api.openai.com", "secrets"]
|
||||
| `views` | `id`、`title`、`icon?`、`location`、`web?`、`group?`、`when?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
|
||||
| `customEditors` | `id`、`title`、`patterns`、`priority`、`layout?`、`web?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
|
||||
| `markerIcons` | `id`、`icon`、`iconDark?`、`markers?`、`tooltip?`(API 1.3):装订区标记图标 | 否 | [语言功能](/zh/plugins/guides/language-features) |
|
||||
| `editorPanels` | `id`、`web`、`width`、`when?`(API 1.9;需要 `editor.read`) | 否 | [README:Editor panels](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#editor-panels) |
|
||||
| `fileIcons` | `id`、`patterns`、`icon`、`iconDark?` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
|
||||
| `fileTemplates` | `id`、`name`、`extension`、`path`;API 1.3:`fileName`、`variables` | 否 | [文件操作](/zh/plugins/guides/file-actions) |
|
||||
| `snippets` | `language`、`path`(API 1.4) | 否 | [语言功能](/zh/plugins/guides/language-features) |
|
||||
|
||||
@@ -38,6 +38,7 @@ macOS 符号:`⌘` Command、`⌥` Option、`⌃` Control、`⇧` Shift、`↵
|
||||
| 转到类型声明 | `⇧⌘B` / `⌃⇧B` | `Ctrl+Shift+B` |
|
||||
| 导航 › super 方法 | `⌘U` | `Ctrl+U` |
|
||||
| 导航 › 测试 | `⇧⌘T` | `Ctrl+Shift+T` |
|
||||
| 导航 › 相关符号… | `⌃⌘↑` | `Ctrl+Alt+Home` |
|
||||
| 查找用法 | `⌥F7` | `Alt+F7` |
|
||||
| 显示用法 | `⌥⌘F7` | `Ctrl+Alt+F7` |
|
||||
| 高亮文件中的用法 | `⇧⌘F7` | `Ctrl+Shift+F7` |
|
||||
|
||||
Loaded 100 of 301 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача